CDCGeoControlPar.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2012 - Belle II Collaboration                             *
 *                                                                                             *
 * Author: The Belle II Collaboration                                          *
 * Contributors: CDC group                                                      *
 *                                                                                              *
 * This software is provided "as is" without any warranty.         *
 **************************************************************************/
 
#ifndef CDCGEOCONTROLPAR_H
#define CDCGEOCONTROLPAR_H
 
#include <string>
 
namespace Belle2 {
  namespace CDC {
 
    class CDCGeoControlPar {
 
    public:
 
      virtual ~CDCGeoControlPar();
 
 
      static CDCGeoControlPar& getInstance();
 
      void setDebug(bool onoff)
      {
        m_debug = onoff;
      }
 
      void setPrintMaterialTable(bool onoff)
      {
        m_printMaterialTable = onoff;
      }
 
      void setMaterialDefinitionMode(int input)
      {
        m_materialDefinitionMode = input;
      }
 
      void setSenseWireZposMode(int input)
      {
        m_senseWireZposMode = input;
      }
 
      void setDisplacement(bool input)
      {
        m_displacement = input;
      }
 
      void setAlignment(bool input)
      {
        m_alignment = input;
      }
 
      void setMisalignment(bool input)
      {
        m_misalignment = input;
      }
 
      void setDisplacementInputType(bool input)
      {
        m_displacementInputType = input;
      }
 
      void setAlignmentInputType(bool input)
      {
        m_alignmentInputType = input;
      }
 
      void setMisalignmentInputType(bool input)
      {
        m_misalignmentInputType = input;
      }
 
      void setXtInputType(bool input)
      {
        m_xtInputType = input;
      }
 
      void setSigmaInputType(bool input)
      {
        m_sigmaInputType = input;
      }
 
      void setFFactorInputType(bool input)
      {
        m_fFactorInputType = input;
      }
 
      void setPropSpeedInputType(bool input)
      {
        m_propSpeedInputType = input;
      }
 
      void setT0InputType(bool input)
      {
        m_t0InputType = input;
      }
 
      void setTwInputType(bool input)
      {
        m_twInputType = input;
      }
 
      void setBwInputType(bool input)
      {
        m_bwInputType = input;
      }
 
      void setChMapInputType(bool input)
      {
        m_chMapInputType = input;
      }
 
      void setEDepToADCInputType(bool input)
      {
        m_eDepToADCInputType = input;
      }
 
      void setDisplacementFile(std::string& input)
      {
        m_displacementFile = input;
      }
 
      void setAlignmentFile(std::string& input)
      {
        m_alignmentFile = input;
      }
 
      void setMisalignmentFile(std::string& input)
      {
        m_misalignmentFile = input;
      }
 
      void setXtFile(std::string& input)
      {
        m_xtFile = input;
      }
 
      void setSigmaFile(std::string& input)
      {
        m_sigmaFile = input;
      }
 
      void setFFactorFile(std::string& input)
      {
        m_fFactorFile = input;
      }
 
      void setPropSpeedFile(std::string& input)
      {
        m_propSpeedFile = input;
      }
 
      void setT0File(std::string& input)
      {
        m_t0File = input;
      }
 
      void setTwFile(std::string& input)
      {
        m_twFile = input;
      }
 
      void setBwFile(std::string& input)
      {
        m_bwFile = input;
      }
 
      void setChMapFile(std::string& input)
      {
        m_chMapFile = input;
      }
 
      void setEDepToADCFile(std::string& input)
      {
        m_eDepToADCFile = input;
      }
 
      void setMaxSpaceResolution(double input)
      {
        m_maxSpaceResol = input;
      }
 
      void setAddFudgeFactorForSigmaForData(double input)
      {
        m_addFudgeFactorForSigmaForData = input;
      }
 
      void setAddFudgeFactorForSigmaForMC(double input)
      {
        m_addFudgeFactorForSigmaForMC = input;
      }
 
      void setMapperGeometry(bool torf)
      {
        m_mapperGeometry = torf;
      }
 
      void setMapperPhiAngle(double phi)
      {
        m_mapperPhiAngle = phi;
      }
 
 
      bool getDebug() const
      {
        return m_debug;
      }
 
      bool getPrintMaterialTable() const
      {
        return m_printMaterialTable;
      }
 
      double getMaterialDefinitionMode() const
      {
        return m_materialDefinitionMode;
      }
 
      int getSenseWireZposMode() const
      {
        return m_senseWireZposMode;
      }
 
      bool getDisplacement() const
      {
        return m_displacement;
      }
 
      bool getAlignment() const
      {
        return m_alignment;
      }
 
      bool getMisalignment() const
      {
        return m_misalignment;
      }
 
