ConfigClasses.h

Go to the documentation of this file.

#ifndef _CONFIG_CLASSES_H_
#define _CONFIG_CLASSES_H_
 
 
//project
#include "CutClasses.h"
#include "CalibrationClasses.h"
 
//c++
#include <vector>
#include <iostream>
#include <map>
//for MC of uncertainties
 #include "../external/eigen/Eigen/Dense"
//declaration to allow friend class construction
// class ExperimentConfig::rebuildMap();
 
 
enum DetType 
{ 
  HPGe,
  CloverLeaf,
  ClovComptonShield,
  Clover,
  OrgScintillator,
  MultiPMTOrgScintillator,
  InorgScintillator,
  NA
};
 
enum ParticleType
{
  NEUTRON,
  GAMMA,
  OTHER
};
class PointSourceInfo
{
public:
  //default constructor puts the class into an empty but working state
  PointSourceInfo();
  //setters
  void setIsotope(std::string a_isotope);
  void setActivity(double a_activity);
  void setEnergy(double a_energy);
  void setX(double a_x);
  void setY(double a_y);
  void setZ(double a_z);
  //getters
  std::string getIsotope() const;
  double getActivity() const;
  double getEnergy() const;
  double getX() const;
  double getY() const;
  double getZ() const;
  std::vector<double> getPosVector() const;
private:
  std::string m_isotope;
  double m_activity;
  // assumes monoenergetic, in keV
  double m_sourceEnergy;
  double m_x;
  double m_y;
  double m_z;
};
 
 
std::ostream& printDetType( std::ostream& a_stream , DetType a_type);
class DetectorInfo
{
public:
  DetectorInfo();
 
  DetType getDetType() const;
  int     getDetectorID() const;
  double  getX() const;
  double  getY() const;
  double  getZ() const;
  double  getrX() const;
  double  getrY() const;
  double  getrZ() const;
  double getDetectorLength() const;
 
  double  getDistance(double a_detHalfLength) const;
  std::vector<double> getLocation(double a_stepLenght) const;
 
  void setDetType(DetType a_detType);
  void setDetectorID(int a_detectorID);
  void setX(double  a_x);
  void setY(double  a_y);
  void setZ(double  a_z);
  virtual void translate(double  a_x,
                         double  a_y,
                         double  a_z
                        );
  void setrX( double a_rX);
  void setrY( double a_rY);
  void setrZ( double a_rZ);
 
  void setDetectorLength( double a_detLength);
  std::vector<double> getDetectorCenter();
  double getScatteringAngle(double a_bx,
                            double a_by,
                            double a_bz,
                            double a_sx,
                            double a_sy,
                            double a_sz);
 
  double getBeamScatteringAngle(double a_bx,
                                double a_by,
                                double a_bz,
                                DetectorInfo& a_rhs
                            );
 
  double getSourceScatteringAngle(double a_sx,
                                  double a_sy,
                                  double a_sz,
                                  DetectorInfo& a_rhs
                            );
  double getDistance( float a_thisDetHalfL,
                      float a_rhsHalfL, 
                      DetectorInfo& a_rhs 
                     );
  virtual std::ostream& print( std::ostream& a_stream ) const;
 
  virtual ~DetectorInfo();
protected:
  DetType m_detType;
  int     m_detectorID;
  double  m_x;
  double  m_y;
  double  m_z;
  double  m_rX;
  double  m_rY;
  double  m_rZ;
  double  m_detectorLength;
};
 
class DetectorElementInfo : public DetectorInfo
{
public:
  DetectorElementInfo();
  DetectorElementInfo(const DetectorElementInfo& a_rhs);
  virtual DetectorElementInfo& operator=(const DetectorElementInfo& a_rhs);
  int getModID() const;
  int getChannel() const;
  DetectorCalib* getGainCalib() const;
  DetectorCalib* getTimeCalib() const;
  void setModID(int a_modID);
  void setChannel(int a_channel);
  void setGainCalib(DetectorCalib* a_gainCalib);
  void setTimeCalib(DetectorCalib* a_timeCalib);
  double getPolarAngle() const;
  double getAzimuthalAngle();
  std::ostream& print( std::ostream& a_stream ) const;
 
