PulseShapeFitOOTPileupCorrection Class Reference

#include <PulseShapeFitOOTPileupCorrection.h>

Public Member Functions
void	apply (const CaloSamples &cs, const std::vector< int > &capidvec, const HcalCalibrations &calibs, double &reconstructedEnergy, float &reconstructedTime, bool &useTriple, float &chi2) const
void	phase1Apply (const HBHEChannelInfo &channelData, float &reconstructedEnergy, float &reconstructedTime, bool &useTriple, float &chi2) const
	PulseShapeFitOOTPileupCorrection ()
void	resetPulseShapeTemplate (const HcalPulseShapes::Shape &ps)
void	setChi2Term (bool isHPD)
void	setPulseShapeTemplate (const HcalPulseShapes::Shape &ps, bool isHPD)
void	setPUParams (bool iPedestalConstraint, bool iTimeConstraint, bool iAddPulseJitter, bool iApplyTimeSlew, double iTS4Min, const std::vector< double > &iTS4Max, double iPulseJitter, double iTimeMean, double iTimeSigHPD, double iTimeSigSiPM, double iPedMean, double iPedSigHPD, double iPedSigSiPM, double iNoiseHPD, double iNoiseSiPM, double iTMin, double iTMax, const std::vector< double > &its4Chi2, HcalTimeSlew::BiasSetting slewFlavor, int iFitTimes, bool iDCConstraint=false)
	~PulseShapeFitOOTPileupCorrection ()

Public Attributes
const HcalPulseShapes::Shape *	currentPulseShape_ =nullptr

Private Member Functions
void	fit (int iFit, float &timevalfit, float &chargevalfit, float &pedvalfit, float &chi2, bool &fitStatus, double &iTSMax, const double &iTSTOTen, double *iEnArr, int(&iBX)[3]) const
int	pulseShapeFit (const double *energyArr, const double *pedenArr, const double *chargeArr, const double *pedArr, const double *gainArr, const double tsTOTen, std::vector< float > &fitParsVec, const double *ADCnoise) const

Private Attributes
bool	addPulseJitter_
bool	applyTimeSlew_
double	chargeThreshold_
int	cntsetPulseShape
bool	dcConstraint_
std::unique_ptr< ROOT::Math::Functor >	dpfunctor_
int	fitTimes_
PSFitter::HybridMinimizer *	hybridfitter
std::array< double, HcalConst::maxSamples >	iniTimesArr
bool	isCurrentChannelHPD_
double	noise_
double	noiseHPD_
double	noiseSiPM_
bool	pedestalConstraint_
double	pedMean_
double	pedSig_
double	pedSigHPD_
double	pedSigSiPM_
std::unique_ptr< FitterFuncs::PulseShapeFunctor >	psfPtr_
double	pulseJitter_
HcalTimeSlew::BiasSetting	slewFlavor_
std::unique_ptr< ROOT::Math::Functor >	spfunctor_
bool	timeConstraint_
double	timeMean_
double	timeSig_
double	timeSigHPD_
double	timeSigSiPM_
std::unique_ptr< ROOT::Math::Functor >	tpfunctor_
double	ts4Chi2_
double	ts4Max_
double	ts4Min_
int	TSMax_
int	TSMin_
bool	unConstrainedFit_
std::vector< double >	vts4Chi2_
std::vector< double >	vts4Max_

Detailed Description

Definition at line 91 of file PulseShapeFitOOTPileupCorrection.h.

Constructor & Destructor Documentation

PulseShapeFitOOTPileupCorrection::PulseShapeFitOOTPileupCorrection

(

)

Definition at line 210 of file PulseShapeFitOOTPileupCorrection.cc.

References hybridfitter, iniTimesArr, and PSFitter::HybridMinimizer::kMigrad.

                                                                   : cntsetPulseShape(0),
                                       psfPtr_(nullptr), spfunctor_(nullptr), dpfunctor_(nullptr), tpfunctor_(nullptr),
                                       TSMin_(0), TSMax_(0), vts4Chi2_(0), pedestalConstraint_(false),
                                       timeConstraint_(false), addPulseJitter_(false), applyTimeSlew_(false),
                                       ts4Min_(0), vts4Max_(0), pulseJitter_(0), timeMean_(0), timeSig_(0), pedMean_(0), pedSig_(0),
                                       noise_(0), dcConstraint_(false) {
   hybridfitter = new PSFitter::HybridMinimizer(PSFitter::HybridMinimizer::kMigrad);
   iniTimesArr = { {-100,-75,-50,-25,0,25,50,75,100,125} };
}

PulseShapeFitOOTPileupCorrection::~PulseShapeFitOOTPileupCorrection

(

)

Definition at line 220 of file PulseShapeFitOOTPileupCorrection.cc.

References hybridfitter.

                                                                    { 
   if(hybridfitter) delete hybridfitter;
}

