Inheritance diagram for MuDTSegmentExtTableProducer:

Public Member Functions
	MuDTSegmentExtTableProducer (const edm::ParameterSet &)
	Constructor. More...

Public Member Functions inherited from MuBaseFlatTableProducer
void	beginRun (const edm::Run &run, const edm::EventSetup &config) final
	Configure event setup for each run. More...

void	endRun (const edm::Run &, const edm::EventSetup &) final
	Empty, needed by interface. More...

	MuBaseFlatTableProducer (const edm::ParameterSet &)
	Constructor. More...

void	produce (edm::Event &, const edm::EventSetup &) final
	Fill ntuples event by event. More...

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)
	Fill descriptors. More...

Protected Member Functions
void	fillTable (edm::Event &) final
	Fill tree branches for a given event. More...

void	getFromES (const edm::Run &, const edm::EventSetup &) final
	Get info from the ES by run. More...

void	getFromES (const edm::EventSetup &) final
	Get info from the ES for a given event. More...

Protected Member Functions inherited from MuBaseFlatTableProducer
template<typename T >
void	addColumn (std::unique_ptr< nanoaod::FlatTable > &table, const std::string name, const std::vector< T > &vec, const std::string descr)

Private Attributes
nano_mu::ESTokenHandle< DTGeometry, MuonGeometryRecord, edm::Transition::BeginRun >	m_dtGeometry
	DT Geometry. More...

std::unique_ptr< DTTTrigBaseSync >	m_dtSync
	Handle DT trigger time pedestals. More...

bool	m_fillExtr
	Fill segment extrapolation table. More...

bool	m_fillHits
	Fill rec-hit table. More...

nano_mu::EDTokenHandle< DTRecSegment4DCollection >	m_token
	The segment token. More...

nano_mu::ESTokenHandle< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	m_trackingGeometry
	Tracking Geometry. More...

Static Private Attributes
static const int	FIRST_LAYER {1}

static const int	LAST_LAYER {4}

static const int	THETA_SL {2}

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Protected Attributes inherited from MuBaseFlatTableProducer
std::string	m_name
	The label name of the FlatTableProducer. More...

Static Protected Attributes inherited from MuBaseFlatTableProducer
static constexpr double	DEFAULT_DOUBLE_VAL {-999.0}
	Definition of default values for float variables. More...

static constexpr double	DEFAULT_DOUBLE_VAL_POS {-1.0}
	Definition of default values for positive float variables. More...

static constexpr int8_t	DEFAULT_INT8_VAL {-99}
	Definition of default values for int8 variables. More...

static constexpr int	DEFAULT_INT_VAL {-999}
	Definition of default values for int variables. More...

static constexpr int	DEFAULT_INT_VAL_POS {-1}
	Definition of default values for positive int variables. More...

Detailed Description

Helper class : the segment TableProducer for Phase-1 / Phase2 segments (the DataFormat is the same)

Author: C. Battilana (INFN BO)

Definition at line 32 of file MuDTSegmentExtTableProducer.cc.

Constructor & Destructor Documentation

◆ MuDTSegmentExtTableProducer()

MuDTSegmentExtTableProducer::MuDTSegmentExtTableProducer ( const edm::ParameterSet & config )

Constructor.

Definition at line 73 of file MuDTSegmentExtTableProducer.cc.

     : MuBaseFlatTableProducer{config},
       m_token{config, consumesCollector(), "src"},
       m_fillHits{config.getParameter<bool>("fillHits")},
       m_fillExtr{config.getParameter<bool>("fillExtrapolation")},
       m_dtGeometry{consumesCollector()},
       m_trackingGeometry{consumesCollector()} {
   produces<nanoaod::FlatTable>();
   if (m_fillHits) {
     produces<nanoaod::FlatTable>("hits");
   }
   if (m_fillExtr) {
     produces<nanoaod::FlatTable>("extr");
   }
 
   m_dtSync = DTTTrigSyncFactory::get()->create(config.getParameter<std::string>("tTrigMode"),
                                                config.getParameter<edm::ParameterSet>("tTrigModeConfig"),
                                                consumesCollector());
 }