  virtual ~DetectorElementInfo();
protected:
  int m_modID;
  int m_channel;
  DetectorCalib* m_gainCalib;
  DetectorCalib* m_timeCalib;
};
 
class OrgScintInfo : public DetectorElementInfo
{
public:
  OrgScintInfo();
  OrgScintInfo(const OrgScintInfo& a_rhs);
  OrgScintInfo& operator=(OrgScintInfo a_rhs);
  std::vector<double> getResParams();
  //this breaks encapsulation and probably needs a little thought
  CutBase* getNeutronCut() const;
  CutBase* getGammaCut() const;
  CutBase* getPSDCut() const;
  CutBase* getEnCut() const;
 
  //Get the particle type of an event with characteristics a_X and a_Y 
  enum ParticleType getParticleType(double a_X, double a_Y) const;
 
  //Check if an event with characteristic a_X, a_Y is neutron
  bool isNeutron(double a_X, double a_Y) const;
  //Check if an event with characteristic a_X, a_Y is gamma
  bool isGamma(double a_X, double a_Y) const;
  
  void setResParams(double a_EC,double a_E1,double a_E2);
  void setNeutronCut(CutBase* a_cut);
  void setGammaCut(CutBase* a_cut);
  void setPSDCut(CutBase* a_cut);
  void setEnCut(CutBase* a_cut);
 
  double getLightResolution(double a_energy) const;
  
  virtual std::ostream& print( std::ostream& a_stream ) const;
 
  virtual ~OrgScintInfo();
protected:
  //resolution terms
  double m_EC;
  double m_E1;
  double m_E2;
  //cuts
  CutBase* m_psdCut;
  CutBase* m_enCut;
  CutBase* m_neutronCut;
  CutBase* m_gammaCut;
};
 
class MultiPMTOrgScintInfo : public DetectorInfo
{
public:
  MultiPMTOrgScintInfo();
  MultiPMTOrgScintInfo(const MultiPMTOrgScintInfo& a_rhs);
  MultiPMTOrgScintInfo& operator=(MultiPMTOrgScintInfo a_rhs);
  void addPMTInfo(int          a_PMTID,
                  OrgScintInfo& a_pmtInfo
                  );
 
  bool hasPMTID(int a_ID) const;
 
  //this funtcion checks if the mod ID and channel are present in the
  //data structure
  bool hasModIDCh(int a_modID,int a_ch) const;
  int getPMTID(int a_modID,int a_ch) const;
  const OrgScintInfo& getPMTInfo(int a_ID) const;
  std::vector<int> getIDList() const;
  std::vector<int> getChList() const;
  //returns the pmt id which all additional pmt's are condisered against
  int getTimeBaseID() const;
 
  double getDtCal(int a_pmtID);
 
  void setDtCal(int a_pmtID, double a_tc);
 
 
  bool isFullSet(std::vector<int> a_chList);
 
  void setWallTime(uint32_t a_t);
  void setTimeBaseID(int a_pmtID);
  void translate(double  a_x,
                 double  a_y,
                 double  a_z
                );
  void clearOScintInfo();
  virtual std::ostream& print( std::ostream& a_stream ) const;
 
private:
  //this container maps between id'd pmts and there daq inputs calibrations etc
  std::map<int,OrgScintInfo> m_pmts;
  std::map<int,double > m_pmtOffset;
  int m_timeBaseID;
 
 
 
};
class InorgScintInfo : public DetectorElementInfo
{
public:
  InorgScintInfo();
private:
};
 
