#include <StoreEcalCondition.h>

Inheritance diagram for StoreEcalCondition:

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

int	convertFromConstructionSMToSlot (int, int)

void	endJob () override

std::shared_ptr< EcalADCToGeVConstant >	readEcalADCToGeVConstantFromFile (const char *)

std::shared_ptr< EcalChannelStatus >	readEcalChannelStatusFromFile (const char *)

std::shared_ptr< EcalGainRatios >	readEcalGainRatiosFromFile (const char *)

std::shared_ptr< EcalIntercalibConstants >	readEcalIntercalibConstantsFromFile (const char , const char )

std::shared_ptr< EcalIntercalibConstantsMC >	readEcalIntercalibConstantsMCFromFile (const char , const char )

std::shared_ptr< EcalPFRecHitThresholds >	readEcalPFRecHitThresholdsFromFile (const char , const char )

std::shared_ptr< EcalTBWeights >	readEcalTBWeightsFromFile (const char *)

std::shared_ptr< EcalWeightXtalGroups >	readEcalWeightXtalGroupsFromFile (const char *)

	StoreEcalCondition (const edm::ParameterSet &iConfig)

void	writeToLogFile (std::string, std::string, unsigned long long)

void	writeToLogFileResults (char *)

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

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)

Private Member Functions
void	fillHeader (char *)

std::string	to_string (char value[])

Private Attributes
std::vector< std::string >	inpFileName_

std::vector< std::string >	inpFileNameEE_

std::string	logfile_

std::vector< std::string >	objectName_

std::string	prog_name_

std::vector< unsigned long long >	since_

int	sm_constr_

int	sm_slot_

Additional Inherited Members
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 edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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)

Detailed Description

Definition at line 39 of file StoreEcalCondition.h.

Constructor & Destructor Documentation

◆ StoreEcalCondition()

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

explicit

Definition at line 18 of file StoreEcalCondition.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), inpFileName_, inpFileNameEE_, logfile_, objectName_, prog_name_, since_, sm_constr_, sm_slot_, AlCaHLTBitMon_QueryRunRegistry::string, and convertXMLtoSQLite_cfg::toPut.

                                                                      {
   prog_name_ = "StoreEcalCondition";
 
   logfile_ = iConfig.getParameter<std::string>("logfile");
   sm_slot_ = iConfig.getUntrackedParameter<unsigned int>("smSlot", 1);
 
   typedef std::vector<edm::ParameterSet> Parameters;
   Parameters toPut = iConfig.getParameter<Parameters>("toPut");
   for (Parameters::iterator itToPut = toPut.begin(); itToPut != toPut.end(); ++itToPut) {
     inpFileName_.push_back(itToPut->getUntrackedParameter<std::string>("inputFile"));
     inpFileNameEE_.push_back(itToPut->getUntrackedParameter<std::string>("inputFileEE"));
     objectName_.push_back(itToPut->getUntrackedParameter<std::string>("conditionType"));
     since_.push_back(itToPut->getUntrackedParameter<unsigned int>("since"));
   }
 
   sm_constr_ = -1;
 }

◆ ~StoreEcalCondition()

StoreEcalCondition::~StoreEcalCondition ( )

override

Definition at line 138 of file StoreEcalCondition.cc.

138 {}

Member Function Documentation

◆ analyze()

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

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 141 of file StoreEcalCondition.cc.

                                                                                    {
   //-------------------------------------------------------------
 }

◆ convertFromConstructionSMToSlot()

int StoreEcalCondition::convertFromConstructionSMToSlot	(	int	sm_constr,
		int	sm_slot
	)

Definition at line 896 of file StoreEcalCondition.cc.

References mps_fire::result.

Referenced by readEcalIntercalibConstantsFromFile(), and readEcalIntercalibConstantsMCFromFile().

                                                                                   {
   // input either cosntruction number or slot number and returns the other
   // the slots are numbered first EB+ slot 1 ...18 then EB- 1... 18
   // the slots start at 1 and the SM start at 0
   //-------------------------------------------------------------
   int slot_to_constr[37] = {-1, 12, 17, 10, 1,  8,  4, 27, 20, 23, 25, 6,  34, 35, 15, 18, 30, 21, 9,
                             24, 22, 13, 31, 26, 16, 2, 11, 5,  0,  29, 28, 14, 33, 32, 3,  7,  19};
   int constr_to_slot[36] = {28, 4,  25, 34, 6,  27, 11, 35, 5,  18, 3,  26, 1,  21, 31, 14, 24, 2,
                             15, 36, 8,  17, 20, 9,  19, 10, 23, 7,  30, 29, 16, 22, 33, 32, 12, 13};
 
   int result = 0;
   if (sm_constr != -1) {
     result = constr_to_slot[sm_constr];
   } else if (sm_slot != -1) {
     result = slot_to_constr[sm_slot];
   }
   return result;
 }

◆ endJob()

void StoreEcalCondition::endJob ( void )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 36 of file StoreEcalCondition.cc.

