#include <SiPixelSCurveCalibrationAnalysis.h>

Inheritance diagram for SiPixelSCurveCalibrationAnalysis:

Public Member Functions
void	buildACurveHistogram (const uint32_t &detid, const uint32_t &row, const uint32_t &col, sCurveErrorFlag errorFlag, const std::vector< float > &efficiencies, const std::vector< float > &errors)

bool	doFits (uint32_t detid, std::vector< SiPixelCalibDigi >::const_iterator ipix) override

void	doSetup (const edm::ParameterSet &)

sCurveErrorFlag	estimateSCurveParameters (const std::vector< float > &eff, float &threshold, float &sigma)

sCurveErrorFlag	fittedSCurveSanityCheck (float threshold, float sigma, float amplitude)

	SiPixelSCurveCalibrationAnalysis (const edm::ParameterSet &iConfig)

	~SiPixelSCurveCalibrationAnalysis () override

Public Member Functions inherited from SiPixelOfflineCalibAnalysisBase
void	addTF1ToDQMMonitoringElement (MonitorElement ele, TF1 func)

MonitorElement *	bookDQMHistogram1D (uint32_t detid, std::string name, std::string title, int nchX, double lowX, double highX)

MonitorElement *	bookDQMHistogram1D (uint32_t detid, std::string name, std::string title, int nchX, float *xbinsize)

MonitorElement *	bookDQMHistogram2D (uint32_t detid, std::string name, std::string title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)

MonitorElement *	bookDQMHistoPlaquetteSummary2D (uint32_t detid, std::string name, std::string title)

std::vector< uint32_t > &	getRunNumbers ()

bool	setDQMDirectory (std::string dirName)

bool	setDQMDirectory (uint32_t detID)

	SiPixelOfflineCalibAnalysisBase (const edm::ParameterSet &)

	SiPixelOfflineCalibAnalysisBase ()

std::string	translateDetIdToString (uint32_t detid)

	~SiPixelOfflineCalibAnalysisBase () override

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Public Attributes
std::vector< float >	vCalPointsAsFloats_

Static Public Attributes
static std::vector< float >	effErrors_

static std::vector< float >	efficiencies_

Static Public Attributes inherited from SiPixelOfflineCalibAnalysisBase
static TF1 *	fitFunction_ = nullptr

Private Member Functions
void	calibrationEnd () override

void	calibrationSetup (const edm::EventSetup &iSetup) override

bool	checkCorrectCalibrationType () override

void	makeThresholdSummary (void)

void	newDetID (uint32_t detid) override

Private Attributes
unsigned int	curvesSavedCounter_

std::map< uint32_t, bool >	detIDsToSave_

detIDHistogramMap	histograms_

unsigned int	maxCurvesToSave_

double	maximumEffAsymptote_

double	maximumSigma_

double	maximumSigmaBin_

double	maximumThreshold_

double	maximumThresholdBin_

double	minimumChi2prob_

double	minimumEffAsymptote_

double	minimumSigma_

double	minimumThreshold_

std::vector< std::string >	plaquettesToSave_

bool	printoutthresholds_

bool	saveCurvesThatFlaggedBad_

std::string	thresholdfilename_

bool	useDetectorHierarchyFolders_

bool	write2dFitResult_

bool	write2dHistograms_

bool	writeZeroes_

Additional Inherited Members
Public Types inherited from SiPixelOfflineCalibAnalysisBase
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from SiPixelOfflineCalibAnalysisBase
static const std::vector< short > *	getVcalValues ()

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from SiPixelOfflineCalibAnalysisBase
uint32_t &	EventNumber ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Protected Attributes inherited from SiPixelOfflineCalibAnalysisBase
edm::ESGetToken< SiPixelFedCablingMap, SiPixelFedCablingMapRcd >	cablingMapToken_

edm::ESHandle< SiPixelCalibConfiguration >	calib_

std::string	calibrationMode_

edm::ESGetToken< SiPixelCalibConfiguration, SiPixelCalibConfigurationRcd >	calibToken_

edm::ESGetToken< SiPixelCalibConfiguration, SiPixelCalibConfigurationRcd >	calibTokenBeginRun_

edm::ESHandle< TrackerGeometry >	geom_

short	nTriggers_

edm::ESHandle< SiPixelFedCablingMap >	theCablingMap_

edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeomToken_

Static Protected Attributes inherited from SiPixelOfflineCalibAnalysisBase
static std::vector< short >	vCalValues_

