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 <QTextStream>
 
#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 bool print_fields(const Eigen::Vector3f& rd,
                             const Eigen::Vector3f& Q,
                             float time,
                             float integ,
                             InvDipoleFitData& fit,
                             const MNELIB::MNEMeasData& data,
                             QTextStream& out);
 
    //=========================================================================================================
    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