References cond::service::PoolDBOutputService::appendOneIOV(), cond::service::PoolDBOutputService::beginOfTime(), cond::service::PoolDBOutputService::createOneIOV(), mps_fire::i, inpFileName_, inpFileNameEE_, edm::Service< T >::isAvailable(), cond::service::PoolDBOutputService::isNewTagRequest(), objectName_, readEcalADCToGeVConstantFromFile(), readEcalChannelStatusFromFile(), readEcalGainRatiosFromFile(), readEcalIntercalibConstantsFromFile(), readEcalIntercalibConstantsMCFromFile(), readEcalPFRecHitThresholdsFromFile(), readEcalTBWeightsFromFile(), readEcalWeightXtalGroupsFromFile(), since_, AlCaHLTBitMon_QueryRunRegistry::string, and writeToLogFileResults().

                                 {
   edm::Service<cond::service::PoolDBOutputService> mydbservice;
   if (!mydbservice.isAvailable()) {
     edm::LogError("StoreEcalCondition") << "PoolDBOutputService is unavailable";
     return;
   }
 
   bool toAppend = false;
   // copy a string to the char *
   std::string message = "finished OK\n";
   size_t messageSize = message.size() + 1;
   char* messChar = new char[messageSize];
   strncpy(messChar, message.c_str(), messageSize);
 
   for (unsigned int i = 0; i < objectName_.size(); i++) {
     cond::Time_t newTime;
 
     if (mydbservice->isNewTagRequest(objectName_[i] + std::string("Rcd"))) {
       // This is the first object for this tag.
       // Append mode should be off.
       // newTime is the end of this new objects IOV.
       newTime = mydbservice->beginOfTime();
     } else {
       // There should already be an object in the DB for this tag.
       // Append IOV mode should be on.
       // newTime is the beginning of this new objects IOV.
       toAppend = true;
       newTime = (cond::Time_t)since_[i];
     }
     edm::LogInfo("StoreEcalCondition") << "Reading " << objectName_[i] << " from file and writing to DB with newTime "
                                        << newTime;
 
     if (objectName_[i] == "EcalWeightXtalGroups") {
       const auto mycali = readEcalWeightXtalGroupsFromFile(inpFileName_[i].c_str());
       if (!toAppend) {
         mydbservice->createOneIOV<EcalWeightXtalGroups>(*mycali, newTime, "EcalWeightXtalGroupsRcd");
       } else {
         mydbservice->appendOneIOV<EcalWeightXtalGroups>(*mycali, newTime, "EcalWeightXtalGroupsRcd");
       }
     } else if (objectName_[i] == "EcalTBWeights") {
       const auto mycali = readEcalTBWeightsFromFile(inpFileName_[i].c_str());
       if (!toAppend) {
         mydbservice->createOneIOV<EcalTBWeights>(*mycali, newTime, "EcalTBWeightsRcd");
       } else {
         mydbservice->appendOneIOV<EcalTBWeights>(*mycali, newTime, "EcalTBWeightsRcd");
       }
     } else if (objectName_[i] == "EcalADCToGeVConstant") {
       const auto mycali = readEcalADCToGeVConstantFromFile(inpFileName_[i].c_str());
       if (!toAppend) {
         mydbservice->createOneIOV<EcalADCToGeVConstant>(*mycali, newTime, "EcalADCToGeVConstantRcd");
       } else {
         mydbservice->appendOneIOV<EcalADCToGeVConstant>(*mycali, newTime, "EcalADCToGeVConstantRcd");
       }
     } else if (objectName_[i] == "EcalIntercalibConstants") {
       const auto mycali = readEcalIntercalibConstantsFromFile(inpFileName_[i].c_str(), inpFileNameEE_[i].c_str());
       if (!toAppend) {
         mydbservice->createOneIOV<EcalIntercalibConstants>(*mycali, newTime, "EcalIntercalibConstantsRcd");
       } else {
         mydbservice->appendOneIOV<EcalIntercalibConstants>(*mycali, newTime, "EcalIntercalibConstantsRcd");
       }
     } else if (objectName_[i] == "EcalPFRecHitThresholds") {
       const auto mycali = readEcalPFRecHitThresholdsFromFile(inpFileName_[i].c_str(), inpFileNameEE_[i].c_str());
       if (!toAppend) {
         mydbservice->createOneIOV<EcalPFRecHitThresholds>(*mycali, newTime, "EcalPFRecHitThresholdsRcd");
       } else {
         mydbservice->appendOneIOV<EcalPFRecHitThresholds>(*mycali, newTime, "EcalPFRecHitThresholdsRcd");
       }
     } else if (objectName_[i] == "EcalIntercalibConstantsMC") {
       const auto mycali = readEcalIntercalibConstantsMCFromFile(inpFileName_[i].c_str(), inpFileNameEE_[i].c_str());
       if (!toAppend) {
         mydbservice->createOneIOV<EcalIntercalibConstantsMC>(*mycali, newTime, "EcalIntercalibConstantsMCRcd");
       } else {
         mydbservice->appendOneIOV<EcalIntercalibConstantsMC>(*mycali, newTime, "EcalIntercalibConstantsMCRcd");
       }
     } else if (objectName_[i] == "EcalGainRatios") {
       const auto mycali = readEcalGainRatiosFromFile(inpFileName_[i].c_str());
       if (!toAppend) {
         mydbservice->createOneIOV<EcalGainRatios>(*mycali, newTime, "EcalGainRatiosRcd");
       } else {
         mydbservice->appendOneIOV<EcalGainRatios>(*mycali, newTime, "EcalGainRatiosRcd");
       }
     } else if (objectName_[i] == "EcalChannelStatus") {
       const auto mycali = readEcalChannelStatusFromFile(inpFileName_[i].c_str());
       if (!toAppend) {
         mydbservice->createOneIOV<EcalChannelStatus>(*mycali, newTime, "EcalChannelStatusRcd");
       } else {
         mydbservice->appendOneIOV<EcalChannelStatus>(*mycali, newTime, "EcalChannelStatusRcd");
       }
     } else {
       edm::LogError("StoreEcalCondition") << "Object " << objectName_[i] << " is not supported by this program.";
     }
 
     //      writeToLogFile(objectName_[i], inpFileName_[i], since_[i]);
     //writeToLogFileResults("finished OK\n");
     writeToLogFileResults(messChar);
 
     edm::LogInfo("StoreEcalCondition") << "Finished endJob";
   }
 
   delete[] messChar;
 }

◆ fillHeader()

void StoreEcalCondition::fillHeader ( char * header )

private

Definition at line 192 of file StoreEcalCondition.cc.

References RecoTauValidation_cfi::header, protons_cff::time, and EnviromentSettings::user.

Referenced by writeToLogFile(), and writeToLogFileResults().

 {
   time_t rawtime;
   struct tm* timeinfo;
   time(&rawtime);
   timeinfo = localtime(&rawtime);
   char user[50];
   sprintf(user, "%s", getlogin());
   sprintf(header, "%s %s:", asctime(timeinfo), user);
 }

◆ readEcalADCToGeVConstantFromFile()

std::shared_ptr< EcalADCToGeVConstant > StoreEcalCondition::readEcalADCToGeVConstantFromFile ( const char * inputFile )

Definition at line 450 of file StoreEcalCondition.cc.

References makeListRunsInFiles::inputFile, mps_splice::line, LogDebug, sm_constr_, str, and to_string().

Referenced by endJob().

                                                                                                               {
   //-------------------------------------------------------------
 
   FILE* inpFile;  // input file
   inpFile = fopen(inputFile, "r");
   if (!inpFile) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << inputFile;
     return nullptr;
   }
 
   char line[256];
 
   std::ostringstream str;
 
   fgets(line, 255, inpFile);
   int sm_number = atoi(line);
   str << "sm= " << sm_number << "\n";
 
   fgets(line, 255, inpFile);
   //int nevents=atoi(line); // not necessary here just for online conddb
 
   fgets(line, 255, inpFile);
   string gen_tag = to_string(line);
   str << "gen tag " << gen_tag << "\n";  // should I use this?
 
   fgets(line, 255, inpFile);
   string cali_method = to_string(line);
   str << "cali method " << cali_method << "\n";  // not important
 
   fgets(line, 255, inpFile);
   string cali_version = to_string(line);
   str << "cali version " << cali_version << "\n";  // not important
 
   fgets(line, 255, inpFile);
   string cali_type = to_string(line);
   str << "cali type " << cali_type << "\n";  // not important
 
   edm::LogInfo("StoreEcalCondition") << "ADCToGeV file " << str.str();
 
   fgets(line, 255, inpFile);
   float adc_to_gev = 0;
   sscanf(line, "%f", &adc_to_gev);
   LogDebug("StoreEcalCondition") << " calib=" << adc_to_gev;
   fgets(line, 255, inpFile);
   float adc_to_gev_ee = 0;
   sscanf(line, "%f", &adc_to_gev_ee);
   LogDebug("StoreEcalCondition") << " calib=" << adc_to_gev_ee;
 
   fclose(inpFile);  // close inp. file
 
   sm_constr_ = sm_number;
 
   // barrel and endcaps the same
   auto agc = std::make_shared<EcalADCToGeVConstant>(adc_to_gev, adc_to_gev_ee);
   edm::LogInfo("StoreEcalCondition") << "ADCtoGeV scale written into the DB";
   return agc;
 }

