MuFilterHit Class Reference

#include <MuFilterHit.h>

Inheritance diagram for MuFilterHit:

Collaboration diagram for MuFilterHit:

Public Member Functions
	MuFilterHit ()
	MuFilterHit (Int_t detID)
	MuFilterHit (Int_t detID, Int_t nP, Int_t nS)
	MuFilterHit (const MuFilterHit &hit)=default
MuFilterHit &	operator= (const MuFilterHit &hit)=default
	MuFilterHit (Int_t detID, std::vector< MuFilterPoint * >)
virtual	~MuFilterHit ()
void	Print () const
Float_t	GetEnergy ()
Float_t	SumOfSignals (char *opt, Bool_t mask=kTRUE)
std::map< TString, Float_t >	SumOfSignals (Bool_t mask=kTRUE)
std::map< Int_t, Float_t >	GetAllSignals (Bool_t mask=kTRUE, Bool_t positive=kTRUE)
std::map< Int_t, Float_t >	GetAllTimes (Bool_t mask=kTRUE)
Float_t	GetDeltaT (Bool_t mask=kTRUE)
Float_t	GetFastDeltaT (Bool_t mask=kTRUE)
Float_t	GetImpactT (Bool_t mask=kTRUE)
bool	isValid () const
bool	isMasked (Int_t i) const
void	SetMasked (Int_t i)
int	GetSystem ()
int	GetPlane ()
bool	isVertical ()
bool	isShort (Int_t)
Public Member Functions inherited from SndlhcHit
	SndlhcHit ()
	SndlhcHit (Int_t detID, Int_t nSiPMs=1, Int_t nSides=0)
virtual	~SndlhcHit ()
Int_t	GetDetectorID () const
Float_t	GetSignal (Int_t nChannel=0)
Float_t	GetTime (Int_t nChannel=0)
Int_t	GetnSiPMs () const
Int_t	GetnSides () const
void	SetDigi (Float_t s, Float_t t, Int_t i=0)
void	SetDetectorID (Int_t detID)
void	SetDaqID (Int_t i, Int_t k, Int_t board_id, Int_t tofpet_id, Int_t tofpet_channel)
Int_t	GetBoardID (Int_t i)
Int_t	GetTofpetID (Int_t i)
Int_t	Getchannel (Int_t i)
Int_t	GetRawHitIndex (Int_t i=0)
virtual void	Print (const Option_t *opt="") const
virtual void	GetPosition (TVector3 L, TVector3 R) const
template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Private Member Functions
	ClassDef (MuFilterHit, 6)
	masked signal

Private Attributes
Float_t	flag
	flag
Float_t	fMasked [16]

Additional Inherited Members
Protected Member Functions inherited from SndlhcHit
	ClassDef (SndlhcHit, 2)
	encodes rawhitindex*100000+(board_id * 1000) + (tofpet_id * 100) + tofpet_channel
Protected Attributes inherited from SndlhcHit
Int_t	fDetectorID
	Detector unique identifier.
Int_t	nSiPMs
Int_t	nSides
	number of SiPMs per side
Float_t	signals [16]
	number of sides
Float_t	times [16]
	SiPM signal.
Int_t	fDaqID [16]
	SiPM time.

Detailed Description

Definition at line 10 of file MuFilterHit.h.

Constructor & Destructor Documentation

MuFilterHit() [1/5]

MuFilterHit::MuFilterHit

(

)

Default constructor

Definition at line 13 of file MuFilterHit.cxx.

  : SndlhcHit()
{
 flag = true;
 for (Int_t i=0;i<16;i++){fMasked[i]=kFALSE;}
}

MuFilterHit() [2/5]

MuFilterHit::MuFilterHit ( Int_t  detID )

explicit

Definition at line 20 of file MuFilterHit.cxx.

  : SndlhcHit(detID)
{
 flag = true;
 for (Int_t i=0;i<16;i++){fMasked[i]=kFALSE;}
}