class HPGeInfo : public DetectorElementInfo
{
public:
  HPGeInfo();
private:
};
 
 
class CloverInfo : public DetectorInfo
{
public:
  CloverInfo();
  //ensures a deep copy of pointer variables
  CloverInfo(const CloverInfo& a_rhs);
  CloverInfo& operator=(const CloverInfo& a_rhs);
  void addLeafInfo(DetectorElementInfo a_leaf);
  void addBGOInfo(DetectorElementInfo a_leaf);
  
  int getLeafNumber(int a_channel) const;
  int getChFromLeaf(int a_leafNumber) const;
  int getBGONumber(int a_channel) const;
  int getChFromBGONumber(int a_BGO) const;
  const DetectorElementInfo&  getDetElInfo(int a_modID,int a_ch) const;
  const DetectorElementInfo&  getLeafInfo(int a_leafID) const;
  
  std::vector<int> getLeafIdList() const;
  int getDetID() const ;
  std::vector<int> getBGOInputs() const;
 
  const DetectorCalib* getCalibFromLeafID(int a_leafID) const;
  const DetectorCalib* getCalibFromLeafCh(int a_channel) const;
 
  const DetectorCalib* getTCalibFromLeafCh(int a_channel) const;
  const DetectorCalib* getTCalibFromLeafID(int a_leafID) const;
 
  const CutBase* getLeafTDCCut() const;
  const CutBase* getBgoTDCCut() const;
  const CutBase* getaddBackCut() const;
  
  void setLeafTDCCut(CutBase* a_cut);
  void setBgoTDCCut(CutBase* a_cut);
  void setAddBackEnCut(CutBase* a_cut);
  void setWallTime(uint32_t a_t);
  //overides base class translate to manage individual leafs
  void translate(double  a_x,
                 double  a_y,
                 double  a_z
                );
  std::vector<double> getCenterPosition();
  std::vector<double> getLeafNormalVector(int a_leaf);
  std::vector<double> getLeafPositionVector(int a_leaf);
  std::vector<int> getChannels();
  bool hasChannel(int a_ch) const ;
  bool thisClover(int a_modID, int a_ch) const;
  bool isLeaf(int a_modID, int a_ch) const;
  bool isBGO(int a_modID, int a_ch) const;
  double getLeafPolarAngle(int a_leafNumber);
  double getLeafDistance(int a_leafNumber);
  double getLeafDistToOrig(int a_leafNumber, double a_detLength) const;
  bool hasBGOChannel(int a_ch) const ;
  std::ostream& print( std::ostream& a_stream=std::cout) const;
 
  std::ostream& printRot(std::ostream & a_stream = std::cout) const;
  virtual ~CloverInfo();
private:
  std::vector<DetectorElementInfo> m_leafs;
  std::vector<DetectorElementInfo> m_BGOs;
  CutBase* m_leafTDCCut;
  CutBase* m_bgoTDCCut;
  CutBase* m_addBackEnCut; 
  std::vector<DetectorElementInfo>& getLeafVector();
  std::vector<DetectorElementInfo>& getBGOVector();
 
  //limited exposure of encapsulated data to allow the construction of and
  //functionalization of the mod id map in the Experiment config
  friend class ExperimentConfig;
 
  DetectorElementInfo m_defDetElementInfo;
};
 
class ExperimentConfig
{
public:
  ExperimentConfig();
  ExperimentConfig(const ExperimentConfig& a_config);
  ExperimentConfig& operator=(const ExperimentConfig& a_rhs);
  
