#include <DTResidualCalibration.h>

Inheritance diagram for DTResidualCalibration:

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

void	beginJob () override

void	beginRun (const edm::Run &, const edm::EventSetup &) override

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

void	endJob () override

	~DTResidualCalibration () override
	Destructor. More...

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	bookHistos (DTSuperLayerId slId)

void	bookHistos (DTLayerId slId)

void	fillHistos (DTSuperLayerId slId, float distance, float residualOnDistance)

void	fillHistos (DTLayerId slId, float distance, float residualOnDistance)

float	segmentToWireDistance (const DTRecHit1D &recHit1D, const DTRecSegment4D &segment)

Private Attributes
bool	detailedAnalysis_

const DTGeometry *	dtGeom_

std::map< DTLayerId, std::vector< TH1F * > >	histoMapPerLayerTH1F_

std::map< DTLayerId, std::vector< TH2F * > >	histoMapPerLayerTH2F_

std::map< DTSuperLayerId, std::vector< TH1F * > >	histoMapTH1F_

std::map< DTSuperLayerId, std::vector< TH2F * > >	histoMapTH2F_

double	histRange_

unsigned int	nevent

std::string	rootBaseDir_

TFile *	rootFile_

unsigned int	segmbad

edm::InputTag	segment4DLabel_

unsigned int	segmok

DTSegmentSelector	select_

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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

Detailed Description

Extracts DT segment residuals

Definition at line 28 of file DTResidualCalibration.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 34 of file DTResidualCalibration.cc.

References edm::ParameterSet::getUntrackedParameter(), nevent, rootFile_, DTAnalyzerDetailed_cfi::rootFileName, segmbad, segment4DLabel_, segmok, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                        :
   select_(pset),
   histRange_(pset.getParameter<double>("histogramRange")),
   segment4DLabel_(pset.getParameter<edm::InputTag>("segment4DLabel")),
   rootBaseDir_(pset.getUntrackedParameter<std::string>("rootBaseDir","DT/Residuals")),
   detailedAnalysis_(pset.getUntrackedParameter<bool>("detailedAnalysis",false)) {
 
   edm::LogVerbatim("Calibration") << "[DTResidualCalibration] Constructor called.";
   consumes< DTRecSegment4DCollection >(edm::InputTag(segment4DLabel_));
   std::string rootFileName = pset.getUntrackedParameter<std::string>("rootFileName","residuals.root");
   rootFile_ = new TFile(rootFileName.c_str(), "RECREATE");
   rootFile_->cd();
 
   segmok=0;
   segmbad=0;
   nevent=0;
 }

DTResidualCalibration::~DTResidualCalibration ( )

override

Destructor.

Definition at line 52 of file DTResidualCalibration.cc.

References nevent, segmbad, and segmok.

                                               {
   edm::LogVerbatim("Calibration") << "[DTResidualCalibration] Destructor called.";
   edm::LogVerbatim("Calibration") << "[DTResidualCalibration] Analyzed events: " << nevent;
   edm::LogVerbatim("Calibration") << "[DTResidualCalibration] Good segments: " << segmok;
   edm::LogVerbatim("Calibration") << "[DTResidualCalibration] Bad segments: " << segmbad;
 }

Member Function Documentation

void DTResidualCalibration::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

override

Definition at line 88 of file DTResidualCalibration.cc.

