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 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 const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
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::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
bool	registeredToConsumeMany (TypeID const &, 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::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
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 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<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_2023v12_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, pixelTopology::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, pixelTopology::layer, m_groups, and Skims_PA_cff::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, pixelTopology::layer, m_groups, and Skims_PA_cff::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(), DMR_cfg::cerr, MuonGeometrySanityCheck_cfi::detectors(), mps_fire::end, Exception, findLayer(), HLT_2023v12_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_2023v12_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().