Inheritance diagram for TrackingRecoMaterialAnalyser:

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

virtual void	bookHistograms (DQMStore::IBooker &i, edm::Run const &, edm::EventSetup const &) override

	TrackingRecoMaterialAnalyser (const edm::ParameterSet &)

virtual	~TrackingRecoMaterialAnalyser ()

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

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

	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 &	itemsToGetFromEvent () 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

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

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
bool	isDoubleSided (DetId, const TrackerTopology &)

Private Attributes
MonitorElement *	deltaP_in_out_vs_eta_

MonitorElement *	deltaP_in_out_vs_eta_2d_

MonitorElement *	deltaP_in_out_vs_eta_vs_phi_2d_

MonitorElement *	deltaP_in_out_vs_z_

MonitorElement *	deltaP_in_out_vs_z_2d_

MonitorElement *	deltaPl_in_out_vs_eta_

MonitorElement *	deltaPl_in_out_vs_z_

MonitorElement *	deltaPt_in_out_2d_

MonitorElement *	deltaPt_in_out_vs_eta_

MonitorElement *	deltaPt_in_out_vs_z_

MonitorElement *	histo_RZ_

MonitorElement *	histo_RZ_Ori_

std::unordered_map < std::string, MonitorElement * >	histosEta_

std::unordered_map < std::string, MonitorElement * >	histosOriEta_

MonitorElement *	P_vs_eta_2d_

TrackTransformer	refitter_

const edm::EDGetTokenT < reco::TrackCollection >	tracksToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::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)

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

Definition at line 32 of file TrackingRecoMaterialAnalyser.cc.

Constructor & Destructor Documentation

TrackingRecoMaterialAnalyser::TrackingRecoMaterialAnalyser ( const edm::ParameterSet & iPSet )

explicit

Definition at line 62 of file TrackingRecoMaterialAnalyser.cc.

                                                                                       :
   refitter_(iPSet),
   tracksToken_(consumes<reco::TrackCollection>(iPSet.getParameter<edm::InputTag>("tracks"))),
   histo_RZ_(0),
   histo_RZ_Ori_(0),
   deltaPt_in_out_2d_(0),
   deltaP_in_out_vs_eta_(0),
   deltaP_in_out_vs_z_(0),
   deltaP_in_out_vs_eta_2d_(0),
   deltaP_in_out_vs_eta_vs_phi_2d_(0),
   deltaP_in_out_vs_z_2d_(0),
   deltaPt_in_out_vs_eta_(0),
   deltaPt_in_out_vs_z_(0),
   deltaPl_in_out_vs_eta_(0),
   deltaPl_in_out_vs_z_(0),
   P_vs_eta_2d_(0)
 {
 }

TrackingRecoMaterialAnalyser::~TrackingRecoMaterialAnalyser ( void )

virtual

Definition at line 82 of file TrackingRecoMaterialAnalyser.cc.

83 {

84 }

Member Function Documentation

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

overridevirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 150 of file TrackingRecoMaterialAnalyser.cc.