      bool getDisplacementInputType()
      {
        return m_displacementInputType;
      }
 
      bool getAlignmentInputType()
      {
        return m_alignmentInputType;
      }
 
      bool getMisalignmentInputType()
      {
        return m_misalignmentInputType;
      }
 
      bool getXtInputType()
      {
        return m_xtInputType;
      }
 
      bool getSigmaInputType()
      {
        return m_sigmaInputType;
      }
 
      bool getFFactorInputType()
      {
        return m_fFactorInputType;
      }
 
      bool getPropSpeedInputType()
      {
        return m_propSpeedInputType;
      }
 
      bool getT0InputType()
      {
        return m_t0InputType;
      }
 
      bool getTwInputType()
      {
        return m_twInputType;
      }
 
      bool getBwInputType()
      {
        return m_bwInputType;
      }
 
      bool getChMapInputType()
      {
        return m_chMapInputType;
      }
 
      bool getEDepToADCInputType()
      {
        return m_eDepToADCInputType;
      }
 
      std::string getDisplacementFile() const
      {
        return m_displacementFile;
      }
 
      std::string getAlignmentFile() const
      {
        return m_alignmentFile;
      }
 
      std::string getMisalignmentFile() const
      {
        return m_misalignmentFile;
      }
 
      std::string getXtFile() const
      {
        return m_xtFile;
      }
 
      std::string getSigmaFile() const
      {
        return m_sigmaFile;
      }
 
      std::string getFFactorFile() const
      {
        return m_fFactorFile;
      }
 
      std::string getPropSpeedFile() const
      {
        return m_propSpeedFile;
      }
 
      std::string getT0File() const
      {
        return m_t0File;
      }
 
      std::string getTwFile() const
      {
        return m_twFile;
      }
 
      std::string getBwFile() const
      {
        return m_bwFile;
      }
 
      std::string getChMapFile() const
      {
        return m_chMapFile;
      }
 
      std::string getEDepToADCFile() const
      {
        return m_eDepToADCFile;
      }
 
      double getMaxSpaceResolution()
      {
        return m_maxSpaceResol;
      }
 
      double getAddFudgeFactorForSigmaForData() const
      {
        return m_addFudgeFactorForSigmaForData;
      }
 
      double getAddFudgeFactorForSigmaForMC() const
      {
        return m_addFudgeFactorForSigmaForMC;
      }
 
      bool getMapperGeometry()
      {
        return m_mapperGeometry;
      }
 
      double getMapperPhiAngle()
      {
        return m_mapperPhiAngle;
      }
 
    private:
      CDCGeoControlPar();
      CDCGeoControlPar(const CDCGeoControlPar&);
      CDCGeoControlPar& operator=(const CDCGeoControlPar&);
 
      bool m_debug = false;                    
      bool m_printMaterialTable = false;       
      int m_materialDefinitionMode = 0;     
      int m_senseWireZposMode = 1;     
      bool m_displacement = true;  
      bool m_alignment = true;  
      bool m_misalignment = false;  
      bool m_displacementInputType = true;  
      bool m_alignmentInputType = true;  
      bool m_misalignmentInputType = true;  
      bool m_xtInputType = true;  
      bool m_sigmaInputType = true;  
      bool m_fFactorInputType = true;  
      bool m_propSpeedInputType = true;  
      bool m_t0InputType = true;  
      bool m_twInputType = true;  
      bool m_bwInputType = true;  
      bool m_chMapInputType = true;  
      bool m_eDepToADCInputType = true;  
      double m_maxSpaceResol = 2.5 * 0.0130; 
      double m_addFudgeFactorForSigmaForData = 1.; 
      double m_addFudgeFactorForSigmaForMC = 1.; 
      bool m_mapperGeometry = false;  
      double m_mapperPhiAngle = 16.7; 
      std::string m_displacementFile = "displacement_v2.2.1.dat";  
      std::string m_alignmentFile = "alignment_v2.dat";  
      std::string m_misalignmentFile = "misalignment_v2.dat";  
      std::string m_xtFile = "xt_v3_chebyshev.dat.gz";  
      std::string m_sigmaFile = "sigma_v2.dat";  
      std::string m_fFactorFile = "fFactor.dat";  
      std::string m_propSpeedFile = "propspeed_v0.dat";  
      std::string m_t0File = "t0_v1.dat";  
      std::string m_twFile = "tw_off.dat";  
      std::string m_bwFile = "badwire_v1.dat";  
      std::string m_chMapFile = "ch_map.dat";  
      std::string m_eDepToADCFile = "edeptoadc.dat";  
      static CDCGeoControlPar* m_pntr;  
    };
 
  } // end of namespace CDC
} // end of namespace Belle2
 
#endif