fwd_eeg_sphere_model.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef FWDEEGSPHEREMODEL_H
#define FWDEEGSPHEREMODEL_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "fwd_global.h"
#include "fwd_eeg_sphere_layer.h"
#include "fwd_coil_set.h"
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QSharedPointer>
#include <QList>
#include <QDebug>
 
//=============================================================================================================
// DEFINE NAMESPACE FWDLIB
//=============================================================================================================
 
namespace FWDLIB
{
 
/*
 * This is the beginning of the specific code
 */
typedef struct {
    double *y;
    double *resi;
    double **M;
    double **uu;
    double **vv;
    double *sing;
    double *fn;
    double *w;
    int    nfit;
    int    nterms;
} *fitUser,fitUserRec;
 
//=============================================================================================================
class FWDSHARED_EXPORT FwdEegSphereModel
{
public:
    typedef QSharedPointer<FwdEegSphereModel> SPtr;              
    typedef QSharedPointer<const FwdEegSphereModel> ConstSPtr;   
 
    //=========================================================================================================
    explicit FwdEegSphereModel();
 
    //=========================================================================================================
    explicit FwdEegSphereModel(const FwdEegSphereModel& p_FwdEegSphereModel);
 
    /*
          * Produce a new sphere model structure
          */
    static FwdEegSphereModel* fwd_create_eeg_sphere_model(const QString& name,
                                                         int nlayer,
                                                         const Eigen::VectorXf& rads,
                                                         const Eigen::VectorXf& sigmas);
 
    //=========================================================================================================
    virtual ~FwdEegSphereModel();
 
    //=========================================================================================================
    static FwdEegSphereModel* setup_eeg_sphere_model(const QString& eeg_model_file, QString eeg_model_name, float eeg_sphere_rad);
 
    static fitUser new_fit_user(int nfit, int nterms);
 
    //=========================================================================================================
    double fwd_eeg_get_multi_sphere_model_coeff(int n);
 
    static void next_legen (int n,
                double x,
                double *p0,         /* Input: P0(n-1) Output: P0(n) */
                double *p01,        /* Input: P0(n-2) Output: P0(n-1) */
                double *p1,     /* Input: P1(n-1) Output: P1(n) */
                double *p11);
 
    static void calc_pot_components(double beta,   /* rd/r */
                    double cgamma, /* Cosine of the angle between
                            * the source and field points */
                    double *Vrp,   /* Potential component for the radial dipole */
                    double *Vtp,   /* Potential component for the tangential dipole */
                    const Eigen::VectorXd& fn,
                    int    nterms);
 
    static int fwd_eeg_multi_spherepot(float   *rd,           /* Dipole position */
                       float   *Q,            /* Dipole moment */
                       float   **el,      /* Electrode positions */
                       int     neeg,      /* Number of electrodes */
                       float   *Vval,         /* The potential values */
                       void    *client);
 
    static int fwd_eeg_multi_spherepot_coil1(float *rd,    /* Dipole position */
                      float      *Q,                /* Dipole moment */
                      FwdCoilSet* els,              /* Electrode positions */
                      float      *Vval,             /* The potential values */
                      void       *client);
 
    //=========================================================================================================
    static bool fwd_eeg_spherepot_vec (float *rd, float **el, int neeg, float **Vval_vec, void *client);
 
    //=========================================================================================================
    static int fwd_eeg_spherepot_coil_vec(float *rd, FwdCoilSet* els, float **Vval_vec, void *client);
 
    static int fwd_eeg_spherepot_grad_coil( float        *rd,      /* The dipole location */
                                            float        Q[],      /* The dipole components (xyz) */
                                            FwdCoilSet*  coils,    /* The coil definitions */
                                            float        Vval[],   /* Results */
                                            float        xgrad[],  /* The derivatives with respect to */
                                            float        ygrad[],  /* the dipole position coordinates */
                                            float        zgrad[],
                                            void         *client);
 
    //=========================================================================================================
    static int fwd_eeg_spherepot( float *rd, float *Q, float **el, int neeg, Eigen::VectorXf& Vval, void *client);
 
    //=========================================================================================================
    static int fwd_eeg_spherepot_coil(float *rd, float *Q, FwdCoilSet* els, float *Vval, void *client);
 
    //=========================================================================================================
    bool fwd_setup_eeg_sphere_model(float rad, bool fit_berg_scherg, int nfit);
 
    // fwd_fit_berg_scherg.c
 
    static void compose_linear_fitting_data(const Eigen::VectorXd& mu,fitUser u);
 
    // fwd_fit_berg_scherg.c
    /*
          * Compute the best-fitting linear parameters
          * Return the corresponding RV
          */
    static double compute_linear_parameters(const Eigen::VectorXd& mu, Eigen::VectorXd& lambda, fitUser u);
 
    // fwd_fit_berg_scherg.c
    /*
          * Evaluate the residual sum of squares fit for one set of
          * mu values
          */
    static double one_step (const Eigen::VectorXd& mu, const void *user_data);
 
    /*
          * This routine fits the Berg-Scherg equivalent spherical model
          * dipole parameters by minimizing the difference between the
          * actual and approximative series expansions
          */
    bool fwd_eeg_fit_berg_scherg(int   nterms,              /* Number of terms to use in the series expansion
                                                                                        * when fitting the parameters */
                                int   nfit,                /* Number of equivalent dipoles to fit */
                                float &rv);

    int   nlayer() const
    {
        return layers.size();
    }
 
public:
    QString                     name;   
    QList<FwdEegSphereLayer>    layers; 
    Eigen::Vector3f             r0;     
 
    Eigen::VectorXd fn;                 
    int             nterms;             
 
    Eigen::VectorXf mu;             
    Eigen::VectorXf lambda;
    int             nfit;           
    int             scale_pos;      
 
// ### OLD STRUCT ###
//    typedef struct {
//      char  *name;                /* Textual identifier */
//      int   nlayer;               /* Number of layers */
//      fwdEegSphereLayer layers;   /* An array of layers */
//      float  r0[3];               /* The origin */
 
//      double *fn;         /* Coefficients saved to speed up the computations */
//      int    nterms;      /* How many? */
 
//      float  *mu;         /* The Berg-Scherg equivalence parameters */
//      float  *lambda;
//      int    nfit;        /* How many? */
//      int    scale_pos;   /* Scale the positions to the surface of the sphere? */
//    } *fwdEegSphereModel,fwdEegSphereModelRec;
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
} // NAMESPACE FWDLIB
 
#endif // FWDEEGSPHEREMODEL_H