References funct::abs(), assert(), deltaP_in_out_vs_eta_, deltaP_in_out_vs_eta_2d_, deltaP_in_out_vs_eta_vs_phi_2d_, deltaP_in_out_vs_z_, deltaP_in_out_vs_z_2d_, deltaPl_in_out_vs_eta_, deltaPl_in_out_vs_z_, deltaPt_in_out_2d_, deltaPt_in_out_vs_eta_, deltaPt_in_out_vs_z_, MonitorElement::Fill(), edm::EventSetup::get(), histo_RZ_, histo_RZ_Ori_, histosEta_, histosOriEta_, SurfaceOrientation::inner, isDoubleSided(), MediumProperties::isValid(), LogTrace, Surface::mediumProperties(), TrackingRecHit::missing, SurfaceOrientation::outer, p2, P_vs_eta_2d_, MediumProperties::radLen(), dt_dqm_sourceclient_common_cff::reco, refitter_, sDETS, TrackTransformer::setServices(), sLAYS, mathSSE::sqrt(), testEve_cfg::tracks, tracksToken_, TrackTransformer::transform(), TrackingRecHit::valid, and MediumProperties::xi().

 {
   using namespace edm;
   using namespace reco;
   using namespace std;
 
   refitter_.setServices(setup);
 
   Handle<TrackCollection> tracks;
   ESHandle<TrackerTopology> trk_topology;
 
   // Get the TrackerTopology
   setup.get<TrackerTopologyRcd>().get(trk_topology);
 
   event.getByToken(tracksToken_, tracks);
   if (!tracks.isValid() || tracks->size() == 0) {
     LogInfo("TrackingRecoMaterialAnalyser") << "Invalid or empty track collection" << endl;
     return;
   }
   auto selector = [&](const Track &track) -> bool {
     return (track.quality(track.qualityByName("highPurity"))
             && track.dxy() < 0.01
             && track.hitPattern().numberOfLostTrackerHits(HitPattern::MISSING_OUTER_HITS) == 0
             && track.p() < 1.05 && track.p() > 0.95);
   };
 
   // Main idea:
   // * select first good tracks in input, according to reasonable criteria
   // * refit the tracks so that we have access to the TrajectoryMeasurements
   //   that internally have all the information about the TSOS on all
   //   crossed layers. We need the refit track and not the original one so
   //   that we are able to correctly compute the path travelled by the track
   //   within the detector, using its updated TSOS. The material description
   //   can in principle be derived also directly from the rechits, via the
   //   det()[(->)GeomDet *]->mediumProperties chain, but that would simply give the
   //   face values, not the "real" ones used while propagating the track.
   // * Loop on all measurements, extract the information about the TSOS,
   //   its surface and its mediumProperties
   // * Make plots for the untouched material properties, but also for the
   //   ones corrected by the track direction, since the material properties,
   //   according to the documentation, should refer to normal incidence of
   //   the track, which is seldom the case, according to the current direction
   TrajectoryStateOnSurface current_tsos;
   DetId current_det;
   for (auto const track : *tracks) {
     if (!selector(track) and false)
       continue;
     auto const inner = track.innerMomentum();
     auto const outer = track.outerMomentum();
     deltaP_in_out_vs_eta_->Fill(inner.eta(), inner.R() - outer.R());
     deltaP_in_out_vs_z_->Fill(track.outerZ(), inner.R() - outer.R());
     deltaP_in_out_vs_eta_2d_->Fill(inner.eta(), inner.R() - outer.R());
     deltaP_in_out_vs_eta_vs_phi_2d_->Fill(inner.eta(), inner.phi(), inner.R() - outer.R());
     deltaP_in_out_vs_z_2d_->Fill(track.outerZ(), inner.R() - outer.R());
     deltaPt_in_out_vs_eta_->Fill(inner.eta(), inner.rho() - outer.rho());
     deltaPt_in_out_vs_z_->Fill(track.outerZ(), inner.rho() - outer.rho());
     deltaPl_in_out_vs_eta_->Fill(inner.eta(), inner.z() - outer.z());
     deltaPl_in_out_vs_z_->Fill(track.outerZ(), inner.z() - outer.z());
     deltaPt_in_out_2d_->Fill(track.outerZ(), track.outerPosition().rho(), inner.rho() - outer.rho());
     P_vs_eta_2d_->Fill(track.eta(), track.p());
     vector<Trajectory> traj  = refitter_.transform(track);
     if (traj.size() > 1 || traj.size() == 0)
       continue;
     for (auto const &tm : traj.front().measurements()) {
       if (tm.recHit().get() &&
         (tm.recHitR().type() == TrackingRecHit::valid ||
          tm.recHitR().type() == TrackingRecHit::missing)) {
         current_tsos = tm.updatedState().isValid() ? tm.updatedState() : tm.forwardPredictedState();
         auto const & localP = current_tsos.localMomentum();
         current_det = tm.recHit()->geographicalId();
         const Surface& surface = current_tsos.surface();
         assert(tm.recHit()->surface() == &surface);
         if (!surface.mediumProperties().isValid()) {
           LogError("TrackingRecoMaterialAnalyser")
             << "Medium properties for material linked to detector"
             << " are invalid at: "
             << current_tsos.globalPosition() << " "
             << (SiStripDetId)current_det << endl;
            assert(0);
           continue;
         }
         float p2 = localP.mag2();
         float xf = std::abs(std::sqrt(p2)/localP.z());
 //        float e2     = p2 + m2;
 //        float beta2  = p2/e2;
         float ori_xi = surface.mediumProperties().xi();
         float ori_radLen = surface.mediumProperties().radLen();
         float xi = ori_xi*xf;
         float radLen = ori_radLen*xf;
 
         // Since there are double-sided (glued) modules all over the tracker,
         // the material budget has been internally partitioned in two equal
         // components, so that each single layer will receive half of the
         // correct radLen. For this reason, only for the double-sided
         // components, we rescale the obtained radLen by 2.
         // In particular see code here: http://cmslxr.fnal.gov/dxr/CMSSW_8_0_5/source/Geometry/TrackerGeometryBuilder/src/TrackerGeomBuilderFromGeometricDet.cc#213
         // where, in the SiStrip Tracker, if the module has a partner
         // (i.e. it's a glued detector) the plane is built with a scaling of
         // 0.5. The actual plane is built few lines below:
         // http://cmslxr.fnal.gov/dxr/CMSSW_8_0_5/source/Geometry/TrackerGeometryBuilder/src/TrackerGeomBuilderFromGeometricDet.cc#287
 
         if (isDoubleSided(current_det, *trk_topology)) {
           LogTrace("TrackingRecoMaterialAnalyser") <<  "Eta: " << track.eta() << " "
              << sDETS[current_det.subdetId()]+sLAYS[trk_topology->layer(current_det)]
              << " has ori_radLen: " << ori_radLen << " and ori_xi: " << xi
              << " and has radLen: " << radLen << "  and xi: " << xi << endl;
           ori_radLen *= 2.;
           radLen *= 2.;
         }
 
         histosOriEta_[sDETS[current_det.subdetId()]+sLAYS[trk_topology->layer(current_det)]]->Fill(current_tsos.globalPosition().eta(), ori_radLen);
         histosEta_[sDETS[current_det.subdetId()]+sLAYS[trk_topology->layer(current_det)]]->Fill(current_tsos.globalPosition().eta(), radLen);
         histo_RZ_Ori_->Fill(current_tsos.globalPosition().z(), current_tsos.globalPosition().perp(), ori_radLen);
         histo_RZ_->Fill(current_tsos.globalPosition().z(), current_tsos.globalPosition().perp(), radLen);
         LogInfo("TrackingRecoMaterialAnalyser") <<  "Eta: " << track.eta() << " "
              << sDETS[current_det.subdetId()]+sLAYS[trk_topology->layer(current_det)]
              << " has ori_radLen: " << ori_radLen << " and ori_xi: " << xi
              << " and has radLen: " << radLen << "  and xi: " << xi << endl;
       }
     }
   }
 }

