CalibrationAlgorithm Class Reference

Algorithm for calibration runs. More...

#include <CalibrationAlgorithm.h>

Inheritance diagram for CalibrationAlgorithm:

Public Member Functions
	CalibrationAlgorithm (const edm::ParameterSet &pset, CalibrationAnalysis *const)
const Histo &	histo (int &i)
	~CalibrationAlgorithm () override
Public Member Functions inherited from CommissioningAlgorithm
void	analysis (const std::vector< TH1 *> &)
	CommissioningAlgorithm (CommissioningAnalysis *const)
	CommissioningAlgorithm ()
virtual	~CommissioningAlgorithm ()

Private Member Functions
void	analyse () override
float	baseLine (TF1 *)
	CalibrationAlgorithm ()
void	correctDistribution (TH1 *) const
float	decayTime (TF1 *)
void	extract (const std::vector< TH1 *> &) override
float	turnOn (TF1 *, const float &)

Private Attributes
std::vector< int >	apvId_
CalibrationAnalysis *	cal_
std::vector< int >	calChan_
std::vector< Histo >	histo_
std::vector< int >	stripId_

Additional Inherited Members
Public Types inherited from CommissioningAlgorithm
typedef std::pair< TH1 *, std::string >	Histo
Protected Member Functions inherited from CommissioningAlgorithm
CommissioningAnalysis *const	anal () const
uint32_t	extractFedKey (const TH1 *const)

Detailed Description

Algorithm for calibration runs.

Author

C. Delaere

Definition at line 19 of file CalibrationAlgorithm.h.

Constructor & Destructor Documentation

CalibrationAlgorithm() [1/2]

CalibrationAlgorithm::CalibrationAlgorithm	(	const edm::ParameterSet &	pset,
		CalibrationAnalysis * const	anal
	)

Definition at line 23 of file CalibrationAlgorithm.cc.

    : CommissioningAlgorithm(anal), cal_(nullptr) {}

~CalibrationAlgorithm()

CalibrationAlgorithm::~CalibrationAlgorithm ( )

inlineoverride

Definition at line 22 of file CalibrationAlgorithm.h.

{ ; }

CalibrationAlgorithm() [2/2]

CalibrationAlgorithm::CalibrationAlgorithm ( )

inlineprivate

Definition at line 27 of file CalibrationAlgorithm.h.

{ ; }

Member Function Documentation

analyse()

void CalibrationAlgorithm::analyse ( )

overrideprivatevirtual

Performs histogram anaylsis.

Implements CommissioningAlgorithm.

Definition at line 88 of file CalibrationAlgorithm.cc.