Member Function Documentation

void PulseShapeFitOOTPileupCorrection::apply	(	const CaloSamples &	cs,
		const std::vector< int > &	capidvec,
		const HcalCalibrations &	calibs,
		double &	reconstructedEnergy,
		float &	reconstructedTime,
		bool &	useTriple,
		float &	chi2
	)		const

Definition at line 299 of file PulseShapeFitOOTPileupCorrection.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, muonCSCDigis_cfi::gain, HcalConst::maxSamples, noise_, HcalCalibrations::pedestal(), psfPtr_, pulseShapeFit(), HcalCalibrations::respcorrgain(), CaloSamples::size(), mathSSE::sqrt(), ts4Chi2_, ts4Max_, ts4Min_, vts4Chi2_, and vts4Max_.

Referenced by heavyIonTools.ConfigureHeavyIons::__call__(), editorTools.UserCodeTool::__call__(), HiCoreTools.RestrictInputToAOD::__call__(), coreTools.RunOnData::__call__(), trackTools.MakeAODTrackCandidates::__call__(), runJetUncertainties.RunJetUncertainties::__call__(), metTools.AddMETCollection::__call__(), heavyIonTools.ProductionDefaults::__call__(), editorTools.ChangeSource::__call__(), HiCoreTools.RemoveMCMatching::__call__(), coreTools.RemoveMCMatching::__call__(), trackTools.MakePATTrackCandidates::__call__(), trigTools.SwitchOnTrigger::__call__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties::__call__(), heavyIonTools.SelectionDefaults::__call__(), HiCoreTools.RemoveAllPATObjectsBut::__call__(), heavyIonTools.DisbaleMonteCarloDeps::__call__(), HiCoreTools.RemoveSpecificPATObjects::__call__(), trigTools.SwitchOnTriggerStandAlone::__call__(), trackTools.MakeTrackCandidates::__call__(), tauTools.AddTauCollection::__call__(), trigTools.SwitchOnTriggerMatching::__call__(), HiCoreTools.RemoveCleaning::__call__(), HiCoreTools.AddCleaning::__call__(), trigTools.SwitchOnTriggerMatchingStandAlone::__call__(), trigTools.SwitchOnTriggerMatchEmbedding::__call__(), jetTools.AddJetCollection::__call__(), jetTools.SwitchJetCollection::__call__(), jetTools.UpdateJetCollection::__call__(), jetTools.AddJetID::__call__(), jetTools.SetTagInfos::__call__(), HcalSimpleRecAlgoImpl::reco(), and HcalSimpleRecAlgoImpl::recoHBHE().

{
   psfPtr_->setDefaultcntNANinfit();

   const unsigned int cssize = cs.size();
// initialize arrays to be zero
   double chargeArr[HcalConst::maxSamples]={}, pedArr[HcalConst::maxSamples]={}, gainArr[HcalConst::maxSamples]={};
   double energyArr[HcalConst::maxSamples]={}, pedenArr[HcalConst::maxSamples]={};
   double noiseADCArr[HcalConst::maxSamples]={};
   double noisePHArr[HcalConst::maxSamples]={};
   double noiseArrSq[HcalConst::maxSamples]={};

   double tsTOT = 0, tstrig = 0; // in fC
   double tsTOTen = 0; // in GeV
   for(unsigned int ip=0; ip<cssize; ++ip){
      if( ip >= (unsigned) HcalConst::maxSamples ) continue; // Too many samples than what we wanna fit (10 is enough...) -> skip them
      const int capid = capidvec[ip];
      double charge = cs[ip];
      double ped = calibs.pedestal(capid);
      double gain = calibs.respcorrgain(capid);

      double energy = charge*gain;
      double peden = ped*gain;

      chargeArr[ip] = charge; pedArr[ip] = ped; gainArr[ip] = gain;
      energyArr[ip] = energy; pedenArr[ip] = peden;

      // HPD fcByPE from
      // https://github.com/cms-sw/cmssw/blob/CMSSW_8_1_0/SimCalorimetry/HcalSimProducers/python/hcalSimParameters_cfi.py#L62
      if((charge-ped)>noise_) {
    noisePHArr[ip] = sqrt((charge-ped)*0.3305); // Add photostatistics uncertainty
      }

      noiseADCArr[ip] = psfPtr_->sigmaHPDQIE8(chargeArr[ip]); // Add Greg's channel discretization
      noiseArrSq[ip] = noise_ * noise_ + noiseADCArr[ip] * noiseADCArr[ip] + noisePHArr[ip] * noisePHArr[ip];

      tsTOT += charge - ped;
      tsTOTen += energy - peden;
      if( ip ==4 || ip==5 ){
         tstrig += charge - ped;
      }
   }

   ts4Max_=vts4Max_[0]; //  HB and HE are identical for Run2
   ts4Chi2_=vts4Chi2_[0]; //  HB and HE are identical for Run2

   std::vector<float> fitParsVec;

   if(tstrig >= ts4Min_&& tsTOTen > 0.) { //Two sigma from 0
     pulseShapeFit(energyArr, pedenArr, chargeArr, pedArr, gainArr, tsTOTen, fitParsVec, noiseArrSq);
   } else {
     fitParsVec.clear();
     fitParsVec.push_back(0.); //charge
     fitParsVec.push_back(-9999); // time
     fitParsVec.push_back(0.); // ped
     fitParsVec.push_back(-9999); // chi2
     fitParsVec.push_back(false); // triple
   }

   reconstructedEnergy=fitParsVec[0];
   reconstructedTime=fitParsVec[1];
   chi2 = fitParsVec[3];
   useTriple=fitParsVec[4];

}