Member Function Documentation

◆ fillDescriptions()

void MuDTSegmentExtTableProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Fill descriptors.

Definition at line 93 of file MuDTSegmentExtTableProducer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                              {
   edm::ParameterSetDescription desc;
 
   desc.add<std::string>("name", "dtSegment");
   desc.add<edm::InputTag>("src", edm::InputTag{"dt4DSegments"});
   desc.add<bool>("fillExtrapolation", true);
   desc.add<bool>("fillHits", true);
 
   desc.add<std::string>("tTrigMode", "DTTTrigSyncFromDB");
 
   edm::ParameterSetDescription tTrigModeParams;
   tTrigModeParams.add<bool>("doTOFCorrection", true);
   tTrigModeParams.add<int>("tofCorrType", 2);
 
   tTrigModeParams.add<double>("vPropWire", 24.4);
   tTrigModeParams.add<bool>("doWirePropCorrection", true);
   tTrigModeParams.add<int>("wirePropCorrType", 0);
 
   tTrigModeParams.add<std::string>("tTrigLabel", "");
   tTrigModeParams.add<bool>("doT0Correction", true);
   tTrigModeParams.add<std::string>("t0Label", "");
   tTrigModeParams.addUntracked<bool>("debug", false);
 
   desc.add<edm::ParameterSetDescription>("tTrigModeConfig", tTrigModeParams);
 
   descriptions.addWithDefaultLabel(desc);
 }

◆ fillTable()

void MuDTSegmentExtTableProducer::fillTable ( edm::Event & ev )

finalprotectedvirtual

Fill tree branches for a given event.

Implements MuBaseFlatTableProducer.

Definition at line 130 of file MuDTSegmentExtTableProducer.cc.

