OxCalculator.h

Go to the documentation of this file.

#ifndef Tomato_OXCALCULATORT1_H
#define Tomato_OXCALCULATORT1_H

#include "tomatolib_export.h"
#include "OxFitter.h"
#include "OxModel.h"
#include "OxSignCalculator.h"
#include "OxStartPointCalculator.h"
#include <map>

#include "KWUtil.h"

namespace Ox {

    template< typename MeasureType >
    class Calculator{

    public:

        virtual int calculate() = 0;

        virtual int prepareToCalculate() = 0;

        /* ****************** */
        /* ***  GETTERS   *** */
        /* ****************** */

        virtual std::map <std::string, MeasureType> getResults() const;

        virtual  Model<MeasureType> *getModel() const;

        virtual Fitter<MeasureType> *getFitter() const;

        virtual StartPointCalculator<MeasureType> *getStartPointCalculator() const;

        virtual SignCalculator<MeasureType> *getSignCalculator() const;

        virtual const MeasureType *getInvTimes() const;

        virtual const MeasureType *getEchoTimes() const;

        virtual const MeasureType *getRepTimes() const;

        virtual const MeasureType *getRelAcqTimes() const;

        virtual const MeasureType *getSigMag() const;

        virtual const MeasureType *getSigPha() const;

        virtual const MeasureType *getNoise() const;

        virtual MeasureType *getSignal() const;

        virtual MeasureType *getSigns() const;

        virtual MeasureType *getStartPoint() ;

        virtual MeasureType getMeanCutOff() const;

        virtual int getNSamples() const;

        virtual int getNDims() const;

        MeasureType *getParametersAfterFitting() const;

        /* ****************** */
        /* ***  SETTERS   *** */
        /* ****************** */
        /* ****************** */

        // setters for the 'has a' classes
        virtual void setModel(Model<MeasureType> *_Model);

        virtual void setFitter(Fitter<MeasureType> *_Fitter);

        virtual void setSignCalculator(SignCalculator<MeasureType> *_SignCalculator);

        virtual void setStartPointCalculator(StartPointCalculator<MeasureType> *_StartPointCalculator);

        // setters for the data
        virtual void setInvTimes(const MeasureType *_InvTimes);

        virtual void setEchoTimes(const MeasureType *_EchoTimes);

        virtual void setSigMag(const MeasureType *_SigMag);

        virtual void setSigPha(const MeasureType *_SigPha);

        virtual void setNoise(const MeasureType *_Noise);

        virtual void setMeanCutOff(MeasureType _MeanCutOff);

        virtual void setNSamples(int _nSamples);

        virtual void setNDims(int _nDims);

        void disp();

        void setAllPointersToNull(){
            // objects
            _Model = 0;
            _Fitter = 0;
            _SignCalculator = 0;
            _StartPointCalculator = 0;

            // arrays
            _InvTimes = 0;
            _EchoTimes = 0;
            _RepTimes = 0;
            _RelAcqTimes = 0;
            _SigMag = 0; // original one
            _SigPha = 0; // original one
            _Noise = 0;
            _Signal = 0; // we will be working with this one
            _Signs = 0;  // we will be working with this one
            _StartPoint = 0;
            _ParametersAfterFitting = 0;
        }

        Calculator() {

            setAllPointersToNull();

            // primitives
            _MeanCutOff = 0;
            _nSamples = 0;
            _nDims = 0;

        };

        Calculator(const Calculator &old){

            setAllPointersToNull();

            // primitives
            setMeanCutOff(old._MeanCutOff);
            setNSamples(old._nSamples);
            setNDims(old._nDims);
        };

        virtual Calculator<MeasureType> *newByCloning() = 0;

        virtual ~Calculator(){
            delete [] _Signal; _Signal = 0;
            delete [] _Signs; _Signs = 0;
            delete [] _StartPoint; _StartPoint = 0;
            delete [] _ParametersAfterFitting; _ParametersAfterFitting = 0;
         };

    protected:

        Model<MeasureType>* _Model;
        Fitter<MeasureType>* _Fitter;
        SignCalculator<MeasureType>* _SignCalculator;
        StartPointCalculator<MeasureType>* _StartPointCalculator;

        const MeasureType* _InvTimes;
        const MeasureType* _EchoTimes;
        const MeasureType* _RepTimes;
        const MeasureType* _RelAcqTimes;
        const MeasureType* _SigMag; // original one
        const MeasureType* _SigPha; // original one
        const MeasureType* _Noise;
        MeasureType* _Signal; // size: nSamples. We will be working with this one
        MeasureType* _Signs;  // size: nSamples. We will be working with this one
        MeasureType* _StartPoint; // size: nDims. We will be working with this one

        int _nSamples;
        int _nDims;
        MeasureType _MeanCutOff;

        MeasureType* _ParametersAfterFitting; // size: nDims
        std::map <std::string, MeasureType> _Results;

    };
} //namespace Ox

#ifndef TOMATOLIB_COMPILED
#include "OxCalculator.hxx"
#endif //TOMATOLIB_COMPILED

#endif //Tomato_OXCALCULATORT1_H