void PulseShapeFitOOTPileupCorrection::fit ( int  iFit, float &  timevalfit, float &  chargevalfit, float &  pedvalfit, float &  chi2, bool &  fitStatus, double &  iTSMax, const double &  iTSTOTen, double *  iEnArr, int(&)  iBX[3]  ) const

private

Definition at line 437 of file PulseShapeFitOOTPileupCorrection.cc.

References funct::abs(), PSFitter::HybridMinimizer::Clear(), dpfunctor_, fitTimes_, hybridfitter, mps_fire::i, iniTimesArr, createfilelist::int, PSFitter::HybridMinimizer::kMigrad, PSFitter::HybridMinimizer::kScan, PSFitter::HybridMinimizer::Minimize(), PSFitter::HybridMinimizer::MinValue(), gen::n, pedMean_, pedSig_, mps_update::results, PSFitter::HybridMinimizer::SetFixedVariable(), PSFitter::HybridMinimizer::SetFunction(), PSFitter::HybridMinimizer::SetLimitedVariable(), PSFitter::HybridMinimizer::SetMinimizerType(), spfunctor_, timeMean_, timeSig_, tpfunctor_, TSMax_, TSMin_, varNames, and PSFitter::HybridMinimizer::X().

Referenced by trackingPlots.Iteration::modules(), and pulseShapeFit().

                                                                                                                                                                                                               { 
  int n = 3;
  if(iFit == 2) n = 5; //Two   Pulse Fit 
  if(iFit == 3) n = 7; //Three Pulse Fit 
  //Step 1 Single Pulse fit
   float pedMax =  iTSMax;   //=> max timeslice
   float tMin   =  TSMin_;   //Fitting Time Min
   float tMax   =  TSMax_;   //Fitting Time Max
   //Checks to make sure fitting happens
   if(pedMax   < 1.) pedMax = 1.;
   // Set starting values andf step sizes for parameters
   double vstart[n];
   for(int i = 0; i < int((n-1)/2); i++) { 
     vstart[2*i+0] = iniTimesArr[iBX[i]]+timeMean_;
     vstart[2*i+1] = iEnArr[iBX[i]];
   }
   vstart[n-1] = pedMean_;

   double step[n];
   for(int i = 0; i < n; i++) step[i] = 0.1;
      
   if(iFit == 1) hybridfitter->SetFunction(*spfunctor_);
   if(iFit == 2) hybridfitter->SetFunction(*dpfunctor_);
   if(iFit == 3) hybridfitter->SetFunction(*tpfunctor_);
   hybridfitter->Clear();
   //Times and amplitudes
   for(int i = 0; i < int((n-1)/2); i++) {
     hybridfitter->SetLimitedVariable(0+i*2, varNames[2*i+0]  , vstart[0+i*2],   step[0+i*2],iniTimesArr[iBX[i]]+tMin, iniTimesArr[ iBX[i] ]+tMax);
     hybridfitter->SetLimitedVariable(1+i*2, varNames[2*i+1]  , vstart[1+i*2],   step[1+i*2],      0, 1.2*iTSTOTEn);
     //Secret Option to fix the time 
     if(timeSig_ < 0) hybridfitter->SetFixedVariable(0+i*2, varNames[2*i+0],vstart[0+i*2]);
   }
   //Pedestal
   if(vstart[n-1] > std::abs(pedMax)) vstart[n-1] = pedMax;
   hybridfitter->SetLimitedVariable(n-1, varNames[n-1], vstart[n-1], step[n-1],-pedMax,pedMax);
   //Secret Option to fix the pedestal
   if(pedSig_ < 0) hybridfitter->SetFixedVariable(n-1,varNames[n-1],vstart[n-1]);
   //a special number to label the initial condition
   chi2=-1;
   //3 fits why?!
   const double *results = nullptr;
   for(int tries=0; tries<=3;++tries){
     if( fitTimes_ != 2 || tries !=1 ){
        hybridfitter->SetMinimizerType(PSFitter::HybridMinimizer::kMigrad);
        fitStatus = hybridfitter->Minimize();
     }
     double chi2valfit = hybridfitter->MinValue();
     const double *newresults = hybridfitter->X();
     if(chi2 == -1 || chi2>chi2valfit+0.01) {
       results=newresults;
       chi2=chi2valfit;
       if( tries == 0 && fitTimes_ == 1 ) break;
       if( tries == 1 && (fitTimes_ == 2 || fitTimes_ ==3 ) ) break;
       if( tries == 2 && fitTimes_ == 4 ) break;
       if( tries == 3 && fitTimes_ == 5 ) break; 
       //Secret option to speed up the fit => perhaps we should drop this
       if(timeSig_ < 0 || pedSig_ < 0) break;
       if(tries==0){
     hybridfitter->SetMinimizerType(PSFitter::HybridMinimizer::kScan);
     fitStatus = hybridfitter->Minimize();
       } else if(tries==1){
     hybridfitter->SetStrategy(1);
       } else if(tries==2){
     hybridfitter->SetStrategy(2);
       }
     } else {
       break;
     }
   }
   assert(results);

   timevalfit   = results[0];
   chargevalfit = results[1];
   pedvalfit    = results[n-1];

}

