ZdcSimpleRecAlgo_Run3 Class Reference

#include <ZdcSimpleRecAlgo_Run3.h>

Public Member Functions
void	initCorrectionMethod (const int method, const int ZdcSection)
void	initRatioSubtraction (const float ratio, const float frac, const int ZdcSection)
void	initTemplateFit (const std::vector< unsigned int > &bxTs, const std::vector< double > &chargeRatios, const int nTs, const int ZdcSection)
ZDCRecHit	reco0 (const QIE10DataFrame &digi, const HcalCoder &coder, const HcalCalibrations &calibs, const HcalPedestal &effPeds, const std::vector< unsigned int > &myNoiseTS, const std::vector< unsigned int > &mySignalTS) const
ZDCRecHit	reconstruct (const QIE10DataFrame &digi, const std::vector< unsigned int > &myNoiseTS, const std::vector< unsigned int > &mySignalTS, const HcalCoder &coder, const HcalCalibrations &calibs, const HcalPedestal &effPeds) const
	ZdcSimpleRecAlgo_Run3 (int recoMethod)

Private Attributes
std::map< int, int >	correctionMethod_
int	nTs_
std::map< int, float >	ootpuFrac_
std::map< int, float >	ootpuRatio_
int	recoMethod_
std::map< int, bool >	templateFitValid_
std::map< int, std::vector< double > >	templateFitValues_

Detailed Description

This class reconstructs RecHits from Digis for ZDC by addition of selected time samples, pedestal subtraction, and gain application. The time of the hit is reconstructed using a weighted peak bin calculation supplemented by precise time lookup table. A consumer of this class also has the option of correcting the reconstructed time for energy-dependent time slew associated with the QIE.

A sencon method based on a based on a event by event substraction is also implelented. signal = (S4 + S5 - 2*(S1+S2+S3 + S7+S8+S9+S10))*(ft-Gev constant) where SN is the signal in the nth time slice

Author

E. Garcia CSU & J. Gomez UMD

Definition at line 39 of file ZdcSimpleRecAlgo_Run3.h.

Constructor & Destructor Documentation

ZdcSimpleRecAlgo_Run3()

ZdcSimpleRecAlgo_Run3::ZdcSimpleRecAlgo_Run3

(

int

recoMethod

)

Simple constructor for PMT-based detectors

Definition at line 11 of file ZdcSimpleRecAlgo_Run3.cc.

: recoMethod_(recoMethod) {}

Member Function Documentation

initCorrectionMethod()

void ZdcSimpleRecAlgo_Run3::initCorrectionMethod	(	const int	method,
		const int	ZdcSection
	)

Definition at line 13 of file ZdcSimpleRecAlgo_Run3.cc.

References correctionMethod_, and AlcaSiPixelAliHarvester0T_cff::method.

Referenced by ZdcHitReconstructor_Run3::ZdcHitReconstructor_Run3().

                                                                                       {
  correctionMethod_[ZdcSection] = method;
};

initRatioSubtraction()

void ZdcSimpleRecAlgo_Run3::initRatioSubtraction	(	const float	ratio,
		const float	frac,
		const int	ZdcSection
	)

Definition at line 55 of file ZdcSimpleRecAlgo_Run3.cc.

References DivergingColor::frac, ootpuFrac_, and ootpuRatio_.

Referenced by ZdcHitReconstructor_Run3::ZdcHitReconstructor_Run3().

                                                                                                          {
  ootpuRatio_[ZdcSection] = ratio;
  ootpuFrac_[ZdcSection] = frac;
}

initTemplateFit()

void ZdcSimpleRecAlgo_Run3::initTemplateFit	(	const std::vector< unsigned int > &	bxTs,
		const std::vector< double > &	chargeRatios,
		const int	nTs,
		const int	ZdcSection
	)

Definition at line 19 of file ZdcSimpleRecAlgo_Run3.cc.

References a, b, mps_fire::i, dqmiolumiharvest::j, nTs_, push_back(), templateFitValid_, templateFitValues_, and heppy_batch::val.

