fitmodel.h

#ifndef FITMODEL_H
#define FITMODEL_H
#define MAX_PC 200

#include "musr.h"
#include "fitthread.h"
#include "plot2D.h"
#include "Moesscalc.h"
#include "array.h"
#include "fparser.hh"
#include <stdio.h>
#include <stdlib.h>
#include <QDir>
#include <QFileInfo>
#include <QMessageBox>
#include <QStringList>
#include <QString>
#include <QtConcurrentRun>
#include <QFutureSynchronizer>
#include <QFutureWatcher>
#include <QTimer>
#include <QMutex>
#include <QProgressBar>
#include <QLocale>
#include "fmpanel.h"

/*Fitmodel definieren*/
enum ObjTyp{funtyp,partyp,maptyp,numtyp,runspecificparameter};
enum ParameterTyp{pObj,pDISTR, pDISTREXT,pMEM,pHR};
enum MSTyp{SHcrystal,afmBexpowder,fmBexpowder,PseudoVoigt,MLR,SHpowder,mSSH,BL, FeCal, FeCaltriang,AnyFit,FeAspowder,DynDiagDiagDiag,DynDiagDiag,Dyn};
enum AdditionalFunTypes{TAbsDeb,TQuadDop,SwaveSFD,Hc2WHH,GLBrandttriang,GLBrandtquad,Errorfunction,OrderParameterDistrTN};

class Obj{
    public:
        Obj(QString name,ObjTyp typ, int i);
        Obj(QString name,double i);     
        Obj(QString name);              
        ~Obj();
        bool operator==(QString name); 
        bool operator==(Obj o);        
        bool operator<(const Obj o2)const;
        double dnumber;                 
        QString name;                   
        ObjTyp typ;                     
        int ref;                        
};
typedef struct Parameter{
    ParameterTyp typ;
    QStringList argv;
    int arg[6];
}Parameter;


class RUN{
    public:
        RUN();
        ~RUN();
        void init(int Speccount, int MEMsamplecount);
        double T;                       
        int cc;                         
        int ccr;                        
        double *v;                      
        double *I;                      
        double *err2rec;                

        double **Ith;
        double *nI;                     
        double *nIth;                   

        QStringList maplist;
        int* map;                       
        double I0;                      
        double A;                       
        double chi2;                    
        double *rho;                    
        double *rhoerror;               
        double MEMstatus[5];            
    private:
        int cmbs;                       
        int cMEM;                       
};

typedef struct MoessbauerSpectrum{
    MSTyp typ;                          
    Parameter p[MAX_PC];                
}MoessbauerSpectrum;

typedef struct fmPara{
    double value;                       
    double step;                        
    QString name;                       
    bool runspecific;                   
    int printDigits;                    
}fmPara;

typedef struct AdditionalFun{
    AdditionalFunTypes typ;
    int cpara;                          
    int arg[6];                         
}AdditionalFun;

typedef struct FunctionStruct{
    QString name;
    QString body;                       
    FunctionParser f;                   
    QList<int> arg;                     
    QList<AdditionalFun> addfunlist;    
}FunctionStruct;

typedef struct SortContainer{
    double x,y,err2;
}SortContainer;


class fitmodel:public QWidget{
    Q_OBJECT
public:
    fitmodel(QString filename);
    fitmodel();
    ~fitmodel();
    void plot(plot2D *plotter, plot2D *MEM);

    void fit();
    void fit_hidden_wait();             
    void errors();                      
    double get_total_chi2();            
    double get_run_chi2(int runi);      
    double calc_changed_runs();         

    int get_affect(int i);
    int calc_run(int i);                
    int is_valid();                     
    void close_fmpa();                  
    void generate_default(QStringList flds);
    short from_fld(char* filename,double** xdata, double** ydata,
                   int* count);         
    fmPanel* get_pannel();
    int cpara;
    fmPara* fmp;
    int crun;
    RUN *run;
private slots:
    void update_fit_progressbar(int ID, int citer, double chi2);
    void finish_fitting(int ID);        
    void error_message(int runi, QString message);
public slots:
    void panel_input(int irun, int ipara);
    void view_run(int i);               
    void view_run_only(int i);          
    void hide_run(int i);               
    void reset_error(int runi, int parai, bool fit);
    void add_noise();                   
private:

