#include <DTT0CalibrationRMS.h>

Inheritance diagram for DTT0CalibrationRMS:

Public Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &eventSetup) override
	Fill the maps with t0 (by channel) More...

	DTT0CalibrationRMS (const edm::ParameterSet &pset)
	Constructor. More...

void	endJob () override
	Compute the mean and the RMS of the t0 from the maps and write them to the DB with channel granularity. More...

	~DTT0CalibrationRMS () override
	Destructor. More...

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
std::string	getHistoName (const DTWireId &wId) const

std::string	getHistoName (const DTLayerId &lId) const

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

bool	correctByChamberMean_

bool	debug

edm::EDGetTokenT< DTDigiCollection >	digiToken

edm::ESHandle< DTGeometry >	dtGeom

const edm::ESGetToken< DTGeometry, MuonGeometryRecord >	dtGeomToken_

unsigned int	eventsForLayerT0

unsigned int	eventsForWireT0

TH1D *	hT0SectorHisto

std::map< DTWireId, double >	mK

std::map< DTWireId, double >	mK_ref

std::map< DTWireId, int >	nDigiPerWire

std::map< DTWireId, int >	nDigiPerWire_ref

unsigned int	nevents

std::map< DTWireId, double >	qK

unsigned int	rejectDigiFromPeak

int	selSector

int	selWheel

std::map< DTWireId, double >	theAbsoluteT0PerWire

std::string	theCalibSector

std::string	theCalibWheel

TFile *	theFile

std::map< DTLayerId, TH1I * >	theHistoLayerMap

std::map< DTWireId, TH1I * >	theHistoWireMap

std::map< DTWireId, TH1I * >	theHistoWireMap_ref

TFile *	theOutputFile

std::map< DTWireId, double >	theRelativeT0PerWire

std::map< std::string, double >	theSigmaT0LayerMap

std::map< DTWireId, double >	theSigmaT0PerWire

std::map< std::string, double >	theT0LayerMap

double	tpPeakWidth

std::vector< DTWireId >	wireIdWithHistos

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

Analyzer class computes the mean and RMS of t0 from pulses. Those values are written in the DB with cell granularity. The mean value for each channel is normalized to a reference time common to all the sector. The t0 of wires in odd layers are corrected for the relative difference between odd and even layers

Definition at line 28 of file DTT0CalibrationRMS.h.

Constructor & Destructor Documentation

◆ DTT0CalibrationRMS()

DTT0CalibrationRMS::DTT0CalibrationRMS ( const edm::ParameterSet & pset )

Constructor.

Definition at line 27 of file DTT0CalibrationRMS.cc.

References cellsWithHistos, correctByChamberMean_, debug, digiToken, eventsForLayerT0, eventsForWireT0, hT0SectorHisto, phase1PixelTopology::layer, nevents, muonDTDigis_cfi::pset, rejectDigiFromPeak, CSCSkim_cfi::rootFileName, selSector, selWheel, relativeConstraints::station, theCalibSector, theCalibWheel, theFile, tpPeakWidth, makeMuonMisalignmentScenario::wheel, and wireIdWithHistos.

                                                                   : dtGeomToken_(esConsumes()) {
   // Get the debug parameter for verbose output
   debug = pset.getUntrackedParameter<bool>("debug");
   if (debug)
     edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS]Constructor called!";
 
   // Get the token to retrieve digis from the event
   digiToken = consumes<DTDigiCollection>(pset.getUntrackedParameter<string>("digiLabel"));
 
   // The root file which contain the histos per layer
   string rootFileName = pset.getUntrackedParameter<string>("rootFileName", "DTT0PerLayer.root");
   theFile = new TFile(rootFileName.c_str(), "RECREATE");
 
   theCalibWheel =
       pset.getUntrackedParameter<string>("calibWheel", "All");  //FIXME amke a vector of integer instead of a string
   if (theCalibWheel != "All") {
     stringstream linestr;
     int selWheel;
     linestr << theCalibWheel;
     linestr >> selWheel;
     edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMSPerLayer] chosen wheel " << selWheel;
   }
 
   // Sector/s to calibrate
   theCalibSector =
       pset.getUntrackedParameter<string>("calibSector", "All");  //FIXME amke a vector of integer instead of a string
   if (theCalibSector != "All") {
     stringstream linestr;
     int selSector;
     linestr << theCalibSector;
     linestr >> selSector;
     edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMSPerLayer] chosen sector " << selSector;
   }
 
   vector<string> defaultCell;
   defaultCell.push_back("None");
   cellsWithHistos = pset.getUntrackedParameter<vector<string> >("cellsWithHisto", defaultCell);
   for (vector<string>::const_iterator cell = cellsWithHistos.begin(); cell != cellsWithHistos.end(); ++cell) {
     if ((*cell) != "None") {
       stringstream linestr;
       int wheel, sector, station, sl, layer, wire;
       linestr << (*cell);
       linestr >> wheel >> sector >> station >> sl >> layer >> wire;
       wireIdWithHistos.push_back(DTWireId(wheel, station, sector, sl, layer, wire));
     }
   }
 
   hT0SectorHisto = nullptr;
 
   nevents = 0;
   eventsForLayerT0 = pset.getParameter<unsigned int>("eventsForLayerT0");
   eventsForWireT0 = pset.getParameter<unsigned int>("eventsForWireT0");
   rejectDigiFromPeak = pset.getParameter<unsigned int>("rejectDigiFromPeak");
   tpPeakWidth = pset.getParameter<double>("tpPeakWidth");
   //useReferenceWireInLayer_ = true;
   correctByChamberMean_ = pset.getParameter<bool>("correctByChamberMean");
 }

