TPG Param Builder for Phase2
More...

Inheritance diagram for EcalEBPhase2TPParamProducer:

Public Member Functions
void	analyze (const edm::Event &evt, const edm::EventSetup &evtSetup) override

void	beginJob () override

	EcalEBPhase2TPParamProducer (edm::ParameterSet const &pSet)

	~EcalEBPhase2TPParamProducer () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	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

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

std::vector< ESResolverIndex > 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

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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
bool	computeLinearizerParam (double theta, double gainRatio, double calibCoeff, int &shift, int &mult)

std::vector< int >	computeWeights (int type)

void	fillFMat (std::vector< unsigned int > clockSampleSet, bool useThirdPulse, std::vector< float > sampleSet, std::vector< float > sampleDotSet, TMatrix &FMat, unsigned int binOfMaximum)

void	getGMatrix (TMatrix FMat, float scaleMatrixBy, TMatrix &GMat)

void	getNumericalDeriv (TGraph graph, TGraph &deriv)

void	getPulseSampleSet (TGraph pulseGraph, float phaseShift, std::vector< float > &sampleSet)

Private Attributes
const unsigned int	binOfMaximum_

const double	et_sat_

int	i2cSub_ [2] = {0, 0}

const edm::FileInPath	inFile_

int	multToInt_ = 0x1000

const UInt_t	NPoints_ = 1599

const int	nSamplesToUse_

const unsigned int	nWeightGroups_

gzFile	out_file_

const std::string	outFile_

const double	phaseShift_

TGraph *	pulseDot_

const edm::ESGetToken< CaloSubdetectorGeometry, EcalBarrelGeometryRecord >	theBarrelGeometryToken_

const edm::ESGetToken< EcalLiteDTUPedestalsMap, EcalLiteDTUPedestalsRcd >	theEcalTPGPedestals_Token_

TGraph *	thePulse_

const bool	useBXPlusOne_

const double	xtal_LSB_

Static Private Attributes
static const int	linTopRange_

static constexpr float	norm_ = 1 / 503.109

static constexpr float	offset_ = 0.

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

Detailed Description

TPG Param Builder for Phase2

Author: L. Lutton, N. Marinelli - Univ. of Notre Dame

Definition at line 38 of file EcalEBPhase2TPParamProducer.cc.

Constructor & Destructor Documentation

◆ EcalEBPhase2TPParamProducer()

EcalEBPhase2TPParamProducer::EcalEBPhase2TPParamProducer ( edm::ParameterSet const & pSet )

explicit

Definition at line 87 of file EcalEBPhase2TPParamProducer.cc.

References binOfMaximum_, corrVsCorr::filename, edm::FileInPath::fullPath(), testHGCalDigi_cfg::inFile, inFile_, nSamplesToUse_, out_file_, outFile_, AlCaHLTBitMon_QueryRunRegistry::string, and thePulse_.

     : theBarrelGeometryToken_(esConsumes(edm::ESInputTag("", "EcalBarrel"))),
       inFile_(pSet.getParameter<edm::FileInPath>("inputFile")),
       outFile_(pSet.getUntrackedParameter<std::string>("outputFile")),
       nSamplesToUse_(pSet.getParameter<unsigned int>("nSamplesToUse")),
       useBXPlusOne_(pSet.getParameter<bool>("useBXPlusOne")),
       phaseShift_(pSet.getParameter<double>("phaseShift")),
       nWeightGroups_(pSet.getParameter<unsigned int>("nWeightGroups")),
       theEcalTPGPedestals_Token_(esConsumes(edm::ESInputTag("EcalLiteDTUPedestals", ""))),
       et_sat_(pSet.getParameter<double>("Et_sat")),
       xtal_LSB_(pSet.getParameter<double>("xtal_LSB")),
       binOfMaximum_(pSet.getParameter<unsigned int>("binOfMaximum"))
 
 {
   out_file_ = gzopen(outFile_.c_str(), "wb");
 
   std::string filename = inFile_.fullPath();
   TFile* inFile = new TFile(filename.c_str(), "READ");
 
   inFile->GetObject("average-pulse", thePulse_);
   delete inFile;
 
   if (binOfMaximum_ != 6 && binOfMaximum_ != 8)
     edm::LogError("EcalEBPhase2TPParamProducer")
         << " Value for binOfMaximum " << binOfMaximum_ << " is wrong, The default binOfMaximum=6  will be used";
 
   if (nSamplesToUse_ != 6 && nSamplesToUse_ != 8 && nSamplesToUse_ != 12)
     edm::LogError("EcalEBPhase2TPParamProducer")
         << " Value for nSamplesToUse " << nSamplesToUse_ << " is wrong, The default nSamplesToUse=8 will be used";
 }