◆ readEcalChannelStatusFromFile()

std::shared_ptr< EcalChannelStatus > StoreEcalCondition::readEcalChannelStatusFromFile ( const char * inputFile )

Definition at line 1057 of file StoreEcalCondition.cc.

References Exception, ecalpyutils::hashedIndex(), LEDCalibrationChannels::ieta, compare_using_db::ifile, cuy::ii, makeListRunsInFiles::inputFile, LEDCalibrationChannels::iphi, ecalpyutils::ism(), EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, mps_splice::line, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, EBDetId::MIN_IPHI, EBDetId::SMCRYSTALMODE, mps_update::status, AlCaHLTBitMon_QueryRunRegistry::string, EBDetId::unhashIndex(), EEDetId::unhashIndex(), EBDetId::validDetId(), and EEDetId::validDetId().

Referenced by endJob().

                                                                                                         {
   auto status = std::make_shared<EcalChannelStatus>();
   // barrel
   for (int ieta = -EBDetId::MAX_IETA; ieta <= EBDetId::MAX_IETA; ++ieta) {
     if (ieta == 0)
       continue;
     for (int iphi = EBDetId::MIN_IPHI; iphi <= EBDetId::MAX_IPHI; ++iphi) {
       if (EBDetId::validDetId(ieta, iphi)) {
         EBDetId ebid(ieta, iphi);
         status->setValue(ebid, 0);
       }
     }
   }
   // endcap
   for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
     for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
       // make an EEDetId since we need EEDetId::rawId() to be used as the key for the pedestals
       if (EEDetId::validDetId(iX, iY, 1)) {
         EEDetId eedetidpos(iX, iY, 1);
         status->setValue(eedetidpos, 0);
       }
       if (EEDetId::validDetId(iX, iY, -1)) {
         EEDetId eedetidneg(iX, iY, -1);
         status->setValue(eedetidneg, 0);
       }
     }
   }
 
   edm::LogInfo("StoreEcalCondition") << "Reading channel status from file " << inputFile;
   FILE* ifile = fopen(inputFile, "r");
   if (!ifile)
     throw cms::Exception("Cannot open ECAL channel status file");
 
   char line[256];
 
   fgets(line, 255, ifile);
   std::string gen_tag = line;
   edm::LogVerbatim("StoreEcalCondition") << "Gen tag " << gen_tag << "\n";
 
   fgets(line, 255, ifile);
   std::string comment = line;
   edm::LogVerbatim("StoreEcalCondition") << "Gen comment " << comment << "\n";
 
   int iovRunStart(0);
   fgets(line, 255, ifile);
   sscanf(line, "%d", &iovRunStart);
   edm::LogVerbatim("StoreEcalCondition") << "IOV START " << iovRunStart << "\n";
   //if -1 start of time
 
   int iovRunEnd(0);
   fgets(line, 255, ifile);
   sscanf(line, "%d", &iovRunEnd);
   edm::LogVerbatim("StoreEcalCondition") << "IOV END " << iovRunEnd << "\n";
   //if -1 end of time
 
   int ii = 0;
   while (fgets(line, 255, ifile)) {
     std::string EBorEE;
     int hashedIndex(0);
     int chStatus(0);
     std::stringstream aStrStream;
     aStrStream << line;
     aStrStream >> EBorEE >> hashedIndex >> chStatus;
     //      if(ii==0)
     edm::LogVerbatim("StoreEcalCondition")
         << EBorEE << " hashedIndex " << hashedIndex << " status " << chStatus << "\n";
 
     if (EBorEE == "EB") {
       EBDetId aEBDetId = EBDetId::unhashIndex(hashedIndex);
       status->setValue(aEBDetId, chStatus);
     } else if (EBorEE == "EE") {
       //        chStatus=1;
       EEDetId aEEDetId = EEDetId::unhashIndex(hashedIndex);
       status->setValue(aEEDetId, chStatus);
     } else if (EBorEE == "EBTT") {
       int ism = hashedIndex;
       int itt = chStatus;
 
       int ixtt = (itt - 1) % 4;
       int iytt = (itt - 1) / 4;
       int ixmin = ixtt * 5;
       int iymin = iytt * 5;
       int ixmax = (ixtt + 1) * 5 - 1;
       int iymax = (iytt + 1) * 5 - 1;
       for (int ieta = iymin; ieta <= iymax; ieta++) {
         for (int iphi = ixmin; iphi <= ixmax; iphi++) {
           int ixt = ieta * 20 + iphi + 1;
           edm::LogVerbatim("StoreEcalCondition") << "killing crystal " << ism << "/" << ixt << "\n";
           EBDetId ebid(ism, ixt, EBDetId::SMCRYSTALMODE);
           status->setValue(ebid, 1);
         }
       }
     }
 
     ii++;
   }
 
   fclose(ifile);
 
   /*
     std::cout <<"KILLING CHANNELS FOR CRAFT EB+16 AND EB+7"<<endl; 
 
     int ism=7;
     for(int ixt=1; ixt<=500; ixt++) {
       EBDetId ebid(ism,ixt,EBDetId::SMCRYSTALMODE);
       status->setValue( ebid, 1 );
     }
     for(int ixt=501; ixt<=900; ixt++) {
       EBDetId ebid(ism,ixt,EBDetId::SMCRYSTALMODE);
       if( ((ixt)%20==0) || ((ixt)%20>10) ){  
         status->setValue( ebid, 1 );
       }
     }
     ism=16;
     for(int ixt=501; ixt<=900; ixt++) {
       EBDetId ebid(ism,ixt,EBDetId::SMCRYSTALMODE);
       if( ((ixt)%20==0) || ((ixt)%20>10) ){  
         status->setValue( ebid, 1 );
       }
     }
 
     */
 
   return status;
 }

◆ readEcalGainRatiosFromFile()

std::shared_ptr< EcalGainRatios > StoreEcalCondition::readEcalGainRatiosFromFile ( const char * inputFile )

Definition at line 916 of file StoreEcalCondition.cc.

References PVValHelper::eta, EBDetId::ETAPHIMODE, mps_fire::i, cuy::ii, makeListRunsInFiles::inputFile, EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, mps_splice::line, phi, DetId::rawId(), EcalMGPAGainRatio::setGain12Over6(), EcalMGPAGainRatio::setGain6Over1(), sm_constr_, sm_slot_, EBDetId::SMCRYSTALMODE, str, to_string(), and EEDetId::validDetId().