void PulseShapeFitOOTPileupCorrection::phase1Apply	(	const HBHEChannelInfo &	channelData,
		float &	reconstructedEnergy,
		float &	reconstructedTime,
		bool &	useTriple,
		float &	chi2
	)		const

Definition at line 514 of file PulseShapeFitOOTPileupCorrection.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, HBHEChannelInfo::darkCurrent(), dcConstraint_, HBHEChannelInfo::fcByPE(), muonCSCDigis_cfi::gain, HBHEChannelInfo::hasTimeInfo(), HBHEChannelInfo::lambda(), HcalConst::maxSamples, HBHEChannelInfo::nSamples(), psfPtr_, pulseShapeFit(), mathSSE::sqrt(), ts4Chi2_, ts4Max_, ts4Min_, HBHEChannelInfo::tsDFcPerADC(), HBHEChannelInfo::tsGain(), HBHEChannelInfo::tsPedestal(), HBHEChannelInfo::tsPedestalWidth(), HBHEChannelInfo::tsRawCharge(), vts4Chi2_, and vts4Max_.

Referenced by SimpleHBHEPhase1Algo::reconstruct().

{

  psfPtr_->setDefaultcntNANinfit();

  const unsigned cssize = channelData.nSamples();
  // initialize arrays to be zero
  double chargeArr[HcalConst::maxSamples]={}, pedArr[HcalConst::maxSamples]={}, gainArr[HcalConst::maxSamples]={};
  double energyArr[HcalConst::maxSamples]={}, pedenArr[HcalConst::maxSamples]={};
  double noiseADCArr[HcalConst::maxSamples]={};
  double noiseDCArr[HcalConst::maxSamples]={};
  double noiseArrSq[HcalConst::maxSamples]={};
  double noisePHArr[HcalConst::maxSamples]={};
  double tsTOT = 0, tstrig = 0; // in fC
  double tsTOTen = 0; // in GeV
  double sipmDarkCurrentWidth = psfPtr_->getSiPMDarkCurrent(channelData.darkCurrent(),channelData.fcByPE(),channelData.lambda());

  // go over the time slices
  for(unsigned int ip=0; ip<cssize; ++ip){
    if( ip >= (unsigned) HcalConst::maxSamples ) continue; // Too many samples than what we wanna fit (10 is enough...) -> skip them

    //      const int capid = channelData.capid(); // not needed
    double charge = channelData.tsRawCharge(ip);
    double ped = channelData.tsPedestal(ip);
    double gain = channelData.tsGain(ip);

    double energy = charge*gain;
    double peden = ped*gain;

    chargeArr[ip] = charge; pedArr[ip] = ped; gainArr[ip] = gain;
    energyArr[ip] = energy; pedenArr[ip] = peden;

    // quantization noise from the ADC (QIE8 or QIE10/11)
    noiseADCArr[ip] = (1./sqrt(12))*channelData.tsDFcPerADC(ip);

    // dark current noise relevant for siPM
    noiseDCArr[ip] = 0;
    if(channelData.hasTimeInfo() && (charge-ped)>channelData.tsPedestalWidth(ip)) {
      noiseDCArr[ip] = sipmDarkCurrentWidth;
    }

    // Photo statistics uncertainties
    //      sigmaFC/FC = 1/sqrt(Ne);
    // Note2. (from kPedro): the output number of photoelectrons after smearing is treated very differently for SiPMs: *each* pe is assigned a different time based on a random generation from the Y11 pulse plus the SimHit time. In HPDs, the overall pulse is shaped all at once using just the SimHit time.

    noisePHArr[ip] = 0;
    if((charge-ped)>channelData.tsPedestalWidth(ip)) {
      noisePHArr[ip] = sqrt((charge-ped)*channelData.fcByPE());
    }

    // sum all in quadrature
    noiseArrSq[ip]= noiseADCArr[ip]*noiseADCArr[ip] + noiseDCArr[ip]*noiseDCArr[ip] + channelData.tsPedestalWidth(ip)*channelData.tsPedestalWidth(ip) +  noisePHArr[ip]*noisePHArr[ip];

    tsTOT += charge - ped;
    tsTOTen += energy - peden;
    if( ip ==4 || ip==5 ){
      tstrig += charge - ped;
    }
  }

  double sipmDarkCurrentWidth2 = 0.;
  if(dcConstraint_) sipmDarkCurrentWidth2 = sipmDarkCurrentWidth*sipmDarkCurrentWidth;
  double averagePedSig2GeV=0.25*((channelData.tsPedestalWidth(0)*channelData.tsPedestalWidth(0)+sipmDarkCurrentWidth2)*channelData.tsGain(0)*channelData.tsGain(0) +
                 (channelData.tsPedestalWidth(1)*channelData.tsPedestalWidth(1)+sipmDarkCurrentWidth2)*channelData.tsGain(1)*channelData.tsGain(1) +
                 (channelData.tsPedestalWidth(2)*channelData.tsPedestalWidth(2)+sipmDarkCurrentWidth2)*channelData.tsGain(2)*channelData.tsGain(2) +
                 (channelData.tsPedestalWidth(3)*channelData.tsPedestalWidth(3)+sipmDarkCurrentWidth2)*channelData.tsGain(3)*channelData.tsGain(3));

  // redefine the invertpedSig2
  psfPtr_->setinvertpedSig2(1./(averagePedSig2GeV));

  if(channelData.hasTimeInfo()) { 
    ts4Max_=vts4Max_[1]; ts4Chi2_=vts4Chi2_[1]; 
  } else {
    ts4Max_=vts4Max_[0]; ts4Chi2_=vts4Chi2_[0];
  }

  std::vector<float> fitParsVec;
  if(tstrig >= ts4Min_ && tsTOTen > 0.) { //Two sigma from 0
    pulseShapeFit(energyArr, pedenArr, chargeArr, pedArr, gainArr, tsTOTen, fitParsVec,noiseArrSq);
  } else {
    fitParsVec.clear();
    fitParsVec.push_back(0.); //charge
    fitParsVec.push_back(-9999); // time
    fitParsVec.push_back(0.); // ped
    fitParsVec.push_back(-9999); // chi2
    fitParsVec.push_back(false); // triple
   }


  reconstructedEnergy = fitParsVec[0];
  reconstructedTime = fitParsVec[1];
  chi2 = fitParsVec[3];
  useTriple = fitParsVec[4];

}