◆ ~DTT0CalibrationRMS()

DTT0CalibrationRMS::~DTT0CalibrationRMS ( )

override

Destructor.

Definition at line 86 of file DTT0CalibrationRMS.cc.

References debug, and theFile.

                                         {
   if (debug)
     edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS]Destructor called!";
 
   theFile->Close();
 }

Member Function Documentation

◆ analyze()

void DTT0CalibrationRMS::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

overridevirtual

Fill the maps with t0 (by channel)

Perform the real analysis.

Implements edm::one::EDAnalyzerBase.

Definition at line 94 of file DTT0CalibrationRMS.cc.

References funct::abs(), DTSuperLayerId::chamberId(), debug, digiToken, dtGeom, dtGeomToken_, options_cfi::eventSetup, eventsForLayerT0, eventsForWireT0, spr::find(), getHistoName(), hT0SectorHisto, mK, mK_ref, nDigiPerWire, nDigiPerWire_ref, nevents, qK, rejectDigiFromPeak, DTChamberId::sector(), selSector, selWheel, DTLayerId::superlayerId(), FrontierCondition_GT_autoExpress_cfi::t0, theAbsoluteT0PerWire, theCalibSector, theCalibWheel, theFile, theHistoLayerMap, theHistoWireMap, theHistoWireMap_ref, theSigmaT0LayerMap, theT0LayerMap, tpPeakWidth, DTChamberId::wheel(), and wireIdWithHistos.

                                                                                        {
   if (debug || event.id().event() % 500 == 0)
     edm::LogVerbatim("DTCalibration") << "--- [DTT0CalibrationRMS] Analysing Event: #Run: " << event.id().run()
                                       << " #Event: " << event.id().event();
   nevents++;
 
   // Get the digis from the event
   const Handle<DTDigiCollection>& digis = event.getHandle(digiToken);
 
   // Get the DT Geometry
   dtGeom = eventSetup.getHandle(dtGeomToken_);
 
   // Iterate through all digi collections ordered by LayerId
   DTDigiCollection::DigiRangeIterator dtLayerIt;
   for (dtLayerIt = digis->begin(); dtLayerIt != digis->end(); ++dtLayerIt) {
     // Get the iterators over the digis associated with this LayerId
     const DTDigiCollection::Range& digiRange = (*dtLayerIt).second;
 
     // Get the layerId
     const DTLayerId layerId = (*dtLayerIt).first;  //FIXME: check to be in the right sector
 
     if ((theCalibWheel != "All") && (layerId.superlayerId().chamberId().wheel() != selWheel))
       continue;
     if ((theCalibSector != "All") && (layerId.superlayerId().chamberId().sector() != selSector))
       continue;
 
     // Loop over all digis in the given layer
     for (DTDigiCollection::const_iterator digi = digiRange.first; digi != digiRange.second; ++digi) {
       double t0 = (*digi).countsTDC();
 
       //Use first bunch of events to fill t0 per layer
       if (nevents < eventsForLayerT0) {
         //Get the per-layer histo from the map
         TH1I* hT0LayerHisto = theHistoLayerMap[layerId];
         //If it doesn't exist, book it
         if (hT0LayerHisto == nullptr) {
           theFile->cd();
           hT0LayerHisto = new TH1I(getHistoName(layerId).c_str(),
                                    "T0 from pulses by layer (TDC counts, 1 TDC count = 0.781 ns)",
                                    200,
                                    t0 - 100,
                                    t0 + 100);
           if (debug)
             edm::LogVerbatim("DTCalibration") << "  New T0 per Layer Histo: " << hT0LayerHisto->GetName();
           theHistoLayerMap[layerId] = hT0LayerHisto;
         }
 
         //Fill the histos
         theFile->cd();
         if (hT0LayerHisto != nullptr) {
           hT0LayerHisto->Fill(t0);
         }
       }
 
       //Use all the remaining events to compute t0 per wire
       if (nevents > eventsForLayerT0) {
         // Get the wireId
         const DTWireId wireId(layerId, (*digi).wire());
         if (debug) {
           edm::LogVerbatim("DTCalibration")
               << "   Wire: " << wireId << "\n       time (TDC counts): " << (*digi).countsTDC();
         }
 
         //Fill the histos per wire for the chosen cells
         vector<DTWireId>::iterator it_wire = find(wireIdWithHistos.begin(), wireIdWithHistos.end(), wireId);
         if (it_wire != wireIdWithHistos.end()) {
           if (theHistoWireMap.find(wireId) == theHistoWireMap.end()) {
             theHistoWireMap[wireId] = new TH1I(getHistoName(wireId).c_str(),
                                                "T0 from pulses by wire (TDC counts, 1 TDC count = 0.781 ns)",
                                                7000,
                                                0,
                                                7000);
             if (debug)
               edm::LogVerbatim("DTCalibration") << "  New T0 per wire Histo: " << (theHistoWireMap[wireId])->GetName();
           }
           if (theHistoWireMap_ref.find(wireId) == theHistoWireMap_ref.end()) {
             theHistoWireMap_ref[wireId] = new TH1I((getHistoName(wireId) + "_ref").c_str(),
                                                    "T0 from pulses by wire (TDC counts, 1 TDC count = 0.781 ns)",
                                                    7000,
                                                    0,
                                                    7000);
             if (debug)
               edm::LogVerbatim("DTCalibration")
                   << "  New T0 per wire Histo: " << (theHistoWireMap_ref[wireId])->GetName();
           }
 
           TH1I* hT0WireHisto = theHistoWireMap[wireId];
           //Fill the histos
           theFile->cd();
           if (hT0WireHisto)
             hT0WireHisto->Fill(t0);
         }
 
         //Check the tzero has reasonable value
         if (abs(hT0SectorHisto->GetBinCenter(hT0SectorHisto->GetMaximumBin()) - t0) > rejectDigiFromPeak) {
           if (debug)
             edm::LogVerbatim("DTCalibration") << "digi skipped because t0 per sector "
                                               << hT0SectorHisto->GetBinCenter(hT0SectorHisto->GetMaximumBin());
           continue;
         }
 
         //Use second bunch of events to compute a t0 reference per wire
         if (nevents < (eventsForLayerT0 + eventsForWireT0)) {
           //Fill reference wire histos
           if (it_wire != wireIdWithHistos.end()) {
             TH1I* hT0WireHisto_ref = theHistoWireMap_ref[wireId];
             theFile->cd();
             if (hT0WireHisto_ref)
               hT0WireHisto_ref->Fill(t0);
           }
           if (!nDigiPerWire_ref[wireId]) {
             mK_ref[wireId] = 0;
           }
           nDigiPerWire_ref[wireId] = nDigiPerWire_ref[wireId] + 1;
           mK_ref[wireId] = mK_ref[wireId] + (t0 - mK_ref[wireId]) / nDigiPerWire_ref[wireId];
         }
         //Use last all the remaining events to compute the mean and sigma t0 per wire
         else if (nevents > (eventsForLayerT0 + eventsForWireT0)) {
           if (abs(t0 - mK_ref[wireId]) > tpPeakWidth)
             continue;
           if (!nDigiPerWire[wireId]) {
             theAbsoluteT0PerWire[wireId] = 0;
             qK[wireId] = 0;
             mK[wireId] = 0;
           }
           nDigiPerWire[wireId] = nDigiPerWire[wireId] + 1;
           theAbsoluteT0PerWire[wireId] = theAbsoluteT0PerWire[wireId] + t0;
           //theSigmaT0PerWire[wireId] = theSigmaT0PerWire[wireId] + (t0*t0);
           qK[wireId] =
               qK[wireId] + ((nDigiPerWire[wireId] - 1) * (t0 - mK[wireId]) * (t0 - mK[wireId]) / nDigiPerWire[wireId]);
           mK[wireId] = mK[wireId] + (t0 - mK[wireId]) / nDigiPerWire[wireId];
         }
       }  //end if(nevents>1000)
     }    //end loop on digi
   }      //end loop on layer
 
   //Use the t0 per layer histos to have an indication about the t0 position
   if (nevents == eventsForLayerT0) {
     for (map<DTLayerId, TH1I*>::const_iterator lHisto = theHistoLayerMap.begin(); lHisto != theHistoLayerMap.end();
          ++lHisto) {
       if (debug)
         edm::LogVerbatim("DTCalibration") << "Reading histogram " << (*lHisto).second->GetName() << " with mean "
                                           << (*lHisto).second->GetMean() << " and RMS " << (*lHisto).second->GetRMS();
 
       //Take the mean as a first t0 estimation
       if ((*lHisto).second->GetRMS() < 5.0) {
         if (hT0SectorHisto == nullptr) {
           hT0SectorHisto = new TH1D("hT0AllLayerOfSector",
                                     "T0 from pulses per layer in sector",
                                     //20, (*lHisto).second->GetMean()-100, (*lHisto).second->GetMean()+100);
                                     700,
                                     0,
                                     7000);
         }
         if (debug)
           edm::LogVerbatim("DTCalibration") << " accepted";
         hT0SectorHisto->Fill((*lHisto).second->GetMean());
       }
       //Take the mean of noise + 400ns as a first t0 estimation
       // if((*lHisto).second->GetRMS()>10.0 && ((*lHisto).second->GetRMS()<15.0)){
       //    double t0_estim = (*lHisto).second->GetMean() + 400;
       //    if(hT0SectorHisto == 0){
       //      hT0SectorHisto = new TH1D("hT0AllLayerOfSector","T0 from pulses per layer in sector",
       //                    //20, t0_estim-100, t0_estim+100);
       //                    700, 0, 7000);
       //    }
       //    if(debug)
       //      edm::LogVerbatim("DTCalibration")<<" accepted + 400ns";
       //    hT0SectorHisto->Fill((*lHisto).second->GetMean() + 400);
       //       }
       //if (debug)
       //  edm::LogVerbatim("DTCalibration");
 
       theT0LayerMap[(*lHisto).second->GetName()] = (*lHisto).second->GetMean();
       theSigmaT0LayerMap[(*lHisto).second->GetName()] = (*lHisto).second->GetRMS();
     }
     if (!hT0SectorHisto) {
       edm::LogVerbatim("DTCalibration")
           << "[DTT0CalibrationRMS]: All the t0 per layer are still uncorrect: trying with greater number of events";
       eventsForLayerT0 = eventsForLayerT0 * 2;
       return;
     }
     if (debug)
       edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS] t0 reference for this sector "
                                         << hT0SectorHisto->GetBinCenter(hT0SectorHisto->GetMaximumBin());
   }
 }