◆ ~EcalEBPhase2TPParamProducer()

EcalEBPhase2TPParamProducer::~EcalEBPhase2TPParamProducer ( )

override

Definition at line 118 of file EcalEBPhase2TPParamProducer.cc.

References out_file_.

118 { gzclose(out_file_); }

EcalEBPhase2TPParamProducer::out_file_

gzFile out_file_

Definition: EcalEBPhase2TPParamProducer.cc:69

Member Function Documentation

◆ analyze()

void EcalEBPhase2TPParamProducer::analyze	(	const edm::Event &	evt,
		const edm::EventSetup &	evtSetup
	)

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 136 of file EcalEBPhase2TPParamProducer.cc.

References funct::abs(), computeLinearizerParam(), computeWeights(), TauDecayModes::dec, DetId::Ecal, EcalBarrel, Exception, ecalph2::gains, edm::EventSetup::getData(), mps_fire::i, i2cSub_, l1ctLayer2EG_cff::id, createfilelist::int, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, EcalLiteDTUPedestals::mean(), VarParsing::mult, ecalPh2::NGAINS, nWeightGroups_, convertSQLiteXML::ok, out_file_, nano_mu_digi_cff::rawId, edm::shift, AlCaHLTBitMon_QueryRunRegistry::string, theBarrelGeometryToken_, theEcalTPGPedestals_Token_, and theta().

                                                                                             {
   using namespace edm;
   using namespace std;
 
   const EcalLiteDTUPedestals* peds = nullptr;
   const auto* theBarrelGeometry = &evtSetup.getData(theBarrelGeometryToken_);
   const auto* theEcalTPPedestals = &evtSetup.getData(theEcalTPGPedestals_Token_);
 
   std::string tmpStringConv;
   const char* tmpStringOut;
 
   // Compute weights  //
   std::vector<int> ampWeights[nWeightGroups_];
   std::vector<int> timeWeights[nWeightGroups_];
 
   for (unsigned int iGr = 0; iGr < nWeightGroups_; iGr++) {
     ampWeights[iGr] = computeWeights(1);
     timeWeights[iGr] = computeWeights(2);
   }
 
   /* write to compressed file  */
   std::stringstream toCompressStream("");
   for (unsigned int iGr = 0; iGr < nWeightGroups_; iGr++) {
     toCompressStream << "  WEIGHTAMP  " << dec << iGr << std::endl;
     for (long unsigned int i = 0; i < ampWeights[iGr].size(); i++) {
       if (ampWeights[iGr][i] < 0)
         toCompressStream << "-0x" << std::hex << abs(ampWeights[iGr][i]) << " ";
       else
         toCompressStream << "0x" << std::hex << ampWeights[iGr][i] << " ";
     }
     toCompressStream << "\n";
   }
   toCompressStream << "\n";
   tmpStringConv = toCompressStream.str();
   tmpStringOut = tmpStringConv.c_str();
   gzwrite(out_file_, tmpStringOut, std::strlen(tmpStringOut));
   toCompressStream.str(std::string());
 
   for (unsigned int iGr = 0; iGr < nWeightGroups_; iGr++) {
     toCompressStream << "WEIGHTTIME " << dec << iGr << std::endl;
     for (long unsigned int i = 0; i < timeWeights[iGr].size(); i++) {
       if (timeWeights[iGr][i] < 0)
         toCompressStream << "-0x" << std::hex << abs(timeWeights[iGr][i]) << " ";
       else
         toCompressStream << "0x" << std::hex << timeWeights[iGr][i] << " ";
     }
     toCompressStream << "\n";
   }
 
   toCompressStream << "\n";
   tmpStringConv = toCompressStream.str();
   tmpStringOut = tmpStringConv.c_str();
   gzwrite(out_file_, tmpStringOut, std::strlen(tmpStringOut));
   toCompressStream.str(std::string());
 
   //  fill  map between xTals and groups. If each xTal is a group there is a one-to-one map
   const std::vector<DetId>& ebCells = theBarrelGeometry->getValidDetIds(DetId::Ecal, EcalBarrel);
   std::map<int, int> mapXtalToGroup;
 
   int iGroup = 0;
   for (const auto& it : ebCells) {
     EBDetId id(it);
     std::pair<int, int> xTalToGroup(id.rawId(), iGroup);
     mapXtalToGroup.insert(xTalToGroup);
     iGroup++;
   }
 
   //write to file
 
   for (std::map<int, int>::const_iterator it = mapXtalToGroup.begin(); it != mapXtalToGroup.end(); it++) {
     toCompressStream << "CRYSTAL " << dec << it->first << std::endl;
     toCompressStream << it->second << std::endl;
   }
   tmpStringConv = toCompressStream.str();
   tmpStringOut = tmpStringConv.c_str();
   gzwrite(out_file_, tmpStringOut, std::strlen(tmpStringOut));
   toCompressStream.str(std::string());
 
 
   for (const auto& it : ebCells) {
     EBDetId id(it);
     toCompressStream << "LINCONST " << dec << id.rawId() << std::endl;
     double theta = theBarrelGeometry->getGeometry(id)->getPosition().theta();
     EcalLiteDTUPedestalsMap::const_iterator itped = theEcalTPPedestals->getMap().find(id);
 
     if (itped != theEcalTPPedestals->end()) {
       peds = &(*itped);
 
     } else {
       edm::LogError("EcalEBPhase2TPParamProducer") << " could not find EcalLiteDTUPedestal entry for " << id;
       throw cms::Exception("could not find pedestals");
     }
 
     int shift, mult;
     double calibCoeff = 1.;
     bool ok;
     for (unsigned int i = 0; i < ecalPh2::NGAINS; ++i) {
       ok = computeLinearizerParam(theta, ecalph2::gains[ecalPh2::NGAINS - 1 - i], calibCoeff, shift, mult);
       if (!ok) {
         edm::LogError("EcalEBPhase2TPParamProducer")
             << "unable to compute the parameters for SM=" << id.ism() << " xt=" << id.ic() << " " << id.rawId();
         throw cms::Exception("unable to compute the parameters");
 
       } else {
         int tmpPedByGain = (int)(peds->mean(i) + 0.5);
         toCompressStream << std::hex << " 0x" << tmpPedByGain << " 0x" << mult << " 0x" << shift << " " << i2cSub_[i]
                          << std::endl;
       }
     }
   }
   tmpStringConv = toCompressStream.str();
   tmpStringOut = tmpStringConv.c_str();
   gzwrite(out_file_, tmpStringOut, std::strlen(tmpStringOut));
   toCompressStream.str(std::string());
 }

