#include <TrackingMaterialAnalyser.h>

Inheritance diagram for TrackingMaterialAnalyser:

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

	~TrackingMaterialAnalyser () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Types
enum	SplitMode { NEAREST_LAYER, INNER_LAYER, OUTER_LAYER, UNDEFINED }

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

void	beginJob () override

void	endJob () override

int	findLayer (const MaterialAccountingDetector &detector)

void	saveLayerPlots ()

void	saveParameters (const char *name)

void	saveXml (const char *name)

void	split (MaterialAccountingTrack &track)

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

std::vector< MaterialAccountingGroup * >	m_groups

bool	m_isHFNose

bool	m_isHGCal

edm::EDGetTokenT< std::vector< MaterialAccountingTrack > >	m_materialToken

TrackingMaterialPlotter *	m_plotter

bool	m_saveDetailedPlots

bool	m_saveParameters

bool	m_saveSummaryPlot

bool	m_saveXml

bool	m_skipAfterLastDetector

bool	m_skipBeforeFirstDetector

SplitMode	m_splitMode

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
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Definition at line 16 of file TrackingMaterialAnalyser.h.

Member Enumeration Documentation

◆ SplitMode

enum TrackingMaterialAnalyser::SplitMode

private

Enumerator
NEAREST_LAYER
INNER_LAYER
OUTER_LAYER
UNDEFINED

Definition at line 22 of file TrackingMaterialAnalyser.h.

22 { NEAREST_LAYER, INNER_LAYER, OUTER_LAYER, UNDEFINED };

Constructor & Destructor Documentation

◆ TrackingMaterialAnalyser()

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

explicit

Definition at line 30 of file TrackingMaterialAnalyser.cc.

                                                                                {
   m_materialToken =
       consumes<std::vector<MaterialAccountingTrack> >(iPSet.getParameter<edm::InputTag>("MaterialAccounting"));
   m_groupNames = iPSet.getParameter<std::vector<std::string> >("Groups");
   const std::string& splitmode = iPSet.getParameter<std::string>("SplitMode");
   if (strcasecmp(splitmode.c_str(), "NearestLayer") == 0) {
     m_splitMode = NEAREST_LAYER;
   } else if (strcasecmp(splitmode.c_str(), "InnerLayer") == 0) {
     m_splitMode = INNER_LAYER;
   } else if (strcasecmp(splitmode.c_str(), "OuterLayer") == 0) {
     m_splitMode = OUTER_LAYER;
   } else {
     m_splitMode = UNDEFINED;
     throw edm::Exception(edm::errors::LogicError)
         << "Invalid SplitMode \"" << splitmode
         << "\". Acceptable values are \"NearestLayer\", \"InnerLayer\", \"OuterLayer\".";
   }
   m_skipAfterLastDetector = iPSet.getParameter<bool>("SkipAfterLastDetector");
   m_skipBeforeFirstDetector = iPSet.getParameter<bool>("SkipBeforeFirstDetector");
   m_saveSummaryPlot = iPSet.getParameter<bool>("SaveSummaryPlot");
   m_saveDetailedPlots = iPSet.getParameter<bool>("SaveDetailedPlots");
   m_saveParameters = iPSet.getParameter<bool>("SaveParameters");
   m_saveXml = iPSet.getParameter<bool>("SaveXML");
   m_isHGCal = iPSet.getParameter<bool>("isHGCal");
   m_isHFNose = iPSet.getParameter<bool>("isHFNose");
   if (m_saveSummaryPlot) {
     if (m_isHGCal) {
       m_plotter = new TrackingMaterialPlotter(550., 300., 10);
     } else if (m_isHFNose) {
       m_plotter = new TrackingMaterialPlotter(1200., 350., 10);
     } else {
       m_plotter = new TrackingMaterialPlotter(300., 120., 10);
     }  // 10x10 points per cm2
   } else {
     m_plotter = nullptr;
   }
 }