◆ endJob()

void DTT0CalibrationRMS::endJob ( void )

overridevirtual

Compute the mean and the RMS of the t0 from the maps and write them to the DB with channel granularity.

Loop on superlayer to correct between even-odd layers (2 different test pulse lines!)

Change t0 absolute reference -> from sector peak to chamber average

Write the t0 map into DB

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 282 of file DTT0CalibrationRMS.cc.

References funct::abs(), DTT0::begin(), DTSuperLayerId::chamberId(), totem::nt2::vfat::channelId(), correctByChamberMean_, DTTimeUnits::counts, debug, dtGeom, DTT0::end(), DTT0::get(), hT0SectorHisto, nDigiPerWire, qK, DTT0::set(), mathSSE::sqrt(), DTGeometry::superLayers(), FrontierCondition_GT_autoExpress_cfi::t0, theAbsoluteT0PerWire, theFile, theHistoLayerMap, theHistoWireMap, theHistoWireMap_ref, theRelativeT0PerWire, theSigmaT0PerWire, tzero, and DTCalibDBUtils::writeToDB().

Referenced by o2olib.O2ORunMgr::executeJob().

                                 {
   DTT0* t0sAbsolute = new DTT0();
   DTT0* t0sRelative = new DTT0();
   DTT0* t0sWRTChamber = new DTT0();
 
   //if(debug)
   edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMSPerLayer]Writing histos to file!";
 
   theFile->cd();
   theFile->WriteTObject(hT0SectorHisto);
   //hT0SectorHisto->Write();
   for (map<DTWireId, TH1I*>::const_iterator wHisto = theHistoWireMap.begin(); wHisto != theHistoWireMap.end();
        ++wHisto) {
     (*wHisto).second->Write();
   }
   for (map<DTWireId, TH1I*>::const_iterator wHisto = theHistoWireMap_ref.begin(); wHisto != theHistoWireMap_ref.end();
        ++wHisto) {
     (*wHisto).second->Write();
   }
   for (map<DTLayerId, TH1I*>::const_iterator lHisto = theHistoLayerMap.begin(); lHisto != theHistoLayerMap.end();
        ++lHisto) {
     (*lHisto).second->Write();
   }
 
   //if(debug)
   edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS] Compute and store t0 and sigma per wire";
 
   for (map<DTWireId, double>::const_iterator wiret0 = theAbsoluteT0PerWire.begin();
        wiret0 != theAbsoluteT0PerWire.end();
        ++wiret0) {
     if (nDigiPerWire[(*wiret0).first]) {
       double t0 = (*wiret0).second / nDigiPerWire[(*wiret0).first];
 
       theRelativeT0PerWire[(*wiret0).first] = t0 - hT0SectorHisto->GetBinCenter(hT0SectorHisto->GetMaximumBin());
 
       //theSigmaT0PerWire[(*wiret0).first] = sqrt((theSigmaT0PerWire[(*wiret0).first] / nDigiPerWire[(*wiret0).first]) - t0*t0);
       theSigmaT0PerWire[(*wiret0).first] = sqrt(qK[(*wiret0).first] / nDigiPerWire[(*wiret0).first]);
 
       edm::LogVerbatim("DTCalibration") << "Wire " << (*wiret0).first << " has t0 " << t0 << "(absolute) "
                                         << theRelativeT0PerWire[(*wiret0).first] << "(relative)"
                                         << "    sigma " << theSigmaT0PerWire[(*wiret0).first];
 
       t0sAbsolute->set((*wiret0).first, t0, theSigmaT0PerWire[(*wiret0).first], DTTimeUnits::counts);
     } else {
       edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS] ERROR: no digis in wire " << (*wiret0).first;
       abort();
     }
   }
 
   if (correctByChamberMean_) {
     // Get all the sls from the setup
     const vector<const DTSuperLayer*> superLayers = dtGeom->superLayers();
     // Loop over all SLs
     for (vector<const DTSuperLayer*>::const_iterator sl = superLayers.begin(); sl != superLayers.end(); sl++) {
       //Compute mean for odd and even superlayers
       double oddLayersMean = 0;
       double evenLayersMean = 0;
       double oddLayersDen = 0;
       double evenLayersDen = 0;
       for (map<DTWireId, double>::const_iterator wiret0 = theRelativeT0PerWire.begin();
            wiret0 != theRelativeT0PerWire.end();
            ++wiret0) {
         if ((*wiret0).first.layerId().superlayerId() == (*sl)->id()) {
           if (debug)
             edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS] Superlayer " << (*sl)->id() << "layer "
                                               << (*wiret0).first.layerId().layer() << " with " << (*wiret0).second;
           if (((*wiret0).first.layerId().layer()) % 2) {
             oddLayersMean = oddLayersMean + (*wiret0).second;
             oddLayersDen++;
           } else {
             evenLayersMean = evenLayersMean + (*wiret0).second;
             evenLayersDen++;
           }
         }
       }
       oddLayersMean = oddLayersMean / oddLayersDen;
       evenLayersMean = evenLayersMean / evenLayersDen;
       //if(debug && oddLayersMean)
       edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS] Relative T0 mean for  odd layers " << oddLayersMean
                                         << "  even layers" << evenLayersMean;
 
       //Compute sigma for odd and even superlayers
       double oddLayersSigma = 0;
       double evenLayersSigma = 0;
       for (map<DTWireId, double>::const_iterator wiret0 = theRelativeT0PerWire.begin();
            wiret0 != theRelativeT0PerWire.end();
            ++wiret0) {
         if ((*wiret0).first.layerId().superlayerId() == (*sl)->id()) {
           if (((*wiret0).first.layerId().layer()) % 2) {
             oddLayersSigma = oddLayersSigma + ((*wiret0).second - oddLayersMean) * ((*wiret0).second - oddLayersMean);
           } else {
             evenLayersSigma =
                 evenLayersSigma + ((*wiret0).second - evenLayersMean) * ((*wiret0).second - evenLayersMean);
           }
         }
       }
       oddLayersSigma = oddLayersSigma / oddLayersDen;
       evenLayersSigma = evenLayersSigma / evenLayersDen;
       oddLayersSigma = sqrt(oddLayersSigma);
       evenLayersSigma = sqrt(evenLayersSigma);
 
       //if(debug && oddLayersMean)
       edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS] Relative T0 sigma for  odd layers " << oddLayersSigma
                                         << "  even layers" << evenLayersSigma;
 
       //Recompute the mean for odd and even superlayers discarding fluctations
       double oddLayersFinalMean = 0;
       double evenLayersFinalMean = 0;
       for (map<DTWireId, double>::const_iterator wiret0 = theRelativeT0PerWire.begin();
            wiret0 != theRelativeT0PerWire.end();
            ++wiret0) {
         if ((*wiret0).first.layerId().superlayerId() == (*sl)->id()) {
           if (((*wiret0).first.layerId().layer()) % 2) {
             if (abs((*wiret0).second - oddLayersMean) < (2 * oddLayersSigma))
               oddLayersFinalMean = oddLayersFinalMean + (*wiret0).second;
           } else {
             if (abs((*wiret0).second - evenLayersMean) < (2 * evenLayersSigma))
               evenLayersFinalMean = evenLayersFinalMean + (*wiret0).second;
           }
         }
       }
       oddLayersFinalMean = oddLayersFinalMean / oddLayersDen;
       evenLayersFinalMean = evenLayersFinalMean / evenLayersDen;
       //if(debug && oddLayersMean)
       edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS] Final relative T0 mean for  odd layers "
                                         << oddLayersFinalMean << "  even layers" << evenLayersFinalMean;
 
       for (map<DTWireId, double>::const_iterator wiret0 = theRelativeT0PerWire.begin();
            wiret0 != theRelativeT0PerWire.end();
            ++wiret0) {
         if ((*wiret0).first.layerId().superlayerId() == (*sl)->id()) {
           double t0 = -999;
           if (((*wiret0).first.layerId().layer()) % 2)
             t0 = (*wiret0).second + (evenLayersFinalMean - oddLayersFinalMean);
           else
             t0 = (*wiret0).second;
 
           edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS] Wire " << (*wiret0).first << " has t0 "
                                             << (*wiret0).second << " (relative, after even-odd layer corrections)  "
                                             << "    sigma " << theSigmaT0PerWire[(*wiret0).first];
 
           //Store the results into DB
           t0sRelative->set((*wiret0).first, t0, theSigmaT0PerWire[(*wiret0).first], DTTimeUnits::counts);
         }
       }
     }
 
     edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS]Computing relative t0 wrt to chamber average";
     //Compute the reference for each chamber
     map<DTChamberId, double> sumT0ByChamber;
     map<DTChamberId, int> countT0ByChamber;
     for (DTT0::const_iterator tzero = t0sRelative->begin(); tzero != t0sRelative->end(); ++tzero) {
       int channelId = tzero->channelId;
       if (channelId == 0)
         continue;
       DTWireId wireId(channelId);
       DTChamberId chamberId(wireId.chamberId());
       //sumT0ByChamber[chamberId] = sumT0ByChamber[chamberId] + tzero->t0mean;
       // @@@ better DTT0 usage
       float t0mean_f;
       float t0rms_f;
       t0sRelative->get(wireId, t0mean_f, t0rms_f, DTTimeUnits::counts);
       sumT0ByChamber[chamberId] = sumT0ByChamber[chamberId] + t0mean_f;
       // @@@ NEW DTT0 END
       countT0ByChamber[chamberId]++;
     }
 
     //Change reference for each wire and store the new t0s in the new map
     for (DTT0::const_iterator tzero = t0sRelative->begin(); tzero != t0sRelative->end(); ++tzero) {
       int channelId = tzero->channelId;
       if (channelId == 0)
         continue;
       DTWireId wireId(channelId);
       DTChamberId chamberId(wireId.chamberId());
       //double t0mean = (tzero->t0mean) - (sumT0ByChamber[chamberId]/countT0ByChamber[chamberId]);
       //double t0rms = tzero->t0rms;
       // @@@ better DTT0 usage
       float t0mean_f;
       float t0rms_f;
       t0sRelative->get(wireId, t0mean_f, t0rms_f, DTTimeUnits::counts);
       double t0mean = t0mean_f - (sumT0ByChamber[chamberId] / countT0ByChamber[chamberId]);
       double t0rms = t0rms_f;
       // @@@ NEW DTT0 END
       t0sWRTChamber->set(wireId, t0mean, t0rms, DTTimeUnits::counts);
       edm::LogVerbatim("DTCalibration") << "Changing t0 of wire " << wireId << " from " << t0mean_f << " to " << t0mean;
     }
   }
 
   if (debug)
     edm::LogVerbatim("DTCalibration") << "[DTT0CalibrationRMS]Writing values in DB!";
   // FIXME: to be read from cfg?
   string t0Record = "DTT0Rcd";
   // Write the t0 map to DB
   if (correctByChamberMean_)
     DTCalibDBUtils::writeToDB(t0Record, t0sWRTChamber);
   else
     DTCalibDBUtils::writeToDB(t0Record, t0sAbsolute);
 }

