dipole_fit_data.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef DIPOLEFITDATA_H
#define DIPOLEFITDATA_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../inverse_global.h"
 
#include <fiff/fiff_types.h>
#include "analyze_types.h"
#include <fwd/fwd_types.h>
#include <fwd/fwd_eeg_sphere_model.h>
#include <fwd/fwd_bem_model.h>
#include "dipole_forward.h"
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QSharedPointer>
 
#include <memory>
 
namespace FIFFLIB { class FiffCoordTrans; }
 
// ToDo move to cpp
#define COLUMN_NORM_NONE 0      /* No column normalization requested */
#define COLUMN_NORM_COMP 1      /* Componentwise normalization */
#define COLUMN_NORM_LOC  2      /* Dipole locationwise normalization */
 
//=============================================================================================================
// DEFINE NAMESPACE INVERSELIB
//=============================================================================================================
 
namespace INVERSELIB
{
 
// (Replaces *dipoleFitFuncs,dipoleFitFuncsRec struct of MNE-C fit_types.h).

typedef struct {
  fwdFieldFunc    meg_field;        /* MEG forward calculation functions */
  fwdVecFieldFunc meg_vec_field;
  void            *meg_client;      /* Client data for MEG field computations */
  MNELIB::mneUserFreeFunc meg_client_free;
 
  fwdFieldFunc    eeg_pot;      /* EEG forward calculation functions */
  fwdVecFieldFunc eeg_vec_pot;
  void            *eeg_client;      /* Client data for EEG field computations */
  MNELIB::mneUserFreeFunc eeg_client_free;
} *dipoleFitFuncs,dipoleFitFuncsRec;

struct FitDipUserRec {
    float          limit;
    int            report_dim;
    float          *B;
    double         B2;
    DipoleForward*  fwd;
};
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
class GuessData;
class ECD;
 
//=============================================================================================================
class INVERSESHARED_EXPORT DipoleFitData
{
public:
    typedef QSharedPointer<DipoleFitData> SPtr;             
    typedef QSharedPointer<const DipoleFitData> ConstSPtr;  
 
    //=========================================================================================================
    explicit DipoleFitData();
 
    //=========================================================================================================
    virtual ~DipoleFitData();
 
    //============================= dipole_fit_setup.c =============================
 
    static int setup_forward_model(DipoleFitData* d, MNELIB::MNECTFCompDataSet* comp_data, FWDLIB::FwdCoilSet* comp_coils);
 
    static std::unique_ptr<MNELIB::MNECovMatrix> ad_hoc_noise(FWDLIB::FwdCoilSet* meg,          /* Channel name lists to define which channels are gradiometers */
                                     FWDLIB::FwdCoilSet* eeg,
                                     float      grad_std,
                                     float      mag_std,
                                     float      eeg_std);
 
    //ToDo  move to mneProjOp class
    static int make_projection(const QList<QString>& projnames,
                               const QList<FIFFLIB::FiffChInfo>& chs,
                               int        nch,
                               MNELIB::MNEProjOp*  *res);
 
    static int scale_noise_cov(DipoleFitData* f,int nave);
 
    static int scale_dipole_fit_noise_cov(DipoleFitData* f,int nave);
 
    static int select_dipole_fit_noise_cov(DipoleFitData* f, mshMegEegData d);
 
    static DipoleFitData* setup_dipole_fit_data(   const QString& mriname,         
                                            const QString& measname,        
                                            const QString& bemname,         
                                            Eigen::Vector3f *r0,            
                                            FWDLIB::FwdEegSphereModel* eeg_model,   
                                            int   accurate_coils,           
                                            const QString& badname,         
                                            const QString& noisename,               
                                            float grad_std,                 
                                            float mag_std,                  
                                            float eeg_std,                  
                                            float mag_reg,                  
                                            float grad_reg,
                                            float eeg_reg,
                                            int   diagnoise,                
                                            const QList<QString>& projnames,
                                            int   include_meg,              
                                            int   include_eeg);
 
    //=========================================================================================================
    static bool fit_one(DipoleFitData* fit, GuessData* guess, float time, float *B, int verbose, ECD& res);
 
//============================= dipole_forward.c
 
    static int compute_dipole_field(DipoleFitData* d, float *rd, int whiten, float **fwd);
 
    //============================= dipole_forward.c
 
    static DipoleForward* dipole_forward_one(DipoleFitData* d,
                                     float         *rd,
                                     DipoleForward* old);
 
public:
      std::unique_ptr<FIFFLIB::FiffCoordTrans>    mri_head_t; 
      std::unique_ptr<FIFFLIB::FiffCoordTrans>    meg_head_t; 
      int               coord_frame;        
      QList<FIFFLIB::FiffChInfo>        chs;       
      int               nmeg;               
      int               neeg;               
      QStringList       ch_names;           
      std::unique_ptr<FIFFLIB::FiffSparseMatrix> pick;   
      std::unique_ptr<FWDLIB::FwdCoilSet>        meg_coils;         
      std::unique_ptr<FWDLIB::FwdCoilSet>        eeg_els;           
      float             r0[3];              
      QString           bemname;           
 
      std::unique_ptr<FWDLIB::FwdEegSphereModel> eeg_model;         
      std::unique_ptr<FWDLIB::FwdBemModel>       bem_model;         
 
      dipoleFitFuncs    sphere_funcs;       
      dipoleFitFuncs    bem_funcs;          
      dipoleFitFuncs    funcs;              
      dipoleFitFuncs    mag_dipole_funcs;   
 
      int               fixed_noise;        
      std::unique_ptr<MNELIB::MNECovMatrix>      noise_orig;         
      std::unique_ptr<MNELIB::MNECovMatrix>      noise;              
      int               nave;               
      std::unique_ptr<MNELIB::MNEProjOp>        proj;               
      int               column_norm;        
      int               fit_mag_dipoles;    
      FitDipUserRec     *user;              
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
} //NAMESPACE
 
#endif // DIPOLEFITDATA_H