Helpers.h

Go to the documentation of this file.

#ifndef HELPERS_H
#define HELPERS_H

#include <fstream>
#include <string>
#include <map>
#include <cmath>

#include "Rtypes.h"
#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexStripEndId.h"
#include "CandDigit/CandDigitHandle.h"
#include "RawData/RawChannelId.h"
#include "REROOT_Classes/REROOT_FLSDigit.h"


class NavKey;

namespace CalHelpers
{
     Int_t GetPlane(const CandDigitHandle&);
     Int_t GetBestStrip(const CandDigitHandle&);
     Int_t GetBestEnd(const CandDigitHandle&);
     float ComputeSine(float p1, float s1, float p2, float s2,
                       float scale_p= 5.8, float scale_s = 4.1);
     NavKey KeyFromPlane(const CandDigitHandle* cdh);
     NavKey KeyFromStrip(const CandDigitHandle* cdh);
     NavKey KeyFromEnd(const CandDigitHandle* cdh);
     NavKey KeyFromTime(const CandDigitHandle* cdh);
     NavKey KeyFromCrate(const CandDigitHandle* cdh);
     NavKey KeyFromVarc(const CandDigitHandle* cdh);
     NavKey KeyFromDigitTime(const CandDigitHandle* cdh);

     class MCDigit{       
     public:
       MCDigit();
       MCDigit(const PlexStripEndId pse, REROOT_FLSDigit flsdig);
       MCDigit(const MCDigit &mcd);
       ~MCDigit();

       //Functions to get MC data members as defined in 
       //REROOT_Classes/REROOT_FLSDigit, this class allows us to
       //read in the info for each end(instead of by plane/strip combo)
       const int GetMCPlane() const;
       const int GetMCExtr() const;
       const int GetMCCell() const;
       const float GetMCTPos() const;
       const float GetMCRAWPE() const;
       const float GetMCCorrPE() const;
       const float GetMCTDC() const;
       const int GetMCTubePixel() const;
       const float GetMCSignalPE() const;
       const float GetMCInitialTDC() const;
       const float GetMCAveDistTrue() const;
       const int GetMCHitBits() const;
       const int GetMCCellPos() const; 
       const int GetMCPlanePos() const;
          const float GetMCSumETrue() const;
     private:
       int fMCPlane;
       int fMCExtr;
       int fMCCell;
       float fMCTPos;
       float fMCRAWPE;
       float fMCCorrPE;
       float fMCTDC;
       int fMCTubePixel;
       float fMCSignalPE;
       float fMCInitialTDC;
       float fMCAveDistTrue;
       int fMCHitBits;
       int fMCCellPos;
       int fMCPlanePos;
          float fMCSumETrue;
     };

     class MCDigitMap{
     public:
       MCDigitMap();
       ~MCDigitMap();
       
       void MakeMCDigitMap();
       std::map<const PlexStripEndId, MCDigit> *GetMCDigitMap();

     private:
       std::map<const PlexStripEndId, MCDigit> fMCDigitMap;
     };

 
inline const int MCDigit::GetMCPlane() const {return fMCPlane;}
inline const int MCDigit::GetMCExtr() const {return fMCExtr;}
inline const int MCDigit::GetMCCell() const {return fMCCell;}
inline const float MCDigit::GetMCTPos() const {return fMCTPos;}
inline const float MCDigit::GetMCRAWPE() const {return fMCRAWPE;}
inline const float MCDigit::GetMCCorrPE() const {return fMCCorrPE;}
inline const float MCDigit::GetMCTDC() const {return fMCTDC;}
inline const int MCDigit::GetMCTubePixel() const {return fMCTubePixel;}
inline const float MCDigit::GetMCSignalPE() const {return fMCSignalPE;}
inline const float MCDigit::GetMCInitialTDC() const {return fMCInitialTDC;}
inline const float MCDigit::GetMCAveDistTrue() const {return fMCAveDistTrue;}
inline const int MCDigit::GetMCHitBits() const {return fMCHitBits;}
inline const int MCDigit::GetMCCellPos() const {return fMCCellPos;} 
inline const int MCDigit::GetMCPlanePos() const {return fMCPlanePos;}

// danger-- this is the total energy in the strip not the end!
inline const float MCDigit::GetMCSumETrue() const {return fMCSumETrue;}

inline std::map<const PlexStripEndId, MCDigit> *MCDigitMap::GetMCDigitMap()
{return &fMCDigitMap;}

     
}

inline Int_t CalHelpers::GetPlane(const CandDigitHandle& cdh)
{
     return cdh.GetPlexSEIdAltL().GetPlane();
}

inline Int_t CalHelpers::GetBestStrip(const CandDigitHandle& cdh)
{
     return cdh.GetPlexSEIdAltL().GetBestSEId().GetStrip();
}

inline Int_t CalHelpers::GetBestEnd(const CandDigitHandle& cdh)
{
     return cdh.GetPlexSEIdAltL().GetBestSEId().GetEnd();
}

inline float CalHelpers::ComputeSine(float p1, float s1, float p2, float s2,
                                       float scale_p, float scale_s)
{
     float s= (s2-s1)*scale_s;
     float p= (p2-p1)*scale_p;
     return s/sqrt(s*s + p*p);
}

namespace CalDetConstants
{

  static const UShort_t PLANECONST=60;
  static const UShort_t STRIPCONST=24;
  static const Float_t PLANEWIDTH=5.90;
  static const Float_t STRIPWIDTH=4.10;
  static const UShort_t KOVCONST=3;
  static const UShort_t TOFCONST=3;
  static const Float_t FARTIMECONVERT=1.5625;

  //soon to be depricated, get special channel info from db
//see CalDetSI/AlgCalDetSI.cxx for example
  static const RawChannelId kCerenkovChannel1(Detector::kCalDet,
                                              ElecType::kVA,
                                              0, 1, 5, 1, 2, 16);
  static const RawChannelId kCerenkovChannel2(Detector::kCalDet,
                                              ElecType::kVA,
                                              0, 2, 5, 1, 2, 16);
  static const RawChannelId kCerenkovChannel3(Detector::kCalDet,
                                              ElecType::kVA,
                                              0, 1, 5, 1, 1, 16);
  static const RawChannelId kTriggerPMTChannel(Detector::kCalDet,
                                              ElecType::kVA,
                                              0, 2, 5, 0, 1,  4);
  static const RawChannelId kTofADCChannel0(Detector::kCalDet,
                                              ElecType::kVA,
                                              0, 2, 5, 1, 0, 16);
  static const RawChannelId kTofADCChannel1(Detector::kCalDet,
                                              ElecType::kVA,
                                              0, 2, 5, 1, 1, 16);
  static const RawChannelId kTofADCChannel2(Detector::kCalDet,
                                              ElecType::kVA,
                                              0, 2, 5, 1, 2, 16);
  static const RawChannelId kTofTimeStampChannel(Detector::kCalDet,
                                              ElecType::kVA,
                                              0, 2, 6, 0, 0,  2);


}

#endif //HELPERS_H

---