Inheritance diagram for PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL:

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

void	beginJob () override

void	endJob () override

	PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL (const edm::ParameterSet &)

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

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::vector< ModuleDescription const * > &modules, 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)

Private Attributes
std::string	inputTxtFile

std::string	rec1

std::string	rec2

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static bool	wantsStreamRuns ()

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

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)

Detailed Description

Definition at line 15 of file PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL.cc.

Constructor & Destructor Documentation

◆ PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL()

PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL::PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL ( const edm::ParameterSet & p )

Definition at line 28 of file PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL.cc.

                               {
   inputTxtFile = p.getUntrackedParameter<std::string>("inputTxtFile");
   rec1 = p.getUntrackedParameter<std::string>("RecordPayload");
   rec2 = p.getUntrackedParameter<std::string>("RecordWP");
 }

References inputTxtFile, AlCaHLTBitMon_ParallelJobs::p, rec1, rec2, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL()

PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL::~PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL ( )

inlineoverride

Definition at line 21 of file PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL.cc.

21 {}

Member Function Documentation

◆ analyze()

void PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL::analyze	(	const edm::Event &	,
		const edm::EventSetup &
	)

inlineoverridevirtual

Implements edm::EDAnalyzer.

Definition at line 19 of file PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL.cc.

19 {}

◆ beginJob()

void PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL::beginJob ( void )

overridevirtual

JUST A STUPID PATCH

Reimplemented from edm::EDAnalyzer.

Definition at line 35 of file PhysicsPerformanceDBWriterTFormula_fromfile_WPandPL.cc.

                                                                    {
   //
   // read object from file
   //
  
   //
   // File Format is
   // - tagger name
   // - cut
   // - concrete class name
   // number of results (btageff, btagSF....)
   // number of binning variables in the parameterization (eta, pt ...)
   // number of bins
   // - results (as ints)
   // - variables (as ints)
   // - formulas
   // - the limits
   //
  
   std::ifstream in;
   in.open(inputTxtFile.c_str());
   std::string tagger;
   float cut;
  
   std::string concreteType;
  
   in >> tagger;
   std::cout << "WP Tagger is " << tagger << std::endl;
  
   in >> cut;
   std::cout << "WP Cut is " << cut << std::endl;
  
   in >> concreteType;
   std::cout << "concrete Type is " << concreteType << std::endl;
  
   int nres = 0, nvar = 0;
  
   in >> nres;
   in >> nvar;
  
   std::cout << "Using " << nres << " results and " << nvar << " variables" << std::endl;
  
   unsigned int bins = 0;  //temporary for now!!!!!!
  
   in >> bins;
  
   std::cout << "Using " << bins << " bins" << std::endl;
  
   int number = 0;
   ;
  
   std::vector<PerformanceResult::ResultType> res;
   std::vector<BinningVariables::BinningVariablesType> bin;
   //
   // read results
   //
   number = 0;
   while (number < nres && !in.eof()) {
     int tmp;
     in >> tmp;
     res.push_back((PerformanceResult::ResultType)(tmp));
     std::cout << " Result #" << number << " is " << tmp << std::endl;
     ;
     number++;
   }
   if (number != nres) {
     std::cout << " Table not well formed" << std::endl;
   }
  
   //
   // read the variables
   //
  
   PerformanceWorkingPoint* wp = new PerformanceWorkingPoint(cut, tagger);
   PerformancePayloadFromBinnedTFormula* btagpl = nullptr;
  
   std::vector<PhysicsTFormulaPayload> v_ppl;
  
   number = 0;
   while (number < nvar && !in.eof()) {
     int tmp;
     in >> tmp;
     bin.push_back((BinningVariables::BinningVariablesType)(tmp));
     std::cout << " Variable #" << number << " is " << tmp << std::endl;
     ;
     number++;
   }
   if (number != nvar) {
     std::cout << " Table not well formed" << std::endl;
   }
  
   //
   // now read the formulas
   //
  
   for (unsigned int recregion = 0; recregion < bins; ++recregion) {
     std::vector<std::pair<float, float> > limits;
     std::vector<std::string> formulas;
  
     number = 0;
  
     while (number < nres && (!in.eof())) {
       std::string temp;
       in >> temp;
       std::cout << " Inserting " << temp << " as formula in position " << number << std::endl;
       number++;
       formulas.push_back(temp);
     }
     /*
       if (nres!= number ){
       std::cout <<" NOT OK, this is not what I would expect"<<std::endl;
       abort();
       }
     */
  
     number = 0;
     while (number < nvar && (!in.eof())) {
       float temp1, temp2;
       in >> temp1;
       in >> temp2;
       std::cout << " Inserting " << temp1 << "," << temp2 << " as limits in position " << number << std::endl;
       number++;
       limits.push_back(std::pair<float, float>(temp1, temp2));
     }
     /*
       if (nvar != number ){
       std::cout <<" NOT OK, this is not what I would expect"<<std::endl;
       abort();
       }
     */
  
     //
     // push it
     //
  
     PhysicsTFormulaPayload ppl(limits, formulas);
     v_ppl.push_back(ppl);
   }
   in.close();
  
   if (concreteType == "PerformancePayloadFromBinnedTFormula") {
     btagpl = new PerformancePayloadFromBinnedTFormula(res, bin, v_ppl);
     std::cout << " CHECK: " << btagpl->formulaPayloads().size() << std::endl;
   } else {
     std::cout << " Non existing request: " << concreteType << std::endl;
   }
  
   std::cout << " Created the " << concreteType << " object" << std::endl;
  
   std::cout << "Start writing the payload" << std::endl;
   edm::Service<cond::service::PoolDBOutputService> s;
   if (s.isAvailable()) {
     if (s->isNewTagRequest(rec1)) {
       s->createNewIOV<PerformancePayload>(btagpl, s->beginOfTime(), s->endOfTime(), rec1);
     } else {
       s->appendSinceTime<PerformancePayload>(btagpl,
                                              // JUST A STUPID PATCH
                                              111,
                                              rec1);
     }
   }
   std::cout << "Finised writing the payload" << std::endl;
  
   // write also the WP
   std::cout << "Start writing the WP" << std::endl;
   if (s.isAvailable()) {
     if (s->isNewTagRequest(rec2)) {
       s->createNewIOV<PerformanceWorkingPoint>(wp, s->beginOfTime(), s->endOfTime(), rec2);
     } else {
       s->appendSinceTime<PerformanceWorkingPoint>(wp,
                                                   111,
                                                   rec2);
     }
   }
   std::cout << "Finished writing the WP" << std::endl;
 }