int PulseShapeFitOOTPileupCorrection::pulseShapeFit ( const double *  energyArr, const double *  pedenArr, const double *  chargeArr, const double *  pedArr, const double *  gainArr, const double  tsTOTen, std::vector< float > &  fitParsVec, const double *  ADCnoise  ) const

private

Definition at line 373 of file PulseShapeFitOOTPileupCorrection.cc.

References funct::abs(), applyTimeSlew_, rpcdqm::BX, vertices_cff::chi2, HcalTimeSlew::delay(), fit(), mps_fire::i, SiStripPI::max, HcalConst::maxSamples, psfPtr_, slewFlavor_, mathSSE::sqrt(), ts4Chi2_, and ts4Max_.

Referenced by apply(), and phase1Apply().

                                                                                                                                                                                                                                                                 {
   double tsMAX=0;
   double tmpx[HcalConst::maxSamples], tmpy[HcalConst::maxSamples], tmperry[HcalConst::maxSamples],tmperry2[HcalConst::maxSamples],tmpslew[HcalConst::maxSamples];
   double tstrig = 0; // in fC
   for(int i=0;i<HcalConst::maxSamples;++i){
      tmpx[i]=i;
      tmpy[i]=energyArr[i]-pedenArr[i];
      //Add Time Slew !!! does this need to be pedestal subtracted
      tmpslew[i] = 0;
      if(applyTimeSlew_) tmpslew[i] = HcalTimeSlew::delay(std::max(1.0,chargeArr[i]),slewFlavor_); 
      // add the noise components
      tmperry2[i]=noiseArrSq[i];

      //Propagate it through
      tmperry2[i]*=(gainArr[i]*gainArr[i]); //Convert from fC to GeV
      tmperry [i]=sqrt(tmperry2[i]);

      if(std::abs(energyArr[i])>tsMAX) tsMAX=std::abs(tmpy[i]);
      if( i ==4 || i ==5 ){
         tstrig += chargeArr[i] - pedArr[i];
      }
   }
   psfPtr_->setpsFitx    (tmpx);
   psfPtr_->setpsFity    (tmpy);
   psfPtr_->setpsFiterry (tmperry);
   psfPtr_->setpsFiterry2(tmperry2);
   psfPtr_->setpsFitslew (tmpslew);
   
   //Fit 1 single pulse
   float timevalfit  = 0;
   float chargevalfit= 0;
   float pedvalfit   = 0;
   float chi2        = 999; //cannot be zero
   bool  fitStatus   = false;
   bool useTriple = false;

   int BX[3] = {4,5,3};
   if(ts4Chi2_ != 0) fit(1,timevalfit,chargevalfit,pedvalfit,chi2,fitStatus,tsMAX,tsTOTen,tmpy,BX);
// Based on the pulse shape ( 2. likely gives the same performance )
   if(tmpy[2] > 3.*tmpy[3]) BX[2] = 2;
// Only do three-pulse fit when tstrig < ts4Max_, otherwise one-pulse fit is used (above)
   if(chi2 > ts4Chi2_ && tstrig < ts4Max_)   { //fails chi2 cut goes straight to 3 Pulse fit
     fit(3,timevalfit,chargevalfit,pedvalfit,chi2,fitStatus,tsMAX,tsTOTen,tmpy,BX);
     useTriple=true;
   }

   /*
   if(chi2 > ts345Chi2_)   { //fails do two pulse chi2 for TS5 
     BX[1] = 5;
     fit(3,timevalfit,chargevalfit,pedvalfit,chi2,fitStatus,tsMAX,tsTOTen,BX);
   }
   */
   //Fix back the timeslew
   //if(applyTimeSlew_) timevalfit+=HcalTimeSlew::delay(std::max(1.0,chargeArr[4]),slewFlavor_);
   int outfitStatus = (fitStatus ? 1: 0 );
   fitParsVec.clear();
   fitParsVec.push_back(chargevalfit);
   fitParsVec.push_back(timevalfit);
   fitParsVec.push_back(pedvalfit);
   fitParsVec.push_back(chi2);
   fitParsVec.push_back(useTriple);
   return outfitStatus;
}