MuFilterHit() [3/5]

MuFilterHit::MuFilterHit	(	Int_t	detID,
		Int_t	nP,
		Int_t	nS
	)

Constructor with detector id, number of SiPMs per side, number of sides

Definition at line 26 of file MuFilterHit.cxx.

  : SndlhcHit(detID,nP,nS)
{
 flag = true;
 for (Int_t i=0;i<16;i++){
      fMasked[i]=kFALSE;
      signals[i]  = -999;
      times[i]    = -999;
      fDaqID[i]  = -1;
   }
}

MuFilterHit() [4/5]

MuFilterHit::MuFilterHit ( const MuFilterHit &  hit )

default

MuFilterHit() [5/5]

MuFilterHit::MuFilterHit	(	Int_t	detID,
		std::vector< MuFilterPoint * >	V
	)

Definition at line 40 of file MuFilterHit.cxx.

  : SndlhcHit()
{
     MuFilter* MuFilterDet = dynamic_cast<MuFilter*> (gROOT->GetListOfGlobals()->FindObject("MuFilter"));
     // get parameters from the MuFilter detector for simulating the digitized information
     nSiPMs  = MuFilterDet->GetnSiPMs(detID);
     nSides = MuFilterDet->GetnSides(detID);
 
     Float_t timeResol = MuFilterDet->GetConfParF("MuFilter/timeResol");
 
     Float_t attLength=0;
     Float_t siPMcalibration=0;
     Float_t siPMcalibrationS=0;
     Float_t propspeed =0;
     if (floor(detID/10000)==3) { 
              if (nSides==2){attLength = MuFilterDet->GetConfParF("MuFilter/DsAttenuationLength");}
              else                    {attLength = MuFilterDet->GetConfParF("MuFilter/DsTAttenuationLength");}
              siPMcalibration = MuFilterDet->GetConfParF("MuFilter/DsSiPMcalibration");
              propspeed = MuFilterDet->GetConfParF("MuFilter/DsPropSpeed");
     }
     else { 
              if (floor(detID/10000)==1 && nSides==1){
                 // top readout with mirror on bottom
                 attLength = 2*MuFilterDet->GetConfParF("MuFilter/VandUpAttenuationLength");
              }
              else {attLength = MuFilterDet->GetConfParF("MuFilter/VandUpAttenuationLength");}
              siPMcalibration = MuFilterDet->GetConfParF("MuFilter/VandUpSiPMcalibration");
              siPMcalibrationS = MuFilterDet->GetConfParF("MuFilter/VandUpSiPMcalibrationS");
              propspeed = MuFilterDet->GetConfParF("MuFilter/VandUpPropSpeed");
     }
 
     for (unsigned int j=0; j<16; ++j){
        signals[j] = -1;
        times[j]    =-1;
     }
     LOG(DEBUG) << "detid "<<detID<< " size "<<nSiPMs<< "  side "<<nSides;
 
     fDetectorID  = detID;
     Float_t signalLeft    = 0;
     Float_t signalRight = 0;
     Float_t earliestToAL = 1E20;
     Float_t earliestToAR = 1E20;
     for(auto p = std::begin(V); p!= std::end(V); ++p) {
 
        Double_t signal = (*p)->GetEnergyLoss();
     
      // Find distances from MCPoint centre to ends of bar 
        TVector3 vLeft,vRight;
        TVector3 impact((*p)->GetX(),(*p)->GetY() ,(*p)->GetZ() );
        MuFilterDet->GetPosition(fDetectorID,vLeft, vRight);
        Double_t distance_Left    =  (vLeft-impact).Mag();
        Double_t distance_Right =  (vRight-impact).Mag();
        // Simple model: divide signal between nSides
        signalLeft+=signal/nSides*TMath::Exp(-distance_Left/attLength);
        signalRight+=signal/nSides*TMath::Exp(-distance_Right/attLength);
 
      // for the timing, find earliest particle and smear with time resolution
        Double_t ptime    = (*p)->GetTime();
        Double_t t_Left    = ptime + distance_Left/propspeed;
        Double_t t_Right = ptime + distance_Right/propspeed;
        if ( t_Left <earliestToAL){earliestToAL = t_Left ;}
        if ( t_Right <earliestToAR){earliestToAR = t_Right ;}
     } 
     // shortSiPM = {3,6,11,14,19,22,27,30,35,38,43,46,51,54,59,62,67,70,75,78}; - counting from 1!
     // In the SndlhcHit class the 'signals' array starts from 0.
     for (unsigned int j=0; j<nSiPMs; ++j){
        if ( floor(detID/10000)==2 && (j==2 or j==5)){                 // only US has small SiPMs
           signals[j] = signalLeft/float(nSiPMs) * siPMcalibrationS;   // most simplest model, divide signal individually. Small SiPMS special
           times[j] = gRandom->Gaus(earliestToAL, timeResol);
        }else{
           signals[j] = signalLeft/float(nSiPMs) * siPMcalibration;   // most simplest model, divide signal individually. 
           times[j] = gRandom->Gaus(earliestToAL, timeResol);
        }
        if (nSides>1){ 
            signals[j+nSiPMs] = signalRight/float(nSiPMs) * siPMcalibration;   // most simplest model, divide signal individually.
            times[j+nSiPMs] = gRandom->Gaus(earliestToAR, timeResol);
        }
     }
     flag = true;
     for (Int_t i=0;i<16;i++){fMasked[i]=kFALSE;}
     LOG(DEBUG) << "signal created";
}