◆ getHistoName() [1/2]

string DTT0CalibrationRMS::getHistoName ( const DTWireId & wId ) const

private

Definition at line 484 of file DTT0CalibrationRMS.cc.

References HltBtagPostValidation_cff::histoName, DTLayerId::layer(), DTChamberId::sector(), DTChamberId::station(), DTSuperLayerId::superlayer(), cond::impl::to_string(), DTChamberId::wheel(), and DTWireId::wire().

Referenced by analyze().

                                                                  {
   string histoName = "Ch_" + std::to_string(wId.wheel()) + "_" + std::to_string(wId.station()) + "_" +
                      std::to_string(wId.sector()) + "_SL" + std::to_string(wId.superlayer()) + "_L" +
                      std::to_string(wId.layer()) + "_W" + std::to_string(wId.wire()) + "_hT0Histo";
   return histoName;
 }

◆ getHistoName() [2/2]

string DTT0CalibrationRMS::getHistoName ( const DTLayerId & lId ) const

private

Definition at line 491 of file DTT0CalibrationRMS.cc.

References HltBtagPostValidation_cff::histoName, DTLayerId::layer(), DTChamberId::sector(), DTChamberId::station(), DTSuperLayerId::superlayer(), cond::impl::to_string(), and DTChamberId::wheel().

                                                                   {
   string histoName = "Ch_" + std::to_string(lId.wheel()) + "_" + std::to_string(lId.station()) + "_" +
                      std::to_string(lId.sector()) + "_SL" + std::to_string(lId.superlayer()) + "_L" +
                      std::to_string(lId.layer()) + "_hT0Histo";
   return histoName;
 }