References CalibrationAnalysis::amplitude_, apvId_, baseLine(), CalibrationAnalysis::baseline_, cal_, calChan_, CalibrationAnalysis::calChan_, CalibrationAnalysis::chi2_, correctDistribution(), decayTime(), CalibrationAnalysis::decayTime_, CalibrationAnalysis::deconv_, relativeConstraints::error, fdeconv(), dqmdumpme::first, fpeak(), histo_, mps_fire::i, CalibrationAnalysis::isvalid_, CalibrationAnalysis::max_amplitude_, CalibrationAnalysis::max_baseline_, CalibrationAnalysis::max_chi2_, CalibrationAnalysis::max_decayTime_, CalibrationAnalysis::max_peakTime_, CalibrationAnalysis::max_riseTime_, CalibrationAnalysis::max_smearing_, CalibrationAnalysis::max_tail_, CalibrationAnalysis::max_turnOn_, CalibrationAnalysis::max_undershoot_, CalibrationAnalysis::maxBaselineThreshold_, CalibrationAnalysis::maxChi2Threshold_, CalibrationAnalysis::maxDecayTimeThreshold_, CalibrationAnalysis::maxDecayTimeThresholdDeco_, CalibrationAnalysis::maxPeakTimeThreshold_, CalibrationAnalysis::maxPeakTimeThresholdDeco_, CalibrationAnalysis::maxRiseTimeThreshold_, CalibrationAnalysis::maxRiseTimeThresholdDeco_, CalibrationAnalysis::maxTurnOnThreshold_, CalibrationAnalysis::maxTurnOnThresholdDeco_, CalibrationAnalysis::mean_amplitude_, CalibrationAnalysis::mean_baseline_, CalibrationAnalysis::mean_chi2_, CalibrationAnalysis::mean_decayTime_, CalibrationAnalysis::mean_peakTime_, CalibrationAnalysis::mean_riseTime_, CalibrationAnalysis::mean_smearing_, CalibrationAnalysis::mean_tail_, CalibrationAnalysis::mean_turnOn_, CalibrationAnalysis::mean_undershoot_, CalibrationAnalysis::min_amplitude_, CalibrationAnalysis::min_baseline_, CalibrationAnalysis::min_chi2_, CalibrationAnalysis::min_decayTime_, CalibrationAnalysis::min_peakTime_, CalibrationAnalysis::min_riseTime_, CalibrationAnalysis::min_smearing_, CalibrationAnalysis::min_tail_, CalibrationAnalysis::min_turnOn_, CalibrationAnalysis::min_undershoot_, CalibrationAnalysis::minAmplitudeThreshold_, CalibrationAnalysis::minBaselineThreshold_, CalibrationAnalysis::minDecayTimeThreshold_, CalibrationAnalysis::minDecayTimeThresholdDeco_, CalibrationAnalysis::minPeakTimeThreshold_, CalibrationAnalysis::minPeakTimeThresholdDeco_, CalibrationAnalysis::minRiseTimeThreshold_, CalibrationAnalysis::minRiseTimeThresholdDeco_, CalibrationAnalysis::minTurnOnThreshold_, CalibrationAnalysis::minTurnOnThresholdDeco_, sistrip::mlCommissioning_, me0TriggerPseudoDigis_cff::nStrips, CalibrationAnalysis::peakTime_, CalibrationAnalysis::riseTime_, Gflash::Rmax, Gflash::Rmin, CalibrationAnalysis::smearing_, CalibrationAnalysis::spread_amplitude_, CalibrationAnalysis::spread_baseline_, CalibrationAnalysis::spread_chi2_, CalibrationAnalysis::spread_decayTime_, CalibrationAnalysis::spread_peakTime_, CalibrationAnalysis::spread_riseTime_, CalibrationAnalysis::spread_smearing_, CalibrationAnalysis::spread_tail_, CalibrationAnalysis::spread_turnOn_, CalibrationAnalysis::spread_undershoot_, mathSSE::sqrt(), stripId_, CalibrationAnalysis::tail_, builder_last_value_cfg::Tmax, builder_last_value_cfg::Tmin, turnOn(), CalibrationAnalysis::turnOn_, and CalibrationAnalysis::undershoot_.

                                   {
  ROOT::Math::MinimizerOptions::SetDefaultMinimizer("Minuit2", "Migrad");
  ROOT::Math::MinimizerOptions::SetDefaultStrategy(0);

  if (!cal_) {
    edm::LogWarning(mlCommissioning_) << "[CalibrationAlgorithm::" << __func__ << "]"
                                      << " NULL pointer to derived Analysis object!";
    return;
  }

  float Amean[2] = {-1., -1.};
  float Amin[2] = {-1., -1.};
  float Amax[2] = {-1., -1.};
  float Aspread[2] = {-1., -1.};
  float Tmean[2] = {-1., -1.};
  float Tmin[2] = {-1., -1.};
  float Tmax[2] = {-1., -1.};
  float Tspread[2] = {-1., -1.};
  float Rmean[2] = {-1., -1.};
  float Rmin[2] = {-1., -1.};
  float Rmax[2] = {-1., -1.};
  float Rspread[2] = {-1., -1.};
  float Cmean[2] = {-1., -1.};
  float Cmin[2] = {-1., -1.};
  float Cmax[2] = {-1., -1.};
  float Cspread[2] = {-1., -1.};
  float Smean[2] = {-1., -1.};
  float Smin[2] = {-1., -1.};
  float Smax[2] = {-1., -1.};
  float Sspread[2] = {-1., -1.};
  float Kmean[2] = {-1., -1.};
  float Kmin[2] = {-1., -1.};
  float Kmax[2] = {-1., -1.};
  float Kspread[2] = {-1., -1.};
  // turnOn
  float Omean[2] = {-1., -1.};
  float Omin[2] = {-1., -1.};
  float Omax[2] = {-1., -1.};
  float Ospread[2] = {-1., -1.};
  // maximum
  float Mmean[2] = {-1., -1.};
  float Mmin[2] = {-1., -1.};
  float Mmax[2] = {-1., -1.};
  float Mspread[2] = {-1., -1.};
  // undershoot
  float Umean[2] = {-1., -1.};
  float Umin[2] = {-1., -1.};
  float Umax[2] = {-1., -1.};
  float Uspread[2] = {-1., -1.};
  // baseline
  float Bmean[2] = {-1., -1.};
  float Bmin[2] = {-1., -1.};
  float Bmax[2] = {-1., -1.};
  float Bspread[2] = {-1., -1.};

  TFitResultPtr fit_result;
  TF1* fit_function = nullptr;
  if (cal_->deconv_) {
    fit_function = new TF1("fit_function_deco", fdeconv, 0, 400, 7);
    fit_function->SetParameters(4, 25, 25, 50, 250, 25, 0.75);
  } else {
    fit_function = new TF1("fit_function_peak", fpeak, 0, 400, 6);
    fit_function->SetParameters(4, 50, 50, 70, 250, 20);
  }

  std::vector<unsigned int> nStrips(2, 0.);

  for (size_t ihist = 0; ihist < histo_.size(); ihist++) {
    if (!histo_[ihist].first) {
      edm::LogWarning(mlCommissioning_) << " NULL pointer to histogram for: " << histo_[ihist].second << " !";
      return;
    }

    cal_->amplitude_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->baseline_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->riseTime_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->turnOn_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->peakTime_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->undershoot_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->tail_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->decayTime_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->smearing_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->chi2_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->isvalid_[apvId_[ihist]][stripId_[ihist]] = true;

    if (histo_[ihist].first->Integral() == 0) {
      cal_->isvalid_[apvId_[ihist]][stripId_[ihist]] = false;
      continue;
    }

    // rescale the plot and set reasonable errors
    correctDistribution(histo_[ihist].first);

    // from NOTE2009_021 : The charge injection provided by the calibration circuit is known with a precision of 5%
    float error = histo_[ihist].first->GetMaximum() * 0.05;
    for (int i = 1; i <= histo_[ihist].first->GetNbinsX(); ++i)
      histo_[ihist].first->SetBinError(i, error);

    // set intial par
    if (cal_->deconv_)
      fit_function->SetParameters(10, 15, 30, 10, 350, 50, 0.75);
    else
      fit_function->SetParameters(6, 40, 40, 70, 350, 20);

    fit_result = histo_[ihist].first->Fit(fit_function, "QS");

    // fit-result should exist and have a resonably good status
    if (not fit_result.Get())
      continue;

    float maximum_ampl = fit_function->GetMaximum();
    float peak_time = fit_function->GetMaximumX();
    float baseline = baseLine(fit_function);
    float turn_on_time = turnOn(fit_function, baseline);
    float rise_time = peak_time - turn_on_time;

    // start filling info
    cal_->amplitude_[apvId_[ihist]][stripId_[ihist]] = maximum_ampl - baseline;
    cal_->baseline_[apvId_[ihist]][stripId_[ihist]] = baseline;
    cal_->riseTime_[apvId_[ihist]][stripId_[ihist]] = rise_time;
    cal_->turnOn_[apvId_[ihist]][stripId_[ihist]] = turn_on_time;
    cal_->peakTime_[apvId_[ihist]][stripId_[ihist]] = peak_time;

    if (cal_->deconv_ and fit_function->GetMinimumX() > peak_time)  // make sure the minimum is after the peak-time
      cal_->undershoot_[apvId_[ihist]][stripId_[ihist]] =
          100 * (fit_function->GetMinimum() - baseline) / (maximum_ampl - baseline);
    else
      cal_->undershoot_[apvId_[ihist]][stripId_[ihist]] = 0;

    // Bin related to peak + 125 ns
    int lastBin = histo_[ihist].first->FindBin(peak_time + 125);
    if (lastBin > histo_[ihist].first->GetNbinsX() - 4)
      lastBin = histo_[ihist].first->GetNbinsX() - 4;

    // tail is the amplitude at 5 bx from the maximum
    cal_->tail_[apvId_[ihist]][stripId_[ihist]] =
        100 * (histo_[ihist].first->GetBinContent(lastBin) - baseline) / (maximum_ampl - baseline);

    // reaches 1/e of the peak amplitude
    cal_->decayTime_[apvId_[ihist]][stripId_[ihist]] = decayTime(fit_function) - peak_time;
    cal_->smearing_[apvId_[ihist]][stripId_[ihist]] = 0;
    cal_->chi2_[apvId_[ihist]][stripId_[ihist]] =
        fit_function->GetChisquare() / (histo_[ihist].first->GetNbinsX() - fit_function->GetNpar());

    // calibration channel
    cal_->calChan_ = calChan_[ihist];

    // apply quality requirements
    bool isvalid = true;
    if (not cal_->deconv_) {  // peak-mode

      if (cal_->amplitude_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minAmplitudeThreshold_)
        isvalid = false;
      if (cal_->baseline_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minBaselineThreshold_)
        isvalid = false;
      else if (cal_->baseline_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxBaselineThreshold_)
        isvalid = false;
      if (cal_->decayTime_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minDecayTimeThreshold_)
        isvalid = false;
      else if (cal_->decayTime_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxDecayTimeThreshold_)
        isvalid = false;
      if (cal_->peakTime_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minPeakTimeThreshold_)
        isvalid = false;
      else if (cal_->peakTime_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxPeakTimeThreshold_)
        isvalid = false;
      if (cal_->riseTime_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minRiseTimeThreshold_)
        isvalid = false;
      else if (cal_->riseTime_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxRiseTimeThreshold_)
        isvalid = false;
      if (cal_->turnOn_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minTurnOnThreshold_)
        isvalid = false;
      else if (cal_->turnOn_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxTurnOnThreshold_)
        isvalid = false;
      if (cal_->chi2_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxChi2Threshold_)
        isvalid = false;

    } else {
      if (fit_function->GetMinimumX() < peak_time)
        isvalid = false;
      if (cal_->amplitude_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minAmplitudeThreshold_)
        isvalid = false;
      if (cal_->baseline_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minBaselineThreshold_)
        isvalid = false;
      if (cal_->baseline_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minBaselineThreshold_)
        isvalid = false;
      else if (cal_->baseline_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxBaselineThreshold_)
        isvalid = false;
      if (cal_->chi2_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxChi2Threshold_)
        isvalid = false;
      if (cal_->turnOn_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minTurnOnThresholdDeco_)
        isvalid = false;
      else if (cal_->turnOn_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxTurnOnThresholdDeco_)
        isvalid = false;
      if (cal_->decayTime_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minDecayTimeThresholdDeco_)
        isvalid = false;
      else if (cal_->decayTime_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxDecayTimeThresholdDeco_)
        isvalid = false;
      if (cal_->peakTime_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minPeakTimeThresholdDeco_)
        isvalid = false;
      else if (cal_->peakTime_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxPeakTimeThresholdDeco_)
        isvalid = false;
      if (cal_->riseTime_[apvId_[ihist]][stripId_[ihist]] < CalibrationAnalysis::minRiseTimeThresholdDeco_)
        isvalid = false;
      else if (cal_->riseTime_[apvId_[ihist]][stripId_[ihist]] > CalibrationAnalysis::maxRiseTimeThresholdDeco_)
        isvalid = false;
    }

    if (not isvalid) {  // not valid set default to zero for all quantities

      cal_->amplitude_[apvId_[ihist]][stripId_[ihist]] = 0;
      cal_->baseline_[apvId_[ihist]][stripId_[ihist]] = 0;
      cal_->riseTime_[apvId_[ihist]][stripId_[ihist]] = 0;
      cal_->turnOn_[apvId_[ihist]][stripId_[ihist]] = 0;
      cal_->peakTime_[apvId_[ihist]][stripId_[ihist]] = 0;
      cal_->undershoot_[apvId_[ihist]][stripId_[ihist]] = 0;
      cal_->tail_[apvId_[ihist]][stripId_[ihist]] = 0;
      cal_->decayTime_[apvId_[ihist]][stripId_[ihist]] = 0;
      cal_->smearing_[apvId_[ihist]][stripId_[ihist]] = 0;
      cal_->chi2_[apvId_[ihist]][stripId_[ihist]] = 0;
      cal_->isvalid_[apvId_[ihist]][stripId_[ihist]] = false;
      continue;
    }

    // in case is valid
    nStrips[apvId_[ihist]]++;

    //compute mean, max, min, spread only for valid strips
    Amean[apvId_[ihist]] += cal_->amplitude_[apvId_[ihist]][stripId_[ihist]];
    Amin[apvId_[ihist]] = Amin[apvId_[ihist]] < cal_->amplitude_[apvId_[ihist]][stripId_[ihist]]
                              ? Amin[apvId_[ihist]]
                              : cal_->amplitude_[apvId_[ihist]][stripId_[ihist]];
    Amax[apvId_[ihist]] = Amax[apvId_[ihist]] > cal_->amplitude_[apvId_[ihist]][stripId_[ihist]]
                              ? Amax[apvId_[ihist]]
                              : cal_->amplitude_[apvId_[ihist]][stripId_[ihist]];
    Aspread[apvId_[ihist]] +=
        cal_->amplitude_[apvId_[ihist]][stripId_[ihist]] * cal_->amplitude_[apvId_[ihist]][stripId_[ihist]];

    Tmean[apvId_[ihist]] += cal_->tail_[apvId_[ihist]][stripId_[ihist]];
    Tmin[apvId_[ihist]] = Tmin[apvId_[ihist]] < cal_->tail_[apvId_[ihist]][stripId_[ihist]]
                              ? Tmin[apvId_[ihist]]
                              : cal_->tail_[apvId_[ihist]][stripId_[ihist]];
    Tmax[apvId_[ihist]] = Tmax[apvId_[ihist]] > cal_->tail_[apvId_[ihist]][stripId_[ihist]]
                              ? Tmax[apvId_[ihist]]
                              : cal_->tail_[apvId_[ihist]][stripId_[ihist]];
    Tspread[apvId_[ihist]] += cal_->tail_[apvId_[ihist]][stripId_[ihist]] * cal_->tail_[apvId_[ihist]][stripId_[ihist]];

    Rmean[apvId_[ihist]] += cal_->riseTime_[apvId_[ihist]][stripId_[ihist]];
    Rmin[apvId_[ihist]] = Rmin[apvId_[ihist]] < cal_->riseTime_[apvId_[ihist]][stripId_[ihist]]
                              ? Rmin[apvId_[ihist]]
                              : cal_->riseTime_[apvId_[ihist]][stripId_[ihist]];
    Rmax[apvId_[ihist]] = Rmax[apvId_[ihist]] > cal_->riseTime_[apvId_[ihist]][stripId_[ihist]]
                              ? Rmax[apvId_[ihist]]
                              : cal_->riseTime_[apvId_[ihist]][stripId_[ihist]];
    Rspread[apvId_[ihist]] +=
        cal_->riseTime_[apvId_[ihist]][stripId_[ihist]] * cal_->riseTime_[apvId_[ihist]][stripId_[ihist]];

    Cmean[apvId_[ihist]] += cal_->decayTime_[apvId_[ihist]][stripId_[ihist]];
    Cmin[apvId_[ihist]] = Cmin[apvId_[ihist]] < cal_->decayTime_[apvId_[ihist]][stripId_[ihist]]
                              ? Cmin[apvId_[ihist]]
                              : cal_->decayTime_[apvId_[ihist]][stripId_[ihist]];
    Cmax[apvId_[ihist]] = Cmax[apvId_[ihist]] > cal_->decayTime_[apvId_[ihist]][stripId_[ihist]]
                              ? Cmax[apvId_[ihist]]
                              : cal_->decayTime_[apvId_[ihist]][stripId_[ihist]];
    Cspread[apvId_[ihist]] +=
        cal_->decayTime_[apvId_[ihist]][stripId_[ihist]] * cal_->decayTime_[apvId_[ihist]][stripId_[ihist]];

    Smean[apvId_[ihist]] += cal_->smearing_[apvId_[ihist]][stripId_[ihist]];
    Smin[apvId_[ihist]] = Smin[apvId_[ihist]] < cal_->smearing_[apvId_[ihist]][stripId_[ihist]]
                              ? Smin[apvId_[ihist]]
                              : cal_->smearing_[apvId_[ihist]][stripId_[ihist]];
    Smax[apvId_[ihist]] = Smax[apvId_[ihist]] > cal_->smearing_[apvId_[ihist]][stripId_[ihist]]
                              ? Smax[apvId_[ihist]]
                              : cal_->smearing_[apvId_[ihist]][stripId_[ihist]];
    Sspread[apvId_[ihist]] +=
        cal_->smearing_[apvId_[ihist]][stripId_[ihist]] * cal_->smearing_[apvId_[ihist]][stripId_[ihist]];

    Kmean[apvId_[ihist]] += cal_->chi2_[apvId_[ihist]][stripId_[ihist]];
    Kmin[apvId_[ihist]] = Kmin[apvId_[ihist]] < cal_->chi2_[apvId_[ihist]][stripId_[ihist]]
                              ? Kmin[apvId_[ihist]]
                              : cal_->chi2_[apvId_[ihist]][stripId_[ihist]];
    Kmax[apvId_[ihist]] = Kmax[apvId_[ihist]] > cal_->chi2_[apvId_[ihist]][stripId_[ihist]]
                              ? Kmax[apvId_[ihist]]
                              : cal_->chi2_[apvId_[ihist]][stripId_[ihist]];
    Kspread[apvId_[ihist]] += cal_->chi2_[apvId_[ihist]][stripId_[ihist]] * cal_->chi2_[apvId_[ihist]][stripId_[ihist]];

    Omean[apvId_[ihist]] += cal_->turnOn_[apvId_[ihist]][stripId_[ihist]];
    Omin[apvId_[ihist]] = Omin[apvId_[ihist]] < cal_->turnOn_[apvId_[ihist]][stripId_[ihist]]
                              ? Omin[apvId_[ihist]]
                              : cal_->turnOn_[apvId_[ihist]][stripId_[ihist]];
    Omax[apvId_[ihist]] = Omax[apvId_[ihist]] > cal_->turnOn_[apvId_[ihist]][stripId_[ihist]]
                              ? Omax[apvId_[ihist]]
                              : cal_->turnOn_[apvId_[ihist]][stripId_[ihist]];
    Ospread[apvId_[ihist]] +=
        cal_->turnOn_[apvId_[ihist]][stripId_[ihist]] * cal_->turnOn_[apvId_[ihist]][stripId_[ihist]];

    Mmean[apvId_[ihist]] += cal_->peakTime_[apvId_[ihist]][stripId_[ihist]];
    Mmin[apvId_[ihist]] = Mmin[apvId_[ihist]] < cal_->peakTime_[apvId_[ihist]][stripId_[ihist]]
                              ? Mmin[apvId_[ihist]]
                              : cal_->peakTime_[apvId_[ihist]][stripId_[ihist]];
    Mmax[apvId_[ihist]] = Mmax[apvId_[ihist]] > cal_->peakTime_[apvId_[ihist]][stripId_[ihist]]
                              ? Mmax[apvId_[ihist]]
                              : cal_->peakTime_[apvId_[ihist]][stripId_[ihist]];
    Mspread[apvId_[ihist]] +=
        cal_->peakTime_[apvId_[ihist]][stripId_[ihist]] * cal_->peakTime_[apvId_[ihist]][stripId_[ihist]];

    Umean[apvId_[ihist]] += cal_->undershoot_[apvId_[ihist]][stripId_[ihist]];
    Umin[apvId_[ihist]] = Umin[apvId_[ihist]] < cal_->undershoot_[apvId_[ihist]][stripId_[ihist]]
                              ? Umin[apvId_[ihist]]
                              : cal_->undershoot_[apvId_[ihist]][stripId_[ihist]];
    Umax[apvId_[ihist]] = Umax[apvId_[ihist]] > cal_->undershoot_[apvId_[ihist]][stripId_[ihist]]
                              ? Umax[apvId_[ihist]]
                              : cal_->undershoot_[apvId_[ihist]][stripId_[ihist]];
    Uspread[apvId_[ihist]] +=
        cal_->undershoot_[apvId_[ihist]][stripId_[ihist]] * cal_->undershoot_[apvId_[ihist]][stripId_[ihist]];

    Bmean[apvId_[ihist]] += cal_->baseline_[apvId_[ihist]][stripId_[ihist]];
    Bmin[apvId_[ihist]] = Bmin[apvId_[ihist]] < cal_->baseline_[apvId_[ihist]][stripId_[ihist]]
                              ? Bmin[apvId_[ihist]]
                              : cal_->baseline_[apvId_[ihist]][stripId_[ihist]];
    Bmax[apvId_[ihist]] = Bmax[apvId_[ihist]] > cal_->baseline_[apvId_[ihist]][stripId_[ihist]]
                              ? Bmax[apvId_[ihist]]
                              : cal_->baseline_[apvId_[ihist]][stripId_[ihist]];
    Bspread[apvId_[ihist]] +=
        cal_->baseline_[apvId_[ihist]][stripId_[ihist]] * cal_->baseline_[apvId_[ihist]][stripId_[ihist]];
  }

  // make mean values
  for (int i = 0; i < 2; i++) {
    if (nStrips[i] != 0) {
      Amean[i] = Amean[i] / nStrips[i];
      Tmean[i] = Tmean[i] / nStrips[i];
      Rmean[i] = Rmean[i] / nStrips[i];
      Cmean[i] = Cmean[i] / nStrips[i];
      Omean[i] = Omean[i] / nStrips[i];
      Mmean[i] = Mmean[i] / nStrips[i];
      Umean[i] = Umean[i] / nStrips[i];
      Bmean[i] = Bmean[i] / nStrips[i];
      Smean[i] = Smean[i] / nStrips[i];
      Kmean[i] = Kmean[i] / nStrips[i];

      Aspread[i] = Aspread[i] / nStrips[i];
      Tspread[i] = Tspread[i] / nStrips[i];
      Rspread[i] = Rspread[i] / nStrips[i];
      Cspread[i] = Cspread[i] / nStrips[i];
      Ospread[i] = Ospread[i] / nStrips[i];
      Mspread[i] = Mspread[i] / nStrips[i];
      Uspread[i] = Uspread[i] / nStrips[i];
      Bspread[i] = Bspread[i] / nStrips[i];
      Sspread[i] = Sspread[i] / nStrips[i];
      Kspread[i] = Kspread[i] / nStrips[i];
    }
  }

  // fill the mean, max, min, spread, ... histograms.
  for (int i = 0; i < 2; ++i) {
    cal_->mean_amplitude_[i] = Amean[i];
    cal_->mean_tail_[i] = Tmean[i];
    cal_->mean_riseTime_[i] = Rmean[i];
    cal_->mean_decayTime_[i] = Cmean[i];
    cal_->mean_turnOn_[i] = Omean[i];
    cal_->mean_peakTime_[i] = Mmean[i];
    cal_->mean_undershoot_[i] = Umean[i];
    cal_->mean_baseline_[i] = Bmean[i];
    cal_->mean_smearing_[i] = Smean[i];
    cal_->mean_chi2_[i] = Kmean[i];

    cal_->min_amplitude_[i] = Amin[i];
    cal_->min_tail_[i] = Tmin[i];
    cal_->min_riseTime_[i] = Rmin[i];
    cal_->min_decayTime_[i] = Cmin[i];
    cal_->min_turnOn_[i] = Omin[i];
    cal_->min_peakTime_[i] = Mmin[i];
    cal_->min_undershoot_[i] = Umin[i];
    cal_->min_baseline_[i] = Bmin[i];
    cal_->min_smearing_[i] = Smin[i];
    cal_->min_chi2_[i] = Kmin[i];

    cal_->max_amplitude_[i] = Amax[i];
    cal_->max_tail_[i] = Tmax[i];
    cal_->max_riseTime_[i] = Rmax[i];
    cal_->max_decayTime_[i] = Cmax[i];
    cal_->max_turnOn_[i] = Omax[i];
    cal_->max_peakTime_[i] = Mmax[i];
    cal_->max_undershoot_[i] = Umax[i];
    cal_->max_baseline_[i] = Bmax[i];
    cal_->max_smearing_[i] = Smax[i];
    cal_->max_chi2_[i] = Kmax[i];

    cal_->spread_amplitude_[i] = sqrt(fabs(Aspread[i] - Amean[i] * Amean[i]));
    cal_->spread_tail_[i] = sqrt(fabs(Tspread[i] - Tmean[i] * Tmean[i]));
    cal_->spread_riseTime_[i] = sqrt(fabs(Rspread[i] - Rmean[i] * Rmean[i]));
    cal_->spread_decayTime_[i] = sqrt(fabs(Cspread[i] - Cmean[i] * Cmean[i]));
    cal_->spread_turnOn_[i] = sqrt(fabs(Ospread[i] - Omean[i] * Omean[i]));
    cal_->spread_peakTime_[i] = sqrt(fabs(Mspread[i] - Mmean[i] * Mmean[i]));
    cal_->spread_undershoot_[i] = sqrt(fabs(Uspread[i] - Umean[i] * Umean[i]));
    cal_->spread_baseline_[i] = sqrt(fabs(Bspread[i] - Bmean[i] * Bmean[i]));
    cal_->spread_smearing_[i] = sqrt(fabs(Sspread[i] - Smean[i] * Smean[i]));
    cal_->spread_chi2_[i] = sqrt(fabs(Kspread[i] - Kmean[i] * Kmean[i]));
  }

  if (fit_function)
    delete fit_function;
}

