THcRawAdcHit.cxx

Go to the documentation of this file.

 
// TODO: Disallow using both SetData and SetDataTimePedestalPeak.
 
 
#include "THcRawAdcHit.h"
#include "TString.h"
#include <iostream>
 
using namespace std;
 
THcRawAdcHit::THcRawAdcHit()
  : fNPedestalSamples(4)
  , fNPeakSamples(9)
  , fPeakPedestalRatio(1.0*fNPeakSamples/fNPedestalSamples)
  , fSubsampleToTimeFactor(0.0625)
  , fSampThreshold(10.)
  , fNSA(-1)
  , fNSAT(-1)
  , fNSB(-1)
  , fPed(0)
  , fSampPed(0)
  , fPulseInt()
  , fPulseAmp()
  , fPulseTime()
  , fSampPulseInt()
  , fSampPulseAmp()
  , fSampPulseTime()
  , fSample()
  , fRefTime(0)
  , fRefDiffTime(0)
  , fHasMulti(kFALSE)
  , fHasRefTime(kFALSE)
  , fNPulses(0)
  , fNSampPulses(0)
  , fNSamples(0)
{}
 
THcRawAdcHit& THcRawAdcHit::operator=(const THcRawAdcHit& right) {
  TObject::operator=(right);
 
  if (this != &right) {
    fPed = right.fPed;
    fSampPed = right.fSampPed;
    for (UInt_t i=0; i<fMaxNPulses; ++i) {
      fPulseInt[i]  = right.fPulseInt[i];
      fPulseAmp[i]  = right.fPulseAmp[i];
      fPulseTime[i] = right.fPulseTime[i];
      fSampPulseInt[i]  = right.fSampPulseInt[i];
      fSampPulseAmp[i]  = right.fSampPulseAmp[i];
      fSampPulseTime[i] = right.fSampPulseTime[i];
   }
    for (UInt_t i=0; i<fMaxNSamples; ++i) {
      fSample[i] = right.fSample[i];
    }
    fHasMulti = right.fHasMulti;
    fNPulses  = right.fNPulses;
    fNSampPulses  = right.fNSampPulses;
    fNSamples = right.fNSamples;
    fRefTime = right.fRefTime;
    fHasRefTime = right.fHasRefTime;
  }
 
  return *this;
}
 
THcRawAdcHit::~THcRawAdcHit() = default;
 
void THcRawAdcHit::Clear(Option_t* opt) {
  TObject::Clear(opt);
 
  fPed = 0;
  for (UInt_t i=0; i<fNPulses; ++i) {
    fPulseInt[i] = 0;
    fPulseAmp[i] = 0;
    fPulseTime[i] = 0;
    fSampPulseInt[i] = 0;
    fSampPulseAmp[i] = 0;
    fSampPulseTime[i] = 0;
  }
  for (UInt_t i=0; i<fNSamples; ++i) {
    fSample[i] = 0 ;
  }
  fHasMulti = kFALSE;
  fNPulses = 0;
  fNSampPulses = 0;
  fNSamples = 0;
  fRefTime = 0;
  fHasRefTime = kFALSE;
}
 
void THcRawAdcHit::SetData(Int_t data) {
  if (fNPulses >= fMaxNPulses) {
    throw std::out_of_range(
      "`THcRawAdcHit::SetData`: too many pulses!"
    );
  }
  fPulseInt[fNPulses] = data;
  ++fNPulses;
}
 
void THcRawAdcHit::SetRefTime(Int_t refTime) {
  fRefTime = refTime;
  fHasRefTime = kTRUE;
}
 
void THcRawAdcHit::SetRefDiffTime(Int_t refDiffTime) {
  fRefDiffTime = refDiffTime;
}
 