References Exception, edm::ParameterSet::getParameter(), INNER_LAYER, edm::errors::LogicError, m_groupNames, m_isHFNose, m_isHGCal, m_materialToken, m_plotter, m_saveDetailedPlots, m_saveParameters, m_saveSummaryPlot, m_saveXml, m_skipAfterLastDetector, m_skipBeforeFirstDetector, m_splitMode, NEAREST_LAYER, OUTER_LAYER, AlCaHLTBitMon_QueryRunRegistry::string, and UNDEFINED.

◆ ~TrackingMaterialAnalyser()

TrackingMaterialAnalyser::~TrackingMaterialAnalyser ( void )

override

Definition at line 69 of file TrackingMaterialAnalyser.cc.

                                                         {
   if (m_plotter)
     delete m_plotter;
 }

References m_plotter.

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 153 of file TrackingMaterialAnalyser.cc.

                                                                                         {
   using namespace edm;
   ESTransientHandle<DDCompactView> hDDD;
   setup.get<IdealGeometryRecord>().get(hDDD);
  
   m_groups.reserve(m_groupNames.size());
   // Initialize m_groups iff it has size equal to zero, so that we are
   // sure it will never be repopulated with the same entries over and
   // over again in the eventloop, at each call of the analyze method.
   if (m_groups.empty()) {
     for (unsigned int i = 0; i < m_groupNames.size(); ++i)
       m_groups.push_back(new MaterialAccountingGroup(m_groupNames[i], *hDDD));
  
     LogInfo("TrackingMaterialAnalyser") << "TrackingMaterialAnalyser: List of the tracker groups: " << std::endl;
     for (unsigned int i = 0; i < m_groups.size(); ++i)
       LogInfo("TrackingMaterialAnalyser") << i << " TrackingMaterialAnalyser:\t" << m_groups[i]->info() << std::endl;
   }
   Handle<std::vector<MaterialAccountingTrack> > h_tracks;
   event.getByToken(m_materialToken, h_tracks);
  
   for (std::vector<MaterialAccountingTrack>::const_iterator t = h_tracks->begin(), end = h_tracks->end(); t != end;
        ++t) {
     MaterialAccountingTrack track(*t);
     split(track);
   }
 }

References mps_fire::end, get, mps_fire::i, m_groupNames, m_groups, m_materialToken, singleTopDQM_cfi::setup, split(), submitPVValidationJobs::t, and HLT_FULL_cff::track.

◆ beginJob()

void TrackingMaterialAnalyser::beginJob ( void )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 25 of file TrackingMaterialAnalyser.h.

25 {}

◆ endJob()

void TrackingMaterialAnalyser::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 134 of file TrackingMaterialAnalyser.cc.

                                           {
   if (m_saveParameters)
     saveParameters("parameters");
  
   if (m_saveXml)
     saveXml("parameters.xml");
  
   if (m_saveDetailedPlots)
     saveLayerPlots();
  
   if (m_saveSummaryPlot and m_plotter) {
     m_plotter->normalize();
     m_plotter->draw();
   }
 }

References TrackingMaterialPlotter::draw(), m_plotter, m_saveDetailedPlots, m_saveParameters, m_saveSummaryPlot, m_saveXml, TrackingMaterialPlotter::normalize(), saveLayerPlots(), saveParameters(), and saveXml().

◆ findLayer()

int TrackingMaterialAnalyser::findLayer ( const MaterialAccountingDetector & detector )

private