References relativeConstraints::chamber, DTGeometry::chamber(), DTRecHitSegmentResidual::compute(), popcon2dropbox::copy(), detailedAnalysis_, dtGeom_, fillHistos(), DTWireId::layerId(), LogTrace, nevent, rootFile_, segmbad, segment4DLabel_, segmentToWireDistance(), segmok, select_, DTRecSegment2D::specificRecHits(), DTLayerId::superlayerId(), and GeomDet::toGlobal().

                                                                                      {
   rootFile_->cd();
   ++nevent;
 
   // Get the 4D rechits from the event
   edm::Handle<DTRecSegment4DCollection> segments4D;
   event.getByLabel(segment4DLabel_, segments4D);
 
   // Loop over segments by chamber
   DTRecSegment4DCollection::id_iterator chamberIdIt;
   for(chamberIdIt = segments4D->id_begin(); chamberIdIt != segments4D->id_end(); ++chamberIdIt){
 
      const DTChamber* chamber = dtGeom_->chamber(*chamberIdIt);
 
      // Get the range for the corresponding ChamberId
      DTRecSegment4DCollection::range range = segments4D->get((*chamberIdIt));
      // Loop over the rechits of this DetUnit
      for(DTRecSegment4DCollection::const_iterator segment  = range.first;
                                                   segment != range.second; ++segment){
 
         LogTrace("Calibration") << "Segment local pos (in chamber RF): " << (*segment).localPosition()
                                 << "\nSegment global pos: " << chamber->toGlobal((*segment).localPosition());
 
         if( !select_(*segment, event, setup) ) { segmbad++; continue; }
         segmok++;
 
         // Get all 1D RecHits at step 3 within the 4D segment
         std::vector<DTRecHit1D> recHits1D_S3;
 
         if( (*segment).hasPhi() ){
            const DTChamberRecSegment2D* phiSeg = (*segment).phiSegment();
            const std::vector<DTRecHit1D>& phiRecHits = phiSeg->specificRecHits();
            std::copy(phiRecHits.begin(), phiRecHits.end(), back_inserter(recHits1D_S3));
         }
 
         if( (*segment).hasZed() ){
            const DTSLRecSegment2D* zSeg = (*segment).zSegment();
            const std::vector<DTRecHit1D>& zRecHits = zSeg->specificRecHits();
            std::copy(zRecHits.begin(), zRecHits.end(), back_inserter(recHits1D_S3));
         }
 
         // Loop over 1D RecHit inside 4D segment
         for(std::vector<DTRecHit1D>::const_iterator recHit1D = recHits1D_S3.begin();
                                                     recHit1D != recHits1D_S3.end(); ++recHit1D) {
            const DTWireId wireId = recHit1D->wireId();
 
            float segmDistance = segmentToWireDistance(*recHit1D,*segment);
            if(segmDistance > 2.1) LogTrace("Calibration") << "WARNING: segment-wire distance: " << segmDistance;
            else                   LogTrace("Calibration") << "segment-wire distance: " << segmDistance;
 
            float residualOnDistance = DTRecHitSegmentResidual().compute(dtGeom_,*recHit1D,*segment);
            LogTrace("Calibration") << "Wire Id " << wireId << " residual on distance: " << residualOnDistance;
 
            fillHistos(wireId.superlayerId(), segmDistance, residualOnDistance);
            if(detailedAnalysis_) fillHistos(wireId.layerId(), segmDistance, residualOnDistance);
         }
      }
   }
 }

void DTResidualCalibration::beginJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 59 of file DTResidualCalibration.cc.

                                      {
   TH1::SetDefaultSumw2(true);
 }

void DTResidualCalibration::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	setup
	)

override

Definition at line 63 of file DTResidualCalibration.cc.

References bookHistos(), DTGeometry::chambers(), detailedAnalysis_, dtGeom_, edm::EventSetup::get(), histoMapTH1F_, LayerTriplets::layers(), and edm::ESHandle< T >::product().

                                                                                   {
 
   // get the geometry
   edm::ESHandle<DTGeometry> dtGeomH; 
   setup.get<MuonGeometryRecord>().get(dtGeomH);
   dtGeom_ = dtGeomH.product();
 
   // Loop over all the chambers
   if(histoMapTH1F_.empty()) {
     for (auto ch_it : dtGeom_->chambers()) {
       // Loop over the SLs
       for (auto sl_it : ch_it->superLayers()) {
         DTSuperLayerId slId = (sl_it)->id();
         bookHistos(slId);
         if(detailedAnalysis_) {
           for (auto layer_it : (sl_it)->layers()) {
             DTLayerId layerId = (layer_it)->id();
             bookHistos(layerId);
           }
         }
       }
     }
   }
 }