Referenced by endJob().

                                                                                                   {
   //-------------------------------------------------------------
 
   // create gain ratios
   auto gratio = std::make_shared<EcalGainRatios>();
 
   FILE* inpFile;  // input file
   inpFile = fopen(inputFile, "r");
   if (!inpFile) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << inputFile;
     return nullptr;
   }
 
   char line[256];
   std::ostringstream str;
 
   fgets(line, 255, inpFile);
   string sm_or_all = to_string(line);
   int sm_number = 0;
   sm_number = atoi(line);
   str << "sm= " << sm_number << "\n";
 
   fgets(line, 255, inpFile);
   //int nevents=atoi(line);
 
   fgets(line, 255, inpFile);
   string gen_tag = to_string(line);
   str << "gen tag " << gen_tag << "\n";
 
   fgets(line, 255, inpFile);
   string cali_method = to_string(line);
   str << "cali method " << cali_method << "\n";
 
   fgets(line, 255, inpFile);
   string cali_version = to_string(line);
   str << "cali version " << cali_version << "\n";
 
   fgets(line, 255, inpFile);
   string cali_type = to_string(line);
 
   str << "cali type " << cali_type << "\n";
 
   edm::LogInfo("StoreEcalCondition") << "GainRatio file " << str.str();
 
   int cry_num[61200] = {0};
   float g1_g12[61200] = {0};
   float g6_g12[61200] = {0};
   int calib_status[61200] = {0};
   int dummy1 = 0;
   int dummy2 = 0;
   int hash1 = 0;
 
   int ii = 0;
 
   if (sm_number != -1) {
     while (fgets(line, 255, inpFile)) {
       sscanf(line, "%d %d %d %f %f %d", &dummy1, &dummy2, &cry_num[ii], &g1_g12[ii], &g6_g12[ii], &calib_status[ii]);
       ii++;
     }
 
     fclose(inpFile);  // close inp. file
 
     edm::LogInfo("StoreEcalCondition") << "Read gainRatios for " << ii << " xtals ";
     if (ii != 1700)
       edm::LogWarning("StoreEcalCondition") << " Missing crystals:: missing channels will be set to 0";
 
     // Get channel ID
     sm_constr_ = sm_number;
 
     for (int i = 0; i < 1700; i++) {
       // EBDetId(int index1, int index2, int mode = ETAPHIMODE)
       // sm and crys index SMCRYSTALMODE index1 is SM index2 is crystal number a la H4
       EBDetId ebid(sm_slot_, cry_num[i], EBDetId::SMCRYSTALMODE);
       EcalMGPAGainRatio gr;
       gr.setGain12Over6(g6_g12[i]);
       gr.setGain6Over1(g1_g12[i] / g6_g12[i]);
       gratio->setValue(ebid.rawId(), gr);
     }  // loop over channels
 
   } else {
     // this is for the whole Barrel
     edm::LogInfo("StoreEcalCondition") << "mode ALL BARREL";
     while (fgets(line, 255, inpFile)) {
       int eta = 0;
       int phi = 0;
       sscanf(line, "%d %d %d %f %f", &hash1, &eta, &phi, &g1_g12[ii], &g6_g12[ii]);
       if (ii < 20)
         edm::LogVerbatim("StoreEcalCondition")
             << "crystal eta/phi=" << eta << "/" << phi << " g1_12/g6_12= " << g1_g12[ii] << "/" << g6_g12[ii] << "\n";
 
       if (g1_g12[ii] < 9 || g1_g12[ii] > 15)
         g1_g12[ii] = 12.0;
       if (g6_g12[ii] < 1 || g6_g12[ii] > 3)
         g6_g12[ii] = 2.0;
 
       if (eta < -85 || eta > 85 || eta == 0)
         edm::LogVerbatim("StoreEcalCondition") << "error!!!\n";
       if (phi < 1 || phi > 360)
         edm::LogVerbatim("StoreEcalCondition") << "error!!!\n";
 
       EBDetId ebid(eta, phi, EBDetId::ETAPHIMODE);
       EcalMGPAGainRatio gr;
       gr.setGain12Over6(g6_g12[ii]);
       gr.setGain6Over1(g1_g12[ii] / g6_g12[ii]);
       gratio->setValue(ebid.rawId(), gr);
 
       ii++;
     }
 
     fclose(inpFile);  // close inp. file
     if (ii != 61200)
       edm::LogWarning("StoreEcalCondition") << " Missing crystals !!!!!!!";
 
     edm::LogInfo("StoreEcalCondition") << "number of crystals read:" << ii;
   }
 
   for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
     for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
       // make an EEDetId since we need EEDetId::rawId() to be used as the key for the pedestals
       EcalMGPAGainRatio gr;
       gr.setGain12Over6(2.);
       gr.setGain6Over1(6.);
 
       if (EEDetId::validDetId(iX, iY, 1)) {
         EEDetId eedetidpos(iX, iY, 1);
         gratio->setValue(eedetidpos.rawId(), gr);
       }
       if (EEDetId::validDetId(iX, iY, -1)) {
         EEDetId eedetidneg(iX, iY, -1);
         gratio->setValue(eedetidneg.rawId(), gr);
       }
     }
   }
 
   edm::LogInfo("StoreEcalCondition") << " gratio pointer=" << gratio;
 
   edm::LogInfo("StoreEcalCondition") << "now leaving";
 
   return gratio;
 }

◆ readEcalIntercalibConstantsFromFile()

std::shared_ptr< EcalIntercalibConstants > StoreEcalCondition::readEcalIntercalibConstantsFromFile	(	const char *	inputFile,
		const char *	inputFileEE
	)

Definition at line 578 of file StoreEcalCondition.cc.

References convertFromConstructionSMToSlot(), mps_fire::i, cuy::ii, makeListRunsInFiles::inputFile, EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, mps_splice::line, DetId::rawId(), sm_constr_, EBDetId::SMCRYSTALMODE, str, to_string(), and EEDetId::validDetId().