Detailed Description

CalibTracker/SiPixelSCurveCalibration/src/SiPixelSCurveCalibrationAnalysis.cc

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 62 of file SiPixelSCurveCalibrationAnalysis.h.

Constructor & Destructor Documentation

◆ SiPixelSCurveCalibrationAnalysis()

SiPixelSCurveCalibrationAnalysis::SiPixelSCurveCalibrationAnalysis ( const edm::ParameterSet & iConfig )

inlineexplicit

Definition at line 64 of file SiPixelSCurveCalibrationAnalysis.h.

References doSetup().

       : SiPixelOfflineCalibAnalysisBase(iConfig) {
     doSetup(iConfig);
   };

◆ ~SiPixelSCurveCalibrationAnalysis()

SiPixelSCurveCalibrationAnalysis::~SiPixelSCurveCalibrationAnalysis ( )

override

Definition at line 138 of file SiPixelSCurveCalibrationAnalysis.cc.

                                                                     {
   // do nothing
 }

Member Function Documentation

◆ buildACurveHistogram()

void SiPixelSCurveCalibrationAnalysis::buildACurveHistogram	(	const uint32_t &	detid,
		const uint32_t &	row,
		const uint32_t &	col,
		sCurveErrorFlag	errorFlag,
		const std::vector< float > &	efficiencies,
		const std::vector< float > &	errors
	)

Definition at line 142 of file SiPixelSCurveCalibrationAnalysis.cc.

References SiPixelOfflineCalibAnalysisBase::bookDQMHistogram1D(), cuy::col, curvesSavedCounter_, electronProducer_cfi::efficiencies, createfilelist::int, maxCurvesToSave_, dqm::impl::MonitorElement::setBinContent(), dqm::impl::MonitorElement::setBinError(), SiPixelOfflineCalibAnalysisBase::setDQMDirectory(), SiPixelOfflineCalibAnalysisBase::translateDetIdToString(), and vCalPointsAsFloats_.

Referenced by doFits().

                                                                                             {
   if (curvesSavedCounter_ > maxCurvesToSave_) {
     edm::LogWarning("SiPixelSCurveCalibrationAnalysis")
         << "WARNING: Request to save curve for [detid](col/row):  [" << detid << "](" << col << "/" << row
         << ") denied. Maximum number of saved curves (defined in .cfi) "
            "exceeded.";
     return;
   }
   std::ostringstream rootName;
   rootName << "SCurve_row_" << row << "_col_" << col;
   std::ostringstream humanName;
   humanName << translateDetIdToString(detid) << "_" << rootName.str() << "_ErrorFlag_" << (int)errorFlag;
 
   unsigned int numberOfVCalPoints = vCalPointsAsFloats_.size() - 1;  // minus one is necessary since the lower
                                                                      // edge of the last bin must be added
   if (efficiencies.size() != numberOfVCalPoints || errors.size() != numberOfVCalPoints) {
     edm::LogError("SiPixelSCurveCalibrationAnalysis")
         << "Error saving single curve histogram!  Number of Vcal values (" << numberOfVCalPoints
         << ") does not match number of efficiency points or error points!";
     return;
   }
   setDQMDirectory(detid);
   float *vcalValuesToPassToCrappyRoot = &vCalPointsAsFloats_[0];
   MonitorElement *aBadHisto =
       bookDQMHistogram1D(detid,
                          rootName.str(),
                          humanName.str(),
                          numberOfVCalPoints,
                          vcalValuesToPassToCrappyRoot);  // ROOT only takes an input as array. :(
                                                          // HOORAY FOR CINT!
   curvesSavedCounter_++;
   for (unsigned int iBin = 0; iBin < numberOfVCalPoints; ++iBin) {
     int rootBin = iBin + 1;  // root bins start at 1
     aBadHisto->setBinContent(rootBin, efficiencies[iBin]);
     aBadHisto->setBinError(rootBin, errors[iBin]);
   }
 }

◆ calibrationEnd()

void SiPixelSCurveCalibrationAnalysis::calibrationEnd ( )

overrideprivatevirtual

Reimplemented from SiPixelOfflineCalibAnalysisBase.

Definition at line 20 of file SiPixelSCurveCalibrationAnalysis.cc.

References makeThresholdSummary(), and printoutthresholds_.

                                                       {
   if (printoutthresholds_)
     makeThresholdSummary();
 }