◆ beginJob()

void EcalEBPhase2TPParamProducer::beginJob ( )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 120 of file EcalEBPhase2TPParamProducer.cc.

120 {}

◆ computeLinearizerParam()

bool EcalEBPhase2TPParamProducer::computeLinearizerParam	(	double	theta,
		double	gainRatio,
		double	calibCoeff,
		int &	shift,
		int &	mult
	)

private

Definition at line 410 of file EcalEBPhase2TPParamProducer.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), et_sat_, createfilelist::int, linTopRange_, VarParsing::mult, mps_fire::result, edm::shift, funct::sin(), theta(), and xtal_LSB_.

Referenced by analyze().

                                                                               {
   bool result = false;
 
   static constexpr double linTopRange_ = 16383.;
   //  linTopRange_ 16383 = (2**14)-1  is setting the top of the range for the linearizer output
   double factor = (linTopRange_ * (xtal_LSB_ * gainRatio * calibCoeff * sin(theta))) / et_sat_;
   //first with shift_ = 0
   //add 0.5 (for rounding) and set to int
   //Here we are getting mult with a max bit length of 8
   //and shift_ with a max bit length of 4
   mult = (int)(factor + 0.5);
   for (shift = 0; shift < 15; shift++) {
     if (mult >= 128 && mult < 256) {
       result = true;
       break;
     }
     factor *= 2;
     mult = (int)(factor + 0.5);
   }
 
   return result;
 }

