TrackingMaterialAnalyser Class Reference

#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
	EDAnalyzer (const EDAnalyzer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
const EDAnalyzer &	operator= (const EDAnalyzer &)=delete
bool	wantsGlobalLuminosityBlocks () const noexcept final
bool	wantsGlobalRuns () const noexcept final
bool	wantsInputProcessBlocks () const noexcept final
bool	wantsProcessBlocks () const noexcept 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 noexcept
bool	wantsStreamRuns () const noexcept
	~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
ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESResolverIndex > 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
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices 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
edm::ESGetToken< DDCompactView, IdealGeometryRecord >	m_dddToken
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
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 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

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.

{ 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.

References edm::EDConsumerBase::esConsumes(), Exception, edm::ParameterSet::getParameter(), INNER_LAYER, edm::errors::LogicError, m_dddToken, 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.

                                                                               {
  m_materialToken =
      consumes<std::vector<MaterialAccountingTrack> >(iPSet.getParameter<edm::InputTag>("MaterialAccounting"));
  m_dddToken = esConsumes();
  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;
  }
}

~TrackingMaterialAnalyser()

TrackingMaterialAnalyser::~TrackingMaterialAnalyser ( void  )

override

Definition at line 70 of file TrackingMaterialAnalyser.cc.

References m_plotter.

                                                        {
  if (m_plotter)
    delete 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 154 of file TrackingMaterialAnalyser.cc.

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

                                                                                        {
  using namespace edm;
  auto hDDD = setup.getHandle(m_dddToken);

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

beginJob()

void TrackingMaterialAnalyser::beginJob ( void  )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 25 of file TrackingMaterialAnalyser.h.

{}

endJob()

void TrackingMaterialAnalyser::endJob ( void  )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 135 of file TrackingMaterialAnalyser.cc.

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

                                          {
  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();
  }
}

findLayer()

int TrackingMaterialAnalyser::findLayer ( const MaterialAccountingDetector &  detector )

private

Definition at line 347 of file TrackingMaterialAnalyser.cc.

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

Referenced by split().

                                                                                  {
  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;
}

saveLayerPlots()

void TrackingMaterialAnalyser::saveLayerPlots ( )

private

Definition at line 127 of file TrackingMaterialAnalyser.cc.

References mps_fire::i, nano_mu_digi_cff::layer, and m_groups.

Referenced by endJob().

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

saveParameters()

void TrackingMaterialAnalyser::saveParameters ( const char *  name )

private

Definition at line 76 of file TrackingMaterialAnalyser.cc.

References gather_cfg::cout, mps_fire::i, nano_mu_digi_cff::layer, m_groups, and mergeVDriftHistosByStation::name.

Referenced by endJob().

                                                              {
  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();
}

saveXml()

void TrackingMaterialAnalyser::saveXml ( const char *  name )

private

Definition at line 111 of file TrackingMaterialAnalyser.cc.

References mps_fire::i, nano_mu_digi_cff::layer, m_groups, and mergeVDriftHistosByStation::name.

Referenced by endJob().

                                                       {
  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;
}

split()

void TrackingMaterialAnalyser::split ( MaterialAccountingTrack &  track )

private

Definition at line 189 of file TrackingMaterialAnalyser.cc.

References cms::cuda::assert(), SplitLinear::begin, DMR_cfg::cerr, MuonGeometrySanityCheck_cfi::detectors(), mps_fire::end, Exception, findLayer(), HLT_2024v14_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, TrackingMaterialPlotter::plotSegmentInLayer(), TrackingMaterialPlotter::plotSegmentUnassigned(), HLT_2024v14_cff::track, and UNDEFINED.

Referenced by analyze().

                                                                   {
  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();
}

Member Data Documentation

m_dddToken

edm::ESGetToken<DDCompactView, IdealGeometryRecord> TrackingMaterialAnalyser::m_dddToken

private

Definition at line 36 of file TrackingMaterialAnalyser.h.

Referenced by analyze(), and TrackingMaterialAnalyser().

m_groupNames

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

private

Definition at line 47 of file TrackingMaterialAnalyser.h.

Referenced by analyze(), and TrackingMaterialAnalyser().

m_groups

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

private

Definition at line 46 of file TrackingMaterialAnalyser.h.

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

m_isHFNose

bool TrackingMaterialAnalyser::m_isHFNose

private

Definition at line 45 of file TrackingMaterialAnalyser.h.

Referenced by TrackingMaterialAnalyser().

m_isHGCal

bool TrackingMaterialAnalyser::m_isHGCal

private

Definition at line 44 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 48 of file TrackingMaterialAnalyser.h.

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

m_saveDetailedPlots

bool TrackingMaterialAnalyser::m_saveDetailedPlots

private

Definition at line 41 of file TrackingMaterialAnalyser.h.

Referenced by endJob(), and TrackingMaterialAnalyser().

m_saveParameters

bool TrackingMaterialAnalyser::m_saveParameters

private

Definition at line 42 of file TrackingMaterialAnalyser.h.

Referenced by endJob(), and TrackingMaterialAnalyser().

m_saveSummaryPlot

bool TrackingMaterialAnalyser::m_saveSummaryPlot

private

Definition at line 40 of file TrackingMaterialAnalyser.h.

Referenced by endJob(), and TrackingMaterialAnalyser().

m_saveXml

bool TrackingMaterialAnalyser::m_saveXml

private

Definition at line 43 of file TrackingMaterialAnalyser.h.

Referenced by endJob(), and TrackingMaterialAnalyser().

m_skipAfterLastDetector

bool TrackingMaterialAnalyser::m_skipAfterLastDetector

private

Definition at line 38 of file TrackingMaterialAnalyser.h.

Referenced by split(), and TrackingMaterialAnalyser().

m_skipBeforeFirstDetector

bool TrackingMaterialAnalyser::m_skipBeforeFirstDetector

private

Definition at line 39 of file TrackingMaterialAnalyser.h.

Referenced by split(), and TrackingMaterialAnalyser().

m_splitMode

SplitMode TrackingMaterialAnalyser::m_splitMode

private

Definition at line 37 of file TrackingMaterialAnalyser.h.

Referenced by split(), and TrackingMaterialAnalyser().