inv_dipole_fit_data.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef INV_DIPOLE_FIT_DATA_H
#define INV_DIPOLE_FIT_DATA_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../inv_global.h"
 
#include <fiff/fiff_types.h>
#include <fwd/fwd_types.h>
#include <fwd/fwd_eeg_sphere_model.h>
#include <fwd/fwd_bem_model.h>
#include "inv_dipole_forward.h"
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QSharedPointer>
 
#include <memory>
 
namespace FIFFLIB { class FiffCoordTrans; }
namespace MNELIB { class MNEMeasData; }
 
constexpr int COLUMN_NORM_NONE = 0;     
constexpr int COLUMN_NORM_COMP = 1;     
constexpr int COLUMN_NORM_LOC  = 2;     
 
//=============================================================================================================
// DEFINE NAMESPACE INVLIB
//=============================================================================================================
 
namespace INVLIB
{
 
// (Replaces *dipoleFitFuncs,dipoleFitFuncsRec struct of MNE-C fit_types.h).

struct dipoleFitFuncsRec {
  ~dipoleFitFuncsRec() {
      if (meg_client_free && meg_client)
          meg_client_free(meg_client);
      if (eeg_client_free && eeg_client)
          eeg_client_free(eeg_client);
  }
  fwdFieldFunc    meg_field = nullptr;       
  fwdVecFieldFunc meg_vec_field = nullptr;   
  void            *meg_client = nullptr;     
  MNELIB::mneUserFreeFunc meg_client_free = nullptr;  
 
  fwdFieldFunc    eeg_pot = nullptr;         
  fwdVecFieldFunc eeg_vec_pot = nullptr;     
  void            *eeg_client = nullptr;     
  MNELIB::mneUserFreeFunc eeg_client_free = nullptr;  
};

using dipoleFitFuncs = dipoleFitFuncsRec*;

struct FitDipUserRec {
    float          limit;
    int            report_dim;
    float          *B;
    double         B2;
    InvDipoleForward*  fwd;
};
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
class InvGuessData;
class InvEcd;
 
//=============================================================================================================
class INVSHARED_EXPORT InvDipoleFitData
{
public:
    typedef QSharedPointer<InvDipoleFitData> SPtr;             
    typedef QSharedPointer<const InvDipoleFitData> ConstSPtr;  
 
    //=========================================================================================================
    explicit InvDipoleFitData();
 
    //=========================================================================================================
    virtual ~InvDipoleFitData();
 
    //=========================================================================================================
    static int setup_forward_model(InvDipoleFitData* d, MNELIB::MNECTFCompDataSet* comp_data, FWDLIB::FwdCoilSet* comp_coils);
 
    //=========================================================================================================
    static std::unique_ptr<MNELIB::MNECovMatrix> ad_hoc_noise(FWDLIB::FwdCoilSet* meg,
                                     FWDLIB::FwdCoilSet* eeg,
                                     float      grad_std,
                                     float      mag_std,
                                     float      eeg_std);
 
    //=========================================================================================================
    static int scale_noise_cov(InvDipoleFitData* f, int nave);
 
    //=========================================================================================================
    static int scale_dipole_fit_noise_cov(InvDipoleFitData* f, int nave);
 
    //=========================================================================================================
    static int select_dipole_fit_noise_cov(InvDipoleFitData* f,
                                           MNELIB::MNEMeasData* meas,
                                           int nave,
                                           const int* sels);
 
    //=========================================================================================================
    static InvDipoleFitData* 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(InvDipoleFitData* fit, InvGuessData* guess, float time, Eigen::Ref<Eigen::VectorXf> B, int verbose, InvEcd& res);
 
    //=========================================================================================================
    static int compute_dipole_field(InvDipoleFitData& d, const Eigen::Vector3f& rd, int whiten, Eigen::Ref<Eigen::MatrixXf> fwd);
 
    //=========================================================================================================
    static InvDipoleForward* dipole_forward_one(InvDipoleFitData* d,
                                     const Eigen::Vector3f& rd,
                                     InvDipoleForward* 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;           
      Eigen::Vector3f     r0;                
      QString           bemname;           
 
      std::unique_ptr<FWDLIB::FwdEegSphereModel> eeg_model;         
      std::unique_ptr<FWDLIB::FwdBemModel>       bem_model;         
 
      std::unique_ptr<dipoleFitFuncsRec>    sphere_funcs;       
      std::unique_ptr<dipoleFitFuncsRec>    bem_funcs;          
      dipoleFitFuncsRec*    funcs = nullptr;    
      std::unique_ptr<dipoleFitFuncsRec>    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 // INV_DIPOLE_FIT_DATA_H