  //functions used to construct the configuration
  void addOrgScints(std::vector<OrgScintInfo>     a_orgScints);
  void addInorgScints(std::vector<InorgScintInfo> a_inorgScints);
  void addHPGEs(std::vector<HPGeInfo>             a_HPGEs);
  void addClovers(std::vector<CloverInfo>         a_clovers);
  void addOrgScint(OrgScintInfo     a_orgScint);
  void addMultiPMTOrgScint(MultiPMTOrgScintInfo    a_orgScint);
  void addInorgScint(InorgScintInfo a_inorgScint);
  void addHPGE(HPGeInfo             a_HPGE);
  void addClover(CloverInfo         a_clover);
  void addDetLengths(std::map<DetType,double> a_lengthMap);
  void addSourceInfo(std::string a_id, PointSourceInfo a_source);
  void setRFOffset(DetectorCalib* a_offset);
  void setRFCalibID(int a_ID);
  void setRFPeriod(double a_RFPeriod);
  void setTDCRes(double a_TDCRes);
  void setRFFilter(bool a_doFilter);
  void setRFSubPeriod(uint16_t a_triggerPeriod);
  void translateCoordinates(double  a_x,
                             double  a_y,
                             double  a_z
                            );
  bool isKnown(int a_modID, int a_ch) const;
  bool isKnownModule(int a_modID) const;
  const DetectorElementInfo& getDetElInfo(int a_modID, int a_ch) const;
  std::ostream& printLayout( std::ostream& a_stream ) const;
 
  DetType getDetType(int a_modID, int a_ch) const;
 
  int getDetID(int a_modID, int a_ch) const;
  const CloverInfo& getCloverInfo(int a_modID, int a_ch) const;
  const CloverInfo& getCloverInfo(int a_clovID) const;
  const std::vector<CloverInfo>& getCloverInfos() const;
  const OrgScintInfo& getOrgScintInfo(int a_modID, int a_ch) const;
  const OrgScintInfo& getOrgScintInfo(int a_orgScintID) const;
 
  const MultiPMTOrgScintInfo& getMultiPMTOrgScintInfo(int a_modID,
                                                     int a_ch) const;
  const MultiPMTOrgScintInfo& getMultiPMTOrgScintInfo(int a_orgScintID) const;
 
  const InorgScintInfo getInorgScintInfo(int a_modID, int a_ch) const;
  const InorgScintInfo getInorgScintInfo(int a_inorgScintID) const;
 
  const HPGeInfo getHPGeInfo(int a_modID, int a_ch) const;
  const HPGeInfo getHPGeInfo(int a_hpgeID) const;
 
  std::vector<int> getDetIDList(DetType a_detType) const;
 
  double getRFOffset() const;
  double getRFCalibID() const;
  double getRFPeriod() const;
  double getTDCRes() const;
  bool getRFFilter() const;
  uint16_t getRFSubPeriod() const;
  double getRFModuleID();
  std::map<DetType, double> getDetectorLengths() const;
  // void readExperimentParameters(std::string a_configFileName);
 
  void setTime(uint32_t a_t);
  double detDistToOrig(DetType a_detType,int a_detID, int a_elementID=0) const;
 
  bool canDoTiming() const;
 
  bool canDoGainConversion() const;
 
  int getNumModules();
  void clearDet(DetType a_type);
  virtual ~ExperimentConfig();
protected:
  //this function rebuild the internal map used to reference mod id and ch to 
  //detector id's
  void rebuildMap();
  std::vector<OrgScintInfo>         m_orgScints;
  std::vector<MultiPMTOrgScintInfo> m_PMTOrgScints;
  std::vector<InorgScintInfo>       m_inorgScints;
  std::vector<HPGeInfo>             m_HPGEs;
  std::vector<CloverInfo>           m_clovers;
  std::map<std::string , PointSourceInfo> m_sourceInfo;
  std::map<int , std::map<int, std::pair< DetType, int > > > m_modChMap;
  std::map<DetType, double> m_detectorLengths;
  DetectorCalib* m_RFOffset;
  int m_RFCalibDetID;
  //stores the rf period in ns 
  double m_RFPeriod;
  //stores the resolution of the TDC (chan to ns)
  double m_TDCRes;
  //sets whether or not to use the rf filter in sorts
  bool m_rfFilter;
  //the observed sub-period of the rf to trigger on
  uint16_t m_rfSubPeriod;
  // std::map<uint32_t,double> m_BCMDataMap;
 