void PulseShapeFitOOTPileupCorrection::resetPulseShapeTemplate

(

const HcalPulseShapes::Shape &

ps

)

Definition at line 289 of file PulseShapeFitOOTPileupCorrection.cc.

References addPulseJitter_, applyTimeSlew_, cntsetPulseShape, FitterFuncs::PulseShapeFunctor::doublePulseShapeFunc(), dpfunctor_, noise_, pedestalConstraint_, pedMean_, pedSig_, psfPtr_, pulseJitter_, FitterFuncs::PulseShapeFunctor::singlePulseShapeFunc(), spfunctor_, timeConstraint_, timeMean_, timeSig_, tpfunctor_, and FitterFuncs::PulseShapeFunctor::triplePulseShapeFunc().

Referenced by setPulseShapeTemplate().

                                                                                             { 
   ++ cntsetPulseShape;
   psfPtr_.reset(new FitterFuncs::PulseShapeFunctor(ps,pedestalConstraint_,timeConstraint_,addPulseJitter_,applyTimeSlew_,
                                 pulseJitter_,timeMean_,timeSig_,pedMean_,pedSig_,noise_));
   spfunctor_    = std::unique_ptr<ROOT::Math::Functor>( new ROOT::Math::Functor(psfPtr_.get(),&FitterFuncs::PulseShapeFunctor::singlePulseShapeFunc, 3) );
   dpfunctor_    = std::unique_ptr<ROOT::Math::Functor>( new ROOT::Math::Functor(psfPtr_.get(),&FitterFuncs::PulseShapeFunctor::doublePulseShapeFunc, 5) );
   tpfunctor_    = std::unique_ptr<ROOT::Math::Functor>( new ROOT::Math::Functor(psfPtr_.get(),&FitterFuncs::PulseShapeFunctor::triplePulseShapeFunc, 7) );

}

void PulseShapeFitOOTPileupCorrection::setChi2Term

(

bool

isHPD

)

Definition at line 224 of file PulseShapeFitOOTPileupCorrection.cc.

References noise_, noiseHPD_, noiseSiPM_, pedSig_, pedSigHPD_, pedSigSiPM_, timeSig_, timeSigHPD_, and timeSigSiPM_.

Referenced by setPulseShapeTemplate().

                                                               {

  if(isHPD) {
    timeSig_            = timeSigHPD_;
    pedSig_             = pedSigHPD_; // unused in Phase1, take the average pedestal width from the DB
    noise_              = noiseHPD_; // unused in Phase1, take the pedestal width from the DB
  } else {
    timeSig_            = timeSigSiPM_;
    pedSig_             = pedSigSiPM_; // unused in Phase1, take the average pedestal width from the DB
    noise_              = noiseSiPM_; // unused in Phase1, take the pedestal width from the DB
  }

}