Referenced by ZdcHitReconstructor_Run3::ZdcHitReconstructor_Run3().

                                                                  {
  int nRatios = chargeRatios.size();
  int nBx = bxTs.size();
  int nCols = nBx + 1;
  double val = 0;
  int index = 0;
  int timeslice = 0;
  nTs_ = nTs;
  Eigen::MatrixXf a(nTs, nCols);
  for (int j = 0; j < nBx; j++) {
    timeslice = bxTs.at(j);
    for (int i = 0; i < nTs; i++) {
      val = 0;
      index = i - timeslice;
      if (index >= 0 && index < nRatios)
        val = chargeRatios.at(index);
      a(i, j) = val;
    }
  }
  for (int i = 0; i < nTs; i++)
    a(i, nBx) = 1;
  Eigen::MatrixXf b = a.transpose() * a;
  if (std::fabs(b.determinant()) < 1E-8) {
    templateFitValid_[ZdcSection] = false;
    return;
  }
  templateFitValid_[ZdcSection] = true;
  Eigen::MatrixXf tfMatrix;
  tfMatrix = b.inverse() * a.transpose();
  for (int i = 0; i < nTs; i++)
    templateFitValues_[ZdcSection].push_back(tfMatrix.coeff(1, i));
}

reco0()

ZDCRecHit ZdcSimpleRecAlgo_Run3::reco0	(	const QIE10DataFrame &	digi,
		const HcalCoder &	coder,
		const HcalCalibrations &	calibs,
		const HcalPedestal &	effPeds,
		const std::vector< unsigned int > &	myNoiseTS,
		const std::vector< unsigned int > &	mySignalTS
	)		const

Definition at line 84 of file ZdcSimpleRecAlgo_Run3.cc.

