ModelContext.hpp

Go to the documentation of this file.

#ifndef SPATIALSEIR_INCLUDEFILES
#define SPATIALSEIR_INCLUDEFILES

#include<cstring>
#include<vector>
#endif

#ifndef MODEL_CONTEXT_INC
#define MODEL_CONTEXT_INC

#define LSS_DEGENERATE_DATA_MODEL 1
#define LSS_OVERDISPERSED_DATA_MODEL 2

#include<Eigen/Core>
namespace SpatialSEIR
{

    typedef Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> MatrixType;
    typedef Eigen::Map<MatrixType, Eigen::ColMajor> MatrixMapType;
    typedef Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic> IntMatrixType;
    typedef Eigen::Map<IntMatrixType, Eigen::ColMajor> IntMatrixMapType;

    class FullConditional;
    class IterationTask;
    class SetCompartmentSamplingIndicesTask;
    class PerformDecorrelationStep;
    class PerformHybridSE_EI_UpdateStep;
    class FC_S0;
    class FC_E0;
    class FC_I0;
    class FC_R0;
    class FC_S_Star;
    class FC_E_Star;
    class FC_R_Star;
    class FC_Beta;
    class FC_Gamma_EI;
    class FC_Gamma_IR;
    class FC_Beta_P_RS;
    class FC_Rho;
    class FC_I_Star_overdispersed;
    class FC_Phi;
    class InitData;

    class CompartmentalModelMatrix;
    class CovariateMatrix;
    class DistanceMatrix;
    class RandomNumberProvider;
    class OCLProvider;
    class IOProvider;
    struct covariateArgs;
    struct compartmentArgs;
    struct distanceArgs;
    struct scaledDistanceArgs;
    struct gammaArgs;
    struct sliceParameters;
    struct priorControl;

    struct modelConfiguration
    {
        int reinfectionMode;
        int compartmentSamplingMode; 
        int parameterSamplingMode; 
        int indexLength;
        int useDecorrelation;
        int performHybridStep;
        int dataModel;
    };



    class ModelContext
    {
        public:
            //Methods
            ModelContext();
            ~ModelContext(); 
            void populate(InitData* _A0, 
                          covariateArgs* xArgs, 
                          covariateArgs* xPrsArgs, 
                          double* offset, 
                          int* Y, 
                          compartmentArgs* S_starArgs, 
                          compartmentArgs* E_starArgs, 
                          compartmentArgs* I_starArgs, 
                          compartmentArgs* R_starArgs,
                          scaledDistanceArgs* scaledDistArgs, 
                          double* rho, 
                          double* phi, 
                          double* beta,
                          double* gamma_ei,
                          double* gamma_ir,
                          double* betaPrs,
                          int* N,
                          sliceParameters* sliceWidths, 
                          priorControl* priorInformation, 
                          modelConfiguration _config 
                              );

            /*buildModel is called at the end of the populate function to fill the ModelContext.model vector with the required 
              full conditional distributions.*/
            void buildModel();

            void configureIterationTasks();
            
            void calculateS_CPU(); 

            void calculateS_CPU(int startLoc, int startTime); 

            void calculateS_givenE_CPU(); 

            void calculateS_givenE_CPU(int startLoc, int startTime); 

            void calculateS_OCL(); 

            void calculateE_CPU(); 

            void calculateE_CPU(int startLoc, int startTime);

            void calculateE_givenI_CPU(); 

            void calculateE_givenI_CPU(int startLoc, int startTime);

            void calculateE_OCL();  

            void calculateI_CPU();

            void calculateI_CPU(int startLoc, int startTime);

            void calculateI_givenR_CPU(); 

            void calculateI_givenR_CPU(int startLoc, int startTime);

            void calculateI_OCL(); 

            void calculateR_CPU();

            void calculateR_CPU(int startLoc, int startTime);

            void calculateR_givenS_CPU();

            void calculateR_givenS_CPU(int startLoc, int startTime);

            void calculateR_OCL();

            void calculateGenericCompartment_CPU(CompartmentalModelMatrix *comp, 
                                                 int *comp0, 
                                                 CompartmentalModelMatrix *compStarAdd, 
                                                 CompartmentalModelMatrix *compStarSub 
                                                 );  