◆ calibrationSetup()

void SiPixelSCurveCalibrationAnalysis::calibrationSetup ( const edm::EventSetup & iSetup )

overrideprivatevirtual

Reimplemented from SiPixelOfflineCalibAnalysisBase.

Definition at line 185 of file SiPixelSCurveCalibrationAnalysis.cc.

References curvesSavedCounter_, SiPixelOfflineCalibAnalysisBase::fitFunction_, SiPixelOfflineCalibAnalysisBase::getVcalValues(), mps_fire::i, maxCurvesToSave_, SiPixelOfflineCalibAnalysisBase::nTriggers_, saveCurvesThatFlaggedBad_, vCalPointsAsFloats_, and SiPixelOfflineCalibAnalysisBase::vCalValues_.

                                                                                    {
   edm::LogInfo("SiPixelSCurveCalibrationAnalysis")
       << "Calibration Settings: VCalLow: " << vCalValues_[0] << "  VCalHigh: " << vCalValues_[vCalValues_.size() - 1]
       << " nVCal: " << vCalValues_.size() << "  nTriggers: " << nTriggers_;
   curvesSavedCounter_ = 0;
   if (saveCurvesThatFlaggedBad_) {
     // build the vCal values as a vector of floats if we want to save single
     // curves
     const std::vector<short> *theVCalValues = this->getVcalValues();
     unsigned int numberOfVCalPoints = theVCalValues->size();
     edm::LogWarning("SiPixelSCurveCalibrationAnalysis")
         << "WARNING: Option set to save indiviual S-Curves - max number: " << maxCurvesToSave_
         << " This can lead to large memory consumption! (Got " << numberOfVCalPoints << " VCal Points";
     for (unsigned int i = 0; i < numberOfVCalPoints; i++) {
       vCalPointsAsFloats_.push_back(static_cast<float>((*theVCalValues)[i]));
       edm::LogInfo("SiPixelSCurveCalibrationAnalysis") << "Adding calibration Vcal: " << (*theVCalValues)[i];
     }
     // must add lower edge of last bin to the vector
     vCalPointsAsFloats_.push_back(vCalPointsAsFloats_[numberOfVCalPoints - 1] + 1);
   }
 
   fitFunction_ = new TF1("sCurve",
                          "0.5*[2]*(1+TMath::Erf( (x-[0]) / ([1]*sqrt(2)) ) )",
                          vCalValues_[0],
                          vCalValues_[vCalValues_.size() - 1]);
 }

◆ checkCorrectCalibrationType()

bool SiPixelSCurveCalibrationAnalysis::checkCorrectCalibrationType ( )

overrideprivatevirtual

Reimplemented from SiPixelOfflineCalibAnalysisBase.

Definition at line 212 of file SiPixelSCurveCalibrationAnalysis.cc.

References SiPixelOfflineCalibAnalysisBase::calibrationMode_.

                                                                    {
   if (calibrationMode_ == "SCurve")
     return true;
   else if (calibrationMode_ == "unknown") {
     edm::LogInfo("SiPixelSCurveCalibrationAnalysis")
         << "calibration mode is: " << calibrationMode_ << ", continuing anyway...";
     return true;
   } else {
     //    edm::LogDebug("SiPixelSCurveCalibrationAnalysis") << "unknown
     //    calibration mode for SCurves, should be \"SCurve\" and is \"" <<
     //    calibrationMode_ << "\"";
   }
   return false;
 }

◆ doFits()

bool SiPixelSCurveCalibrationAnalysis::doFits	(	uint32_t	detid,
		std::vector< SiPixelCalibDigi >::const_iterator	ipix
	)

overridevirtual

Reimplemented from SiPixelOfflineCalibAnalysisBase.

Definition at line 324 of file SiPixelSCurveCalibrationAnalysis.cc.