baseLine()

float CalibrationAlgorithm::baseLine ( TF1 *  f )

private

Definition at line 503 of file CalibrationAlgorithm.cc.

References f, npoints, x, and TrackerOfflineValidation_Dqm_cff::xmax.

Referenced by analyse().

                                           {
  float xmax = 10;
  float baseline = 0;
  int npoints = 0;
  float x = f->GetXmin();
  for (; x < xmax; x += 0.1) {
    baseline += f->Eval(x);
    npoints++;
  }
  return baseline / npoints;
}

correctDistribution()

void CalibrationAlgorithm::correctDistribution ( TH1 *  histo ) const

private

Definition at line 495 of file CalibrationAlgorithm.cc.

References histo().

Referenced by analyse().

                                                               {
  // 20 events per point in the TM loop  --> divide by 20 to have the amplitude of a single event readout
  for (int iBin = 0; iBin < histo->GetNbinsX(); iBin++) {
    histo->SetBinContent(iBin + 1, -histo->GetBinContent(iBin + 1) / 20.);
  }
}

decayTime()

float CalibrationAlgorithm::decayTime ( TF1 *  f )

private

Definition at line 526 of file CalibrationAlgorithm.cc.

References JetChargeProducer_cfi::exp, f, x, and makeMEIFBenchmarkPlots::xval.