            void calculateGenericCompartment_CPU(CompartmentalModelMatrix *comp, 
                                                 int *comp0,
                                                 CompartmentalModelMatrix *compStarAdd, 
                                                 CompartmentalModelMatrix *compStarSub,
                                                 int startLoc, 
                                                 int startTime 
                                                 );

            void calculateGenericCompartment_OCL(int *comp, 
                                                 int *comp0,
                                                 int *compStarAdd, 
                                                 int *compStarSub 
                                                 );

            int checkCompartmentBounds(); 

            void printFCValues(); 

            void setRandomSeed(unsigned int seedValue); 
              
            void simulationIter(bool verbose, bool debug); 
                                                  
            void runSimulation(int nIterations,  bool verbose, bool debug);             

            void updateSamplingParameters(double desiredRatio, 
                                          double targetWidth, 
                                          double proportionChange 
                                          );

            void setCompartmentSamplingMode(int mode);

            int getCompartmentSamplingMode();

            void setParameterSamplingMode(int mode);

            int getParameterSamplingMode();





            void cacheP_SE_Calculation();

            void calculateP_SE_CPU();

            void calculateP_SE_CPU(int startLoc, int startTime);

            void calculateP_SE_OCL();

            void calculateP_EI_CPU();

            void calculateP_IR_CPU();

            void calculateP_RS_CPU();

            int totalS();
            int totalE();
            int totalI();
            int totalR();

            int totalS(int tpt);
            int totalE(int tpt);
            int totalI(int tpt);
            int totalR(int tpt);

            int totalS_star();
            int totalE_star();
            int totalI_star();
            int totalR_star();

            int totalS_star(int tpt);
            int totalE_star(int tpt);
            int totalI_star(int tpt);
            int totalR_star(int tpt);

            double avgP_SE();
            double avgP_RS();
            double avgP_SE(int tpt);

            double estimateR0();
            double* estimateR0(int t);
            double estimateEffectiveR0();
            double* estimateEffectiveR0(int t);
            double* calculateR0Components(int t);
            double* calculateEffectiveR0Components(int t);
            double* calculateG(int t);
            double* calculateIntegratedG(int t);
    



            //Logic provider and utility classes
            IOProvider *fileProvider;
            RandomNumberProvider *random;
            OCLProvider *oclProvider; 
            FC_S0 *S0_fc;
            FC_E0 *E0_fc;
            FC_I0 *I0_fc;
            FC_R0 *R0_fc;
            FC_S_Star *S_star_fc;
            FC_E_Star *E_star_fc;
            FC_R_Star *R_star_fc;
            FC_Beta *beta_fc;
            FC_Rho *rho_fc;
            FC_Beta_P_RS *betaPrs_fc;
            FC_Gamma_EI *gamma_ei_fc;
            FC_Gamma_IR *gamma_ir_fc;
            FC_I_Star_overdispersed *I_star_overdispersed_fc;
            FC_Phi *phi_fc;

            SetCompartmentSamplingIndicesTask* setSamplingIndicesTask;
            PerformHybridSE_EI_UpdateStep* performHybridSE_EI_UpdateTask;
            PerformDecorrelationStep* decorrelationStepTask;

            //Data
            int* Y;
            CompartmentalModelMatrix* S;
            CompartmentalModelMatrix* E;
            CompartmentalModelMatrix* I;
            CompartmentalModelMatrix* R;
            CompartmentalModelMatrix* S_star;
            CompartmentalModelMatrix* E_star;
            CompartmentalModelMatrix* I_star;
            CompartmentalModelMatrix* R_star;
            InitData* A0;
            CovariateMatrix* X;
            CovariateMatrix* X_pRS;
            std::vector<DistanceMatrix*>* scaledDistMatrices;
            CompartmentalModelMatrix* tmpContainer;
            modelConfiguration* config;
            std::vector<FullConditional*>* model; 
            std::vector<IterationTask*>* iterationTasks;
            double* beta;
            double* betaPrs;
            double* rho;
            double* phi;
            double* gamma;
            double* eta;
            double* offset;
            double* p_se;
            double* p_se_components;
            double* compartmentCache;
            int* indexLength;
            int* indexList;
            double* gamma_ei;
            double* p_ei;
            double* gamma_ir;
            double* p_ir;
            double* p_rs;
            int* N;
            int* isPopulated;
            int* singleLocation;
            int* numIterations;
    };
}
#endif