References CustomPhysics_cfi::amplitude, buildACurveHistogram(), calculateEffAndError(), hltPixelTracks_cff::chi2, chi2toMinimize(), cuy::col, detIDsToSave_, effErrors_, efficiencies_, errBadChi2Prob, errOK, relativeConstraints::error, estimateSCurveParameters(), fittedSCurveSanityCheck(), histograms_, kChi2s, kChi2Summary, kFitResults, kFitResultSummary, kSigmas, kSigmaSummary, kThresholds, kThresholdSummary, minimumChi2prob_, SiPixelOfflineCalibAnalysisBase::nTriggers_, submitPVValidationJobs::params, saveCurvesThatFlaggedBad_, remoteMonitoring_LASER_era2018_cfg::threshold, SiPixelOfflineCalibAnalysisBase::vCalValues_, write2dFitResult_, and write2dHistograms_.

                                                                                                                  {
   sCurveErrorFlag errorFlag = errOK;
   uint32_t nVCalPts = calibDigi->getnpoints();
   // reset and fill static datamembers with vector of points and errors
   efficiencies_.resize(0);
   effErrors_.resize(0);
   for (uint32_t iVcalPt = 0; iVcalPt < nVCalPts; iVcalPt++) {
     float eff;
     float error;
     calculateEffAndError(calibDigi->getnentries(iVcalPt), nTriggers_, eff, error);
     edm::LogInfo("SiPixelSCurveCalibrationAnalysis")
         << "Eff: " << eff << " Error:  " << error << "  nEntries: " << calibDigi->getnentries(iVcalPt)
         << "  nTriggers: " << nTriggers_ << " VCalPt " << vCalValues_[iVcalPt];
     efficiencies_.push_back(eff);
     effErrors_.push_back(error);
   }
 
   // estimate the S-Curve parameters
   float thresholdGuess = -1.0;
   float sigmaGuess = -1.0;
   errorFlag = estimateSCurveParameters(efficiencies_, thresholdGuess, sigmaGuess);
 
   // these -1.0 default values will only be filled if the curve is all zeroes,
   // or doesn't turn on, WHICH INDICATES A SERIOUS PROBLEM
   Double_t sigma = -1.0;
   Double_t sigmaError = -1.0;
   Double_t threshold = -1.0;
   Double_t thresholdError = -1.0;
   Double_t amplitude = -1.0;
   Double_t amplitudeError = -1.0;
   Double_t chi2 = -1.0;
   // calculate NDF
   Int_t nDOF = vCalValues_.size() - 3;
   Double_t chi2probability = 0;
 
   if (errorFlag == errOK)  // only do fit if curve is fittable
   {
     // set up minuit fit
     TMinuit *gMinuit = new TMinuit(3);
     gMinuit->SetPrintLevel(-1);  // save ourselves from gigabytes of stdout
     gMinuit->SetFCN(chi2toMinimize);
 
     // define threshold parameters - choose step size 1, max 300, min -50
     gMinuit->DefineParameter(0, "Threshold", (Double_t)thresholdGuess, 1, -50, 300);
     // sigma
     gMinuit->DefineParameter(1, "Sigma", (Double_t)sigmaGuess, 0.1, 0, 255);
     // amplitude
     gMinuit->DefineParameter(2, "Amplitude", 1, 0.1, -0.001, 200);
 
     // Do Chi2 minimazation
     gMinuit->Migrad();
     gMinuit->GetParameter(0, threshold, thresholdError);
     gMinuit->GetParameter(1, sigma, sigmaError);
     gMinuit->GetParameter(2, amplitude, amplitudeError);
 
     // get Chi2
     Double_t params[3] = {threshold, sigma, amplitude};
     gMinuit->Eval(3, nullptr, chi2, params, 0);
     // calculate Chi2 proability
     if (nDOF <= 0)
       chi2probability = 0;
     else
       chi2probability = TMath::Prob(chi2, nDOF);
 
     // check to make sure output makes sense (i.e. threshold > 0)
     if (chi2probability > minimumChi2prob_)
       errorFlag = fittedSCurveSanityCheck(threshold, sigma, amplitude);
     else
       errorFlag = errBadChi2Prob;
 
     edm::LogInfo("SiPixelSCurveCalibrationAnalysis")
         << "Fit finished with errorFlag: " << errorFlag << " - threshold: " << threshold << "  sigma: " << sigma
         << "  chi2: " << chi2 << "  nDOF: " << nDOF << " chi2Prob: " << chi2probability
         << " chi2MinUser: " << minimumChi2prob_;
 
     delete gMinuit;
   }
   // get row and column for this pixel
   uint32_t row = calibDigi->row();
   uint32_t col = calibDigi->col();
 
   // get iterator to histogram holder for this detid
   detIDHistogramMap::iterator thisDetIdHistoGrams;
   thisDetIdHistoGrams = histograms_.find(detid);
   if (thisDetIdHistoGrams != histograms_.end()) {
     edm::LogInfo("SiPixelSCurveCalibrationAnalysisHistogramReport")
         << "Filling histograms for [detid](col/row):  [" << detid << "](" << col << "/" << row
         << ") ErrorFlag: " << errorFlag;
     // always fill fit result
     (*thisDetIdHistoGrams).second[kFitResultSummary]->Fill(errorFlag);
     if (write2dFitResult_)
       (*thisDetIdHistoGrams)
           .second[kFitResults]
           ->setBinContent(col + 1,
                           row + 1,
                           errorFlag);  // +1 because root bins start at 1
 
     // fill sigma/threshold result
     (*thisDetIdHistoGrams).second[kSigmaSummary]->Fill(sigma);
     (*thisDetIdHistoGrams).second[kThresholdSummary]->Fill(threshold);
     if (write2dHistograms_) {
       (*thisDetIdHistoGrams)
           .second[kSigmas]
           ->setBinContent(col + 1,
                           row + 1,
                           sigma);  // +1 because root bins start at 1
       (*thisDetIdHistoGrams)
           .second[kThresholds]
           ->setBinContent(col + 1,
                           row + 1,
                           threshold);  // +1 because root bins start at 1
     }
     // fill chi2
     (*thisDetIdHistoGrams).second[kChi2Summary]->Fill(chi2probability);
     if (write2dHistograms_)
       (*thisDetIdHistoGrams).second[kChi2s]->Fill(col, row, chi2probability);
   }
   // save individual curves, if requested
   if (saveCurvesThatFlaggedBad_) {
     bool thisDetIDinList = false;
     if (detIDsToSave_.find(detid) != detIDsToSave_.end())  // see if we want to save this histogram
       thisDetIDinList = true;
 
     if (errorFlag != errOK || thisDetIDinList) {
       edm::LogError("SiPixelSCurveCalibrationAnalysis") << "Saving error histogram for [detid](col/row):  [" << detid
                                                         << "](" << col << "/" << row << ") ErrorFlag: " << errorFlag;
       buildACurveHistogram(detid, row, col, errorFlag, efficiencies_, effErrors_);
     }
   }
 
   return true;
 }