Definition at line 347 of file TrackingMaterialAnalyser.cc.

                                                                                   {
   int index = 0;
   size_t inside = 0;
   for (size_t i = 0; i < m_groups.size(); ++i)
     if (m_groups[i]->inside(detector)) {
       ++inside;
       index = i + 1;
     }
   if (inside == 0) {
     index = 0;
     std::cerr << "TrackingMaterialAnalyser::findLayer(...): ERROR: detector does not belong to any DetLayer"
               << std::endl;
     std::cerr << "TrackingMaterialAnalyser::findLayer(...): detector position: " << std::fixed
               << " (r: " << std::setprecision(1) << std::setw(5) << detector.position().perp()
               << ", z: " << std::setprecision(1) << std::setw(6) << detector.position().z()
               << ", phi: " << std::setprecision(3) << std::setw(6) << detector.position().phi() << ")" << std::endl;
   }
   if (inside > 1) {
     index = 0;
     std::cerr << "TrackingMaterialAnalyser::findLayer(...): ERROR: detector belongs to " << inside << " DetLayers"
               << std::endl;
     std::cerr << "TrackingMaterialAnalyser::findLayer(...): detector position: " << std::fixed
               << " (r: " << std::setprecision(1) << std::setw(5) << detector.position().perp()
               << ", z: " << std::setprecision(1) << std::setw(6) << detector.position().z()
               << ", phi: " << std::setprecision(3) << std::setw(6) << detector.position().phi() << ")" << std::endl;
   }
  
   return index;
 }

References EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, hgcalTestNeighbor_cfi::detector, alignBH_cfg::fixed, mps_fire::i, and m_groups.

Referenced by split().

◆ saveLayerPlots()

void TrackingMaterialAnalyser::saveLayerPlots ( )

private

Definition at line 126 of file TrackingMaterialAnalyser.cc.

                                               {
   for (unsigned int i = 0; i < m_groups.size(); ++i) {
     MaterialAccountingGroup& layer = *(m_groups[i]);
     layer.savePlots();
   }
 }

References mps_fire::i, m_groups, and MaterialAccountingGroup::savePlots().

Referenced by endJob().

◆ saveParameters()

void TrackingMaterialAnalyser::saveParameters ( const char * name )

private

Definition at line 75 of file TrackingMaterialAnalyser.cc.

                                                               {
   std::ofstream parameters(name);
   std::cout << std::endl;
   for (unsigned int i = 0; i < m_groups.size(); ++i) {
     MaterialAccountingGroup& layer = *(m_groups[i]);
     std::cout << layer.name() << std::endl;
     std::cout << fmt::sprintf("\tnumber of hits:               %9d", layer.tracks()) << std::endl;
     std::cout << fmt::sprintf(
                      "\tnormalized segment length:    %9.1f ± %9.1f cm", layer.averageLength(), layer.sigmaLength())
               << std::endl;
     std::cout << fmt::sprintf("\tnormalized radiation lengths: %9.3f ± %9.3f",
                               layer.averageRadiationLengths(),
                               layer.sigmaRadiationLengths())
               << std::endl;
     std::cout << fmt::sprintf("\tnormalized energy loss:       %6.5fe-03 ± %6.5fe-03 GeV",
                               layer.averageEnergyLoss(),
                               layer.sigmaEnergyLoss())
               << std::endl;
     parameters << fmt::sprintf("%-20s\t%7d\t%5.1f ± %5.1f cm\t%6.4f ± %6.4f \t%6.4fe-03 ± %6.4fe-03 GeV",
                                layer.name(),
                                layer.tracks(),
                                layer.averageLength(),
                                layer.sigmaLength(),
                                layer.averageRadiationLengths(),
                                layer.sigmaRadiationLengths(),
                                layer.averageEnergyLoss(),
                                layer.sigmaEnergyLoss())
                << std::endl;
   }
   std::cout << std::endl;
  
   parameters.close();
 }

References MaterialAccountingGroup::averageEnergyLoss(), MaterialAccountingGroup::averageLength(), MaterialAccountingGroup::averageRadiationLengths(), gather_cfg::cout, mps_fire::i, m_groups, Skims_PA_cff::name, MaterialAccountingGroup::name(), MaterialAccountingGroup::sigmaEnergyLoss(), MaterialAccountingGroup::sigmaLength(), MaterialAccountingGroup::sigmaRadiationLengths(), and MaterialAccountingGroup::tracks().

Referenced by endJob().

◆ saveXml()

void TrackingMaterialAnalyser::saveXml ( const char * name )

private