Referenced by analyse().

            {  // if we approximate the decay to an exp(-t/tau), in one constant unit, the amplited is reduced by e^{-1}
  float xval = f->GetMaximumX();
  float max_amplitude = f->GetMaximum();
  float x = xval;
  for (; x < 1000; x = x + 0.1) {
    if (f->Eval(x) < max_amplitude * exp(-1))
      break;
  }
  return x;
}

extract()

void CalibrationAlgorithm::extract ( const std::vector< TH1 *> &  )

overrideprivatevirtual

Extracts and organises histograms.

extract isha, vfs and calchan values, as well as filling the histogram objects

Implements CommissioningAlgorithm.

Definition at line 28 of file CalibrationAlgorithm.cc.

References CommissioningAnalysis::addErrorCode(), CommissioningAlgorithm::anal(), apvId_, cal_, calChan_, sistrip::CALIBRATION, sistrip::CALIBRATION_DECO, CommissioningAlgorithm::extractFedKey(), CommissioningAnalysis::fedKey(), histo_, mergeVDriftHistosByStation::histos, sistrip::mlCommissioning_, AlCaHLTBitMon_QueryRunRegistry::string, stripId_, runGCPTkAlMap::title, createJobs::tmp, unpackBuffers-CaloStage2::token, and sistrip::unexpectedTask_.

                                                                {
  // extract analysis object which should be already created
  if (!anal()) {
    edm::LogWarning(mlCommissioning_) << "[CalibrationAlgorithm::" << __func__ << "]"
                                      << " NULL pointer to base Analysis object!";
    return;
  }

  CommissioningAnalysis* tmp = const_cast<CommissioningAnalysis*>(anal());
  cal_ = dynamic_cast<CalibrationAnalysis*>(tmp);

  if (!cal_) {
    edm::LogWarning(mlCommissioning_) << "[CalibrationAlgorithm::" << __func__ << "]"
                                      << " NULL pointer to derived Analysis object!";
    return;
  }

  // Extract FED key from histo title
  if (!histos.empty()) {
    cal_->fedKey(extractFedKey(histos.front()));
  }

  // Extract histograms
  std::vector<TH1*>::const_iterator ihis = histos.begin();
  unsigned int cnt = 0;
  for (; ihis != histos.end(); ihis++, cnt++) {
    // Check for NULL pointer
    if (!(*ihis)) {
      continue;
    }

    // Check name
    SiStripHistoTitle title((*ihis)->GetName());
    if (title.runType() != sistrip::CALIBRATION && title.runType() != sistrip::CALIBRATION_DECO) {
      cal_->addErrorCode(sistrip::unexpectedTask_);
      continue;
    }

    std::vector<std::string> tokens;
    std::string token;
    std::istringstream tokenStream(title.extraInfo());
    while (std::getline(tokenStream, token, '_')) {
      tokens.push_back(token);
    }

    Histo histo_temp;
    histo_temp.first = *ihis;
    histo_temp.second = (*ihis)->GetTitle();
    histo_temp.first->Sumw2();
    histo_.push_back(histo_temp);
    apvId_.push_back(title.channel() % 2);
    stripId_.push_back(std::stoi(tokens.at(1)) * 16 + std::stoi(tokens.at(3)));
    calChan_.push_back(std::stoi(tokens.at(1)));
  }
}