◆ doSetup()

void SiPixelSCurveCalibrationAnalysis::doSetup ( const edm::ParameterSet & iConfig )

Definition at line 108 of file SiPixelSCurveCalibrationAnalysis.cc.

References detIDsToSave_, edm::ParameterSet::getUntrackedParameter(), mps_fire::i, maxCurvesToSave_, maximumEffAsymptote_, maximumSigma_, maximumSigmaBin_, maximumThreshold_, maximumThresholdBin_, minimumChi2prob_, minimumEffAsymptote_, minimumSigma_, minimumThreshold_, printoutthresholds_, saveCurvesThatFlaggedBad_, AlCaHLTBitMon_QueryRunRegistry::string, thresholdfilename_, useDetectorHierarchyFolders_, write2dFitResult_, write2dHistograms_, and writeZeroes_.

Referenced by SiPixelSCurveCalibrationAnalysis().

                                                                              {
   edm::LogInfo("SiPixelSCurveCalibrationAnalysis") << "Setting up calibration paramters.";
   std::vector<uint32_t> anEmptyDefaultVectorOfUInts;
   std::vector<uint32_t> detIDsToSaveVector_;
   useDetectorHierarchyFolders_ = iConfig.getUntrackedParameter<bool>("useDetectorHierarchyFolders", true);
   saveCurvesThatFlaggedBad_ = iConfig.getUntrackedParameter<bool>("saveCurvesThatFlaggedBad", false);
   detIDsToSaveVector_ =
       iConfig.getUntrackedParameter<std::vector<uint32_t>>("detIDsToSave", anEmptyDefaultVectorOfUInts);
   maxCurvesToSave_ = iConfig.getUntrackedParameter<uint32_t>("maxCurvesToSave", 1000);
   write2dHistograms_ = iConfig.getUntrackedParameter<bool>("write2dHistograms", true);
   write2dFitResult_ = iConfig.getUntrackedParameter<bool>("write2dFitResult", true);
   printoutthresholds_ = iConfig.getUntrackedParameter<bool>("writeOutThresholdSummary", true);
   thresholdfilename_ = iConfig.getUntrackedParameter<std::string>("thresholdOutputFileName", "thresholds.txt");
   minimumChi2prob_ = iConfig.getUntrackedParameter<double>("minimumChi2prob", 0);
   minimumThreshold_ = iConfig.getUntrackedParameter<double>("minimumThreshold", -10);
   maximumThreshold_ = iConfig.getUntrackedParameter<double>("maximumThreshold", 300);
   minimumSigma_ = iConfig.getUntrackedParameter<double>("minimumSigma", 0);
   maximumSigma_ = iConfig.getUntrackedParameter<double>("maximumSigma", 100);
   minimumEffAsymptote_ = iConfig.getUntrackedParameter<double>("minimumEffAsymptote", 0);
   maximumEffAsymptote_ = iConfig.getUntrackedParameter<double>("maximumEffAsymptote", 1000);
   maximumSigmaBin_ = iConfig.getUntrackedParameter<double>("maximumSigmaBin", 10);
   maximumThresholdBin_ = iConfig.getUntrackedParameter<double>("maximumThresholdBin", 255);
 
   writeZeroes_ = iConfig.getUntrackedParameter<bool>("alsoWriteZeroThresholds", false);
 
   // convert the vector into a map for quicker lookups.
   for (unsigned int i = 0; i < detIDsToSaveVector_.size(); i++)
     detIDsToSave_.insert(std::make_pair(detIDsToSaveVector_[i], true));
 }