Definition at line 110 of file TrackingMaterialAnalyser.cc.

                                                        {
   std::ofstream xml(name);
   xml << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
   xml << "<Groups>" << std::endl;
   for (unsigned int i = 0; i < m_groups.size(); ++i) {
     MaterialAccountingGroup& layer = *(m_groups[i]);
     xml << "  <Group name=\"" << layer.name() << "\">\n"
         << "    <Parameter name=\"TrackerRadLength\" value=\"" << layer.averageRadiationLengths() << "\"/>\n"
         << "    <Parameter name=\"TrackerXi\" value=\"" << layer.averageEnergyLoss() << "\"/>\n"
         << "  </Group>\n"
         << std::endl;
   }
   xml << "</Groups>" << std::endl;
 }

References MaterialAccountingGroup::averageEnergyLoss(), MaterialAccountingGroup::averageRadiationLengths(), mps_fire::i, m_groups, Skims_PA_cff::name, and MaterialAccountingGroup::name().

Referenced by endJob().

◆ split()

void TrackingMaterialAnalyser::split ( MaterialAccountingTrack & track )

private

Definition at line 189 of file TrackingMaterialAnalyser.cc.

                                                                    {
   using namespace edm;
   // group sensitive detectors by their DetLayer
   std::vector<int> group(track.detectors().size());
   for (unsigned int i = 0; i < track.detectors().size(); ++i)
     group[i] = findLayer(track.detectors()[i]);
  
   for (unsigned int i = 0; i < group.size(); ++i)
     if (group[i] > 0)
       LogInfo("TrackingMaterialAnalyser") << "For detector i: " << i << " index: " << group[i]
                                           << " R-ranges: " << m_groups[group[i] - 1]->getBoundingR().first << ", "
                                           << m_groups[group[i] - 1]->getBoundingR().second << group[i]
                                           << " Z-ranges: " << m_groups[group[i] - 1]->getBoundingZ().first << ", "
                                           << m_groups[group[i] - 1]->getBoundingZ().second << std::endl;
  
   unsigned int detectors = track.detectors().size();
   if (detectors == 0) {
     // the track doesn't cross any active detector:
     // keep al material as unassigned
     if (m_plotter)
       for (unsigned int i = 1; i < track.steps().size(); ++i)
         m_plotter->plotSegmentUnassigned(track.steps()[i]);
   } else {
     const double TOLERANCE = 0.0001;  // 1 um tolerance
     std::vector<double> limits(detectors + 2);
  
     // define the trivial limits
     if (m_skipBeforeFirstDetector)
       limits[0] = track.detectors()[0].m_curvilinearIn - TOLERANCE;
     else
       limits[0] = -TOLERANCE;
     if (m_skipAfterLastDetector)
       limits[detectors] = track.detectors()[detectors - 1].m_curvilinearOut + TOLERANCE;
     else
       limits[detectors] = track.summary().length() + TOLERANCE;
     limits[detectors + 1] = INFINITY;  // this is probably no more needed, but doesn't harm...
  
     // pick the algorithm to define the non-trivial limits
     switch (m_splitMode) {
       // assign each segment to the the nearest layer
       // e.g. the material between pixel barrel 3 and TIB 1 will be split among the two
       case NEAREST_LAYER:
         for (unsigned int i = 1; i < detectors; ++i) {
           limits[i] = (track.detectors()[i - 1].m_curvilinearOut + track.detectors()[i].m_curvilinearIn) / 2.;
         }
         break;
  
       // assign each segment to the the inner layer
       // e.g. all material between pixel barrel 3 and TIB 1 will go into the pixel barrel
       case INNER_LAYER:
         for (unsigned int i = 1; i < detectors; ++i)
           limits[i] = track.detectors()[i].m_curvilinearIn - TOLERANCE;
         break;
  
       // assign each segment to the the outer layer
       // e.g. all material between pixel barrel 3 and TIB 1 will go into the TIB
       case OUTER_LAYER:
         for (unsigned int i = 1; i < detectors; ++i)
           limits[i] = track.detectors()[i - 1].m_curvilinearOut + TOLERANCE;
         break;
  
       case UNDEFINED:
         [[fallthrough]];
  
       default:
         // throw something
         throw edm::Exception(edm::errors::LogicError) << "Invalid SplitMode";
     }
  
     double begin = 0.;   // beginning of step, along the track
     double end = 0.;     // end of step, along the track
     unsigned int i = 1;  // step conter
  
     // skip the material before the first layer
     while (end < limits[0]) {
       const MaterialAccountingStep& step = track.steps()[i++];
       end = begin + step.length();
  
       // do not account material before the first layer
       if (m_plotter)
         m_plotter->plotSegmentUnassigned(step);
  
       begin = end;
     }
  
     unsigned int index = 0;  // which detector
     while (i < track.steps().size()) {
       const MaterialAccountingStep& step = track.steps()[i++];
  
       end = begin + step.length();
  
       if (begin > limits[detectors]) {
         // segment after last layer and skipping requested in configuation
         if (m_plotter)
           m_plotter->plotSegmentUnassigned(step);
         begin = end;
         continue;
       }
  
       // from here onwards we should be in the accountable region, either completely in a single layer:
       //   limits[index] <= begin < end <= limits[index+1]
       // or possibly split between 2 layers
       //   limits[index] < begin < limits[index+1] < end <  limits[index+2]
       if (begin < limits[index] or end > limits[index + 2]) {
         // sanity check
         std::cerr << "MaterialAccountingTrack::split(): ERROR: internal logic error, expected " << limits[index]
                   << " < " << begin << " < " << limits[index + 1] << std::endl;
         break;
       }
  
       if (limits[index] <= begin and end <= limits[index + 1]) {
         // step completely inside current detector range
         track.detectors()[index].account(step, begin, end);
         if (m_plotter)
           m_plotter->plotSegmentInLayer(step, group[index]);
       } else {
         // step shared beteewn two detectors, transition at limits[index+1]
         double fraction = (limits[index + 1] - begin) / (end - begin);
         assert(fraction < 1.);
         std::pair<MaterialAccountingStep, MaterialAccountingStep> parts = step.split(fraction);
  
         if (m_plotter) {
           if (index > 0)
             m_plotter->plotSegmentInLayer(parts.first, group[index]);
           else
             // track outside acceptance, keep as unassocated
             m_plotter->plotSegmentUnassigned(parts.first);
  
           if (index + 1 < detectors)
             m_plotter->plotSegmentInLayer(parts.second, group[index + 1]);
           else
             // track outside acceptance, keep as unassocated
             m_plotter->plotSegmentUnassigned(parts.second);
         }
  
         track.detectors()[index].account(parts.first, begin, limits[index + 1]);
         ++index;  // next layer
         if (index < detectors)
           track.detectors()[index].account(parts.second, limits[index + 1], end);
       }
       begin = end;
     }
   }
  
   // add the material from each detector to its layer (if there is one and only one)
   for (unsigned int i = 0; i < track.detectors().size(); ++i)
     if (group[i] != 0)
       m_groups[group[i] - 1]->addDetector(track.detectors()[i]);
  
   // end of track: commit internal buffers and reset the m_groups internal state for a new track
   for (unsigned int i = 0; i < m_groups.size(); ++i)
     m_groups[i]->endOfTrack();
 }