void DTResidualCalibration::bookHistos ( DTSuperLayerId slId )

private

Definition at line 196 of file DTResidualCalibration.cc.

References histoMapTH1F_, histoMapTH2F_, histRange_, rootBaseDir_, rootFile_, DTChamberId::sector(), DTChamberId::station(), AlCaHLTBitMon_QueryRunRegistry::string, DTSuperLayerId::superlayer(), and DTChamberId::wheel().

Referenced by beginRun().

                                                           {
   TH1AddDirectorySentry addDir;
   rootFile_->cd();
 
   edm::LogVerbatim("Calibration") << "[DTResidualCalibration] Booking histos for SL: " << slId;
 
   // Compose the chamber name
   // Define the step
   int step = 3;
 
   std::string wheelStr = std::to_string(slId.wheel());
   std::string stationStr = std::to_string(slId.station());
   std::string sectorStr = std::to_string(slId.sector());
 
   std::string slHistoName =
     "_STEP" + std::to_string(step) +
     "_W" + wheelStr +
     "_St" + stationStr +
     "_Sec" +  sectorStr +
     "_SL" + std::to_string(slId.superlayer());
 
   edm::LogVerbatim("Calibration") << "Accessing " << rootBaseDir_;
   TDirectory* baseDir = rootFile_->GetDirectory(rootBaseDir_.c_str());
   if(!baseDir) baseDir = rootFile_->mkdir(rootBaseDir_.c_str());
   edm::LogVerbatim("Calibration") << "Accessing " << ("Wheel" + wheelStr);
   TDirectory* wheelDir = baseDir->GetDirectory(("Wheel" + wheelStr).c_str());
   if(!wheelDir) wheelDir = baseDir->mkdir(("Wheel" + wheelStr).c_str());
   edm::LogVerbatim("Calibration") << "Accessing " << ("Station" + stationStr);
   TDirectory* stationDir = wheelDir->GetDirectory(("Station" + stationStr).c_str());
   if(!stationDir) stationDir = wheelDir->mkdir(("Station" + stationStr).c_str());
   edm::LogVerbatim("Calibration") << "Accessing " << ("Sector" + sectorStr);
   TDirectory* sectorDir = stationDir->GetDirectory(("Sector" + sectorStr).c_str());
   if(!sectorDir) sectorDir = stationDir->mkdir(("Sector" + sectorStr).c_str()); 
 
   sectorDir->cd();
 
   // Create the monitor elements
   std::vector<TH1F*> histosTH1F;
   histosTH1F.push_back(new TH1F(("hResDist"+slHistoName).c_str(),
                                  "Residuals on the distance from wire (rec_hit - segm_extr) (cm)",
                                  200, -histRange_, histRange_));
   std::vector<TH2F*> histosTH2F;
   histosTH2F.push_back(new TH2F(("hResDistVsDist"+slHistoName).c_str(),
                                  "Residuals on the dist. (cm) from wire (rec_hit - segm_extr) vs dist. (cm)",
                                  100, 0, 2.5, 200, -histRange_, histRange_));
   histoMapTH1F_[slId] = histosTH1F;
   histoMapTH2F_[slId] = histosTH2F;
 }

void DTResidualCalibration::bookHistos ( DTLayerId slId )

private

Definition at line 245 of file DTResidualCalibration.cc.

