#include <CSCChipSpeedCorrectionDBConditions.h>

Inheritance diagram for CSCChipSpeedCorrectionDBConditions:

Public Types
typedef std::unique_ptr< CSCDBChipSpeedCorrection >	ReturnType

Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair< DataKey, edm::propagate_const< std::shared_ptr< DataProxy > > > >	KeyedProxies

typedef std::vector< EventSetupRecordKey >	Keys

typedef std::map< EventSetupRecordKey, KeyedProxies >	RecordProxies

Public Member Functions
	CSCChipSpeedCorrectionDBConditions (const edm::ParameterSet &)

ReturnType	produceDBChipSpeedCorrection (const CSCDBChipSpeedCorrectionRcd &)

	~CSCChipSpeedCorrectionDBConditions () override

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer ()(false) override

Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()

void	newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval) override
	overrides DataProxyProvider method More...

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
	DataProxyProvider ()

const ComponentDescription &	description () const

bool	isUsingRecord (const EventSetupRecordKey &) const

const KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey) const

void	resetProxies (const EventSetupRecordKey &iRecordType)

void	resetProxiesIfTransient (const EventSetupRecordKey &iRecordType)

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

std::set< eventsetup::EventSetupRecordKey >	findingForRecords () const

const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)

void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)

virtual	~EventSetupRecordIntervalFinder () noexcept(false)

Static Public Member Functions
static CSCDBChipSpeedCorrection *	prefillDBChipSpeedCorrection (bool isForMC, std::string dataCorrFileName, float dataOffse)

Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)

Private Member Functions
void	setIntervalFor (const edm::eventsetup::EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &) override

Private Attributes
CSCDBChipSpeedCorrection *	cndbChipCorr

std::string	dataCorrFileName

float	dataOffset

bool	isForMC

Additional Inherited Members
Protected Member Functions inherited from edm::ESProducer
	ESProducer (const ESProducer &)=delete

ESProducer const &	operator= (const ESProducer &)=delete

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})

Protected Member Functions inherited from edm::ESProxyFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const eventsetup::EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList) override
	override DataProxyProvider method More...

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
void	eraseAll (const EventSetupRecordKey &iRecordKey)
	deletes all the Proxies in aStream More...

void	invalidateProxies (const EventSetupRecordKey &iRecordKey)

template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &)

Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Detailed Description

Definition at line 21 of file CSCChipSpeedCorrectionDBConditions.h.

Member Typedef Documentation

typedef std::unique_ptr<CSCDBChipSpeedCorrection> CSCChipSpeedCorrectionDBConditions::ReturnType

Definition at line 30 of file CSCChipSpeedCorrectionDBConditions.h.

Constructor & Destructor Documentation

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

Definition at line 8 of file CSCChipSpeedCorrectionDBConditions.cc.

