#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 ()

	SiPixelOfflineCalibAnalysisBase (const edm::ParameterSet &)

std::string	translateDetIdToString (uint32_t detid)

	~SiPixelOfflineCalibAnalysisBase () override

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () 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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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 &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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::EDAnalyzer
typedef EDAnalyzer	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::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from SiPixelOfflineCalibAnalysisBase
uint32_t &	EventNumber ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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

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

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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

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

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

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

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

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

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

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.

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

References doSetup().

◆ ~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.

                                                                                             {
   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]);
   }
 }

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().

◆ calibrationEnd()

void SiPixelSCurveCalibrationAnalysis::calibrationEnd ( )

overrideprivatevirtual

Reimplemented from SiPixelOfflineCalibAnalysisBase.

Definition at line 20 of file SiPixelSCurveCalibrationAnalysis.cc.

                                                       {
   if (printoutthresholds_)
     makeThresholdSummary();
 }

References makeThresholdSummary(), and printoutthresholds_.

◆ calibrationSetup()

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

overrideprivatevirtual

Reimplemented from SiPixelOfflineCalibAnalysisBase.

Definition at line 185 of file SiPixelSCurveCalibrationAnalysis.cc.

                                                                                    {
   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]);
 }

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

◆ checkCorrectCalibrationType()

bool SiPixelSCurveCalibrationAnalysis::checkCorrectCalibrationType ( )

overrideprivatevirtual

Reimplemented from SiPixelOfflineCalibAnalysisBase.

Definition at line 212 of file SiPixelSCurveCalibrationAnalysis.cc.

                                                                    {
   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;
 }

References SiPixelOfflineCalibAnalysisBase::calibrationMode_.

◆ 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.

                                                                                                                  {
   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;
 }

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_, CalibrationSummaryClient_cfi::params, saveCurvesThatFlaggedBad_, remoteMonitoring_LED_IterMethod_cfg::threshold, SiPixelOfflineCalibAnalysisBase::vCalValues_, write2dFitResult_, and write2dHistograms_.

◆ doSetup()

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

Definition at line 108 of file SiPixelSCurveCalibrationAnalysis.cc.

                                                                              {
   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));
 }

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().

◆ estimateSCurveParameters()

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

Definition at line 227 of file SiPixelSCurveCalibrationAnalysis.cc.

                                                                                          {
   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;
 }

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

Referenced by doFits().

◆ fittedSCurveSanityCheck()

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

Definition at line 255 of file SiPixelSCurveCalibrationAnalysis.cc.

                                                                                            {
   // 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;
 }

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

Referenced by doFits().

◆ makeThresholdSummary()

void SiPixelSCurveCalibrationAnalysis::makeThresholdSummary ( void )

private

Definition at line 25 of file SiPixelSCurveCalibrationAnalysis.cc.

                                                                 {
   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();
 }

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().

◆ newDetID()

void SiPixelSCurveCalibrationAnalysis::newDetID ( uint32_t detid )

overrideprivatevirtual

Reimplemented from SiPixelOfflineCalibAnalysisBase.

Definition at line 279 of file SiPixelSCurveCalibrationAnalysis.cc.

                                                               {
   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));
   }
 }