Member Data Documentation

◆ cellsWithHistos

std::vector<std::string> DTT0CalibrationRMS::cellsWithHistos

private

Definition at line 90 of file DTT0CalibrationRMS.h.

Referenced by DTT0CalibrationRMS().

◆ correctByChamberMean_

bool DTT0CalibrationRMS::correctByChamberMean_

private

Definition at line 75 of file DTT0CalibrationRMS.h.

Referenced by DTT0CalibrationRMS(), and endJob().

◆ debug

bool DTT0CalibrationRMS::debug

private

Definition at line 51 of file DTT0CalibrationRMS.h.

Referenced by analyze(), rrapi.RRApi::dprint(), util.rrapi.RRApi::dprint(), DTT0CalibrationRMS(), endJob(), pkg.AbstractPkg::generate(), rrapi.RRApi::get(), util.rrapi.RRApi::get(), pkg.AbstractPkg::get_kwds(), runTauIdMVA.TauIDEmbedder::loadMVA_WPs_run2_2017(), runTauIdMVA.TauIDEmbedder::runTauID(), crabFunctions.CrabController::submit(), pkg.AbstractPkg::write(), and ~DTT0CalibrationRMS().

◆ digiToken

edm::EDGetTokenT<DTDigiCollection> DTT0CalibrationRMS::digiToken

