mne_cov_matrix.h

Go to the documentation of this file.

//=============================================================================================================
#ifndef MNECOVMATRIX_H
#define MNECOVMATRIX_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "../mne_global.h"
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QSharedPointer>
#include <QStringList>
 
/*
 * The class field in mneCovMatrix can have these values
 */
#define MNE_COV_CH_UNKNOWN  -1  /* No idea */
#define MNE_COV_CH_MEG_MAG   0  /* Axial gradiometer or magnetometer [T] */
#define MNE_COV_CH_MEG_GRAD  1  /* Planar gradiometer [T/m] */
#define MNE_COV_CH_EEG       2  /* EEG [V] */
 
//=============================================================================================================
// FORWARD DECLARATIONS
//=============================================================================================================
 
namespace FIFFLIB
{
    class FiffSparseMatrix;
}
 
//=============================================================================================================
// DEFINE NAMESPACE MNELIB
//=============================================================================================================
 
namespace MNELIB
{
 
//=============================================================================================================
// MNELIB FORWARD DECLARATIONS
//=============================================================================================================
 
class MneProjOp;
class MneSssData;
 
//=============================================================================================================
class MNESHARED_EXPORT MneCovMatrix
{
public:
    typedef QSharedPointer<MneCovMatrix> SPtr;              
    typedef QSharedPointer<const MneCovMatrix> ConstSPtr;   
    //=========================================================================================================
    MneCovMatrix(int p_kind, int p_ncov, const QStringList& p_names, double *p_cov, double *p_cov_diag, FIFFLIB::FiffSparseMatrix* p_cov_sparse);
 
    //=========================================================================================================
    ~MneCovMatrix();
 
    static MneCovMatrix* mne_dup_cov(MneCovMatrix* c);
 
    static MneCovMatrix* mne_new_cov_dense(int    kind,
                                   int    ncov,
                                   const QStringList& names,
                                   double *cov)
    {
        return new MneCovMatrix(kind,ncov,names,cov,NULL,NULL);
    }
 
    static MneCovMatrix* mne_new_cov_diag(int    kind,
                                  int    ncov,
                                  const QStringList& names,
                                  double *cov_diag)
    {
        return new MneCovMatrix(kind,ncov,names,NULL,cov_diag,NULL);
    }
 
    static MneCovMatrix* mne_new_cov_sparse(    int kind,
                                                int ncov,
                                                const QStringList& names,
                                                FIFFLIB::FiffSparseMatrix* cov_sparse)
    {
        return new MneCovMatrix(kind,ncov,names,NULL,NULL,cov_sparse);
    }
 
    static MneCovMatrix* mne_new_cov(   int kind,
                                        int ncov,
                                        const QStringList& names,
                                        double      *cov,
                                        double *cov_diag)
    {
        return new MneCovMatrix(kind,ncov,names,cov,cov_diag,NULL);
    }
 
    static int mne_is_diag_cov(MneCovMatrix* c);
 
    static int mne_add_inv_cov(MneCovMatrix* c);
 
    static int condition_cov(MneCovMatrix* c, float rank_threshold, int use_rank);
 
    static int mne_decompose_eigen_cov_small(MneCovMatrix* c,float p_small, int use_rank);
 
    static int mne_decompose_eigen_cov(MneCovMatrix* c);
 
private:
 
    static int mne_lt_packed_index(int j, int k);
 
public:
    int         kind;                           /* Sensor or source covariance */
    int         ncov;                           /* Dimension */
    int         nfree;                          /* Number of degrees of freedom */
    int         nproj;                          /* Number of dimensions projected out */
    int         nzero;                          /* Number of zero or small eigenvalues */
    QStringList names;                          /* Names of the entries (optional) */
    double      *cov;                           /* Covariance matrix in packed representation (lower triangle) */
    double      *cov_diag;                      /* Diagonal covariance matrix */
    FIFFLIB::FiffSparseMatrix* cov_sparse;   /* A sparse covariance matrix (Note: data are floats in this which is an inconsistency) */
    double      *lambda;                /* Eigenvalues of cov */
    double      *inv_lambda;            /* Inverses of the square roots of the eigenvalues of cov */
    float       **eigen;                /* Eigenvectors of cov */
    double      *chol;                  /* Cholesky decomposition */
    MneProjOp*  proj;       /* The projection which was active when this matrix was computed */
    MneSssData* sss;        /* The SSS data present in the associated raw data file */
    int         *ch_class;              /* This will allow grouping of channels for regularization (MEG [T/m], MEG [T], EEG [V] */
    QStringList bads;                   /* Which channels were designated bad when this noise covariance matrix was computed? */
    int         nbad;                   /* How many of them */
 
// ### OLD STRUCT ###
//typedef struct {                                /* Covariance matrix storage */
//    int         kind;                           /* Sensor or source covariance */
//    int         ncov;                           /* Dimension */
//    int         nfree;                          /* Number of degrees of freedom */
//    int         nproj;                          /* Number of dimensions projected out */
//    int         nzero;                          /* Number of zero or small eigenvalues */
//    char        **names;                        /* Names of the entries (optional) */
//    double      *cov;                           /* Covariance matrix in packed representation (lower triangle) */
//    double      *cov_diag;                      /* Diagonal covariance matrix */
//    MNELIB::FiffSparseMatrix* cov_sparse;   /* A sparse covariance matrix (Note: data are floats in this which is an inconsistency) */
//    double      *lambda;                /* Eigenvalues of cov */
//    double      *inv_lambda;            /* Inverses of the square roots of the eigenvalues of cov */
//    float       **eigen;                /* Eigenvectors of cov */
//    double      *chol;                  /* Cholesky decomposition */
//    MNELIB::MneProjOp*  proj;       /* The projection which was active when this matrix was computed */
//    MNELIB::MneSssData* sss;        /* The SSS data present in the associated raw data file */
//    int         *ch_class;              /* This will allow grouping of channels for regularization (MEG [T/m], MEG [T], EEG [V] */
//    char        **bads;                 /* Which channels were designated bad when this noise covariance matrix was computed? */
//    int         nbad;                   /* How many of them */
//} *mneCovMatrix,mneCovMatrixRec;
};
 
//=============================================================================================================
// INLINE DEFINITIONS
//=============================================================================================================
} // NAMESPACE MNELIB
 
#endif // MNECOVMATRIX_H