References MuBaseFlatTableProducer::addColumn(), anyDirection, DTGeometry::chamber(), nano_mu::EDTokenHandle< T >::conditionalGet(), MuBaseFlatTableProducer::DEFAULT_DOUBLE_VAL, MuBaseFlatTableProducer::DEFAULT_INT_VAL_POS, validationMuonRPCDigis_cfi::digiTime, DeadROC_duringRun::dir, makeMEIFBenchmarkPlots::ev, FIRST_LAYER, GlobalTrackingGeometry::idToDet(), LAST_LAYER, nano_mu_digi_cff::layer, DTGeometry::layer(), m_dtGeometry, m_dtSync, m_fillExtr, m_fillHits, MuBaseFlatTableProducer::m_name, m_token, m_trackingGeometry, eostools::move(), nHits, GeomDet::position(), FastTimerService_cff::range, rpcPointValidation_cfi::recHit, FastTrackerRecHitMaskProducer_cfi::recHits, nano_mu_digi_cff::sector, findQualityFiles::size, DTRecSegment2D::specificRecHits(), relativeConstraints::station, summarizeEdmComparisonLogfiles::success, TableParser::table, THETA_SL, dttriganalyzer_cfi::tTrig, trackerHitRTTI::vector, makeMuonMisalignmentScenario::wheel, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

                                                         {
   unsigned int nSegments{0};
 
   std::vector<float> seg4D_posLoc_x_SL1;
   std::vector<float> seg4D_posLoc_x_SL3;
   std::vector<float> seg4D_posLoc_x_midPlane;
 
   std::vector<uint32_t> seg4D_extr_begin;
   std::vector<uint32_t> seg4D_extr_end;
 
   std::vector<uint32_t> seg2D_hits_begin;
   std::vector<uint32_t> seg2D_hits_end;
 
   // segment extrapolation to DT layers filled, if m_fillExtr == true
   unsigned int nExtr{0};
 
   std::vector<float> seg4D_hitsExpPos;
   std::vector<float> seg4D_hitsExpPosCh;
   std::vector<int16_t> seg4D_hitsExpWire;
 
   // rec-hits vectors, filled if m_fillHits == true
   unsigned int nHits{0};
 
   std::vector<float> seg2D_hits_pos;
   std::vector<float> seg2D_hits_posCh;
   std::vector<float> seg2D_hits_posErr;
   std::vector<int16_t> seg2D_hits_side;
   std::vector<int16_t> seg2D_hits_wire;
   std::vector<int16_t> seg2D_hits_wirePos;
   std::vector<int16_t> seg2D_hits_layer;
   std::vector<int16_t> seg2D_hits_superLayer;
   std::vector<float> seg2D_hits_time;
   std::vector<float> seg2D_hits_timeCali;
 
   auto fillHits = [&](const DTRecSegment2D* seg, const GeomDet* chamb) {
     const auto& recHits = seg->specificRecHits();
 
     for (const auto& recHit : recHits) {
       ++nHits;
 
       const auto wireId = recHit.wireId();
       const auto layerId = wireId.layerId();
       const auto* layer = m_dtGeometry->layer(layerId);
 
       seg2D_hits_pos.push_back(recHit.localPosition().x());
       seg2D_hits_posCh.push_back(chamb->toLocal(layer->toGlobal(recHit.localPosition())).x());
       seg2D_hits_posErr.push_back(recHit.localPositionError().xx());
 
       seg2D_hits_side.push_back(recHit.lrSide());
       seg2D_hits_wire.push_back(wireId.wire());
       seg2D_hits_wirePos.push_back(layer->specificTopology().wirePosition(wireId.wire()));
       seg2D_hits_layer.push_back(layerId.layer());
       seg2D_hits_superLayer.push_back(layerId.superlayer());
 
       auto digiTime = recHit.digiTime();
 
       auto tTrig = m_dtSync->offset(wireId);
 
       seg2D_hits_time.push_back(digiTime);
       seg2D_hits_timeCali.push_back(digiTime - tTrig);
     }
   };
 
   auto segments4D = m_token.conditionalGet(ev);
 
   if (segments4D.isValid()) {
     auto chambIt = segments4D->id_begin();
     const auto chambEnd = segments4D->id_end();
 
     for (; chambIt != chambEnd; ++chambIt) {
       const auto& range = segments4D->get(*chambIt);
 
       for (auto segment4D = range.first; segment4D != range.second; ++segment4D) {
         auto station = (*chambIt).station();
         auto wheel = (*chambIt).wheel();
         auto sector = (*chambIt).sector();
 
         bool hasPhi = segment4D->hasPhi();
         bool hasZed = segment4D->hasZed();
 
         auto pos = segment4D->localPosition();
         auto dir = segment4D->localDirection();
 
         std::array<float, 2> xPosLocSL{{DEFAULT_DOUBLE_VAL, DEFAULT_DOUBLE_VAL}};
         std::array<bool, 2> hasPptSL{{false, false}};
         auto xPosLocMidPlane = DEFAULT_DOUBLE_VAL;
 
         const auto* chamb = m_dtGeometry->chamber(*chambIt);
 
         StraightLinePlaneCrossing segmentPlaneCrossing{
             chamb->toGlobal(pos).basicVector(), chamb->toGlobal(dir).basicVector(), anyDirection};
 
         if (hasPhi) {
           for (int iSL = 0; iSL < 2; ++iSL) {
             const auto* sl = chamb->superLayer(1 + iSL * 2);
 
             auto pptSL = segmentPlaneCrossing.position(sl->surface());
             hasPptSL[iSL] = pptSL.first;
 
             if (hasPptSL[iSL]) {
               GlobalPoint segExrapolationToSL(pptSL.second);
               xPosLocSL[iSL] = chamb->toLocal(segExrapolationToSL).x();
             }
           }
         }
 
         seg4D_posLoc_x_SL1.push_back(xPosLocSL[0]);
         seg4D_posLoc_x_SL3.push_back(xPosLocSL[1]);
 
         if (hasPptSL[0] && hasPptSL[1])
           xPosLocMidPlane = (xPosLocSL[0] + xPosLocSL[1]) * 0.5;
 
         seg4D_posLoc_x_midPlane.push_back(xPosLocMidPlane);
 
         const auto begin = seg4D_hitsExpPos.size();
 
         const auto size{station == 4 ? 8 : 12};
 
         nExtr += size;
         seg4D_extr_begin.push_back(begin);
         seg4D_extr_end.push_back(begin + size);
 
         const auto iSLs = station < 4 ? std::vector{1, 2, 3} : std::vector{1, 3};
 
         for (int iL = FIRST_LAYER; iL <= LAST_LAYER; ++iL) {
           for (const auto iSL : iSLs) {
             auto* layer = m_dtGeometry->layer(DTWireId{wheel, station, sector, iSL, iL, 2});
             auto ppt = segmentPlaneCrossing.position(layer->surface());
 
             bool success{ppt.first};  // check for failure
 
             auto expPos{DEFAULT_DOUBLE_VAL};
             auto expPosCh{DEFAULT_DOUBLE_VAL};
             auto expWire{DEFAULT_INT_VAL_POS};
 
             if (success) {
               GlobalPoint segExrapolationToLayer(ppt.second);
               LocalPoint segPosAtZWireLayer = layer->toLocal(segExrapolationToLayer);
               LocalPoint segPosAtZWireChamber = chamb->toLocal(segExrapolationToLayer);
 
               if (hasPhi && iSL != THETA_SL) {
                 expPos = segPosAtZWireLayer.x();
                 expPosCh = segPosAtZWireChamber.x();
                 expWire = layer->specificTopology().channel(segPosAtZWireLayer);
               } else if (hasZed && iSL == THETA_SL) {
                 expPos = segPosAtZWireLayer.x();
                 expPosCh = segPosAtZWireChamber.y();
                 expWire = layer->specificTopology().channel(segPosAtZWireLayer);
               }
             }
 
             seg4D_hitsExpPos.push_back(expPos);
             seg4D_hitsExpPosCh.push_back(expPosCh);
             seg4D_hitsExpWire.push_back(expWire);
           }
         }
 
         seg2D_hits_begin.push_back(seg2D_hits_pos.size());
 
         const GeomDet* geomDet = m_trackingGeometry->idToDet(segment4D->geographicalId());
         if (hasPhi) {
           fillHits(segment4D->phiSegment(), geomDet);
         }
 
         if (hasZed) {
           fillHits(segment4D->zSegment(), geomDet);
         }
 
         seg2D_hits_end.push_back(seg2D_hits_pos.size());
         ++nSegments;
       }
     }
   }
 
   auto table = std::make_unique<nanoaod::FlatTable>(nSegments, m_name, false, true);
 
   table->setDoc("DT segment information");
 
   addColumn(table, "seg4D_posLoc_x_SL1", seg4D_posLoc_x_SL1, "position x at SL1 in local coordinates - cm");
   addColumn(table, "seg4D_posLoc_x_SL3", seg4D_posLoc_x_SL3, "position x at SL3 in local coordinates - cm");
   addColumn(table,
             "seg4D_posLoc_x_midPlane",
             seg4D_posLoc_x_midPlane,
             "position x at SL1 - SL3 mid plane in local coordinates - cm");
 
   addColumn(table, "seg2D_hits_begin", seg2D_hits_begin, "begin() of range of quantities in the *_hits_* vectors");
   addColumn(table, "seg2D_hits_end", seg2D_hits_end, "end() of range of quantities in the *_hits_* vectors");
 
   addColumn(table, "seg4D_extr_begin", seg4D_extr_begin, "begin() of range of quantities in the *_extr_* vectors");
   addColumn(table, "seg4D_extr_end", seg4D_extr_end, "end() of range of quantities in the *_extr_* vectors");
 
   ev.put(std::move(table));
 
   if (m_fillHits) {
     auto tabHits = std::make_unique<nanoaod::FlatTable>(nHits, m_name + "_hits", false, false);
 
     tabHits->setDoc("Size of DT segment *_hits_* vectors");
 
     addColumn(tabHits, "pos", seg2D_hits_pos, "local x position of a hit in layer local coordinates");
     addColumn(tabHits, "posCh", seg2D_hits_posCh, "local x position of a hit in chamber local coordinates");
     addColumn(tabHits,
               "posErr",
               seg2D_hits_posErr,
               "local position error of a hit in layer local coordinates - xx component of error matrix");
     addColumn(tabHits, "side", seg2D_hits_side, "is hit on L/R side of a cell wire - 1/2 is R/L");
     addColumn(tabHits, "wire", seg2D_hits_wire, "hit wire number - range depends on chamber size");
     addColumn(tabHits, "wirePos", seg2D_hits_wirePos, "hit wire x position in layer local coordinates");
     addColumn(tabHits, "layer", seg2D_hits_layer, "hit layer number - range [1:4]");
     addColumn(tabHits,
               "superLayer",
               seg2D_hits_superLayer,
               "hit superlayer - [1:3] range"
               "<br />SL 1 and 3 are phi SLs"
               "<br />SL 2 is theta SL");
     addColumn(tabHits, "time", seg2D_hits_time, "digi time - ns, pedestal not subtracted");
     addColumn(tabHits, "timeCali", seg2D_hits_timeCali, "digi time - ns, pedestal subtracted");
 
     ev.put(std::move(tabHits), "hits");
   }
 
   if (m_fillExtr) {
     auto tabExtr = std::make_unique<nanoaod::FlatTable>(nExtr, m_name + "_extr", false, false);
 
     tabExtr->setDoc("Size of DT segment *_extr_* vectors");
     addColumn(tabExtr,
               "ExpPos",
               seg4D_hitsExpPos,
               "expected position of segment extrapolated"
               "<br />to a given layer in layer local coordinates - cm");
 
     addColumn(tabExtr,
               "ExpPosCh",
               seg4D_hitsExpPosCh,
               "expected position of segment extrapolated"
               "<br />to a given layer in chhamber local coordinates - cm");
 
     addColumn(tabExtr,
               "ExpWire",
               seg4D_hitsExpWire,
               "expected wire crossed by segment extrapolated"
               "<br />to a given layer - range depends on chamber size");
 
     ev.put(std::move(tabExtr), "extr");
   }
 }

◆ getFromES() [1/2]

void MuDTSegmentExtTableProducer::getFromES	(	const edm::Run &	run,
		const edm::EventSetup &	environment
	)

finalprotectedvirtual

Get info from the ES by run.

Reimplemented from MuBaseFlatTableProducer.

Definition at line 121 of file MuDTSegmentExtTableProducer.cc.

References reco_calib_source_client_cfg::environment, nano_mu::ESTokenHandle< T, R, TR >::getFromES(), and m_dtGeometry.

                                                                                                {
   m_dtGeometry.getFromES(environment);
 }

◆ getFromES() [2/2]

void MuDTSegmentExtTableProducer::getFromES ( const edm::EventSetup & environment )

finalprotectedvirtual

Get info from the ES for a given event.

Reimplemented from MuBaseFlatTableProducer.

Definition at line 125 of file MuDTSegmentExtTableProducer.cc.

References reco_calib_source_client_cfg::environment, nano_mu::ESTokenHandle< T, R, TR >::getFromES(), m_dtSync, and m_trackingGeometry.

                                                                             {
   m_trackingGeometry.getFromES(environment);
   m_dtSync->setES(environment);
 }