SplineMonolith.h

Go to the documentation of this file.

#pragma once
 
#include "Splines/SplineBase.h"
 
//KS: Joy of forward declaration https://gieseanw.wordpress.com/2018/02/25/the-joys-of-forward-declarations-results-from-the-real-world/
class SMonolithGPU;
 
class SMonolith : public SplineBase {
  public:
    SMonolith(std::vector<std::vector<TResponseFunction_red*> > &MasterSpline,
              const std::vector<RespFuncType> &SplineType,
              const bool SaveFlatTree = false);
    SMonolith(const std::string& FileName);
    virtual ~SMonolith();
 
    void Evaluate() override;
 
    inline std::string GetName() const {return "SplineMonolith";};
 
    void SynchroniseMemTransfer();
 
    inline const float* retPointer(const int event) {return &cpu_total_weights[event];}
    
    inline void setSplinePointers(std::vector< const double* > spline_ParsPointers) {
      splineParsPointer = spline_ParsPointers;
      for (M3::int_t i = 0; i < nParams; ++i) SplineInfoArray[i].splineParsPointer = spline_ParsPointers[i];
    };
    
    float* cpu_weights;
    float* cpu_total_weights;
 
  private:
    inline void Initialise();
    inline void ScanMasterSpline(std::vector<std::vector<TResponseFunction_red*> > & MasterSpline,
                                 unsigned int &nEvents,
                                 short int &MaxPoints,
                                 short int &numParams,
                                 int &nSplines,
                                 unsigned int &NSplinesValid,
                                 unsigned int &numKnots,
                                 unsigned int &nTF1Valid,
                                 unsigned int &nTF1_coeff,
                                 const std::vector<RespFuncType> &SplineType);
    inline void PrepareForGPU(std::vector<std::vector<TResponseFunction_red*> > &MasterSpline, const std::vector<RespFuncType> &SplineType);
    inline void MoveToGPU();
        
    inline void PrintInitialsiation();
 
    inline void getSplineCoeff_SepMany(TSpline3_red* &spl, int &nPoints, float *&xArray, float *&manyArray);
 
    inline void CalcSplineWeights() override;
    inline void ModifyWeights() override;
    inline void ModifyWeights_GPU();
    
    inline void PrepareSplineFile();
    inline void LoadSplineFile(std::string FileName);
 
    std::vector< const double* > splineParsPointer;
 
    unsigned int NEvents;
    short int _max_knots;
    std::vector<int> index_spline_cpu;
    std::vector<int> index_TF1_cpu;
 
    unsigned int NSplines_valid;
    unsigned int NTF1_valid;
 
    unsigned int NSplines_total_large;
 
    unsigned int nKnots;
    unsigned int nTF1coeff;
 
    float *cpu_weights_spline_var;
    float *cpu_weights_tf1_var;
 
    std::vector<unsigned int> cpu_nParamPerEvent;
 
    std::vector<unsigned int> cpu_nParamPerEvent_tf1;
 
    SplineMonoStruct* cpu_spline_handler;
 
    SMonolithGPU* gpu_spline_handler;
 
    std::vector<float> cpu_coeff_TF1_many;
 
    std::vector<short int> cpu_nPoints_arr;
 
    std::vector<short int> cpu_paramNo_TF1_arr;
 
    bool SaveSplineFile;
};