void PulseShapeFitOOTPileupCorrection::setPulseShapeTemplate	(	const HcalPulseShapes::Shape &	ps,
		bool	isHPD
	)

Definition at line 277 of file PulseShapeFitOOTPileupCorrection.cc.

References currentPulseShape_, isCurrentChannelHPD_, resetPulseShapeTemplate(), and setChi2Term().

                                                                                                       {
  // initialize for every different channel types (HPD vs SiPM)

  if (!(&ps == currentPulseShape_ && isHPD == isCurrentChannelHPD_))
    {
      setChi2Term(isHPD);
      resetPulseShapeTemplate(ps);
      currentPulseShape_ = &ps;
      isCurrentChannelHPD_ = isHPD;
    }
}

void PulseShapeFitOOTPileupCorrection::setPUParams	(	bool	iPedestalConstraint,
		bool	iTimeConstraint,
		bool	iAddPulseJitter,
		bool	iApplyTimeSlew,
		double	iTS4Min,
		const std::vector< double > &	iTS4Max,
		double	iPulseJitter,
		double	iTimeMean,
		double	iTimeSigHPD,
		double	iTimeSigSiPM,
		double	iPedMean,
		double	iPedSigHPD,
		double	iPedSigSiPM,
		double	iNoiseHPD,
		double	iNoiseSiPM,
		double	iTMin,
		double	iTMax,
		const std::vector< double > &	its4Chi2,
		HcalTimeSlew::BiasSetting	slewFlavor,
		int	iFitTimes,
		bool	iDCConstraint = false
	)

Definition at line 239 of file PulseShapeFitOOTPileupCorrection.cc.

References addPulseJitter_, applyTimeSlew_, dcConstraint_, fitTimes_, noiseHPD_, noiseSiPM_, pedestalConstraint_, pedMean_, pedSigHPD_, pedSigSiPM_, pulseJitter_, slewFlavor_, timeConstraint_, timeMean_, timeSigHPD_, timeSigSiPM_, ts4Min_, TSMax_, TSMin_, vts4Chi2_, and vts4Max_.

                                                                                                  {

  TSMin_ = iTMin;
  TSMax_ = iTMax;
  //  ts4Chi2_   = its4Chi2;
  vts4Chi2_   = its4Chi2;
  pedestalConstraint_ = iPedestalConstraint;
  timeConstraint_     = iTimeConstraint;
  addPulseJitter_     = iAddPulseJitter;
  applyTimeSlew_      = iApplyTimeSlew;
  ts4Min_             = iTS4Min;
  //  ts4Max_            = iTS4Max;
  vts4Max_            = iTS4Max;
  pulseJitter_        = iPulseJitter*iPulseJitter;
  timeMean_           = iTimeMean;
  //  timeSig_            = iTimeSig;
  timeSigHPD_         = iTimeSigHPD;
  timeSigSiPM_        = iTimeSigSiPM;
  pedMean_            = iPedMean;
  //  pedSig_             = iPedSig;
  pedSigHPD_          = iPedSigHPD;
  pedSigSiPM_         = iPedSigSiPM;
  //  noise_              = iNoise;
  noiseHPD_           = iNoiseHPD;
  noiseSiPM_          = iNoiseSiPM;
  slewFlavor_         = slewFlavor;
  fitTimes_           = iFitTimes;
  dcConstraint_       = iDCConstraint;

}

Member Data Documentation

bool PulseShapeFitOOTPileupCorrection::addPulseJitter_

private

Definition at line 148 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by resetPulseShapeTemplate(), and setPUParams().

bool PulseShapeFitOOTPileupCorrection::applyTimeSlew_

private

Definition at line 150 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by pulseShapeFit(), resetPulseShapeTemplate(), and setPUParams().

double PulseShapeFitOOTPileupCorrection::chargeThreshold_

private

Definition at line 135 of file PulseShapeFitOOTPileupCorrection.h.

int PulseShapeFitOOTPileupCorrection::cntsetPulseShape

private

Definition at line 133 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by resetPulseShapeTemplate().

const HcalPulseShapes::Shape* PulseShapeFitOOTPileupCorrection::currentPulseShape_ =nullptr

Definition at line 120 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by setPulseShapeTemplate().

bool PulseShapeFitOOTPileupCorrection::dcConstraint_

private

Definition at line 167 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by phase1Apply(), and setPUParams().

std::unique_ptr<ROOT::Math::Functor> PulseShapeFitOOTPileupCorrection::dpfunctor_

private

Definition at line 140 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), and resetPulseShapeTemplate().

int PulseShapeFitOOTPileupCorrection::fitTimes_

private

Definition at line 136 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), and setPUParams().