private

Definition at line 54 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

◆ dtGeom

edm::ESHandle<DTGeometry> DTT0CalibrationRMS::dtGeom

private

Definition at line 109 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and endJob().

◆ dtGeomToken_

const edm::ESGetToken<DTGeometry, MuonGeometryRecord> DTT0CalibrationRMS::dtGeomToken_

private

Definition at line 110 of file DTT0CalibrationRMS.h.

Referenced by analyze().

◆ eventsForLayerT0

unsigned int DTT0CalibrationRMS::eventsForLayerT0

private

Definition at line 64 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

◆ eventsForWireT0

unsigned int DTT0CalibrationRMS::eventsForWireT0

private

Definition at line 66 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

◆ hT0SectorHisto

TH1D* DTT0CalibrationRMS::hT0SectorHisto

private

Definition at line 86 of file DTT0CalibrationRMS.h.

Referenced by analyze(), DTT0CalibrationRMS(), and endJob().

◆ mK

std::map<DTWireId, double> DTT0CalibrationRMS::mK

private

Definition at line 98 of file DTT0CalibrationRMS.h.

Referenced by analyze().

◆ mK_ref

std::map<DTWireId, double> DTT0CalibrationRMS::mK_ref

private

Definition at line 99 of file DTT0CalibrationRMS.h.