◆ computeWeights()

std::vector< int > EcalEBPhase2TPParamProducer::computeWeights ( int type )

private

Definition at line 253 of file EcalEBPhase2TPParamProducer.cc.

References binOfMaximum_, fillFMat(), getGMatrix(), getNumericalDeriv(), getPulseSampleSet(), multToInt_, nSamplesToUse_, phaseShift_, pulseDot_, thePulse_, and useBXPlusOne_.

Referenced by analyze().

                                                                    {
   std::vector<float> sampleSet;
   std::vector<float> sampleDotSet;
   std::vector<unsigned int> clockSampleSet;
   double scaleMatrixBy = 1.;
   int lbinOfMaximum = binOfMaximum_;
 
   switch (binOfMaximum_) {
     case 6:
       break;
     case 8:
       break;
     default:
       lbinOfMaximum = 6;
       break;
   }
 
   switch (nSamplesToUse_) {
     case 12:
       clockSampleSet = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
       break;
     case 8:
       switch (lbinOfMaximum) {
         case 8:
           clockSampleSet = {2, 3, 4, 5, 6, 7, 8, 9};
           break;
         case 6:
           clockSampleSet = {0, 1, 2, 3, 4, 5, 6, 7};
           break;
       }
       break;
 
     case 6:
       switch (lbinOfMaximum) {
         case 8:
           clockSampleSet = {3, 4, 6, 7, 8, 9};
           break;
         case 6:
           clockSampleSet = {1, 2, 4, 5, 6, 7};
           break;
       }
       break;
 
     default:
       clockSampleSet = {0, 1, 2, 3, 4, 5, 6, 7};
       break;
   }
 
   getPulseSampleSet(*thePulse_, phaseShift_, sampleSet);
   pulseDot_ = new TGraph();
   getNumericalDeriv(*thePulse_, *pulseDot_);
   getPulseSampleSet(*pulseDot_, phaseShift_, sampleDotSet);
 
   unsigned int fMatColumns = useBXPlusOne_ ? 6 : 4;
 
   TMatrix fMat(clockSampleSet.size(), fMatColumns);
   fillFMat(clockSampleSet, useBXPlusOne_, sampleSet, sampleDotSet, fMat, lbinOfMaximum);
   TMatrix gMat(fMatColumns, clockSampleSet.size());
 
   getGMatrix(fMat, scaleMatrixBy, gMat);
 
   std::vector<int> tmpWeightVec;
   std::vector<int> tmpTimeWeightVec;
   unsigned int iClock = 0;
   for (unsigned int iSample = 0; iSample < 12; iSample++) {
     bool inSampleSet = false;
     for (unsigned int clockSample = 0; clockSample < clockSampleSet.size(); clockSample++) {
       if (iSample == clockSampleSet[clockSample]) {
         inSampleSet = true;
         iClock = clockSample;
         break;
       }
     }
     if (inSampleSet) {
       if (type == 1)
         tmpWeightVec.push_back(round(gMat(2, iClock) * multToInt_));  // amp weights
       if (type == 2)
         tmpWeightVec.push_back(round(gMat(3, iClock) * multToInt_));  // time weights
     } else {
       if (type == 1)
         tmpWeightVec.push_back(0);  // amp weights
       if (type == 2)
         tmpWeightVec.push_back(0);  // time weights
     }
   }
 
   return tmpWeightVec;
 }

◆ fillDescriptions()

void EcalEBPhase2TPParamProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 122 of file EcalEBPhase2TPParamProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                              {
   edm::ParameterSetDescription desc;
   desc.add<edm::FileInPath>("inputFile");
   desc.addUntracked<std::string>("outputFile");
   desc.add<unsigned int>("nSamplesToUse", 8);
   desc.add<bool>("useBXPlusOne", false);
   desc.add<double>("phaseShift", 2.581);
   desc.add<unsigned int>("nWeightGroups", 61200);
   desc.add<double>("Et_sat", 1998.36);
   desc.add<double>("xtal_LSB", 0.0488);
   desc.add<unsigned int>("binOfMaximum", 6);
   descriptions.add("ecalEBPhase2TPParamProducerDefault", desc);
 }

◆ fillFMat()