Referenced by endJob().

                                                     {
   //-------------------------------------------------------------
 
   auto ical = std::make_shared<EcalIntercalibConstants>();
 
   FILE* inpFile;  // input file
   inpFile = fopen(inputFile, "r");
   if (!inpFile) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << inputFile;
     return nullptr;
   }
 
   char line[256];
 
   std::ostringstream str;
 
   fgets(line, 255, inpFile);
   string sm_or_all = to_string(line);
   int sm_number = 0;
   int nchan = 1700;
   sm_number = atoi(line);
   str << "sm= " << sm_number << "\n";
   if (sm_number != -1) {
     nchan = 1700;
   } else {
     nchan = 61200;
   }
 
   fgets(line, 255, inpFile);
   //int nevents=atoi(line); // not necessary here just for online conddb
 
   fgets(line, 255, inpFile);
   string gen_tag = to_string(line);
   str << "gen tag " << gen_tag << "\n";  // should I use this?
 
   fgets(line, 255, inpFile);
   string cali_method = to_string(line);
   str << "cali method " << cali_method << "\n";  // not important
 
   fgets(line, 255, inpFile);
   string cali_version = to_string(line);
   str << "cali version " << cali_version << "\n";  // not important
 
   fgets(line, 255, inpFile);
   string cali_type = to_string(line);
   str << "cali type " << cali_type << "\n";  // not important
 
   edm::LogInfo("StoreEcalCondition") << "Intercalibration file " << str.str();
 
   int sm_num[61200] = {0};
   int cry_num[61200] = {0};
   float calib[61200] = {0};
   float calib_rms[61200] = {0};
   int calib_nevents[61200] = {0};
   int calib_status[61200] = {0};
 
   int ii = 0;
   if (sm_number != -1) {
     while (fgets(line, 255, inpFile)) {
       sscanf(line, "%d %f %f %d %d", &cry_num[ii], &calib[ii], &calib_rms[ii], &calib_nevents[ii], &calib_status[ii]);
       //       if(ii<10) { // print out only the first ten channels
       //    cout << "cry="<<cry_num[ii]<<" calib="<<calib[ii]<<endl;
       //       }
       sm_num[ii] = sm_number;
       ii++;
     }
   } else {
     // this is for the whole Barrel
     edm::LogInfo("StoreEcalCondition") << "mode ALL BARREL";
     while (fgets(line, 255, inpFile)) {
       sscanf(line, "%d %d %f %f %d", &sm_num[ii], &cry_num[ii], &calib[ii], &calib_rms[ii], &calib_status[ii]);
       if (ii == 0)
         edm::LogVerbatim("StoreEcalCondition")
             << "crystal " << cry_num[ii] << " of sm " << sm_num[ii] << " cali= " << calib[ii] << "\n";
       ii++;
     }
   }
 
   //    inf.close();           // close inp. file
   fclose(inpFile);  // close inp. file
 
   edm::LogInfo("StoreEcalCondition") << "Read intercalibrations for " << ii << " xtals ";
 
   if (ii != nchan)
     edm::LogWarning("StoreEcalCondition") << "Some crystals missing. Missing channels will be set to 0";
 
   // Get channel ID
 
   sm_constr_ = sm_number;
 
   // Set the data
   for (int i = 0; i < nchan; i++) {
     // EBDetId(int index1, int index2, int mode = ETAPHIMODE)
     // sm and crys index SMCRYSTALMODE index1 is SM index2 is crystal number a la H4
 
     int slot_num = convertFromConstructionSMToSlot(sm_num[i], -1);
     EBDetId ebid(slot_num, cry_num[i], EBDetId::SMCRYSTALMODE);
 
     ical->setValue(ebid.rawId(), calib[i]);
 
     if (i == 0)
       edm::LogVerbatim("StoreEcalCondition") << "crystal " << cry_num[i] << " of sm " << sm_num[i] << " in slot "
                                              << slot_num << " calib= " << calib[i] << "\n";
 
   }  // loop over channels
 
   edm::LogInfo("StoreEcalCondition") << "loop on channels done";
 
   FILE* inpFileEE;  // input file
   inpFileEE = fopen(inputFileEE, "r");
   if (!inpFileEE) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << inputFile;
 
     // dummy endcap data
 
     for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
       for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
         // make an EEDetId since we need EEDetId::rawId() to be used as the key for the pedestals
         if (EEDetId::validDetId(iX, iY, 1)) {
           EEDetId eedetidpos(iX, iY, 1);
           ical->setValue(eedetidpos, 1.0);
         }
         if (EEDetId::validDetId(iX, iY, -1)) {
           EEDetId eedetidneg(iX, iY, -1);
           ical->setValue(eedetidneg, 1.0);
         }
       }
     }
 
   } else {
     edm::LogInfo("StoreEcalCondition") << "... now reading EE file ...";
 
     int ii = 0;
     while (fgets(line, 255, inpFileEE)) {
       int iz, ix, iy;
       float calibee;
       sscanf(line, "%d %d %d %f", &iz, &ix, &iy, &calibee);
       if (ii <= 0)
         edm::LogVerbatim("StoreEcalCondition")
             << "crystal " << iz << "/" << ix << "/" << iy << " cali=" << calibee << "\n";
 
       if (EEDetId::validDetId(ix, iy, iz)) {
         EEDetId eedetid(ix, iy, iz);
         ical->setValue(eedetid, calibee);
       }
 
       ii++;
     }
 
     fclose(inpFileEE);  // close inp. file
   }
 
   edm::LogInfo("StoreEcalCondition") << "loop on EE channels done";
 
   return ical;
 }

◆ readEcalIntercalibConstantsMCFromFile()

std::shared_ptr< EcalIntercalibConstantsMC > StoreEcalCondition::readEcalIntercalibConstantsMCFromFile	(	const char *	inputFile,
		const char *	inputFileEE
	)

Definition at line 737 of file StoreEcalCondition.cc.

References convertFromConstructionSMToSlot(), mps_fire::i, cuy::ii, makeListRunsInFiles::inputFile, EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, mps_splice::line, DetId::rawId(), sm_constr_, EBDetId::SMCRYSTALMODE, str, to_string(), and EEDetId::validDetId().