Referenced by analyze().

◆ nDigiPerWire

std::map<DTWireId, int> DTT0CalibrationRMS::nDigiPerWire

private

Definition at line 96 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and endJob().

◆ nDigiPerWire_ref

std::map<DTWireId, int> DTT0CalibrationRMS::nDigiPerWire_ref

private

Definition at line 97 of file DTT0CalibrationRMS.h.

Referenced by analyze().

◆ nevents

unsigned int DTT0CalibrationRMS::nevents

private

Definition at line 62 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

◆ qK

std::map<DTWireId, double> DTT0CalibrationRMS::qK

private

Definition at line 100 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and endJob().

◆ rejectDigiFromPeak

unsigned int DTT0CalibrationRMS::rejectDigiFromPeak

private

Definition at line 69 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

◆ selSector

int DTT0CalibrationRMS::selSector

private

Definition at line 81 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

◆ selWheel

int DTT0CalibrationRMS::selWheel

private

Definition at line 79 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

◆ theAbsoluteT0PerWire

std::map<DTWireId, double> DTT0CalibrationRMS::theAbsoluteT0PerWire

private

Definition at line 93 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and endJob().

◆ theCalibSector

std::string DTT0CalibrationRMS::theCalibSector

private

Definition at line 80 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

◆ theCalibWheel