void THcRawAdcHit::SetSampThreshold(Double_t thres) {
  fSampThreshold = thres;
}
 
 
void THcRawAdcHit::SetSampNSAT(Int_t nsat) {
  fNSAT = nsat;
}
 
 
void THcRawAdcHit::SetSample(Int_t data) {
  if (fNSamples >= fMaxNSamples) {
    throw std::out_of_range(
      "`THcRawAdcHit::SetSample`: too many samples!"
    );
  }
  fSample[fNSamples] = data;
  ++fNSamples;
}
 
 
void THcRawAdcHit::SetSampIntTimePedestalPeak() {
  /*
  if ( fNPulses ==0) {
 std::cout << " in SetSampIntTimePedestalPeak " << fNPedestalSamples << " " << fNSamples<< std::endl;
  if (fNPulses>0) {
    for (UInt_t np=0;np<fNPulses;np++) {
      std::cout << " Npulse = " << np+1 << " " << fPulseInt[np] << " " << GetPulseInt(np) <<  " " << fPulseAmp[np] << " " << GetPulseAmp(np)  << " " << fPulseTime[np] << " " << GetPulseTime(np)<< std::endl;
    }
  } else {
    std::cout << " No pulses found " << std::endl;
  }
  }
  */
  fHasMulti = kTRUE;
  fSampPed = GetIntegral(0, fNPedestalSamples - 1);
  //
  Int_t NS = fNPedestalSamples - 1;
  fNSampPulses = 0;
  if( fSampThreshold == 0 ) { // just want to get the pedestal for determining FADC threshold
    fSampPulseInt[fNSampPulses] = GetIntegral(TMath::Max(NS - fNSB, 0),
                                              TMath::Min((NS + fNSA - 1), int(fNSamples - 1)));
    fNPeakSamples = TMath::Min((NS + fNSA - 1), int(fNSamples - 1)) - TMath::Max(NS - fNSB, 0) + 1;
    fPeakPedestalRatio = 1.0 * fNPeakSamples / fNPedestalSamples;
    fSampPulseAmp[fNSampPulses] = GetSampleRaw(NS);
    fSampPulseTime[fNSampPulses] = 64 * NS;
    fNSampPulses = 1;
 
  } else {
    //
    Bool_t CheckSampBelowThres = kFALSE;
     Int_t LastFourSampPed = GetIntegral(fNSamples - fNPedestalSamples, fNSamples - 1);
    if ( LastFourSampPed < fSampPed) {
           fSampPed= LastFourSampPed;
           CheckSampBelowThres = kTRUE;
    }
    while( NS < int(fNSamples) && fNSampPulses < fMaxNPulses ) {
      // GetSample(NS) Pedestal subtracted sample value (mV)
      if( CheckSampBelowThres ) { // find sample below threshold to start search
        if( GetSample(NS) < fSampThreshold ) CheckSampBelowThres = kFALSE;
      } else {
        Int_t ns_found = 0;
        for( Int_t nt = NS; nt < TMath::Min((NS + fNSAT), int(fNSamples)); nt++ ) {
          if( GetSample(nt) > fSampThreshold ) ns_found++;
        }
        if( ns_found == fNSAT ) { // NS is The TC bin
          fSampPulseInt[fNSampPulses] = GetIntegral(TMath::Max(NS - fNSB, 0),
                                                    TMath::Min((NS + fNSA - 1), int(fNSamples - 1)));
          fNPeakSamples = TMath::Min((NS + fNSA - 1), int(fNSamples - 1)) - TMath::Max(NS - fNSB, 0) + 1;
          fPeakPedestalRatio = 1.0 * fNPeakSamples / fNPedestalSamples;
          fSampPulseAmp[fNSampPulses] = 0;
          fSampPulseTime[fNSampPulses] = 0;
          Int_t PeakBin = 0;
          Double_t PeakVal = GetSample(NS);
          for( Int_t nt = NS + 1; nt < TMath::Min((NS + fNSA), int(fNSamples)); nt++ ) {
            if( GetSample(nt) < PeakVal && PeakBin == 0 ) {
              PeakBin = nt - 1;
            } else if( PeakBin == 0 ) {
              PeakVal = GetSample(nt);
            }
          }
          if( PeakBin > 0 ) {
            fSampPulseAmp[fNSampPulses] = GetSampleRaw(PeakBin);
            Int_t Time = NS * 64; // Raw time in ADC bin number * 64 = "subsamples"
            Double_t VMid = (GetSample(PeakBin)) / 2.;
            for( Int_t nt = TMath::Max(NS - fNSB, 0); nt < TMath::Min(PeakBin, int(fNSamples - 1)); nt++ ) {
              if( VMid >= GetSample(nt) && VMid < GetSample(nt + 1) ) {
                Time = 64 * nt + int(64 * (VMid - GetSample(nt)) /
                                     (GetSample(nt + 1) - GetSample(nt)));
              }
            }
            fSampPulseTime[fNSampPulses] = Time;
          } else {
            fSampPulseAmp[fNSampPulses] = GetSampleRaw(NS);
            fSampPulseTime[fNSampPulses] = 64 * NS;
          }
          //      if (fNPulses ==0)       std::cout << " NsampPulse = " << fNSampPulses+1 << " " << fSampPulseInt[fNSampPulses] << " " << GetSampPulseInt(fNSampPulses) << " npeak = " <<PeakBin << " " << fSampPulseAmp[fNSampPulses] << " " << GetSampPulseAmp(fNSampPulses) << " " << fSampPulseTime[fNSampPulses]<< " " << GetSampPulseTime(fNSampPulses) << " Vmid = " << VMid  << " TC = " << NS << " TC+NSA-1 ="  << NS+fNSA << std::endl;
          fNSampPulses++;
          NS = NS + fNSA;
          CheckSampBelowThres = kTRUE;
        }
      }
      NS++;
    }
  } // match else
  /*
  if ( fNSampPulses==0 && fNPulses==0) {
     std::cout << " No sample pulses found" << std::endl;
     for (Int_t nt=0;nt<fNSamples;nt++) {
       cout << GetSample(nt) << " " ;
       if (nt%10 ==0 && nt !=0) cout << endl;
        }
     cout << endl;
  }
  */
}
//
void THcRawAdcHit::SetDataTimePedestalPeak( Int_t data, Int_t time,
                                            Int_t pedestal, Int_t peak ) {
  if( fNPulses >= fMaxNPulses ) {
    throw std::out_of_range(
      "`THcRawAdcHit::SetDataTimePedestalPeak`: too many pulses!"
    );
  }
  fPulseInt[fNPulses] = data;
  fPulseTime[fNPulses] = time;
  fPed = pedestal;
  fPulseAmp[fNPulses] = peak;
  fHasMulti = kTRUE;
  ++fNPulses;
}
 
void THcRawAdcHit::SetF250Params( Int_t NSA, Int_t NSB, Int_t NPED ) {
  if( NSA < 0 || NSB < 0 || NPED < 0 ) {
    TString msg = TString::Format(
      "`THcRawAdcHit::SetF250Params`: One of the params is negative!  NSA = %d  NSB = %d  NPED = %d",
      NSA, NSB, NPED
    );
    throw std::invalid_argument(msg.Data());
  }
  fNPedestalSamples = NPED;
  fNPeakSamples = NSA + NSB;
  fPeakPedestalRatio = 1.0 * fNPeakSamples / fNPedestalSamples;
  fNSA = NSA;
  fNSB = NSB;
  fNSAT = 2;
}
 
void THcRawAdcHit::throw_bad_index( const char* loc, UInt_t i, UInt_t N )
{
  throw std::out_of_range(Form("%s: Bad index %u %u", loc, i, N));
}
 
void THcRawAdcHit::throw_bad_range( const char* loc, UInt_t lo, UInt_t hi,
                                    UInt_t N )
{
  throw std::out_of_range(Form("%s: bad range %u %u %u", loc, lo, hi, N));
 
}
 
ClassImp(THcRawAdcHit)