Algorithm for latency run. More...

#include <SamplingAlgorithm.h>

Inheritance diagram for SamplingAlgorithm:

Public Member Functions
const Histo &	histo () const

	SamplingAlgorithm (const edm::ParameterSet &pset, SamplingAnalysis *const, uint32_t latencyCode=0)

	~SamplingAlgorithm () 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

void	correctBinning (TProfile *prof) const

void	correctProfile (TProfile *profile, float SoNcut=3.) const

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

void	pruneProfile (TProfile *profile) const

	SamplingAlgorithm ()

Private Attributes
TF1 *	deconv_fitter_

Histo	histo_

uint32_t	latencyCode_

TF1 *	peak_fitterA_

TF1 *	peak_fitterB_

SamplingAnalysis *	samp_

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 latency run.

Author: C. Delaere

Definition at line 18 of file SamplingAlgorithm.h.

Constructor & Destructor Documentation

SamplingAlgorithm::SamplingAlgorithm	(	const edm::ParameterSet &	pset,
		SamplingAnalysis * const	anal,
		uint32_t	latencyCode = `0`
	)

Definition at line 18 of file SamplingAlgorithm.cc.

References deconv_fitter_, fdeconv_convoluted(), fpeak_convoluted(), peak_fitterA_, and peak_fitterB_.

     : CommissioningAlgorithm(anal),
       histo_(nullptr, ""),
       deconv_fitter_(nullptr),
       peak_fitterA_(nullptr),
       peak_fitterB_(nullptr),
       latencyCode_(latencyCode),
       samp_(nullptr) {
   peak_fitterA_ = new TF1("peak_fitterA", fpeak_convoluted, -4800, 0, 5);
   peak_fitterA_->SetNpx(2000);
   peak_fitterA_->FixParameter(0, 0);
   peak_fitterA_->SetParLimits(1, 0, 4800);
   peak_fitterA_->SetParLimits(2, 0, 20);
   peak_fitterA_->FixParameter(3, 50);
   peak_fitterA_->SetParLimits(4, 0, 75);
   peak_fitterA_->SetParameters(0., 1250, 10, 50, 10);
 
   peak_fitterB_ = new TF1("peak_fitterB", fpeak_convoluted, -100, 100, 5);
   peak_fitterB_->SetNpx(200);
   peak_fitterB_->FixParameter(0, 0);
   peak_fitterB_->SetParLimits(1, -100, 100);
   peak_fitterB_->SetParLimits(2, 0, 20);
   peak_fitterB_->FixParameter(3, 50);
   peak_fitterB_->SetParLimits(4, 0, 75);
   peak_fitterB_->SetParameters(0., -50, 10, 50, 10);
 
   deconv_fitter_ = new TF1("deconv_fitter", fdeconv_convoluted, -50, 50, 5);
   deconv_fitter_->SetNpx(1000);
   deconv_fitter_->FixParameter(0, 0);
   deconv_fitter_->SetParLimits(1, -50, 50);
   deconv_fitter_->SetParLimits(2, 0, 200);
   deconv_fitter_->SetParLimits(3, 5, 100);
   deconv_fitter_->FixParameter(3, 50);
   deconv_fitter_->SetParLimits(4, 0, 75);
   deconv_fitter_->SetParameters(0., -2.82, 0.96, 50, 20);
 }

SamplingAlgorithm::~SamplingAlgorithm ( )

inlineoverride

Definition at line 22 of file SamplingAlgorithm.h.

References histo().

22 { ; }

SamplingAlgorithm::SamplingAlgorithm ( )

inlineprivate

Definition at line 27 of file SamplingAlgorithm.h.

References analyse(), correctBinning(), correctProfile(), extract(), PostProcessor_cff::profile, and pruneProfile().

27 { ; }

Member Function Documentation

void SamplingAlgorithm::analyse ( )

overrideprivatevirtual

Performs histogram anaylsis.

Implements CommissioningAlgorithm.

Definition at line 113 of file SamplingAlgorithm.cc.