Referenced by endJob().

                                                     {
   //-------------------------------------------------------------
 
   auto ical = std::make_shared<EcalIntercalibConstantsMC>();
 
   FILE* inpFile;  // input file
   inpFile = fopen(inputFile, "r");
   if (!inpFile) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << inputFile;
     return nullptr;
   }
 
   char line[256];
 
   std::ostringstream str;
 
   fgets(line, 255, inpFile);
   string sm_or_all = to_string(line);
   int sm_number = 0;
   int nchan = 1700;
   sm_number = atoi(line);
   str << "sm= " << sm_number << "\n";
   if (sm_number != -1) {
     nchan = 1700;
   } else {
     nchan = 61200;
   }
 
   fgets(line, 255, inpFile);
   //int nevents=atoi(line); // not necessary here just for online conddb
 
   fgets(line, 255, inpFile);
   string gen_tag = to_string(line);
   str << "gen tag " << gen_tag << "\n";  // should I use this?
 
   fgets(line, 255, inpFile);
   string cali_method = to_string(line);
   str << "cali method " << cali_method << "\n";  // not important
 
   fgets(line, 255, inpFile);
   string cali_version = to_string(line);
   str << "cali version " << cali_version << "\n";  // not important
 
   fgets(line, 255, inpFile);
   string cali_type = to_string(line);
   str << "cali type " << cali_type << "\n";  // not important
 
   edm::LogInfo("StoreEcalCondition") << "Intercalibration file " << str.str();
 
   int sm_num[61200] = {0};
   int cry_num[61200] = {0};
   float calib[61200] = {0};
   float calib_rms[61200] = {0};
   int calib_nevents[61200] = {0};
   int calib_status[61200] = {0};
 
   int ii = 0;
   if (sm_number != -1) {
     while (fgets(line, 255, inpFile)) {
       sscanf(line, "%d %f %f %d %d", &cry_num[ii], &calib[ii], &calib_rms[ii], &calib_nevents[ii], &calib_status[ii]);
       //       if(ii<10) { // print out only the first ten channels
       //    cout << "cry="<<cry_num[ii]<<" calib="<<calib[ii]<<endl;
       //       }
       sm_num[ii] = sm_number;
       ii++;
     }
   } else {
     // this is for the whole Barrel
     edm::LogInfo("StoreEcalCondition") << "mode ALL BARREL";
     while (fgets(line, 255, inpFile)) {
       sscanf(line, "%d %d %f %f %d", &sm_num[ii], &cry_num[ii], &calib[ii], &calib_rms[ii], &calib_status[ii]);
       if (ii == 0)
         edm::LogVerbatim("StoreEcalCondition")
             << "crystal " << cry_num[ii] << " of sm " << sm_num[ii] << " cali= " << calib[ii] << "\n";
       ii++;
     }
   }
 
   //    inf.close();           // close inp. file
   fclose(inpFile);  // close inp. file
 
   edm::LogInfo("StoreEcalCondition") << "Read intercalibrations for " << ii << " xtals ";
 
   if (ii != nchan)
     edm::LogWarning("StoreEcalCondition") << "Some crystals missing. Missing channels will be set to 0";
 
   // Get channel ID
 
   sm_constr_ = sm_number;
 
   // Set the data
   for (int i = 0; i < nchan; i++) {
     // EBDetId(int index1, int index2, int mode = ETAPHIMODE)
     // sm and crys index SMCRYSTALMODE index1 is SM index2 is crystal number a la H4
 
     int slot_num = convertFromConstructionSMToSlot(sm_num[i], -1);
     EBDetId ebid(slot_num, cry_num[i], EBDetId::SMCRYSTALMODE);
 
     ical->setValue(ebid.rawId(), calib[i]);
 
     if (i == 0)
       edm::LogVerbatim("StoreEcalCondition") << "crystal " << cry_num[i] << " of sm " << sm_num[i] << " in slot "
                                              << slot_num << " calib= " << calib[i] << "\n";
 
   }  // loop over channels
 
   edm::LogInfo("StoreEcalCondition") << "loop on channels done";
 
   FILE* inpFileEE;  // input file
   inpFileEE = fopen(inputFileEE, "r");
   if (!inpFileEE) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << inputFile;
 
     // dummy endcap data
 
     for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
       for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
         // make an EEDetId since we need EEDetId::rawId() to be used as the key for the pedestals
         if (EEDetId::validDetId(iX, iY, 1)) {
           EEDetId eedetidpos(iX, iY, 1);
           ical->setValue(eedetidpos, 1.0);
         }
         if (EEDetId::validDetId(iX, iY, -1)) {
           EEDetId eedetidneg(iX, iY, -1);
           ical->setValue(eedetidneg, 1.0);
         }
       }
     }
 
   } else {
     edm::LogInfo("StoreEcalCondition") << "... now reading EE file ...";
 
     int ii = 0;
     while (fgets(line, 255, inpFileEE)) {
       int iz, ix, iy;
       float calibee;
       sscanf(line, "%d %d %d %f", &iz, &ix, &iy, &calibee);
       if (ii <= 0)
         edm::LogVerbatim("StoreEcalCondition")
             << "crystal " << iz << "/" << ix << "/" << iy << " cali=" << calibee << "\n";
 
       if (EEDetId::validDetId(ix, iy, iz)) {
         EEDetId eedetid(ix, iy, iz);
         ical->setValue(eedetid, calibee);
       }
 
       ii++;
     }
 
     fclose(inpFileEE);  // close inp. file
   }
 
   edm::LogInfo("StoreEcalCondition") << "loop on EE channels done";
 
   return ical;
 }

◆ readEcalPFRecHitThresholdsFromFile()

std::shared_ptr< EcalPFRecHitThresholds > StoreEcalCondition::readEcalPFRecHitThresholdsFromFile	(	const char *	inputFile,
		const char *	inputFileEE
	)

Definition at line 509 of file StoreEcalCondition.cc.

References LEDCalibrationChannels::ieta, cuy::ii, makeListRunsInFiles::inputFile, LEDCalibrationChannels::iphi, mps_splice::line, DetId::rawId(), DMR_cfg::thresh, EBDetId::validDetId(), and EEDetId::validDetId().

Referenced by endJob().

                                                     {
   //-------------------------------------------------------------
 
   auto ical = std::make_shared<EcalPFRecHitThresholds>();
 
   FILE* inpFile;  // input file
   inpFile = fopen(inputFile, "r");
   if (!inpFile) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << inputFile;
     return nullptr;
   }
 
   char line[256];
 
   int ieta = 0;
   int iphi = 0;
   int ix = 0;
   int iy = 0;
   int iz = 0;
 
   float thresh = 0;
 
   int ii = 0;
   while (fgets(line, 255, inpFile)) {
     sscanf(line, "%d %d %f ", &ieta, &iphi, &thresh);
     if (ii == 0)
       edm::LogVerbatim("StoreEcalCondition") << "crystal " << ieta << "/" << iphi << " Thresh= " << thresh << "\n";
 
     if (EBDetId::validDetId(ieta, iphi)) {
       EBDetId ebid(ieta, iphi);
       ical->setValue(ebid.rawId(), thresh);
       ii++;
     }
   }
 
   //    inf.close();           // close inp. file
   fclose(inpFile);  // close inp. file
 
   edm::LogInfo("StoreEcalCondition") << "Read PF RecHits for " << ii << " xtals ";
 
   FILE* inpFileEE;  // input file
   inpFileEE = fopen(inputFileEE, "r");
   if (!inpFileEE) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << inputFileEE;
     return nullptr;
   }
   ii = 0;
   while (fgets(line, 255, inpFileEE)) {
     sscanf(line, "%d %d %d %f ", &ix, &iy, &iz, &thresh);
     if (ii == 0)
       edm::LogVerbatim("StoreEcalCondition")
           << "crystal " << ix << "/" << iy << "/" << iz << " Thresh= " << thresh << "\n";
     if (EEDetId::validDetId(ix, iy, iz)) {
       EEDetId eeid(ix, iy, iz);
       ical->setValue(eeid.rawId(), thresh);
       ii++;
     }
   }
 
   //    inf.close();           // close inp. file
   fclose(inpFileEE);  // close inp. file
 
   edm::LogInfo("StoreEcalCondition") << "loop on EE channels done - number of crystals =" << ii;
 
   return ical;
 }

◆ readEcalTBWeightsFromFile()

std::shared_ptr< EcalTBWeights > StoreEcalCondition::readEcalTBWeightsFromFile ( const char * inputFile )

Definition at line 302 of file StoreEcalCondition.cc.