References cms::cuda::assert(), EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, MuonGeometrySanityCheck_cfi::detectors(), mps_fire::end, Exception, findLayer(), HLT_FULL_cff::fraction, watchdog::group, mps_fire::i, INNER_LAYER, TH2PolyOfflineMaps::limits, edm::errors::LogicError, m_groups, m_plotter, m_skipAfterLastDetector, m_skipBeforeFirstDetector, m_splitMode, NEAREST_LAYER, or, OUTER_LAYER, contentValuesFiles::parts, TrackingMaterialPlotter::plotSegmentInLayer(), TrackingMaterialPlotter::plotSegmentUnassigned(), HLT_FULL_cff::track, and UNDEFINED.

Referenced by analyze().

Member Data Documentation

◆ m_groupNames

std::vector<std::string> TrackingMaterialAnalyser::m_groupNames

private

Definition at line 46 of file TrackingMaterialAnalyser.h.

Referenced by analyze(), and TrackingMaterialAnalyser().

◆ m_groups

std::vector<MaterialAccountingGroup *> TrackingMaterialAnalyser::m_groups

private

Definition at line 45 of file TrackingMaterialAnalyser.h.

Referenced by analyze(), findLayer(), saveLayerPlots(), saveParameters(), saveXml(), and split().

◆ m_isHFNose