References sistrip::APV_LATENCY, correctBinning(), correctProfile(), deconv_fitter_, SamplingAnalysis::error_, histo_, mps_fire::i, latencyCode_, SiStripPI::max, SamplingAnalysis::max_, sistrip::mlCommissioning_, peak_fitterA_, peak_fitterB_, pruneProfile(), SamplingAnalysis::runType_, samp_, SamplingAnalysis::sOnCut_, and mathSSE::sqrt().

Referenced by SamplingAlgorithm().

                                 {
   if (!samp_) {
     edm::LogWarning(mlCommissioning_) << "[SamplingAlgorithm::" << __func__ << "]"
                                       << " NULL pointer to derived Analysis object!";
     return;
   }
 
   TProfile* prof = (TProfile*)(histo_.first);
   if (!prof) {
     edm::LogWarning(mlCommissioning_) << " NULL pointer to histogram!";
     return;
   }
 
   // set the right error mode: rms
   prof->SetErrorOption(" ");
 
   //that should not be needed, but it seems histos are stored with error option " " and errors "s" in all cases.
   //it MUST be removed if the DQM (?) bug is solved
   for (int i = 0; i < prof->GetNbinsX(); ++i) {
     if (prof->GetBinEntries(i) > 0)
       prof->SetBinError(i, prof->GetBinError(i) / sqrt(prof->GetBinEntries(i)));
   }
 
   // prune the profile
   pruneProfile(prof);
 
   // correct for the binning
   correctBinning(prof);
 
   // correct for clustering effects
   correctProfile(prof, samp_->sOnCut_);
 
   // fit depending on the mode
   if (samp_->runType_ == sistrip::APV_LATENCY) {
     // initialize  the fit (overal latency)
     float max = prof->GetBinCenter(prof->GetMaximumBin());
     float ampl = prof->GetMaximum();
     peak_fitterA_->SetParameters(0., 50 - max, ampl / 20., 50, 10);
 
     // fit
     if (prof->Fit(peak_fitterA_, "Q") == 0)
       prof->Fit(peak_fitterA_, "QEM");
 
     // Set monitorables
     samp_->max_ = peak_fitterA_->GetMaximumX();
     samp_->error_ = peak_fitterA_->GetParError(1);
 
   } else {  // sistrip::FINE_DELAY
 
     // initialize  the fit (overal latency)
     float max = prof->GetBinCenter(prof->GetMaximumBin());
     float ampl = prof->GetMaximum();
     deconv_fitter_->SetParameters(0., -max, ampl / 10., 50, 20);
     peak_fitterB_->SetParameters(0., 50 - max, ampl / 20., 50, 10);
     if (latencyCode_ & 0x80) {  // deconv mode
       // fit
       if (prof->Fit(deconv_fitter_, "Q") == 0)
         prof->Fit(deconv_fitter_, "QEM");
       // Set monitorables
       samp_->max_ = deconv_fitter_->GetMaximumX();
       samp_->error_ = deconv_fitter_->GetParError(1);
     } else {  // peak mode
       // fit
       if (prof->Fit(peak_fitterB_, "Q") == 0)
         prof->Fit(peak_fitterB_, "QEM");
       // Set monitorables
       samp_->max_ = peak_fitterB_->GetMaximumX();
       samp_->error_ = peak_fitterB_->GetParError(1);
     }
   }
 }

void SamplingAlgorithm::correctBinning ( TProfile * prof ) const

private

Definition at line 204 of file SamplingAlgorithm.cc.

Referenced by analyse(), and SamplingAlgorithm().

                                                            {
   prof->GetXaxis()->SetLimits(prof->GetXaxis()->GetXmin() - prof->GetBinWidth(1) / 2.,
                               prof->GetXaxis()->GetXmax() - prof->GetBinWidth(1) / 2.);
 }

void SamplingAlgorithm::correctProfile	(	TProfile *	profile,
		float	SoNcut = `3.`
	)		const

private

Definition at line 211 of file SamplingAlgorithm.cc.

References newFWLiteAna::bin, SamplingAnalysis::correctMeasurement(), SamplingAnalysis::limit(), min(), LaserClient_cfi::nbins, and samp_.