void TrackingRecoMaterialAnalyser::bookHistograms	(	DQMStore::IBooker &	i,
		edm::Run const &	,
		edm::EventSetup const &	setup
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 87 of file TrackingRecoMaterialAnalyser.cc.

References DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), DQMStore::IBooker::bookProfile2D(), data, deltaP_in_out_vs_eta_, deltaP_in_out_vs_eta_2d_, deltaP_in_out_vs_eta_vs_phi_2d_, deltaP_in_out_vs_z_, deltaP_in_out_vs_z_2d_, deltaPl_in_out_vs_eta_, deltaPl_in_out_vs_z_, deltaPt_in_out_2d_, deltaPt_in_out_vs_eta_, deltaPt_in_out_vs_z_, edm::EventSetup::get(), histo_RZ_, histo_RZ_Ori_, histosEta_, histosOriEta_, relval_steps::key, P_vs_eta_2d_, sDETS, DQMStore::IBooker::setCurrentFolder(), and SiPixelPhase1TrackClusters_cfi::title.

                                                                               {
   using namespace std;
   edm::ESHandle<TrackerGeometry> trackerGeometry;
   setup.get<TrackerDigiGeometryRecord>().get(trackerGeometry);
 
   ibook.setCurrentFolder("RecoMaterialFromRecoTracks");
   histo_RZ_Ori_ = ibook.bookProfile2D("OriRadLen", "Original_RadLen",
                                   600, -300., 300, 120, 0., 120., 0., 1.);
   histo_RZ_ = ibook.bookProfile2D("RadLen", "RadLen",
                                   600, -300., 300, 120, 0., 120., 0., 1.);
   deltaP_in_out_vs_eta_vs_phi_2d_ = ibook.bookProfile2D("DeltaP_in_out_vs_eta_vs_phi_2d",
                                                         "DeltaP_in_out_vs_eta_vs_phi_2d",
                                                         100, -3.0, 3.0,
                                                         100, -3.15, 3.15,
                                                         0., 100.);
   deltaP_in_out_vs_eta_2d_ = ibook.book2D("DeltaP_in_out_vs_eta_2d", "DeltaP_in_out_vs_eta_2d",
                                           100, -3.0, 3.0, 100, 0., 1);
   deltaP_in_out_vs_z_2d_   = ibook.book2D("DeltaP_in_out_vs_z_2d", "DeltaP_in_out_vs_z_2d",
                                           600, -300, 300, 200., -1, 1.);
   deltaP_in_out_vs_eta_ = ibook.bookProfile("DeltaP_in_out_vs_eta", "DeltaP_in_out_vs_eta",
                                       100, -3.0, 3.0, -100., 100.);
   deltaP_in_out_vs_z_   = ibook.bookProfile("DeltaP_in_out_vs_z", "DeltaP_in_out_vs_z",
                                       600, -300, 300, -100., 100.);
   deltaPt_in_out_vs_eta_ = ibook.bookProfile("DeltaPt_in_out_vs_eta", "DeltaPt_in_out_vs_eta",
                                       100, -3.0, 3.0, -100., 100.);
   deltaPt_in_out_vs_z_   = ibook.bookProfile("DeltaPt_in_out_vs_z", "DeltaPt_in_out_vs_z",
                                       600, -300, 300, -100., 100);
   deltaPl_in_out_vs_eta_ = ibook.bookProfile("DeltaPz_in_out_vs_eta", "DeltaPz_in_out_vs_eta",
                                       100, -3.0, 3.0, -100., 100.);
   deltaPl_in_out_vs_z_   = ibook.bookProfile("DeltaPz_in_out_vs_z", "DeltaPz_in_out_vs_z",
                                       600, -300, 300, -100., 100.);
   deltaPt_in_out_2d_     = ibook.bookProfile2D("DeltaPt 2D", "DeltaPt 2D",
                                                600, -300., 300, 120, 0., 120., -100., 100.);
   P_vs_eta_2d_   = ibook.book2D("P_vs_eta_2d", "P_vs_eta_2d",
                                           100, -3.0, 3.0, 100., 0., 5.);
   char title[50];
   char key[20];
   for (unsigned int det = 1; det < sDETS.size(); ++det ) {
     for (unsigned int sub_det = 1;
       sub_det <= trackerGeometry->numberOfLayers(det); ++sub_det) {
       memset(title, 0, sizeof(title));
       snprintf(title, sizeof(title), "Original_RadLen_vs_Eta_%s%d", sDETS[det].data(), sub_det);
       snprintf(key, sizeof(key), "%s%d", sDETS[det].data(), sub_det);
       histosOriEta_.insert(make_pair<string, MonitorElement*>(key,
         ibook.bookProfile(title, title, 250, -5.0, 5.0, 0., 1.)));
       snprintf(title, sizeof(title), "RadLen_vs_Eta_%s%d", sDETS[det].data(), sub_det);
       histosEta_.insert(make_pair<string, MonitorElement*>(key,
         ibook.bookProfile(title, title, 250, -5.0, 5.0, 0., 1.)));
     }
   }
 }

bool TrackingRecoMaterialAnalyser::isDoubleSided	(	DetId	id,
		const TrackerTopology &	trk_topology
	)

private

Definition at line 141 of file TrackingRecoMaterialAnalyser.cc.

References SiStripDetId::glued(), SiStripDetId::subDetector(), SiStripDetId::TEC, SiStripDetId::TIB, SiStripDetId::TID, and SiStripDetId::TOB.

Referenced by analyze().

                                                                                                {
   SiStripDetId strip_id(id);
   return (((strip_id.subDetector() == SiStripDetId::TIB) ||
            (strip_id.subDetector() == SiStripDetId::TOB) ||
            (strip_id.subDetector() == SiStripDetId::TID) ||
            (strip_id.subDetector() == SiStripDetId::TEC)) && strip_id.glued());
 }