◆ estimateSCurveParameters()

sCurveErrorFlag SiPixelSCurveCalibrationAnalysis::estimateSCurveParameters	(	const std::vector< float > &	eff,
		float &	threshold,
		float &	sigma
	)

Definition at line 227 of file SiPixelSCurveCalibrationAnalysis.cc.

References dumpMFGeometry_cfg::delta, errAllZeros, errNoTurnOn, errOK, convertSQLitetoXML_cfg::output, remoteMonitoring_LASER_era2018_cfg::threshold, and SiPixelOfflineCalibAnalysisBase::vCalValues_.

Referenced by doFits().

                                                                                          {
   sCurveErrorFlag output = errAllZeros;
   bool allZeroSoFar = true;
   int turnOnBin = -1;
   int saturationBin = -1;
   for (uint32_t iVcalPt = 0; iVcalPt < eff.size(); iVcalPt++) {
     if (allZeroSoFar && eff[iVcalPt] != 0) {
       turnOnBin = iVcalPt;
       allZeroSoFar = false;
       output = errNoTurnOn;
     } else if (eff[iVcalPt] > 0.90) {
       saturationBin = iVcalPt;
       short turnOnVcal = vCalValues_[turnOnBin];
       short saturationVcal = vCalValues_[saturationBin];
       short delta = saturationVcal - turnOnVcal;
       sigma = delta * 0.682;
       if (sigma < 1)  // check to make sure sigma guess is larger than our X resolution.
                       // Hopefully prevents Minuit from getting stuck at boundary
         sigma = 1;
       threshold = turnOnVcal + (0.5 * delta);
       return errOK;
     }
   }
   return output;
 }

◆ fittedSCurveSanityCheck()

sCurveErrorFlag SiPixelSCurveCalibrationAnalysis::fittedSCurveSanityCheck	(	float	threshold,
		float	sigma,
		float	amplitude
	)

Definition at line 255 of file SiPixelSCurveCalibrationAnalysis.cc.

References errFitNonPhysical, errFlaggedBadByUser, errOK, maximumEffAsymptote_, maximumSigma_, maximumThreshold_, minimumSigma_, remoteMonitoring_LASER_era2018_cfg::threshold, and SiPixelOfflineCalibAnalysisBase::vCalValues_.

Referenced by doFits().

                                                                                            {
   // check if nonsensical
   if (threshold > vCalValues_[vCalValues_.size() - 1] || threshold < vCalValues_[0] ||
       sigma > vCalValues_[vCalValues_.size() - 1] - vCalValues_[0])
     return errFitNonPhysical;
 
   if (threshold < minimumThreshold_ || threshold > maximumThreshold_ || sigma < minimumSigma_ ||
       sigma > maximumSigma_ || amplitude < minimumEffAsymptote_ || amplitude > maximumEffAsymptote_)
     return errFlaggedBadByUser;
 
   return errOK;
 }

◆ makeThresholdSummary()

void SiPixelSCurveCalibrationAnalysis::makeThresholdSummary ( void )

private

Definition at line 25 of file SiPixelSCurveCalibrationAnalysis.cc.