Referenced by analyse(), and SamplingAlgorithm().

                                                                             {
   if (!samp_) {
     return;
   }
   uint32_t nbins = profile->GetNbinsX();
   float min = samp_->limit(SoNcut);
   for (uint32_t bin = 1; bin <= nbins; ++bin)
     if (profile->GetBinContent(bin) < min) {
       profile->SetBinContent(bin, 0.);
       profile->SetBinError(bin, 0.);
       profile->SetBinEntries(bin, 0);
     } else {
       profile->SetBinContent(
           bin, profile->GetBinEntries(bin) * samp_->correctMeasurement(profile->GetBinContent(bin), SoNcut));
     }
 }

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

overrideprivatevirtual

Extracts and organises histograms.

Implements CommissioningAlgorithm.

Definition at line 57 of file SamplingAlgorithm.cc.

References CommissioningAnalysis::addErrorCode(), CommissioningAlgorithm::anal(), sistrip::APV_LATENCY, sistrip::extrainfo::clusterCharge_, CommissioningAlgorithm::extractFedKey(), CommissioningAnalysis::fedKey(), sistrip::FINE_DELAY, SamplingAnalysis::granularity_, histo_, sistrip::mlCommissioning_, sistrip::numberOfHistos_, SamplingAnalysis::runType_, samp_, overlapproblemtsosanalyzer_cfi::title, createJobs::tmp, and sistrip::unexpectedTask_.

Referenced by SamplingAlgorithm().

                                                              {
   if (!anal()) {
     edm::LogWarning(mlCommissioning_) << "[SamplingAlgorithm::" << __func__ << "]"
                                       << " NULL pointer to Analysis object!";
     return;
   }
 
   CommissioningAnalysis* tmp = const_cast<CommissioningAnalysis*>(anal());
   samp_ = dynamic_cast<SamplingAnalysis*>(tmp);
   if (!samp_) {
     edm::LogWarning(mlCommissioning_) << "[SamplingAlgorithm::" << __func__ << "]"
                                       << " NULL pointer to derived Analysis object!";
     return;
   }
 
   // Check
   if (histos.size() != 1 && histos.size() != 2) {
     samp_->addErrorCode(sistrip::numberOfHistos_);
   }
 
   // Extract FED key from histo title
   if (!histos.empty()) {
     samp_->fedKey(extractFedKey(histos.front()));
   }
 
   // Extract
   std::vector<TH1*>::const_iterator ihis = histos.begin();
   for (; ihis != histos.end(); ihis++) {
     // Check pointer
     if (!(*ihis)) {
       edm::LogWarning(mlCommissioning_) << " NULL pointer to histogram!";
       continue;
     }
 
     // Check name
     SiStripHistoTitle title((*ihis)->GetName());
     if (title.runType() != sistrip::APV_LATENCY && title.runType() != sistrip::FINE_DELAY) {
       samp_->addErrorCode(sistrip::unexpectedTask_);
       continue;
     }
     // Set the mode for later fits
     samp_->runType_ = title.runType();
 
     // Set the granularity
     samp_->granularity_ = title.granularity();
 
     // Extract timing histo
     if (title.extraInfo().find(sistrip::extrainfo::clusterCharge_) != std::string::npos) {
       histo_.first = *ihis;
       histo_.second = (*ihis)->GetName();
     }
   }
 }

const Histo& SamplingAlgorithm::histo ( ) const

inline

Referenced by ~SamplingAlgorithm().

void SamplingAlgorithm::pruneProfile ( TProfile * profile ) const

private

Definition at line 187 of file SamplingAlgorithm.cc.

References newFWLiteAna::bin, SiStripPI::max, min(), and LaserClient_cfi::nbins.

Referenced by analyse(), and SamplingAlgorithm().

                                                             {
   // loop over bins to find the max stat
   uint32_t nbins = profile->GetNbinsX();
   uint32_t max = 0;
   for (uint32_t bin = 1; bin <= nbins; ++bin)
     max = max < profile->GetBinEntries(bin) ? uint32_t(profile->GetBinEntries(bin)) : max;
   // loop over bins to clean
   uint32_t min = max / 10;
   for (uint32_t bin = 1; bin <= nbins; ++bin)
     if (profile->GetBinEntries(bin) < min) {
       profile->SetBinContent(bin, 0.);
       profile->SetBinError(bin, 0.);
     }
 }