~MuFilterHit()

MuFilterHit::~MuFilterHit ( )

virtual

Destructor

Definition at line 124 of file MuFilterHit.cxx.

{ }

Member Function Documentation

ClassDef()

MuFilterHit::ClassDef ( MuFilterHit  , 6    )

private

masked signal

GetAllSignals()

std::map< Int_t, Float_t > MuFilterHit::GetAllSignals	(	Bool_t	mask = kTRUE,
		Bool_t	positive = kTRUE
	)

Definition at line 153 of file MuFilterHit.cxx.

{
          std::map<Int_t,Float_t> allSignals;
          for (unsigned int s=0; s<nSides; ++s){
              for (unsigned int j=0; j<nSiPMs; ++j){
               unsigned int channel = j+s*nSiPMs;
               if (signals[channel]<-900){continue;}
               if (signals[channel]> 0 || !positive){
                 if (!fMasked[channel] || !mask){
                    allSignals[channel] = signals[channel];
                    }
                }
              }
          }
          return allSignals;
}

GetAllTimes()

std::map< Int_t, Float_t > MuFilterHit::GetAllTimes

(

Bool_t

mask = kTRUE

)

Definition at line 171 of file MuFilterHit.cxx.

{
          std::map<Int_t,Float_t> allTimes;
          for (unsigned int s=0; s<nSides; ++s){
              for (unsigned int j=0; j<nSiPMs; ++j){
               unsigned int channel = j+s*nSiPMs;
               if (signals[channel]> 0){
                 if (!fMasked[channel] || !mask){
                    allTimes[channel] = times[channel];
                    }
                }
              }
          }
          return allTimes;
}

GetDeltaT()

Float_t MuFilterHit::GetDeltaT

(

Bool_t

mask = kTRUE

)

Definition at line 188 of file MuFilterHit.cxx.

{
          Float_t mean[] = {0,0}; 
          Int_t count[] = {0,0}; 
          Float_t dT = -999.;
          for (unsigned int s=0; s<nSides; ++s){
              for (unsigned int j=0; j<nSiPMs; ++j){
               unsigned int channel = j+s*nSiPMs;
               if (signals[channel]> 0){
                 if (!fMasked[channel] || !mask){
                    mean[s] += times[channel];
                    count[s] += 1;
                    }
                }
              }
          }
          if (count[0]>0 && count[1]>0) {
                dT = mean[0]/count[0] - mean[1]/count[1];
          }
          return dT;
}