References gather_cfg::cout, sipixelobjects::ElectronicIndex::dcol, sipixelobjects::LocalPixel::DcolPxid::dcol, hgcalTestNeighbor_cfi::detector, PixelSLinkDataInputSource_cfi::fedid, SiPixelFedCablingMap::findItem(), dqm::impl::MonitorElement::getBinContent(), dqm::impl::MonitorElement::getNbinsX(), dqm::impl::MonitorElement::getNbinsY(), dqm::impl::MonitorElement::getTitle(), histograms_, sipixelobjects::PixelROC::idInDetUnit(), kSigmas, kThresholds, sipixelobjects::ElectronicIndex::link, Skims_PA_cff::name, castor_dqm_sourceclient_file_cfg::path, edm::ESHandle< T >::product(), sipixelobjects::ElectronicIndex::pxid, sipixelobjects::LocalPixel::DcolPxid::pxid, sipixelobjects::ElectronicIndex::roc, sipixelobjects::LocalPixel::rocCol(), sipixelobjects::LocalPixel::rocRow(), AlCaHLTBitMon_QueryRunRegistry::string, SiPixelOfflineCalibAnalysisBase::theCablingMap_, thresholdfilename_, SiPixelFrameConverter::toCabling(), and writeZeroes_.

Referenced by calibrationEnd().

                                                                 {
   std::ofstream myfile;
   myfile.open(thresholdfilename_.c_str());
   for (detIDHistogramMap::iterator thisDetIdHistoGrams = histograms_.begin(); thisDetIdHistoGrams != histograms_.end();
        ++thisDetIdHistoGrams) {
     // loop over det id (det id = number (unsigned int) of pixel module
     const MonitorElement *sigmahist = (*thisDetIdHistoGrams).second[kSigmas];
     const MonitorElement *thresholdhist = (*thisDetIdHistoGrams).second[kThresholds];
     uint32_t detid = (*thisDetIdHistoGrams).first;
     std::string name = sigmahist->getTitle();
     std::string rocname = name.substr(0, name.size() - 7);
     rocname += "_ROC";
     int total_rows = sigmahist->getNbinsY();
     int total_columns = sigmahist->getNbinsX();
     // loop over all rows on columns on all ROCs
     for (int irow = 0; irow < total_rows; ++irow) {
       for (int icol = 0; icol < total_columns; ++icol) {
         float threshold_error = sigmahist->getBinContent(icol + 1, irow + 1);  // +1 because root bins start at 1
         if (writeZeroes_ || (!writeZeroes_ && threshold_error > 0)) {
           // changing from offline to online numbers
           int realfedID = -1;
           for (int fedid = 0; fedid <= 40; ++fedid) {
             SiPixelFrameConverter converter(theCablingMap_.product(), fedid);
             if (converter.hasDetUnit(detid)) {
               realfedID = fedid;
               break;
             }
           }
           if (realfedID == -1) {
             std::cout << "error: could not obtain real fed ID" << std::endl;
           }
           sipixelobjects::DetectorIndex detector = {detid, irow, icol};
           sipixelobjects::ElectronicIndex cabling;
           SiPixelFrameConverter formatter(theCablingMap_.product(), realfedID);
           formatter.toCabling(cabling, detector);
           // cabling should now contain cabling.roc and cabling.dcol  and
           // cabling.pxid however, the coordinates now need to be converted from
           // dcl,pxid to the row,col coordinates used in the calibration info
           sipixelobjects::LocalPixel::DcolPxid loc;
           loc.dcol = cabling.dcol;
           loc.pxid = cabling.pxid;
           // FIX to adhere to new cabling map. To be replaced with
           // CalibTracker/SiPixelTools detid - > hardware id classes ASAP.
           //        const sipixelobjects::PixelFEDCabling *theFed=
           //        theCablingMap.product()->fed(realfedID); const
           //        sipixelobjects::PixelFEDLink * link =
           //        theFed->link(cabling.link); const sipixelobjects::PixelROC
           //        *theRoc = link->roc(cabling.roc);
           sipixelobjects::LocalPixel locpixel(loc);
           sipixelobjects::CablingPathToDetUnit path = {static_cast<unsigned int>(realfedID),
                                                        static_cast<unsigned int>(cabling.link),
                                                        static_cast<unsigned int>(cabling.roc)};
           const sipixelobjects::PixelROC *theRoc = theCablingMap_->findItem(path);
           // END of FIX
           int newrow = locpixel.rocRow();
           int newcol = locpixel.rocCol();
           myfile << rocname << theRoc->idInDetUnit() << " " << newcol << " " << newrow << " "
                  << thresholdhist->getBinContent(icol + 1, irow + 1) << " "
                  << threshold_error;  // +1 because root bins start at 1
           myfile << "\n";
         }
       }
     }
   }
   myfile.close();
 }