References histoMapPerLayerTH1F_, histoMapPerLayerTH2F_, histRange_, DTLayerId::layer(), rootBaseDir_, rootFile_, DTChamberId::sector(), DTChamberId::station(), AlCaHLTBitMon_QueryRunRegistry::string, DTSuperLayerId::superlayer(), and DTChamberId::wheel().

                                                         {
   TH1AddDirectorySentry addDir;
   rootFile_->cd();
 
   edm::LogVerbatim("Calibration") << "[DTResidualCalibration] Booking histos for layer: " << layerId;
 
   // Compose the chamber name
   std::string wheelStr = std::to_string(layerId.wheel());
   std::string stationStr = std::to_string(layerId.station());
   std::string sectorStr = std::to_string(layerId.sector());
   std::string superLayerStr = std::to_string(layerId.superlayer());
   std::string layerStr = std::to_string(layerId.layer());
   // Define the step
   int step = 3;
 
   std::string layerHistoName =
     "_STEP" + std::to_string(step) +
     "_W" + wheelStr +
     "_St" + stationStr +
     "_Sec" + sectorStr +
     "_SL" + superLayerStr + 
     "_Layer" + layerStr;
   
   edm::LogVerbatim("Calibration") << "Accessing " << rootBaseDir_;
   TDirectory* baseDir = rootFile_->GetDirectory(rootBaseDir_.c_str());
   if(!baseDir) baseDir = rootFile_->mkdir(rootBaseDir_.c_str());
   edm::LogVerbatim("Calibration") << "Accessing " << ("Wheel" + wheelStr);
   TDirectory* wheelDir = baseDir->GetDirectory(("Wheel" + wheelStr).c_str());
   if(!wheelDir) wheelDir = baseDir->mkdir(("Wheel" + wheelStr).c_str());
   edm::LogVerbatim("Calibration") << "Accessing " << ("Station" + stationStr);
   TDirectory* stationDir = wheelDir->GetDirectory(("Station" + stationStr).c_str());
   if(!stationDir) stationDir = wheelDir->mkdir(("Station" + stationStr).c_str());
   edm::LogVerbatim("Calibration") << "Accessing " << ("Sector" + sectorStr);
   TDirectory* sectorDir = stationDir->GetDirectory(("Sector" + sectorStr).c_str());
   if(!sectorDir) sectorDir = stationDir->mkdir(("Sector" + sectorStr).c_str()); 
   edm::LogVerbatim("Calibration") << "Accessing " << ("SL" + superLayerStr);
   TDirectory* superLayerDir = sectorDir->GetDirectory(("SL" + superLayerStr).c_str());
   if(!superLayerDir) superLayerDir = sectorDir->mkdir(("SL" + superLayerStr).c_str()); 
 
   superLayerDir->cd();
   // Create histograms
   std::vector<TH1F*> histosTH1F;
   histosTH1F.push_back(new TH1F(("hResDist"+layerHistoName).c_str(),
                                  "Residuals on the distance from wire (rec_hit - segm_extr) (cm)",
                                  200, -histRange_, histRange_));
   std::vector<TH2F*> histosTH2F;
   histosTH2F.push_back(new TH2F(("hResDistVsDist"+layerHistoName).c_str(),
                                  "Residuals on the dist. (cm) from wire (rec_hit - segm_extr) vs dist. (cm)",
                                  100, 0, 2.5, 200, -histRange_, histRange_));
   histoMapPerLayerTH1F_[layerId] = histosTH1F;
   histoMapPerLayerTH2F_[layerId] = histosTH2F;
 }

void DTResidualCalibration::endJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 175 of file DTResidualCalibration.cc.

References rootFile_.

Referenced by o2olib.O2ORunMgr::executeJob().

                                   {
   
   edm::LogVerbatim("Calibration") << "[DTResidualCalibration] Writing histos to file.";
   rootFile_->cd();
   rootFile_->Write();
   rootFile_->Close();
 
   /*std::map<DTSuperLayerId, std::vector<TH1F*> >::const_iterator itSlHistos = histoMapTH1F_.begin();
   std::map<DTSuperLayerId, std::vector<TH1F*> >::const_iterator itSlHistos_end = histoMapTH1F_.end(); 
   for(; itSlHistos != itSlHistos_end; ++itSlHistos){
      std::vector<TH1F*>::const_iterator itHistTH1F = (*itSlHistos).second.begin();
      std::vector<TH1F*>::const_iterator itHistTH1F_end = (*itSlHistos).second.end();
      for(; itHistTH1F != itHistTH1F_end; ++itHistTH1F) (*itHistTH1F)->Write();
 
      std::vector<TH2F*>::const_iterator itHistTH2F = histoMapTH2F_[(*itSlHistos).first].begin();
      std::vector<TH2F*>::const_iterator itHistTH2F_end = histoMapTH2F_[(*itSlHistos).first].end();
      for(; itHistTH2F != itHistTH2F_end; ++itHistTH2F) (*itHistTH2F)->Write();
   }*/
 
 }

