GENIEHelper.h

Go to the documentation of this file.

#ifndef EVGB_GENIEHELPER_H
#define EVGB_GENIEHELPER_H

#include <vector>
#include <set>

#include "TGeoManager.h"

#include "EVGDrivers/GFluxI.h"
#include "EVGDrivers/GeomAnalyzerI.h"
#include "EVGDrivers/GMCJDriver.h"

class TH1D;
class TH2D;
class TF1;
class TRandom3;
class TRotation;

namespace fhicl {
  class ParameterSet;
}

namespace ifdh_ns {
  class ifdh;
}

namespace simb {
  class MCTruth;
  class MCFlux;
  class GTruth;
}

namespace genie { class EventRecord; }

namespace evgb {

  class EvtTimeShiftI;   // for shifting time within a spill

  class GENIEHelper {

  public:

    explicit GENIEHelper(fhicl::ParameterSet const& pset,
                         TGeoManager*               rootGeom,
                         std::string         const& rootFile,
                         double              const& detectorMass);
    ~GENIEHelper();

    void                   Initialize();
    bool                   Stop();
    bool                   Sample(simb::MCTruth &truth,
                                  simb::MCFlux  &flux,
                                  simb::GTruth  &gtruth);

    double                 TotalHistFlux();
    double                 TotalExposure()    const { return fTotalExposure;  }

    // Call the following method before calling Stop, otherwise fSpillExposure
    // will be reset to 0
    double                 SpillExposure()    const { return fSpillExposure;  }
    std::string            FluxType()         const { return fFluxType;       }
    std::string            DetectorLocation() const { return fDetLocation;    }

    // methods for checking the various algorithms in GENIEHelper - please
    // do not use these in your code!!!!!
    std::vector<TH1D*>     FluxHistograms()   const { return fFluxHistograms; }
    double                 TotalMass()        const { return fDetectorMass+fSurroundingMass; }

    genie::EventRecord *  GetGenieEventRecord() { return fGenieEventRecord; }

    // access the random number generator that is supplying additional values for helper
    TRandom3*             GetHelperRandom() { return fHelperRandom; }

    // direct access to flux driver ... no ownership handover
    // base is the "real" flux driver, might be wrapped by a flavor mixer
    genie::GFluxI*        GetFluxDriver(bool base = true )
      { return ( (base) ? fFluxD : fFluxD2GMCJD ); }

  private:

    void InitializeGeometry();
    void InitializeFiducialSelection();
    void InitializeRockBoxSelection();
    void InitializeFluxDriver();
    void ConfigGeomScan();
    void SetMaxPathOutInfo();


    void PackNuMIFlux(simb::MCFlux &flux);
    void PackSimpleFlux(simb::MCFlux &flux);
    void PackMCTruth(genie::EventRecord *record, simb::MCTruth &truth);
    void PackGTruth(genie::EventRecord *record, simb::GTruth &truth);

    void BuildFluxRotation();
    void ExpandFluxPaths();
    void ExpandFluxFilePatternsDirect();
    void ExpandFluxFilePatternsIFDH();
    bool StringToBool(std::string v);

    void SetGXMLPATH();
    void SetGMSGLAYOUT();
    void StartGENIEMessenger(std::string prodmode);
    void FindEventGeneratorList();
    void ReadXSecTable();

    TGeoManager*             fGeoManager;        
    std::string              fGeoFile;           

    genie::EventRecord*      fGenieEventRecord;  
    genie::GeomAnalyzerI*    fGeomD;
    genie::GFluxI*           fFluxD;             
    genie::GFluxI*           fFluxD2GMCJD;       
    genie::GMCJDriver*       fDriver;

    // for now leave this here ... but not necessary when using IFDH_service
    ifdh_ns::ifdh*           fIFDH;              

    TRandom3*                fHelperRandom;      
    bool                     fUseHelperRndGen4GENIE;   
    evgb::EvtTimeShiftI*     fTimeShifter;       

    std::string              fFluxType;          

    std::string              fFluxSearchPaths;   
    std::vector<std::string> fFluxFilePatterns;  
    std::vector<std::string> fSelectedFluxFiles; 
    int                      fMaxFluxFileMB;     
    int                      fMaxFluxFileNumber; 
    std::string              fFluxCopyMethod;    
    std::string              fFluxCleanup;       
    std::string              fBeamName;          
    std::string              fFluxRotCfg;        
    std::vector<double>      fFluxRotValues;     
    TRotation*               fFluxRotation;      

    std::string              fTopVolume;         
    std::string              fWorldVolume;       
    std::string              fDetLocation;       
    std::vector<TH1D *>      fFluxHistograms;    

    double                   fFluxUpstreamZ;     
    double                   fEventsPerSpill;    
    double                   fPOTPerSpill;       
    double                   fHistEventsPerSpill;
    int                      fSpillEvents;       
    double                   fSpillExposure;     
    double                   fTotalExposure;     
    double                   fMonoEnergy;        
    std::string              fFunctionalFlux;
    int                      fFunctionalBinning;
    double                   fEmin;
    double                   fEmax;
    double                   fXSecMassPOT;       
    double                   fTotalHistFlux;     
    TVector3                 fBeamDirection;     
    TVector3                 fBeamCenter;        
    double                   fBeamRadius;        
    double                   fDetectorMass;      
    double                   fSurroundingMass;   
    double                   fGlobalTimeOffset;  
    double                   fRandomTimeOffset;  
    std::string              fSpillTimeConfig;   
    std::vector<int>         fGenFlavors;        
    double                   fAtmoEmin;          
    double                   fAtmoEmax;          
    double                   fAtmoRl;            
    double                   fAtmoRt;            
    std::vector<std::string> fEnvironment;       
    std::string              fXSecTable;         
    std::string              fEventGeneratorList;
    std::string              fGXMLPATH;          
    std::string              fGMSGLAYOUT;        
    std::string              fGENIEMsgThresholds;
    int                      fGHepPrintLevel;    
    std::string              fMixerConfig;       
    double                   fMixerBaseline;     
    std::string              fFiducialCut;       
    std::string              fGeomScan;          
    std::string              fMaxPathOutInfo;    
    unsigned int             fDebugFlags;        
  };
}
#endif //EVGB_GENIEHELPER_H