GetEnergy()

Float_t MuFilterHit::GetEnergy

(

)

Definition at line 128 of file MuFilterHit.cxx.

{
  // to be calculated from digis and calibration constants, missing!
  Float_t E = 0;
  for (unsigned int j=0; j<nSiPMs; ++j){
        E+=signals[j];
        if (nSides>1){ E+=signals[j+nSiPMs];}
  }
  return E;
}

GetFastDeltaT()

Float_t MuFilterHit::GetFastDeltaT

(

Bool_t

mask = kTRUE

)

Definition at line 210 of file MuFilterHit.cxx.

{
          Float_t first[] = {1E20,1E20}; 
          Float_t dT = -999.;
          for (unsigned int s=0; s<nSides; ++s){
              for (unsigned int j=0; j<nSiPMs; ++j){
               unsigned int channel = j+s*nSiPMs;
               if (signals[channel]> 0){
                 if (!fMasked[channel] || !mask){
                    if  (times[channel]<first[s]) {first[s] = times[channel];}
                    }
                }
              }
          }
          if (first[0]<1E10 && first[1]<1E10) {
                dT = first[0] - first[1];
          }
          return dT;
}

GetImpactT()

Float_t MuFilterHit::GetImpactT

(

Bool_t

mask = kTRUE

)

Definition at line 233 of file MuFilterHit.cxx.

{
          Float_t mean[] = {0,0}; 
          Int_t count[] = {0,0}; 
          Float_t dT = -999.;
          Float_t dL;
          MuFilter* MuFilterDet = dynamic_cast<MuFilter*> (gROOT->GetListOfGlobals()->FindObject("MuFilter"));
          if (floor(fDetectorID/10000==3)) { 
             dL = MuFilterDet->GetConfParF("MuFilterDet/DownstreamBarX") / MuFilterDet->GetConfParF("MuFilter/DsPropSpeed");}
          else if (floor(fDetectorID/10000==2)) { 
             dL = MuFilterDet->GetConfParF("MuFilterDet/UpstreamBarX") / MuFilterDet->GetConfParF("MuFilter/VandUpPropSpeed");}
          else { 
             dL = MuFilterDet->GetConfParF("MuFilterDet/VetoBarX") / MuFilterDet->GetConfParF("MuFilter/VandUpPropSpeed");}
 
          for (unsigned int s=0; s<nSides; ++s){
              for (unsigned int j=0; j<nSiPMs; ++j){
               unsigned int channel = j+s*nSiPMs;
               if (signals[channel]> 0){
                 if (!fMasked[channel] || !mask){
                    mean[s] += times[channel];
                    count[s] += 1;
                    }
                }
              }
          }
          if (count[0]>0 && count[1]>0) {
                dT = (mean[0]/count[0] + mean[1]/count[1])/2.*6.25 -  dL/2.; // TDC to ns = 6.25
          }
          return dT;
}

GetPlane()

int MuFilterHit::GetPlane ( )

inline

Definition at line 42 of file MuFilterHit.h.

{return int(fDetectorID/1000)%10;}

GetSystem()

int MuFilterHit::GetSystem ( )

inline

Definition at line 41 of file MuFilterHit.h.

{return floor(fDetectorID/10000);}

isMasked()

bool MuFilterHit::isMasked ( Int_t  i ) const

inline

Definition at line 39 of file MuFilterHit.h.

{return fMasked[i];}

isShort()

bool MuFilterHit::isShort

(

Int_t

i

)

Definition at line 147 of file MuFilterHit.cxx.

                                {
  if (i%8==2 || i%8==5) {return kTRUE;}
  else{return kFALSE;}
}

isValid()

bool MuFilterHit::isValid ( ) const