bool TrackingMaterialAnalyser::m_isHFNose

private

Definition at line 44 of file TrackingMaterialAnalyser.h.

Referenced by TrackingMaterialAnalyser().

◆ m_isHGCal

bool TrackingMaterialAnalyser::m_isHGCal

private

Definition at line 43 of file TrackingMaterialAnalyser.h.

Referenced by TrackingMaterialAnalyser().

◆ m_materialToken

edm::EDGetTokenT<std::vector<MaterialAccountingTrack> > TrackingMaterialAnalyser::m_materialToken

private

Definition at line 35 of file TrackingMaterialAnalyser.h.

Referenced by analyze(), and TrackingMaterialAnalyser().

◆ m_plotter

TrackingMaterialPlotter* TrackingMaterialAnalyser::m_plotter

private

Definition at line 47 of file TrackingMaterialAnalyser.h.

Referenced by endJob(), split(), TrackingMaterialAnalyser(), and ~TrackingMaterialAnalyser().

◆ m_saveDetailedPlots

bool TrackingMaterialAnalyser::m_saveDetailedPlots

private

Definition at line 40 of file TrackingMaterialAnalyser.h.

Referenced by endJob(), and TrackingMaterialAnalyser().

◆ m_saveParameters

bool TrackingMaterialAnalyser::m_saveParameters

private

Definition at line 41 of file TrackingMaterialAnalyser.h.

Referenced by endJob(), and TrackingMaterialAnalyser().

◆ m_saveSummaryPlot

bool TrackingMaterialAnalyser::m_saveSummaryPlot

private

Definition at line 39 of file TrackingMaterialAnalyser.h.

Referenced by endJob(), and TrackingMaterialAnalyser().

◆ m_saveXml

bool TrackingMaterialAnalyser::m_saveXml

private

Definition at line 42 of file TrackingMaterialAnalyser.h.

Referenced by endJob(), and TrackingMaterialAnalyser().

◆ m_skipAfterLastDetector

bool TrackingMaterialAnalyser::m_skipAfterLastDetector

private

Definition at line 37 of file TrackingMaterialAnalyser.h.

Referenced by split(), and TrackingMaterialAnalyser().

◆ m_skipBeforeFirstDetector

bool TrackingMaterialAnalyser::m_skipBeforeFirstDetector

private

Definition at line 38 of file TrackingMaterialAnalyser.h.

Referenced by split(), and TrackingMaterialAnalyser().

◆ m_splitMode

SplitMode TrackingMaterialAnalyser::m_splitMode

private

Definition at line 36 of file TrackingMaterialAnalyser.h.

Referenced by split(), and TrackingMaterialAnalyser().

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ SplitMode

Constructor & Destructor Documentation

◆ TrackingMaterialAnalyser()

◆ ~TrackingMaterialAnalyser()

Member Function Documentation

◆ analyze()

◆ beginJob()

◆ endJob()

◆ findLayer()

◆ saveLayerPlots()

◆ saveParameters()

◆ saveXml()

◆ split()

Member Data Documentation

◆ m_groupNames

◆ m_groups

◆ m_isHFNose

◆ m_isHGCal

◆ m_materialToken

◆ m_plotter

◆ m_saveDetailedPlots

◆ m_saveParameters

◆ m_saveSummaryPlot

◆ m_saveXml

◆ m_skipAfterLastDetector

◆ m_skipBeforeFirstDetector

◆ m_splitMode