References HcalCoder::adc2fC(), correctionMethod_, HBHEDarkening_cff::energy, Hcal_Conditions_forGlobalTag_cff::gain, zdchelper::getNoiseOOTPURatio(), HcalPedestal::getValue(), HcalPedestal::getWidth(), QIE10DataFrame::id(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::iv, LogDebug, WZElectronSkims53X_cff::max, findQualityFiles::maxI, hgchebackDigitizer_cfi::noise, nTs_, ootpuFrac_, ootpuRatio_, QIE10Task_cfi::ped, HcalCalibrations::respcorrgain(), QIE10DataFrame::samples(), HcalZDCDetId::section(), ZDCRecHit::setEnergySOIp1(), CaloSamples::size(), zdchelper::subPedestal(), templateFitValid_, templateFitValues_, hcalRecHitTable_cff::time, and ApeEstimator_cff::width.

Referenced by reconstruct().

                                                                                        {
  CaloSamples tool;
  coder.adc2fC(digi, tool);
  // Reads noiseTS and signalTS from database
  int ifirst = mySignalTS[0];
  double ampl = 0;
  int maxI = -1;
  double maxA = -1e10;
  double ta = 0;
  double energySOIp1 = 0;
  double ratioSOIp1 = -1.0;
  double chargeWeightedTime = -99.0;

  double Allnoise = 0;
  int noiseslices = 0;
  int CurrentTS = 0;
  double noise = 0;
  int digi_size = digi.samples();
  HcalZDCDetId cell = digi.id();
  int zdcsection = cell.section();

  // determining noise
  for (unsigned int iv = 0; iv < myNoiseTS.size(); ++iv) {
    CurrentTS = myNoiseTS[iv];
    int capid = digi[CurrentTS].capid();
    float ped = effPeds.getValue(capid);
    float width = effPeds.getWidth(capid);
    float gain = calibs.respcorrgain(capid);
    if (CurrentTS >= digi_size)
      continue;
    float energy1 = zdchelper::subPedestal(tool[CurrentTS], ped, width) * gain;
    float energy0 = 0;
    if (CurrentTS > 0) {
      capid = digi[CurrentTS - 1].capid();
      ped = effPeds.getValue(capid);
      width = effPeds.getWidth(capid);
      gain = calibs.respcorrgain(capid);
      energy0 = zdchelper::subPedestal(tool[CurrentTS - 1], ped, width) * gain;
    }
    Allnoise += zdchelper::getNoiseOOTPURatio(energy0, energy1, ootpuRatio_.at(zdcsection), ootpuFrac_.at(zdcsection));
    noiseslices++;
  }
  if (noiseslices != 0) {
    noise = (Allnoise) / double(noiseslices);
  }

  // determining signal energy and max Ts
  for (unsigned int ivs = 0; ivs < mySignalTS.size(); ++ivs) {
    CurrentTS = mySignalTS[ivs];
    if (CurrentTS >= digi_size)
      continue;
    float energy1 = -1;
    int capid = digi[CurrentTS].capid();
    // float ped = calibs.pedestal(capid);
    float ped = effPeds.getValue(capid);
    float width = effPeds.getWidth(capid);
    float gain = calibs.respcorrgain(capid);
    float energy0 = std::max(0.0, zdchelper::subPedestal(tool[CurrentTS], ped, width)) * gain;
    if (CurrentTS < digi_size - 1) {
      capid = digi[CurrentTS].capid();
      ped = effPeds.getValue(capid);
      width = effPeds.getWidth(capid);
      gain = calibs.respcorrgain(capid);
      energy1 = std::max(0.0, zdchelper::subPedestal(tool[CurrentTS + 1], ped, width)) * gain;
    }
    ta = energy0 - noise;
    if (ta > 0)
      ampl += ta;

    if (ta > maxA) {
      ratioSOIp1 = (energy0 > 0 && energy1 > 0) ? energy0 / energy1 : -1.0;
      maxA = ta;
      maxI = CurrentTS;
    }
  }

  // determine energy if using Template Fit method
  if (correctionMethod_.at(zdcsection) == 1 && templateFitValid_.at(zdcsection)) {
    double energy = 0;
    for (int iv = 0; iv < nTs_; iv++) {
      int capid = digi[iv].capid();
      float ped = effPeds.getValue(capid);
      float width = effPeds.getWidth(capid);
      float gain = calibs.respcorrgain(capid);
      if (iv >= digi_size)
        continue;
      energy += zdchelper::subPedestal(tool[iv], ped, width) * (templateFitValues_.at(zdcsection)).at(iv) * gain;
    }
    ampl = std::max(0.0, energy);
  }

  double time = -9999;
  // Time based on regular energy
  if (maxI == 0 || maxI == (tool.size() - 1)) {
    LogDebug("HCAL Pulse") << "ZdcSimpleRecAlgo::reco2 :"
                           << " Invalid max amplitude position, "
                           << " max Amplitude: " << maxI << " first: " << ifirst << " last: " << (tool.size() - 1)
                           << std::endl;
  } else {
    int capid = digi[maxI - 1].capid();
    double Energy0 = std::max(0.0, ((tool[maxI - 1]) * calibs.respcorrgain(capid)));

    capid = digi[maxI].capid();
    double Energy1 = std::max(0.0, ((tool[maxI]) * calibs.respcorrgain(capid)));
    capid = digi[maxI + 1].capid();
    double Energy2 = std::max(0.0, ((tool[maxI + 1]) * calibs.respcorrgain(capid)));

    double TSWeightEnergy = ((maxI - 1) * Energy0 + maxI * Energy1 + (maxI + 1) * Energy2);
    double EnergySum = Energy0 + Energy1 + Energy2;
    double AvgTSPos = 0.;
    if (EnergySum != 0)
      AvgTSPos = TSWeightEnergy / EnergySum;
    // If time is zero, set it to the "nonsensical" -99
    // Time should be between 75ns and 175ns (Timeslices 3-7)
    if (AvgTSPos == 0) {
      time = -99;
    } else {
      time = (AvgTSPos * 25.0);
    }
  }

  // find energy for signal TS + 1
  for (unsigned int ivs = 0; ivs < mySignalTS.size(); ++ivs) {
    CurrentTS = mySignalTS[ivs] + 1;
    if (CurrentTS >= digi_size)
      continue;
    int capid = digi[CurrentTS].capid();
    // ta = tool[CurrentTS] - noise;
    ta = tool[CurrentTS];
    ta *= calibs.respcorrgain(capid);  // fC --> GeV
    if (ta > 0)
      energySOIp1 += ta;
  }

  double tmp_energy = 0;
  double tmp_TSWeightedEnergy = 0;
  for (int ts = 0; ts < digi_size; ++ts) {
    int capid = digi[ts].capid();

    // max sure there are no negative values in time calculation
    ta = std::max(0.0, tool[ts]);
    ta *= calibs.respcorrgain(capid);  // fC --> GeV
    if (ta > 0) {
      tmp_energy += ta;
      tmp_TSWeightedEnergy += (ts)*ta;
    }
  }

  if (tmp_energy > 0)
    chargeWeightedTime = (tmp_TSWeightedEnergy / tmp_energy) * 25.0;
  auto rh = ZDCRecHit(digi.id(), ampl, time, -99);
  rh.setEnergySOIp1(energySOIp1);

  if (maxI >= 0 && maxI < tool.size()) {
    float tmp_tdctime = 0;
    int le_tdc = digi[maxI].le_tdc();
    // TDC error codes will be 60=-1, 61 = -2, 62 = -3, 63 = -4
    if (le_tdc >= 60)
      tmp_tdctime = -1 * (le_tdc - 59);
    else
      tmp_tdctime = maxI * 25. + (le_tdc / 2.0);
    rh.setTDCtime(tmp_tdctime);
  }

  rh.setChargeWeightedTime(chargeWeightedTime);
  rh.setRatioSOIp1(ratioSOIp1);
  return rh;
}

reconstruct()

ZDCRecHit ZdcSimpleRecAlgo_Run3::reconstruct	(	const QIE10DataFrame &	digi,
		const std::vector< unsigned int > &	myNoiseTS,
		const std::vector< unsigned int > &	mySignalTS,
		const HcalCoder &	coder,
		const HcalCalibrations &	calibs,
		const HcalPedestal &	effPeds
	)		const

Definition at line 259 of file ZdcSimpleRecAlgo_Run3.cc.

References Exception, and reco0().

Referenced by ZdcHitReconstructor_Run3::produce().

                                                                                {
  return ZdcSimpleRecAlgo_Run3::reco0(digi, coder, calibs, effPeds, myNoiseTS, mySignalTS);

  edm::LogError("ZDCSimpleRecAlgoImpl::reconstruct, recoMethod was not declared");
  throw cms::Exception("ZDCSimpleRecoAlgos::exiting process");
}

Member Data Documentation

correctionMethod_

std::map<int, int> ZdcSimpleRecAlgo_Run3::correctionMethod_

private

Definition at line 71 of file ZdcSimpleRecAlgo_Run3.h.

Referenced by initCorrectionMethod(), and reco0().

nTs_

int ZdcSimpleRecAlgo_Run3::nTs_

private

Definition at line 66 of file ZdcSimpleRecAlgo_Run3.h.

Referenced by initTemplateFit(), and reco0().

ootpuFrac_

std::map<int, float> ZdcSimpleRecAlgo_Run3::ootpuFrac_

private

Definition at line 70 of file ZdcSimpleRecAlgo_Run3.h.

Referenced by initRatioSubtraction(), and reco0().

ootpuRatio_

std::map<int, float> ZdcSimpleRecAlgo_Run3::ootpuRatio_

private

Definition at line 69 of file ZdcSimpleRecAlgo_Run3.h.

Referenced by initRatioSubtraction(), and reco0().

recoMethod_

int ZdcSimpleRecAlgo_Run3::recoMethod_

private

Definition at line 65 of file ZdcSimpleRecAlgo_Run3.h.

templateFitValid_

std::map<int, bool> ZdcSimpleRecAlgo_Run3::templateFitValid_

private

Definition at line 68 of file ZdcSimpleRecAlgo_Run3.h.

Referenced by initTemplateFit(), and reco0().

templateFitValues_

std::map<int, std::vector<double> > ZdcSimpleRecAlgo_Run3::templateFitValues_

private

Definition at line 67 of file ZdcSimpleRecAlgo_Run3.h.

Referenced by initTemplateFit(), and reco0().