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>
 
// 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
{
 
/*
 * These are the type definitions for dipole fitting
 */
typedef void (*fitUserFreeFunc)(void *);
 
// (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 */
  mneUserFreeFunc meg_client_free;
 
  fwdFieldFunc    eeg_pot;      /* EEG forward calculation functions */
  fwdVecFieldFunc eeg_vec_pot;
  void            *eeg_client;      /* Client data for EEG field computations */
  mneUserFreeFunc eeg_client_free;
} *dipoleFitFuncs,dipoleFitFuncsRec;
 
//=============================================================================================================
// 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 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:
      FIFFLIB::FiffCoordTransOld*    mri_head_t; 
      FIFFLIB::FiffCoordTransOld*    meg_head_t; 
      int               coord_frame;        
      QList<FIFFLIB::FiffChInfo>        chs;       
      int               nmeg;               
      int               neeg;               
      QStringList       ch_names;           
      FIFFLIB::FiffSparseMatrix* pick;   
      FWDLIB::FwdCoilSet*        meg_coils;         
      FWDLIB::FwdCoilSet*        eeg_els;           
      float             r0[3];              
      QString           bemname;           
      FWDLIB::FwdEegSphereModel *eeg_model;         
      FWDLIB::FwdBemModel       *bem_model;         
      dipoleFitFuncs    sphere_funcs;       
      dipoleFitFuncs    bem_funcs;          
      dipoleFitFuncs    funcs;              
      dipoleFitFuncs    mag_dipole_funcs;   
      int               fixed_noise;        
      MNELIB::MneCovMatrix*      noise_orig;         
      MNELIB::MneCovMatrix*      noise;              
      int               nave;               
      MNELIB::MneProjOp*        proj;               
      int               column_norm;        
      int               fit_mag_dipoles;    
      void              *user;              
      fitUserFreeFunc   user_free;          
// ### OLD STRUCT ###
//    typedef struct {            /* This structure holds all fitting-related data */
//      fiffCoordTrans    mri_head_t;         /* MRI <-> head coordinate transformation */
//      fiffCoordTrans    meg_head_t;         /* MEG <-> head coordinate transformation */
//      int               coord_frame;      /* Common coordinate frame */
//      fiffChInfo        chs;              /* Channels */
//      int               nmeg;       /* How many MEG */
//      int               neeg;       /* How many EEG */
//      char              **ch_names;         /* List of all channel names */
//      mneSparseMatrix   pick;       /* Matrix to pick data from the
//                         full data set which may contain channels
//                         we are not interested in */
//      fwdCoilSet        meg_coils;          /* MEG coil definitions */
//      fwdCoilSet        eeg_els;        /* EEG electrode definitions */
//      float             r0[3];          /* Sphere model origin */
//      char              *bemname;       /* Using a BEM? */
 
//      FwdEegSphereModel *eeg_model;         /* EEG sphere model definition */
//      fwdBemModel       bem_model;          /* BEM model definition */
 
//      dipoleFitFuncs    sphere_funcs;     /* These are the sphere model forward functions */
//      dipoleFitFuncs    bem_funcs;          /* These are the BEM forward functions */
//      dipoleFitFuncs    funcs;          /* Points to one of the two above */
//      dipoleFitFuncs    mag_dipole_funcs; /* Functions to fit a magnetic dipole */
 
//      int               fixed_noise;      /* Were fixed noise values used rather than a noise-covariance
//                           * matrix read from a file */
//      MneCovMatrix*      noise_orig;        /* Noise covariance matrix (original) */
//      MneCovMatrix*      noise;         /* Noise covariance matrix (weighted to take the selection into account) */
//      int               nave;       /* How many averages does this correspond to? */
//      mneProjOp         proj;       /* The projection operator to use */
//      int               column_norm;      /* What kind of column normalization to apply to the forward solution */
//      int               fit_mag_dipoles;  /* Fit magnetic dipoles? */
//      void              *user;          /* User data for anything we need */
//      fitUserFreeFunc   user_free;          /* Function to free the above */
//    } *dipoleFitData,dipoleFitDataRec;
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
} //NAMESPACE
 
#endif // DIPOLEFITDATA_H