  //used for safe return of default constructed const empty references
  OrgScintInfo m_defOrgScintInfo; 
  MultiPMTOrgScintInfo m_defMultiPMTOrgScintInfo;
  InorgScintInfo m_defInorgScintInfo;
  HPGeInfo m_defHPGeInfo;
  CloverInfo m_defCloverInfo;
  DetectorElementInfo m_defDetElementInfo;
 
};
 
class ScintConfig : protected ExperimentConfig
{
public:
  ScintConfig();
  ScintConfig(const ExperimentConfig& a_obj);
  using ExperimentConfig::addOrgScint;
  using ExperimentConfig::addMultiPMTOrgScint;
  using ExperimentConfig::addInorgScint;
  using ExperimentConfig::isKnown;
  using ExperimentConfig::getDetElInfo;
  using ExperimentConfig::printLayout;
  using ExperimentConfig::getDetType;
  using ExperimentConfig::getDetID;
  using ExperimentConfig::getOrgScintInfo;
  using ExperimentConfig::getMultiPMTOrgScintInfo;
  using ExperimentConfig::getInorgScintInfo;
  using ExperimentConfig::getDetIDList;
  using ExperimentConfig::canDoTiming;
  using ExperimentConfig::canDoGainConversion;
  using ExperimentConfig::clearDet;
 
 
 
private:
};
 
class OrgScintUncertaintiesInfo
{
public:
  OrgScintUncertaintiesInfo();
  int    getDetectorID() const;
  int    getModID() const;
  int    getChannel() const;
  double getXUnc() const;
  double getYUnc() const;
  double getZUnc() const;
  double getEnCutMinUnc() const;
  double getEnCutMaxUnc() const;
 
  Eigen::VectorXd getCalibrationAndResolution() const;
  Eigen::MatrixXd getCalibResCovariance() const;
 
  void setDetectorID(int a_detectorID);
  void setModID(int a_modID);
  void setChannel(int a_channel);
  void setXUnc(double a_xUnc);
  void setYUnc(double a_yUnc);
  void setZUnc(double a_zUnc);
  void setLYParams(std::vector<double> a_lyParams);
  void setLYCovMat(std::vector<double> a_lyCovMat);
  void setEnCutMinUnc(double a_EncutUnc);
  void setEnCutMaxUnc(double a_EncutUnc);
 
  protected:
  int     m_detectorID;
  int     m_modID;
  int     m_channel;
  double  m_xUnc;
  double  m_yUnc;
  double  m_zUnc;
  double  m_EnCutMinUnc;
  double  m_EnCutMaxUnc;
 
  Eigen::VectorXd m_lyParams;
  Eigen::MatrixXd m_lyCovariances;
};  
 
class ExperimentUncertaintiesConfig
{
public:
  ExperimentUncertaintiesConfig();
  ExperimentUncertaintiesConfig(const ExperimentUncertaintiesConfig& a_config);
  
  //functions used to construct the configuration
  void addOrgScintsUnc(std::vector<OrgScintUncertaintiesInfo>  a_orgScints);
  void addOrgScintUnc(OrgScintUncertaintiesInfo     a_orgScint);
  bool isKnown(int a_modID, int a_ch) const;
  std::ostream& printLayout( std::ostream& a_stream ) const;
 
  const OrgScintUncertaintiesInfo getOrgScintUncInfo(int a_modID, int a_ch) const;
  const OrgScintUncertaintiesInfo getOrgScintUncInfo(int a_orgScintID) const;
 
protected:
  //this function rebuild the internal map used to reference mod id and ch to 
  //detector id's
  void rebuildMap();
  std::vector<OrgScintUncertaintiesInfo> m_orgScintsUnc;
 
  std::map<std::pair< int, int > ,int > m_modChMap;
 
};
 
#endif