inline

Definition at line 38 of file MuFilterHit.h.

{return flag;}

isVertical()

bool MuFilterHit::isVertical

(

)

Definition at line 139 of file MuFilterHit.cxx.

                            {
  if  ( (floor(fDetectorID/10000)==3&&fDetectorID%1000>59) ||
         (floor(fDetectorID/10000)==1&&int(fDetectorID/1000)%10==2) ) {  
      return kTRUE;
  }
  else{return kFALSE;}
}

operator=()

MuFilterHit & MuFilterHit::operator= ( const MuFilterHit &  hit )

default

Print()

void MuFilterHit::Print

(

)

const

Output to screen

Definition at line 301 of file MuFilterHit.cxx.

{
  std::cout << "-I- MuFilterHit: MuFilter hit " << " in detector " << fDetectorID;
 
  if ( floor(fDetectorID/10000)==3&&fDetectorID%1000>59) {
     std::cout << " with vertical bars"<<std::endl;
     std::cout << "top digis:";
     for (unsigned int j=0; j<nSiPMs; ++j){
         std::cout << signals[j] <<" ";
     }
  }else{
     std::cout << " with horizontal bars"<<std::endl;
     for (unsigned int s=0; s<nSides; ++s){
       if (s==0) {std::cout << "left digis:";}
       else {std::cout << "right digis:";}
       for (unsigned int j=0; j<nSiPMs; ++j){
         std::cout << signals[j] <<" ";
      }
     }
 }
std::cout << std::endl;
}

SetMasked()

void MuFilterHit::SetMasked ( Int_t  i )

inline

Definition at line 40 of file MuFilterHit.h.

{fMasked[i]=kTRUE;}

SumOfSignals() [1/2]

std::map< TString, Float_t > MuFilterHit::SumOfSignals

(

Bool_t

mask = kTRUE

)

Definition at line 264 of file MuFilterHit.cxx.

{   
/*    use cases, for Veto and DS small/large ignored
        sum of signals left large SiPM:    LL
        sum of signals right large SiPM: RL
        sum of signals left small SiPM:    LS
        sum of signals right small SiPM: RS
        sum of signals left and right:  
*/
          Float_t theSumL     = 0;
          Float_t theSumR    = 0;
          Float_t theSumLS   = 0;
          Float_t theSumRS  = 0;
          for (unsigned int s=0; s<nSides; ++s){
              for (unsigned int j=0; j<nSiPMs; ++j){
               unsigned int channel = j+s*nSiPMs;
               if (signals[channel]> 0){
                 if (!fMasked[channel] || !mask){
                    if (s==0 and !isShort(j)){theSumL+= signals[channel];}
                    if (s==0 and isShort(j)){theSumLS+= signals[channel];}
                    if (s==1 and !isShort(j)){theSumR+= signals[channel];}
                    if (s==1 and isShort(j)){theSumRS+= signals[channel];}
                    }
                }
              }
          }
         std::map<TString,Float_t> sumSignals;
         sumSignals["SumL"]=theSumL;
         sumSignals["SumR"]=theSumR;
         sumSignals["SumLS"]=theSumLS;
         sumSignals["SumRS"]=theSumRS;
         sumSignals["Sum"]=theSumL+theSumR;
         sumSignals["SumS"]=theSumLS+theSumRS;
         return sumSignals;
}

SumOfSignals() [2/2]

Float_t MuFilterHit::SumOfSignals	(	char *	opt,
		Bool_t	mask = kTRUE
	)

Member Data Documentation

flag

Float_t MuFilterHit::flag

private

flag

Definition at line 47 of file MuFilterHit.h.

fMasked

Float_t MuFilterHit::fMasked[16]

private

Definition at line 48 of file MuFilterHit.h.

---

The documentation for this class was generated from the following files:

• shipLHC/MuFilterHit.h
• shipLHC/MuFilterHit.cxx