void EcalEBPhase2TPParamProducer::fillFMat	(	std::vector< unsigned int >	clockSampleSet,
		bool	useThirdPulse,
		std::vector< float >	sampleSet,
		std::vector< float >	sampleDotSet,
		TMatrix &	FMat,
		unsigned int	binOfMaximum
	)

private

Definition at line 363 of file EcalEBPhase2TPParamProducer.cc.

References ecalEBTriggerPrimitiveDigis_cfi::binOfMaximum, and mps_fire::i.

Referenced by computeWeights().

                                                               {
   Int_t iShift = 8 - binOfMaximum;
   for (UInt_t i = 0; i < clockSampleSet.size(); i++) {
     Int_t tmpClockToSample = clockSampleSet[i] + iShift;
     fMat(i, 0) = sampleSet[tmpClockToSample];
     fMat(i, 1) = sampleDotSet[tmpClockToSample];
     if (tmpClockToSample > 4) {
       fMat(i, 2) = sampleSet[tmpClockToSample - 4];
       fMat(i, 3) = sampleDotSet[tmpClockToSample - 4];
     }
     if (clockSampleSet[i] > 8 && useThirdPulse) {
       fMat(i, 4) = sampleSet[tmpClockToSample - 8];
       fMat(i, 5) = sampleDotSet[tmpClockToSample - 8];
     }
   }
 }

◆ getGMatrix()

void EcalEBPhase2TPParamProducer::getGMatrix	(	TMatrix	FMat,
		float	scaleMatrixBy,
		TMatrix &	GMat
	)

private

Definition at line 385 of file EcalEBPhase2TPParamProducer.cc.

References JetComb::kMult.

Referenced by computeWeights().

                                                                                              {
   TMatrix FT = fMat;
   FT.T();
   TMatrix tmpFT = FT;
   TMatrix FTDotF = TMatrix(tmpFT, TMatrix::kMult, fMat);
   TMatrix InvFTDotF = FTDotF;
 
   //Possible for this bit to fail depending on the sample set and phase shift
   InvFTDotF.Invert();
 
   TMatrix tmpMat(InvFTDotF, TMatrix::kMult, FT);
   gMat = tmpMat;
   gMat *= scaleMatrixBy;
 }

◆ getNumericalDeriv()

void EcalEBPhase2TPParamProducer::getNumericalDeriv	(	TGraph	graph,
		TGraph &	deriv
	)

private

Definition at line 342 of file EcalEBPhase2TPParamProducer.cc.

References NPoints_, AlCaHLTBitMon_ParallelJobs::p, writedatasetfile::run, makeMEIFBenchmarkPlots::xval, and makeMEIFBenchmarkPlots::yval.

Referenced by computeWeights().

                                                                                {
   UInt_t numPoints = graph.GetN();
   if (numPoints != NPoints_) {
     edm::LogWarning("EcalEBPhase2TPParamProducer") << "Error! Wrong amount of points in pulse graph! ";
   }
   Double_t xval;
   Double_t yval;
   Double_t xvalPOne;
   Double_t yvalPOne;
 
   for (UInt_t p = 0; p < NPoints_ - 1; p++) {
     graph.GetPoint(p, xval, yval);
     graph.GetPoint(p + 1, xvalPOne, yvalPOne);
     float midpoint = (xvalPOne + xval) / 2;
     float rise = yvalPOne - yval;
     float run = xvalPOne - xval;
     deriv.SetPoint(deriv.GetN(), midpoint, rise / run);
   }
   deriv.SetName("pulse_prime");
 }

◆ getPulseSampleSet()

void EcalEBPhase2TPParamProducer::getPulseSampleSet	(	TGraph	pulseGraph,
		float	phaseShift,
		std::vector< float > &	sampleSet
	)

private

Definition at line 400 of file EcalEBPhase2TPParamProducer.cc.

References mps_fire::i, norm_, offset_, ecalPh2::Samp_Period, ecalPh2::sampleSize, submitPVValidationJobs::t, and y.

Referenced by computeWeights().

                                                                                  {
   for (UInt_t i = 0; i < ecalPh2::sampleSize; i++) {
     float t = (ecalPh2::Samp_Period * i) + phaseShift;
     float y = pulseGraph.Eval(t + offset_) * norm_;
     sampleSet.push_back(y);
   }
 }