PSFitter::HybridMinimizer* PulseShapeFitOOTPileupCorrection::hybridfitter

private

Definition at line 132 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), PulseShapeFitOOTPileupCorrection(), and ~PulseShapeFitOOTPileupCorrection().

std::array<double,HcalConst::maxSamples> PulseShapeFitOOTPileupCorrection::iniTimesArr

private

Definition at line 134 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), and PulseShapeFitOOTPileupCorrection().

bool PulseShapeFitOOTPileupCorrection::isCurrentChannelHPD_

private

Definition at line 169 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by setPulseShapeTemplate().

double PulseShapeFitOOTPileupCorrection::noise_

private

Definition at line 163 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by apply(), resetPulseShapeTemplate(), and setChi2Term().

double PulseShapeFitOOTPileupCorrection::noiseHPD_

private

Definition at line 164 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by setChi2Term(), and setPUParams().

double PulseShapeFitOOTPileupCorrection::noiseSiPM_

private

Definition at line 165 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by setChi2Term(), and setPUParams().

bool PulseShapeFitOOTPileupCorrection::pedestalConstraint_

private

Definition at line 146 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by resetPulseShapeTemplate(), and setPUParams().

double PulseShapeFitOOTPileupCorrection::pedMean_

private

Definition at line 159 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), resetPulseShapeTemplate(), and setPUParams().

double PulseShapeFitOOTPileupCorrection::pedSig_

private

Definition at line 160 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), resetPulseShapeTemplate(), and setChi2Term().

double PulseShapeFitOOTPileupCorrection::pedSigHPD_

private

Definition at line 161 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by setChi2Term(), and setPUParams().

double PulseShapeFitOOTPileupCorrection::pedSigSiPM_

private

Definition at line 162 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by setChi2Term(), and setPUParams().

std::unique_ptr<FitterFuncs::PulseShapeFunctor> PulseShapeFitOOTPileupCorrection::psfPtr_

private

Definition at line 138 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by apply(), phase1Apply(), pulseShapeFit(), and resetPulseShapeTemplate().

double PulseShapeFitOOTPileupCorrection::pulseJitter_

private

Definition at line 154 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by resetPulseShapeTemplate(), and setPUParams().

HcalTimeSlew::BiasSetting PulseShapeFitOOTPileupCorrection::slewFlavor_

private

Definition at line 166 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by pulseShapeFit(), and setPUParams().

std::unique_ptr<ROOT::Math::Functor> PulseShapeFitOOTPileupCorrection::spfunctor_

private

Definition at line 139 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), and resetPulseShapeTemplate().

bool PulseShapeFitOOTPileupCorrection::timeConstraint_

private

Definition at line 147 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by resetPulseShapeTemplate(), and setPUParams().

double PulseShapeFitOOTPileupCorrection::timeMean_

private

Definition at line 155 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), resetPulseShapeTemplate(), and setPUParams().

double PulseShapeFitOOTPileupCorrection::timeSig_

private

Definition at line 156 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), resetPulseShapeTemplate(), and setChi2Term().

double PulseShapeFitOOTPileupCorrection::timeSigHPD_

private

Definition at line 157 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by setChi2Term(), and setPUParams().

double PulseShapeFitOOTPileupCorrection::timeSigSiPM_

private

Definition at line 158 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by setChi2Term(), and setPUParams().

std::unique_ptr<ROOT::Math::Functor> PulseShapeFitOOTPileupCorrection::tpfunctor_

private

Definition at line 141 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), and resetPulseShapeTemplate().

double PulseShapeFitOOTPileupCorrection::ts4Chi2_

mutableprivate

Definition at line 144 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by apply(), phase1Apply(), and pulseShapeFit().

double PulseShapeFitOOTPileupCorrection::ts4Max_

mutableprivate

Definition at line 152 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by apply(), phase1Apply(), and pulseShapeFit().

double PulseShapeFitOOTPileupCorrection::ts4Min_

private

Definition at line 151 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by apply(), phase1Apply(), and setPUParams().

int PulseShapeFitOOTPileupCorrection::TSMax_

private

Definition at line 143 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), and setPUParams().

int PulseShapeFitOOTPileupCorrection::TSMin_

private

Definition at line 142 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by fit(), and setPUParams().

bool PulseShapeFitOOTPileupCorrection::unConstrainedFit_

private

Definition at line 149 of file PulseShapeFitOOTPileupCorrection.h.

std::vector<double> PulseShapeFitOOTPileupCorrection::vts4Chi2_

private

Definition at line 145 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by apply(), phase1Apply(), and setPUParams().

std::vector<double> PulseShapeFitOOTPileupCorrection::vts4Max_

private

Definition at line 153 of file PulseShapeFitOOTPileupCorrection.h.

Referenced by apply(), phase1Apply(), and setPUParams().