References dataCorrFileName, dataOffset, edm::ParameterSet::getUntrackedParameter(), isForMC, produceDBChipSpeedCorrection(), edm::ESProducer::setWhatProduced(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                      {
   // the following line is needed to tell the framework what
   // data is being produced
   isForMC = iConfig.getUntrackedParameter<bool>("isForMC", true);
   dataCorrFileName = iConfig.getUntrackedParameter<std::string>("dataCorrFileName", "empty.txt");
   dataOffset = 170.;
   // added by Zhen (changed since 1_2_0)
   setWhatProduced(this, &CSCChipSpeedCorrectionDBConditions::produceDBChipSpeedCorrection);
   findingRecord<CSCDBChipSpeedCorrectionRcd>();
   // now do what ever other initialization is needed
 }

CSCChipSpeedCorrectionDBConditions::~CSCChipSpeedCorrectionDBConditions ( )

override

Definition at line 20 of file CSCChipSpeedCorrectionDBConditions.cc.

                                                                         {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

CSCDBChipSpeedCorrection * CSCChipSpeedCorrectionDBConditions::prefillDBChipSpeedCorrection	(	bool	isForMC,
		std::string	dataCorrFileName,
		float	dataOffse
	)

inlinestatic

Definition at line 58 of file CSCChipSpeedCorrectionDBConditions.h.

References relativeConstraints::chamber, CSCDetId::chamber(), trackerTree::check(), CSCIndexer::chipIndex(), CSCDBChipSpeedCorrection::chipSpeedCorr, cndbChipCorr, CSCIndexer::detIdFromChamberIndex(), dt, CSCDetId::endcap(), makeMuonMisalignmentScenario::endcap, CSCDBChipSpeedCorrection::factor_speedCorr, groupFilesInBlocks::fin, mps_fire::i, createfilelist::int, relativeConstraints::ring, CSCDetId::ring(), relativeConstraints::station, CSCDetId::station(), and protons_cff::t.

Referenced by produceDBChipSpeedCorrection().

                                                                                                                     {
   if (isMC)
     printf("\n Generating fake DB constants for MC\n");
   else {
     printf("\n Reading chip corrections from file %s \n", filename.data());
     printf("my data offset value is %f \n", dataOffset);
   }
 
   CSCIndexer indexer;
 
   const int CHIP_FACTOR = 100;
   const int MAX_SIZE = 15768;
   const int MAX_SHORT = 32767;
   CSCDBChipSpeedCorrection *cndbChipCorr = new CSCDBChipSpeedCorrection();
 
   CSCDBChipSpeedCorrection::ChipSpeedContainer &itemvector = cndbChipCorr->chipSpeedCorr;
   itemvector.resize(MAX_SIZE);
   cndbChipCorr->factor_speedCorr = int(CHIP_FACTOR);
 
   // Fill chip corrections for MC is very simple
   if (isMC) {
     for (int i = 0; i < MAX_SIZE; i++) {
       itemvector[i].speedCorr = 0;
     }
     return cndbChipCorr;
   }
 
   // Filling for data takes a little more time
   FILE *fin = fopen(filename.data(), "r");
 
   int serialChamber, endcap, station, ring, chamber, chip;
   float t, dt;
   int nPulses;
 
   std::vector<int> new_index_id;
   std::vector<float> new_chipPulse;
   double runningTotal = 0;
   int numNonZero = 0;
   while (!feof(fin)) {
     // note space at end of format string to convert last \n
     // int check = fscanf(fin,"%d %d %f %f \n",&serialChamber,&chip,&t,&dt);
     int check = fscanf(fin,
                        "%d %d %d %d %d %d %f %f %d \n",
                        &serialChamber,
                        &endcap,
                        &station,
                        &ring,
                        &chamber,
                        &chip,
                        &t,
                        &dt,
                        &nPulses);
     if (check != 9) {
       printf("The input file format is not as expected\n");
       assert(0);
     }
 
     int serialChamber_safecopy = serialChamber;
     // Now to map from S. Durkin's serialChamber index convention
     // ME+1/1-ME+41 = 1  -234
     // ME+4/2       = 235-270*
     // ME-1/1-ME-41 = 271-504*
     // ME-4/2       = 505-540
     // To the convention used in /DataFormats/MuonDetId/interface/CSCIndexer.h
     // ME+1/1-ME+41 = 1  -234
     // ME+4/2       = 469-504*
     // ME-1/1-ME-41 = 235-468*
     // ME-4/2       = 505-540
     // Only the chambers marked * need to be remapped
 
     if (serialChamber >= 235 && serialChamber <= 270)
       serialChamber += 234;
     else {  // not in ME+4\2
       if (serialChamber >= 271 && serialChamber <= 504)
         serialChamber -= 36;
     }
 
     CSCDetId chamberId = indexer.detIdFromChamberIndex(serialChamber);
     // Now to map from S. Durkin's chip index convention 0-29 (with
     // 4,9,14,19,24,29 unused in ME1/3) To the convention used in
     // /DataFormats/MuonDetId/interface/CSCIndexer.h Layer 1-6 and chip 1-5 for
     // all chambers except ME1/3 which is chip 1-4
     int layer = (chip) / 5 + 1;
     CSCDetId cscId(chamberId.endcap(), chamberId.station(), chamberId.ring(), chamberId.chamber(), layer);
     // This should yield the same CSCDetId as decoding the chamber serial does
     // If not, some debugging is needed
     CSCDetId cscId_doubleCheck(endcap, station, ring, chamber, layer);
     if (cscId != cscId_doubleCheck) {
       printf("Why doesn't chamberSerial %d map to e: %d s: %d r: %d c: %d ? \n",
              serialChamber_safecopy,
              endcap,
              station,
              ring,
              chamber);
       assert(0);
     }
 
     chip = (chip % 5) + 1;
     // The file produced by Stan starts from the geometrical strip number stored
     // in the CSCStripDigi When the strip digis are built, the conversion from
     // electronics channel to geometrical strip (reversing ME+1/1a and, more
     // importantly, ME-1/1b) is done before the digi is filled
     // (EventFilter/CSCRawToDigi/src/CSCCFEBData.cc). Since we're filling an
     // electronics channel database, I'll flip again ME-1/1b
     if (endcap == 2 && station == 1 && ring == 1 && chip < 5) {
       chip = 5 - chip;  // change 1-4 to 4-1
     }
 
     new_index_id.push_back(indexer.chipIndex(cscId, chip));
     new_chipPulse.push_back(t);
     if (t != 0) {
       runningTotal += t;
       numNonZero++;
     }
   }
   fclose(fin);
 
   // Fill the chip corrections with zeros to start
   for (int i = 0; i < MAX_SIZE; i++) {
     itemvector[i].speedCorr = 0;
   }
 
   for (unsigned int i = 0; i < new_index_id.size(); i++) {
     if ((short int)(fabs((dataOffset - new_chipPulse[i]) * CHIP_FACTOR + 0.5)) < MAX_SHORT)
       itemvector[new_index_id[i] - 1].speedCorr =
           (short int)((dataOffset - new_chipPulse[i]) * CHIP_FACTOR + 0.5 * (dataOffset >= new_chipPulse[i]) -
                       0.5 * (dataOffset < new_chipPulse[i]));
     // printf("i= %d \t new index id = %d \t corr = %f \n",i,new_index_id[i],
     // new_chipPulse[i]);
   }
 
   // For now, calculate the mean chip correction and use it for all chambers
   // that don't have calibration pulse data (speedCorr ==0) or had values of
   // zero (speedCorr == dataOffset) This should be a temporary fix until all
   // chips that will read out in data have calibration information Since there
   // is only a handful out of 15K chips with values more than 3 ns away from the
   // average, this is probably very safe to first order
   float ave = runningTotal / numNonZero;
   for (int i = 0; i < MAX_SIZE; i++) {
     if (itemvector[i].speedCorr == 0 || itemvector[i].speedCorr == (short int)(dataOffset * CHIP_FACTOR + 0.5))
       itemvector[i].speedCorr =
           (short int)((dataOffset - ave) * CHIP_FACTOR + 0.5 * (dataOffset >= ave) - 0.5 * (dataOffset < ave));
   }
 
   return cndbChipCorr;
 }

CSCChipSpeedCorrectionDBConditions::ReturnType CSCChipSpeedCorrectionDBConditions::produceDBChipSpeedCorrection ( const CSCDBChipSpeedCorrectionRcd & iRecord )

Definition at line 30 of file CSCChipSpeedCorrectionDBConditions.cc.

References dataCorrFileName, dataOffset, isForMC, and prefillDBChipSpeedCorrection().

Referenced by CSCChipSpeedCorrectionDBConditions().

                                                 {
   // need a new object so to not be deleted at exit
   return CSCChipSpeedCorrectionDBConditions::ReturnType(
       prefillDBChipSpeedCorrection(isForMC, dataCorrFileName, dataOffset));
 }

void CSCChipSpeedCorrectionDBConditions::setIntervalFor	(	const edm::eventsetup::EventSetupRecordKey &	,
		const edm::IOVSyncValue &	,
		edm::ValidityInterval &	oValidity
	)

overrideprivatevirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 37 of file CSCChipSpeedCorrectionDBConditions.cc.

References edm::IOVSyncValue::beginOfTime(), and edm::IOVSyncValue::endOfTime().

                                                                                         {
   oValidity = edm::ValidityInterval(edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());
 }