    int link();
    void interprete_commands(int* linkOK);
    void parse_functions(int* linkOK);  
    int find_obj(QString name);
    int set_obj(int i, int irun, double v);
    int set_error(int i, int irun, double v);
    fmPanel* fmpa;                      
    QString InputFile;                  
    QString ErrorMessage;               
    QList<Obj> obj;                     
    int read_fitparameters(FILE*f);     
    int read_functions(FILE*f);         
    int read_theory(FILE*f);            
    int read_run(char* mbspath, FILE*f);
    int read_plot(FILE*f);              
    int read_commands(FILE*f);          
    int read_fitdata();                 
    int read_MEMdata();                 
    int process_theory();
    bool blockend(char* line);          
    bool validline(char* line);         
    void print_fitdata();               
    short from_fld(char* filename,double** xdata, double** ydata,
                   double**yerror, int* count);

    void build_iterator(double* p, int ip, int spectrumi,
                        int irun, int ims,
                        MoessCalc *mc, bool sumweightonly,
                        double weight, double* integratedweight,
                        double **MEMIm, int MEMIndex, int maxMEMIndex);
    void build_spectrum(double* p, int ip, int spectrumi,
                        int irun, int ims,
                        MoessCalc *mc,
                        double weight, double* integratedweight,
                        double **MEMIm, int MEMIndex, int maxMEMIndex);
    void   WeightSum(double* p, int ip, int spectrumi, int irun, int ims,
                     double weight, double* integratedweight);
    void init();                        
    short load_run(char* mbspath, char* T,int index);
    int load_run(char* fldpath, double UseT, int index);

    double KSconfidence(int irun);
    void anyfit(int irun, int ims);
    void merge(SortContainer*,SortContainer*,int,int,int);
    void mergesort(SortContainer *a, SortContainer*b, int low, int high);
    double eval_error(int iobj, int irun);
    double eval(int iobj, int irun);    
    double fv(int ir, int ifun);
    void get_MEMcode(int istep, char* code);
    double get_MEMcode(int istep, int ipara);

    int pc(MSTyp m);                    
    int pc(int spectrumi);              
    int ac(ParameterTyp m);             
    void restrict_fitrange(double* mins, double* maxs, int crange, int irun);


    int isvalid;                        
    int cfun;                           
    FunctionStruct* fun;
    int cmbs;
    int cMEMsubspec;
    int i1stMEMspec;
    int cMEMpara;

    MoessbauerSpectrum* spectra;
    int AnyFit_in;                      

    ParameterTyp Distrtyp;


    double *pData;
    double *pError;                     


    int *pIsChanged;

    double ***rData;

    double ***rError;
    int cSpec;                          
    int cGlobal;                        
    int cConst;                         

    int *affect;
    int ***raffect;
    int fitruns;                        

    ErrMod errormode;


    int autorange;

    QString sautoI0, sautoA, sMEMsteps, sMaxIter, sconv, sMEMmaxlambda, sMEMmaxlambdaI0,
            sMEMtollerance, sMEMstepsize,sta,somegasrc,somegaabs,sfr,sHR,sHRc,sMCi;
    int autoI0, autoA, MEMsteps, MaxIter, conv, MEMmaxlambda, MEMmaxlambdaI0,
        MEMtollerance, MEMstepsize,ta,omegasrc,omegaabs,fr,HR,HRc,MCi;
    bool forcesimplex;
    QList<double> plotrunlist;
    double plotxmin;
    double plotxmax;
    double plotymin;
    double plotymax;


    bool ProgressPrint;
    QMutex fmutex;
    QProgressDialog pbinstance;

    int* pgvs;

    double* pgchi2;
    int runiterations;

    int is_seriell_fit();               
    fitthread** ft;

    void fgetss(char* buffer,int max,FILE* f);


signals:

    void ready_to_plot();
    void all_fitting_finished();
};

#endif // FITMODEL_H