histo()

const Histo& CalibrationAlgorithm::histo ( int &  i )

inline

Definition at line 24 of file CalibrationAlgorithm.h.

References histo_, and mps_fire::i.

Referenced by correctDistribution().

{ return histo_[i]; }

turnOn()

float CalibrationAlgorithm::turnOn ( TF1 *  f, const float &  baseline  )

private

Definition at line 516 of file CalibrationAlgorithm.cc.

References f, and hcalRecHitTable_cff::time.

Referenced by analyse().

                                                          {  // should happen within 100 ns in both deco and peak modes
  float max_amplitude = f->GetMaximum();
  float time = 10.;
  for (; time < 100 && (f->Eval(time) - baseline) < 0.05 * (max_amplitude - baseline); time += 0.1) {
  }  // flucutation higher than 5% of the pulse height
  return time;
}

Member Data Documentation

apvId_

std::vector<int> CalibrationAlgorithm::apvId_

private

Definition at line 44 of file CalibrationAlgorithm.h.

Referenced by analyse(), and extract().

cal_

CalibrationAnalysis* CalibrationAlgorithm::cal_

private

analysis object

Definition at line 47 of file CalibrationAlgorithm.h.

Referenced by analyse(), and extract().

calChan_

std::vector<int> CalibrationAlgorithm::calChan_

private

Definition at line 43 of file CalibrationAlgorithm.h.

Referenced by analyse(), and extract().

histo_

std::vector<Histo> CalibrationAlgorithm::histo_

private

pulse shape

Definition at line 41 of file CalibrationAlgorithm.h.

Referenced by analyse(), extract(), and histo().

stripId_

std::vector<int> CalibrationAlgorithm::stripId_

private

Definition at line 42 of file CalibrationAlgorithm.h.

Referenced by analyse(), and extract().