std::string DTT0CalibrationRMS::theCalibWheel

private

Definition at line 78 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

◆ theFile

TFile* DTT0CalibrationRMS::theFile

private

Definition at line 57 of file DTT0CalibrationRMS.h.

Referenced by analyze(), DTT0CalibrationRMS(), endJob(), and ~DTT0CalibrationRMS().

◆ theHistoLayerMap

std::map<DTLayerId, TH1I*> DTT0CalibrationRMS::theHistoLayerMap

private

Definition at line 84 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and endJob().

◆ theHistoWireMap

std::map<DTWireId, TH1I*> DTT0CalibrationRMS::theHistoWireMap

private

Definition at line 102 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and endJob().

◆ theHistoWireMap_ref

std::map<DTWireId, TH1I*> DTT0CalibrationRMS::theHistoWireMap_ref

private

Definition at line 103 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and endJob().

◆ theOutputFile

TFile* DTT0CalibrationRMS::theOutputFile

private

Definition at line 59 of file DTT0CalibrationRMS.h.

◆ theRelativeT0PerWire

std::map<DTWireId, double> DTT0CalibrationRMS::theRelativeT0PerWire

private

Definition at line 94 of file DTT0CalibrationRMS.h.

Referenced by endJob().

◆ theSigmaT0LayerMap

std::map<std::string, double> DTT0CalibrationRMS::theSigmaT0LayerMap

private

Definition at line 106 of file DTT0CalibrationRMS.h.

Referenced by analyze().

◆ theSigmaT0PerWire

std::map<DTWireId, double> DTT0CalibrationRMS::theSigmaT0PerWire

private

Definition at line 95 of file DTT0CalibrationRMS.h.

Referenced by endJob().

◆ theT0LayerMap

std::map<std::string, double> DTT0CalibrationRMS::theT0LayerMap

private

Definition at line 105 of file DTT0CalibrationRMS.h.

Referenced by analyze().

◆ tpPeakWidth

double DTT0CalibrationRMS::tpPeakWidth

private

Definition at line 72 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

◆ wireIdWithHistos

std::vector<DTWireId> DTT0CalibrationRMS::wireIdWithHistos

private

Definition at line 89 of file DTT0CalibrationRMS.h.

Referenced by analyze(), and DTT0CalibrationRMS().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DTT0CalibrationRMS()

◆ ~DTT0CalibrationRMS()

Member Function Documentation

◆ analyze()

◆ endJob()

◆ getHistoName() [1/2]

◆ getHistoName() [2/2]

Member Data Documentation

◆ cellsWithHistos

◆ correctByChamberMean_

◆ debug

◆ digiToken

◆ dtGeom

◆ dtGeomToken_

◆ eventsForLayerT0

◆ eventsForWireT0

◆ hT0SectorHisto

◆ mK

◆ mK_ref

◆ nDigiPerWire

◆ nDigiPerWire_ref

◆ nevents

◆ qK

◆ rejectDigiFromPeak

◆ selSector

◆ selWheel

◆ theAbsoluteT0PerWire

◆ theCalibSector

◆ theCalibWheel

◆ theFile

◆ theHistoLayerMap

◆ theHistoWireMap

◆ theHistoWireMap_ref

◆ theOutputFile

◆ theRelativeT0PerWire

◆ theSigmaT0LayerMap

◆ theSigmaT0PerWire

◆ theT0LayerMap

◆ tpPeakWidth

◆ wireIdWithHistos