STOFConfig.h

Go to the documentation of this file.

#ifndef _STOF_CONFIG_H_
#define _STOF_CONFIG_H_
 
//project includes
#include "ConfigClasses.h"
#include "ConfigBuilder.h"
#include "CalibrationClasses.h"
//external inputs
#include "json.hpp"
 
class STOFConfig
{
public:
STOFConfig();
STOFConfig(const STOFConfig& a_config);
virtual STOFConfig& operator=(const STOFConfig& a_rhs);
 
void procFile(std::string a_jsonConfig);
 
bool isConstructed();
 
bool isKnown(int a_ch,
             int a_modID =0
             ) const;
bool isTarget(int a_ch,
  
              int a_modID =0
              ) const;
bool isScatter(int a_ch,
               int a_modID =0
               ) const;
bool isRF(int a_ch) const;
int getRFCh() const;
double getTCal(int a_targID,int a_scatID);
double getTarTCal(int a_targID);
const ScintConfig& getTargetConfig() const;
const ScintConfig& getScatterConfig() const;
bool canDoTiming();
bool hasOffsetCalib();
bool passesDtCut(int a_targID,
                 double a_timeDiff
                 );
void buildTarScatDistMap();
double getTargScatDistance(int a_targID,int a_scatID);
 
double getTarScintBUDistance(int a_targID);
double getRFPeriod();
double getTargetSR(int a_targID);
 
double getAvgTheta();
 
double getAvgExitFP();
 
CutBase* getTargZCut(int a_targID);
CutBase* getScatZCut(int a_scatID);
void setTargZCut(int a_targID,CutBase* a_cut);
void setScatZCut(int a_scatID,CutBase* a_cut);
//this function is a passthrough to the target timeing calibratoins
void setTime(uint32_t a_t);
void setTargetConfig(ScintConfig a_targetConfig);
void setScatterConfig(ScintConfig a_scatterConfig);
void clearScintConfigs();
//clean up internally managed memory
virtual ~STOFConfig();
protected:
double m_detHalfLength; //in m
std::map<int,double> m_targetArea;
ScintConfig m_targetConfig;
ScintConfig m_scatterConfig;
uint        m_rfChID;
std::map<std::pair<int,int>, double > m_tCalibs;
std::map<int, DetectorCalib*> m_tarTCalibs;
std::map<int, double> m_tarBUDistance; 
std::map<int, CutBase*> m_tarDTCuts;
std::map<std::pair<int,int>,double> m_tarScatDist;
std::map<int, CutBase*> m_scatZCuts;
std::map<int, CutBase*> m_targZCuts;
 
double m_RFPeriod;
bool m_isConstructed;
 
 
};
 
class STOFErrorConfig
{
public:
  STOFErrorConfig();
  void procMCConfig(std::string a_config);
 
  const ExperimentUncertaintiesConfig& getTargetUncConfig() const;
  const ExperimentUncertaintiesConfig& getScatterUncConfig() const;
 
  double getCoinTOFCalibUnc(int a_targID,
                            int a_scatID);
  double getIncTOFCalibUnc(int a_targID);
  double getIncFlightPathUnc(int a_targID);
  std::vector<double> getMatchWindow();
  double getMatchWindowUncertainty();
  double getZCutUncTarget(int a_targID);
  double getZCutUncScatter(int a_scatID);
 
private:
  ExperimentUncertaintiesConfig m_targUnc;
  ExperimentUncertaintiesConfig m_scatUnc;
   //map for storing uncertainties on incoming time calibrations
  std::map<int, double> m_incTOFCalibUnc;
  //map for storing uncertainties on coincident time calibrations
  std::map<std::pair<int,int>, double> m_coinTOFCalibUnc;
  //map for storing uncertainties on zcut 
  std::map<int, double> m_targZCutsUnc;
  std::map<int, double> m_scatZCutsUnc;
  std::map<int, double> m_tarBUDistanceUnc; 
  std::vector<double> m_matchWindow;
  double m_matchUnc;
};
 
#endif