References EcalWeightSet::getChi2WeightsAfterGainSwitch(), EcalWeightSet::getChi2WeightsBeforeGainSwitch(), EcalWeightSet::getWeightsAfterGainSwitch(), EcalWeightSet::getWeightsBeforeGainSwitch(), mps_fire::i, makeListRunsInFiles::inputFile, dqmiolumiharvest::j, dqmdumpme::k, LogDebug, PresampleTask_cfi::nSamples, sm_constr_, str, and groupFilesInBlocks::temp.

Referenced by endJob().

                                                                                                 {
   //-------------------------------------------------------------
 
   // Zabi code to be written here
 
   auto tbwgt = std::make_shared<EcalTBWeights>();
 
   std::ifstream WeightsFileTB(inputFile);
   if (!WeightsFileTB.is_open()) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << inputFile;
     return nullptr;
   }
 
   int smnumber = -99999;
 
   std::ostringstream str;
   WeightsFileTB >> smnumber;
   if (smnumber == -99999)
     return nullptr;
 
   str << "sm= " << smnumber << "\n";
 
   char temp[256];
   //Reading the other 5 header lines containing various informations
   for (int i = 0; i <= 5; i++) {
     WeightsFileTB.getline(temp, 255);
     str << temp << "\n";
   }
 
   edm::LogInfo("StoreEcalCondition") << "Weights file " << str.str();
 
   int ngroups = 0;
   while (WeightsFileTB.good()) {
     int igroup_ID = -99999;
     int nSamples = -99999;
     int nTdcBins = -99999;
 
     WeightsFileTB >> igroup_ID >> nSamples >> nTdcBins;
     if (igroup_ID == -99999 || nSamples == -99999 || nTdcBins == -99999)
       break;
 
     std::ostringstream str;
     str << "Igroup=" << igroup_ID << " Nsamples=" << nSamples << " NTdcBins=" << nTdcBins << "\n";
 
     for (int iTdcBin = 0; iTdcBin < nTdcBins; iTdcBin++) {
       EcalWeightSet wgt;  // one set of weights
       EcalWeightSet::EcalWeightMatrix& wgt1 = wgt.getWeightsBeforeGainSwitch();
       EcalWeightSet::EcalWeightMatrix& wgt2 = wgt.getWeightsAfterGainSwitch();
       EcalWeightSet::EcalChi2WeightMatrix& chisq1 = wgt.getChi2WeightsBeforeGainSwitch();
       EcalWeightSet::EcalChi2WeightMatrix& chisq2 = wgt.getChi2WeightsAfterGainSwitch();
 
       //    std::vector<EcalWeight> wamp, wped, wtime; //weights before gain switch
       //    std::vector<EcalWeight> wamp2, wped2, wtime2; //weights after gain switch
 
       //WEIGHTS BEFORE GAIN SWITCH
       //Amplitude weights
       for (int j = 0; j < nSamples; ++j) {
         double ww = 0.0;
         WeightsFileTB >> ww;
         wgt1(0, j) = ww;
         str << ww << " ";
       }  // loop Samples
       str << "\n";
 
       //Pedestal weights
       for (int j = 0; j < nSamples; ++j) {
         double ww = 0.0;
         WeightsFileTB >> ww;
         wgt1(1, j) = ww;
         str << ww << " ";
       }  //loop Samples
       str << "\n";
 
       //Timing weights
       for (int j = 0; j < nSamples; ++j) {
         double ww = 0.0;
         WeightsFileTB >> ww;
         wgt1(2, j) = ww;
         str << ww << " ";
       }  //loop Samples
       str << "\n";
 
       for (int j = 0; j < nSamples; ++j) {
         // fill chi2 matrix
         //std::vector<EcalWeight> vChi2; // row of chi2 matrix
         for (int k = 0; k < nSamples; ++k) {
           double ww = 0.0;
           WeightsFileTB >> ww;
           chisq1(j, k) = ww;
           str << ww << " ";
         }  //loop samples
         str << "\n";
       }  //loop lines
 
       //WEIGHTS AFTER GAIN SWITCH
       for (int j = 0; j < nSamples; ++j) {
         double ww = 0.0;
         WeightsFileTB >> ww;
         wgt2(0, j) = ww;
         str << ww << " ";
       }  // loop Samples
       str << "\n";
 
       //Pedestal weights
       for (int j = 0; j < nSamples; ++j) {
         double ww = 0.0;
         WeightsFileTB >> ww;
         wgt2(1, j) = ww;
         str << ww << " ";
       }  //loop Samples
       str << "\n";
 
       //Timing weights
       for (int j = 0; j < nSamples; ++j) {
         double ww = 0.0;
         WeightsFileTB >> ww;
         wgt2(2, j) = ww;
         str << ww << " ";
       }  //loop Samples
       str << "\n";
 
       for (int j = 0; j < nSamples; ++j) {
         // fill chi2 matrix
         //std::vector<EcalWeight> vChi2; // row of chi2 matrix
         for (int k = 0; k < nSamples; ++k) {
           double ww = 0.0;
           WeightsFileTB >> ww;
           chisq2(j, k) = ww;
           str << ww << " ";
         }  //loop samples
         str << "\n";
       }  //loop lines
 
       LogDebug("StoreEcalCondition") << str.str();
 
       //modif-27-07-06 tdcid should start from 1
       tbwgt->setValue(std::make_pair(igroup_ID, iTdcBin + 1), wgt);
     }  //loop Tdc bins
     ngroups++;
   }  //loop groupID
 
   sm_constr_ = smnumber;
 
   edm::LogInfo("StoreEcalCondition") << "Weights for " << ngroups << " groups written into DB";
   return tbwgt;
 }

◆ readEcalWeightXtalGroupsFromFile()

std::shared_ptr< EcalWeightXtalGroups > StoreEcalCondition::readEcalWeightXtalGroupsFromFile ( const char * inputFile )

Definition at line 236 of file StoreEcalCondition.cc.

References mps_fire::i, makeListRunsInFiles::inputFile, LogDebug, DetId::rawId(), sm_constr_, sm_slot_, EBDetId::SMCRYSTALMODE, str, and groupFilesInBlocks::temp.