◆ newDetID()

void SiPixelSCurveCalibrationAnalysis::newDetID ( uint32_t detid )

overrideprivatevirtual

Reimplemented from SiPixelOfflineCalibAnalysisBase.

Definition at line 279 of file SiPixelSCurveCalibrationAnalysis.cc.

References SiPixelOfflineCalibAnalysisBase::bookDQMHistogram1D(), SiPixelOfflineCalibAnalysisBase::bookDQMHistoPlaquetteSummary2D(), histograms_, kChi2s, kChi2Summary, kFitResults, kFitResultSummary, kSigmas, kSigmaSummary, kThresholds, kThresholdSummary, maximumSigmaBin_, maximumThresholdBin_, SiPixelOfflineCalibAnalysisBase::setDQMDirectory(), AlCaHLTBitMon_QueryRunRegistry::string, SiPixelOfflineCalibAnalysisBase::translateDetIdToString(), useDetectorHierarchyFolders_, write2dFitResult_, and write2dHistograms_.

                                                               {
   edm::LogInfo("SiPixelSCurveCalibrationAnalysis")
       << "Found a new DetID (" << detid << ")!  Checking to make sure it has not been added.";
   // ensure that this DetID has not been added yet
   sCurveHistogramHolder tempMap;
   std::pair<detIDHistogramMap::iterator, bool> insertResult;
   insertResult = histograms_.insert(std::make_pair(detid, tempMap));
   if (insertResult.second)  // indicates successful insertion
   {
     edm::LogInfo("SiPixelSCurveCalibrationAnalysisHistogramReport")
         << "Histogram Map.insert() returned true!  Booking new histogrames for "
            "detID: "
         << detid;
     // use detector hierarchy folders if desired
     if (useDetectorHierarchyFolders_)
       setDQMDirectory(detid);
 
     std::string detIdName = translateDetIdToString(detid);
     if (write2dHistograms_) {
       MonitorElement *D2sigma = bookDQMHistoPlaquetteSummary2D(detid, "ScurveSigmas", detIdName + " Sigmas");
       MonitorElement *D2thresh = bookDQMHistoPlaquetteSummary2D(detid, "ScurveThresholds", detIdName + " Thresholds");
       MonitorElement *D2chi2 = bookDQMHistoPlaquetteSummary2D(detid, "ScurveChi2Prob", detIdName + " Chi2Prob");
       insertResult.first->second.insert(std::make_pair(kSigmas, D2sigma));
       insertResult.first->second.insert(std::make_pair(kThresholds, D2thresh));
       insertResult.first->second.insert(std::make_pair(kChi2s, D2chi2));
     }
     if (write2dFitResult_) {
       MonitorElement *D2FitResult = bookDQMHistoPlaquetteSummary2D(detid, "ScurveFitResult", detIdName + " Fit Result");
       insertResult.first->second.insert(std::make_pair(kFitResults, D2FitResult));
     }
     MonitorElement *D1sigma =
         bookDQMHistogram1D(detid, "ScurveSigmasSummary", detIdName + " Sigmas Summary", 100, 0, maximumSigmaBin_);
     MonitorElement *D1thresh = bookDQMHistogram1D(
         detid, "ScurveThresholdSummary", detIdName + " Thresholds Summary", 255, 0, maximumThresholdBin_);
     MonitorElement *D1chi2 =
         bookDQMHistogram1D(detid, "ScurveChi2ProbSummary", detIdName + " Chi2Prob Summary", 101, 0, 1.01);
     MonitorElement *D1FitResult =
         bookDQMHistogram1D(detid, "ScurveFitResultSummary", detIdName + " Fit Result Summary", 10, -0.5, 9.5);
     insertResult.first->second.insert(std::make_pair(kSigmaSummary, D1sigma));
     insertResult.first->second.insert(std::make_pair(kThresholdSummary, D1thresh));
     insertResult.first->second.insert(std::make_pair(kChi2Summary, D1chi2));
     insertResult.first->second.insert(std::make_pair(kFitResultSummary, D1FitResult));
   }
 }