void DTResidualCalibration::fillHistos	(	DTSuperLayerId	slId,
		float	distance,
		float	residualOnDistance
	)

private

Definition at line 299 of file DTResidualCalibration.cc.

References histoMapTH1F_, and histoMapTH2F_.

Referenced by analyze().

                                                                  {
   std::vector<TH1F*> const& histosTH1F = histoMapTH1F_[slId];
   std::vector<TH2F*> const& histosTH2F = histoMapTH2F_[slId];
   histosTH1F[0]->Fill(residualOnDistance);
   histosTH2F[0]->Fill(distance, residualOnDistance);
 }

void DTResidualCalibration::fillHistos	(	DTLayerId	slId,
		float	distance,
		float	residualOnDistance
	)

private

Definition at line 309 of file DTResidualCalibration.cc.

References histoMapPerLayerTH1F_, and histoMapPerLayerTH2F_.

                                                                  {
   std::vector<TH1F*> const& histosTH1F = histoMapPerLayerTH1F_[layerId];
   std::vector<TH2F*> const& histosTH2F = histoMapPerLayerTH2F_[layerId];
   histosTH1F[0]->Fill(residualOnDistance);
   histosTH2F[0]->Fill(distance, residualOnDistance);
 }

float DTResidualCalibration::segmentToWireDistance	(	const DTRecHit1D &	recHit1D,
		const DTRecSegment4D &	segment
	)

private

Definition at line 148 of file DTResidualCalibration.cc.

References relativeConstraints::chamber, DTGeometry::chamber(), DTSuperLayerId::chamberId(), funct::cos(), dtGeom_, DTGeometry::layer(), DTWireId::layerId(), DTRecSegment4D::localDirection(), DTRecSegment4D::localPosition(), DTRecHit1D::localPosition(), DTLayer::specificTopology(), DTSuperLayerId::superlayer(), PV3DBase< T, PVType, FrameType >::theta(), GeomDet::toGlobal(), GeomDet::toLocal(), DTWireId::wire(), DTRecHit1D::wireId(), DTTopology::wirePosition(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

                                                                                                            {
 
   // Get the layer and the wire position
   const DTWireId wireId = recHit1D.wireId();
   const DTLayer* layer = dtGeom_->layer(wireId);
   float wireX = layer->specificTopology().wirePosition(wireId.wire());
 
   // Extrapolate the segment to the z of the wire
   // Get wire position in chamber RF
   // (y and z must be those of the hit to be coherent in the transf. of RF in case of rotations of the layer alignment)
   LocalPoint wirePosInLay(wireX,recHit1D.localPosition().y(),recHit1D.localPosition().z());
   GlobalPoint wirePosGlob = layer->toGlobal(wirePosInLay);
   const DTChamber* chamber = dtGeom_->chamber(wireId.layerId().chamberId());
   LocalPoint wirePosInChamber = chamber->toLocal(wirePosGlob);
 
   // Segment position at Wire z in chamber local frame
   LocalPoint segPosAtZWire = segment.localPosition() + segment.localDirection()*wirePosInChamber.z()/cos(segment.localDirection().theta());
 
   // Compute the distance of the segment from the wire
   int sl = wireId.superlayer();
   float segmDistance = -1;
   if(sl == 1 || sl == 3) segmDistance = fabs(wirePosInChamber.x() - segPosAtZWire.x());
   else if(sl == 2)       segmDistance =  fabs(segPosAtZWire.y() - wirePosInChamber.y());
 
   return segmDistance;
 }