Referenced by endJob().

                                                                                                               {
   //-------------------------------------------------------------
 
   // Code taken from EcalWeightTools/test/MakeOfflineDbFromAscii.cpp
 
   auto xtalGroups = std::make_shared<EcalWeightXtalGroups>();
   std::ifstream groupid_in(inputFile);
 
   if (!groupid_in.is_open()) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << inputFile;
     return nullptr;
   }
 
   int smnumber = -99999;
 
   std::ostringstream str;
   groupid_in >> smnumber;
   if (smnumber == -99999) {
     edm::LogError("StoreEcalCondition") << "ERROR: SM number not found in file";
     return nullptr;
   }
   str << "sm= " << smnumber << "\n";
   sm_constr_ = smnumber;
 
   char temp[256];
   //Reading the other 5 header lines containing various informations
   for (int i = 0; i <= 5; i++) {
     groupid_in.getline(temp, 255);
     str << temp << "\n";
   }
 
   // Skip the nGroup/Mean line
   groupid_in.getline(temp, 255);
   str << temp << "\n";
 
   edm::LogInfo("StoreEcalCondition") << "GROUPID file " << str.str();
 
   int xtals = 0;
   int xtal, ietaf, iphif, groupID;
   while (groupid_in.good()) {
     groupid_in >> xtal >> ietaf >> iphif >> groupID;
     if (groupid_in.eof()) {
       break;
     }
 
     LogDebug("StoreEcalCondition") << "XTAL=" << xtal << " ETA=" << ietaf << " PHI=" << iphif << " GROUP=" << groupID;
 
     //EBDetId ebid(ieta,iphi);
     EBDetId ebid(sm_slot_, xtal, EBDetId::SMCRYSTALMODE);
     // xtalGroups->setValue(ebid.rawId(), EcalXtalGroupId( ebid.hashedIndex()) );
     xtalGroups->setValue(ebid.rawId(), EcalXtalGroupId(groupID));
     xtals++;
   }  //loop iphi
 
   if (xtals != 1700) {
     edm::LogError("StoreEcalCondition") << "ERROR:  GROUPID file did not contain data for 1700 crystals";
     return nullptr;
   }
 
   edm::LogInfo("StoreEcalCondition") << "Groups for " << xtals << " xtals written into DB";
   sm_constr_ = smnumber;
 
   return xtalGroups;
 }

◆ to_string()

std::string StoreEcalCondition::to_string ( char value[] )

inlineprivate

Definition at line 72 of file StoreEcalCondition.h.

References relativeConstraints::value.

Referenced by readEcalADCToGeVConstantFromFile(), readEcalGainRatiosFromFile(), readEcalIntercalibConstantsFromFile(), and readEcalIntercalibConstantsMCFromFile().

                                     {
     std::ostringstream streamOut;
     streamOut << value;
     return streamOut.str();
   }

◆ writeToLogFile()

void StoreEcalCondition::writeToLogFile	(	std::string	,
		std::string	,
		unsigned long	long
	)

Definition at line 146 of file StoreEcalCondition.cc.

References a, b, fillHeader(), RecoTauValidation_cfi::header, createfilelist::int, logfile_, L1TdeCSCTF_cfi::outFile, SiStripBadComponentsDQMServiceTemplate_cfg::since, sm_constr_, and sm_slot_.

                                                                                     {
   //-------------------------------------------------------------
 
   FILE* outFile;  // output log file for appending
   outFile = fopen(logfile_.c_str(), "a");
   if (!outFile) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << logfile_;
     return;
   }
   char header[256];
   fillHeader(header);
   char appendMode[10];
   if (since != 0)
     sprintf(appendMode, "append");
   else
     sprintf(appendMode, "create");
 
   fprintf(outFile,
           "%s %s condition from file %s written into DB for SM %d (mapped to SM %d) in %s mode (since run %u)\n",
           header,
           a.c_str(),
           b.c_str(),
           sm_constr_,
           sm_slot_,
           appendMode,
           (unsigned int)since);
 
   fclose(outFile);  // close out file
 }

◆ writeToLogFileResults()

void StoreEcalCondition::writeToLogFileResults ( char * arg )

Definition at line 176 of file StoreEcalCondition.cc.

References fillHeader(), RecoTauValidation_cfi::header, logfile_, and L1TdeCSCTF_cfi::outFile.

Referenced by endJob().

                                                         {
   //-------------------------------------------------------------
 
   FILE* outFile;  // output log file for appending
   outFile = fopen(logfile_.c_str(), "a");
   if (!outFile) {
     edm::LogError("StoreEcalCondition") << "*** Can not open file: " << logfile_;
     return;
   }
   char header[256];
   fillHeader(header);
   fprintf(outFile, "%s %s\n", header, arg);
   fclose(outFile);  // close out file
 }

Member Data Documentation

◆ inpFileName_

std::vector<std::string> StoreEcalCondition::inpFileName_

private

Definition at line 64 of file StoreEcalCondition.h.

Referenced by endJob(), and StoreEcalCondition().

◆ inpFileNameEE_

std::vector<std::string> StoreEcalCondition::inpFileNameEE_

private

Definition at line 65 of file StoreEcalCondition.h.

Referenced by endJob(), and StoreEcalCondition().

◆ logfile_

std::string StoreEcalCondition::logfile_

private

Definition at line 70 of file StoreEcalCondition.h.

Referenced by StoreEcalCondition(), writeToLogFile(), and writeToLogFileResults().

◆ objectName_

std::vector<std::string> StoreEcalCondition::objectName_

private

Definition at line 62 of file StoreEcalCondition.h.

Referenced by endJob(), and StoreEcalCondition().

◆ prog_name_

std::string StoreEcalCondition::prog_name_

private

Definition at line 66 of file StoreEcalCondition.h.

Referenced by StoreEcalCondition().

◆ since_

std::vector<unsigned long long> StoreEcalCondition::since_

private

Definition at line 69 of file StoreEcalCondition.h.

Referenced by endJob(), and StoreEcalCondition().

◆ sm_constr_

int StoreEcalCondition::sm_constr_

private

Definition at line 67 of file StoreEcalCondition.h.

Referenced by readEcalADCToGeVConstantFromFile(), readEcalGainRatiosFromFile(), readEcalIntercalibConstantsFromFile(), readEcalIntercalibConstantsMCFromFile(), readEcalTBWeightsFromFile(), readEcalWeightXtalGroupsFromFile(), StoreEcalCondition(), and writeToLogFile().

◆ sm_slot_

int StoreEcalCondition::sm_slot_

private

Definition at line 68 of file StoreEcalCondition.h.

Referenced by readEcalGainRatiosFromFile(), readEcalWeightXtalGroupsFromFile(), StoreEcalCondition(), and writeToLogFile().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ StoreEcalCondition()

◆ ~StoreEcalCondition()

Member Function Documentation

◆ analyze()

◆ convertFromConstructionSMToSlot()

◆ endJob()

◆ fillHeader()

◆ readEcalADCToGeVConstantFromFile()

◆ readEcalChannelStatusFromFile()

◆ readEcalGainRatiosFromFile()

◆ readEcalIntercalibConstantsFromFile()

◆ readEcalIntercalibConstantsMCFromFile()

◆ readEcalPFRecHitThresholdsFromFile()

◆ readEcalTBWeightsFromFile()

◆ readEcalWeightXtalGroupsFromFile()

◆ to_string()

◆ writeToLogFile()

◆ writeToLogFileResults()

Member Data Documentation

◆ inpFileName_

◆ inpFileNameEE_

◆ logfile_

◆ objectName_

◆ prog_name_

◆ since_

◆ sm_constr_

◆ sm_slot_