Inheritance diagram for DD4hep_ListGroups:

Public Member Functions
	DD4hep_ListGroups (const edm::ParameterSet &iConfig)

	~DD4hep_ListGroups () 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

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 Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

void	endJob () override

void	fillColor ()

void	fillGradient ()

void	fillMaterialDifferences ()

std::vector< std::pair< std::shared_ptr< TLine >, std::shared_ptr< TText > > >	overlayEtaReferences ()

void	produceAndSaveSummaryPlot (const cms::DDCompactView &cpv)

Private Attributes
const edm::ESGetToken< cms::DDCompactView, IdealGeometryRecord >	ddToken_

std::vector< unsigned int >	m_color

std::map< std::string, std::pair< float, float > >	m_diff

std::vector< int >	m_gradient

std::set< std::string_view >	m_group_names

std::vector< DD4hep_MaterialAccountingGroup * >	m_groups

std::vector< TH2F * >	m_plots

const bool	m_saveSummaryPlot

const edm::ESInputTag	m_tag

std::map< std::string, std::pair< float, float > >	m_values

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 36 of file DD4hep_ListGroups.cc.

Constructor & Destructor Documentation

◆ DD4hep_ListGroups()

DD4hep_ListGroups::DD4hep_ListGroups ( const edm::ParameterSet & iConfig )

Definition at line 66 of file DD4hep_ListGroups.cc.

References fillColor(), fillGradient(), fillMaterialDifferences(), m_groups, and m_plots.

     : m_tag(iConfig.getParameter<edm::ESInputTag>("DDDetector")),
       m_saveSummaryPlot(iConfig.getUntrackedParameter<bool>("SaveSummaryPlot")),
       ddToken_(esConsumes<cms::DDCompactView, IdealGeometryRecord>(m_tag)) {
   m_plots.clear();
   m_groups.clear();
   TColor::InitializeColors();
   fillColor();
   fillMaterialDifferences();
   fillGradient();
 }

◆ ~DD4hep_ListGroups()

DD4hep_ListGroups::~DD4hep_ListGroups ( )

override

Definition at line 78 of file DD4hep_ListGroups.cc.

78 {}

Member Function Documentation

◆ analyze()

void DD4hep_ListGroups::analyze	(	const edm::Event &	evt,
		const edm::EventSetup &	setup
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 366 of file DD4hep_ListGroups.cc.

References class-composition::children, ddToken_, ALCARECOTkAlBeamHalo_cff::filter, mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, m_group_names, m_saveSummaryPlot, castor_dqm_sourceclient_file_cfg::path, produceAndSaveSummaryPlot(), singleTopDQM_cfi::setup, cms::DDFilteredView::specpars(), and submitPVValidationJobs::t.

                                                                                {
   edm::ESTransientHandle<cms::DDCompactView> cpv = setup.getTransientHandle(ddToken_);
   cms::DDFilter filter("TrackingMaterialGroup", "");
   cms::DDFilteredView fv(*cpv, filter);
 
   for (const auto &t : fv.specpars()) {
     m_group_names.insert(t.second->strValue("TrackingMaterialGroup"));
   }
 
   for (const auto &i : m_group_names) {
     cms::DDFilter filter1("TrackingMaterialGroup", {i.data(), i.size()});
     cms::DDFilteredView fv1(*cpv, filter1);
     bool firstChild = fv1.firstChild();
 
     for (const auto &j : fv1.specpars()) {
       for (const auto &k : j.second->paths) {
         if (firstChild) {
           std::vector<std::vector<cms::Node *>> children = fv1.children(k);
           for (auto const &path : children) {
             for (auto const &node : path) {
               edm::LogVerbatim("TrackingMaterialGroup") << node->GetName() << "/";
             }
             cms::Translation trans = fv1.translation(path);
             edm::LogVerbatim("TrackingMaterialGroup")
                 << "(" << trans.x() << ", " << trans.y() << ", " << trans.z() << ")\n";
           }
         }
       }
     }
   }
 
   if (m_saveSummaryPlot)
     produceAndSaveSummaryPlot(*cpv);
 }

◆ beginJob()

void DD4hep_ListGroups::beginJob ( void )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 43 of file DD4hep_ListGroups.cc.

43 {}

◆ endJob()

void DD4hep_ListGroups::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 401 of file DD4hep_ListGroups.cc.

401 {}

◆ fillColor()

void DD4hep_ListGroups::fillColor ( void )

private

Definition at line 196 of file DD4hep_ListGroups.cc.

References m_color.

Referenced by DD4hep_ListGroups().

                                       {
   // With the introduction of the support for PhaseI and PhaseII detectors it
   // became quite difficult to maintain a list of colors that is in sync with
   // the real number of grouping used in the different scenarios. We therefore
   // define some reasonable set and loop over it in case the number of grouping
   // is larger than the number of colors.
 
   m_color.emplace_back(kBlack);  // unassigned
 
   m_color.emplace_back(kAzure);      // PixelBarrelLayer0_Z0
   m_color.emplace_back(kAzure - 1);  // PixelBarrelLayer0_Z20
   m_color.emplace_back(kAzure + 1);  // Layer1_Z0
   m_color.emplace_back(kAzure + 2);  // Layer1_Z20
 
   m_color.emplace_back(kGreen);       // EndCapDisk1_R0
   m_color.emplace_back(kGreen + 2);   // EndcapDisk1_R11
   m_color.emplace_back(kGreen + 4);   // EndcapDisk1_R7
   m_color.emplace_back(kSpring + 9);  // EndcapDisk2_R0
   m_color.emplace_back(kSpring + 4);  // EndcapDisk2_R7
   m_color.emplace_back(kSpring);      // EndcapDisk2_R7
 
   m_color.emplace_back(kRed);          // TECDisk0_R20
   m_color.emplace_back(kRed + 2);      // TECDisk0_R40
   m_color.emplace_back(kRed - 7);      // TECDisk0_R50
   m_color.emplace_back(kRed - 5);      // TECDisk0_R60
   m_color.emplace_back(kRed - 10);     // TECDisk0_R90
   m_color.emplace_back(kRed - 1);      // TECDisk1_Inner
   m_color.emplace_back(kRed - 2);      // TECDisk1_Outer
   m_color.emplace_back(kRed - 3);      // TECDisk1_R20
   m_color.emplace_back(kPink - 2);     // TECDisk2_Inner
   m_color.emplace_back(kPink - 3);     // TECDisk2_Outer
   m_color.emplace_back(kPink - 4);     // TECDisk2_R20
   m_color.emplace_back(kPink + 9);     // TECDisk3_Inner
   m_color.emplace_back(kPink + 8);     // TECDisk3_Outer
   m_color.emplace_back(kPink + 7);     // TECDisk3
   m_color.emplace_back(kMagenta - 2);  // TECDisk4_Inner
   m_color.emplace_back(kMagenta - 3);  // TECDisk4_Outer
   m_color.emplace_back(kMagenta - 4);  // TECDisk4_R33
   m_color.emplace_back(kMagenta - 5);  // TECDisk5_Inner
   m_color.emplace_back(kMagenta - 6);  // TECDisk5_Outer
   m_color.emplace_back(kMagenta - 7);  // TECDisk5_R33
   m_color.emplace_back(kRed);          // TECDisk6
   m_color.emplace_back(kMagenta - 9);  // TECDisk7_R40
   m_color.emplace_back(kViolet);       // TECDisk8
 
   m_color.emplace_back(kOrange + 9);   // TIBLayer0_Z0
   m_color.emplace_back(kOrange + 7);   // TIBLayer0_Z20
   m_color.emplace_back(kOrange + 5);   // TIBLayer0_Z40
   m_color.emplace_back(kOrange - 2);   // TIBLayer1_Z0
   m_color.emplace_back(kOrange - 3);   // TIBLayer1_Z30
   m_color.emplace_back(kOrange - 6);   // TIBLayer1_Z60
   m_color.emplace_back(kOrange + 4);   // TIBLayer2_Z0
   m_color.emplace_back(kOrange - 7);   // TIBLayer2_Z40
   m_color.emplace_back(kOrange);       // TIBLayer3_Z0
   m_color.emplace_back(kOrange + 10);  // TIBLayer3_Z50
 
   m_color.emplace_back(kViolet + 10);  // TIDDisk1_R0
   m_color.emplace_back(kViolet + 6);   // TIDDisk1_R30
   m_color.emplace_back(kViolet + 3);   // TIDDisk1_R40
   m_color.emplace_back(kViolet - 7);   // TIDDisk2_R25
   m_color.emplace_back(kViolet - 1);   // TIDDisk2_R30
   m_color.emplace_back(kViolet + 9);   // TIDDisk2_R40
   m_color.emplace_back(kViolet - 5);   // TIDDisk3_R24
   m_color.emplace_back(kViolet - 3);   // TIDDisk3_R30
   m_color.emplace_back(kViolet);       // TIDDisk3_R40
 
   m_color.emplace_back(kAzure);      // TOBLayer0_Z0
   m_color.emplace_back(kAzure + 8);  // TOBLayer0_Z20
   m_color.emplace_back(kAzure + 2);  // TOBLayer0_Z70
   m_color.emplace_back(kAzure + 4);  // TOBLayer0_Z80
   m_color.emplace_back(kCyan + 1);   // TOBLayer1_Z0
   m_color.emplace_back(kCyan - 9);   // TOBLayer1_Z20
   m_color.emplace_back(kCyan + 3);   // TOBLayer1_Z80
   m_color.emplace_back(kCyan + 4);   // TOBLayer1_Z90
   m_color.emplace_back(kAzure);      // TOBLayer2_Z0
   m_color.emplace_back(kAzure + 8);  // TOBLayer2_Z25
   m_color.emplace_back(kAzure + 2);  // TOBLayer2_Z80
   m_color.emplace_back(kAzure + 5);  // TOBLayer2_Z90
   m_color.emplace_back(kCyan + 1);   // TOBLayer3_Z0
   m_color.emplace_back(kCyan - 9);   // TOBLayer3_Z25
   m_color.emplace_back(kCyan + 3);   // TOBLayer3_Z80
   m_color.emplace_back(kCyan + 4);   // TOBLayer3_Z90
   m_color.emplace_back(kAzure);      // TOBLayer4_Z0
   m_color.emplace_back(kAzure + 8);  // TOBLayer4_Z25
   m_color.emplace_back(kAzure + 2);  // TOBLayer4_Z80
   m_color.emplace_back(kAzure + 5);  // TOBLayer4_Z90
   m_color.emplace_back(kCyan + 1);   // TOBLayer5_Z0
   m_color.emplace_back(kCyan - 9);   // TOBLayer5_Z25
   m_color.emplace_back(kCyan + 3);   // TOBLayer5_Z80
   m_color.emplace_back(kCyan + 4);   // TOBLayer5_Z90
 }

◆ fillGradient()

void DD4hep_ListGroups::fillGradient ( )

private

Definition at line 288 of file DD4hep_ListGroups.cc.

References b1, b2, hitfit::delta_r(), diffTwoXMLs::g1, diffTwoXMLs::g2, mps_fire::i, cuy::ii, m_gradient, diffTwoXMLs::r1, diffTwoXMLs::r2, and customisers::steps.

Referenced by DD4hep_ListGroups().

                                      {
   m_gradient.reserve(200);
   unsigned int steps = 100;
   // if no index was given, find the highest used one and start from that plus one
   unsigned int index = ((TObjArray *)gROOT->GetListOfColors())->GetLast() + 1;
 
   float r1, g1, b1, r2, g2, b2;
   static_cast<TColor *>(gROOT->GetListOfColors()->At(kBlue + 1))->GetRGB(r1, g1, b1);
   static_cast<TColor *>(gROOT->GetListOfColors()->At(kAzure + 10))->GetRGB(r2, g2, b2);
   float delta_r = (r2 - r1) / (steps - 1);
   float delta_g = (g2 - g1) / (steps - 1);
   float delta_b = (b2 - b1) / (steps - 1);
 
   m_gradient.emplace_back(kBlue + 4);  // Underflow lowest bin
   unsigned int ii = 0;
   for (unsigned int i = 0; i < steps; ++i, ++ii) {
     new TColor(static_cast<Int_t>(index + ii), r1 + delta_r * i, g1 + delta_g * i, b1 + delta_b * i);
     m_gradient.emplace_back(index + ii);
   }
 
   m_gradient.emplace_back(kWhite);  // 0 level perfectly white
 
   static_cast<TColor *>(gROOT->GetListOfColors()->At(kOrange))->GetRGB(r1, g1, b1);
   static_cast<TColor *>(gROOT->GetListOfColors()->At(kOrange + 7))->GetRGB(r2, g2, b2);
   delta_r = (r2 - r1) / (steps - 1);
   delta_g = (g2 - g1) / (steps - 1);
   delta_b = (b2 - b1) / (steps - 1);
   for (unsigned int i = 0; i < steps; ++i, ++ii) {
     new TColor(static_cast<Int_t>(index + ii), r1 + delta_r * i, g1 + delta_g * i, b1 + delta_b * i);
     m_gradient.emplace_back(index + ii);
   }
   m_gradient.emplace_back(kRed);  // Overflow highest bin
 }

◆ fillMaterialDifferences()

void DD4hep_ListGroups::fillMaterialDifferences ( )

inlineprivate

Definition at line 6 of file DD4hep_ListGroupsMaterialDifference.h.

Referenced by DD4hep_ListGroups().

6 {}

◆ overlayEtaReferences()

std::vector< std::pair< std::shared_ptr< TLine >, std::shared_ptr< TText > > > DD4hep_ListGroups::overlayEtaReferences ( )

private

Definition at line 322 of file DD4hep_ListGroups.cc.

References PbPb_ZMuSkimMuonDPG_cff::deltaR, l1tTrackerHTMiss_cfi::deltaZ, PVValHelper::eta, JetChargeProducer_cfi::exp, groupFilesInBlocks::lines, funct::tan(), and theta().

Referenced by produceAndSaveSummaryPlot().

                                                                                                        {
   std::vector<std::pair<std::shared_ptr<TLine>, std::shared_ptr<TText>>> lines;
 
   lines.reserve(40);
   std::pair<float, float> deltaZ(293, 298);
   std::pair<float, float> deltaR(115, 118);
   float text_size = 0.033;
 
   for (float eta = 0.; eta <= 3.8; eta += 0.2) {
     float theta = 2. * atan(exp(-eta));
     if (eta >= 1.8) {
       lines.emplace_back(
           std::make_shared<TLine>(deltaZ.first, deltaZ.first * tan(theta), deltaZ.second, deltaZ.second * tan(theta)),
           std::make_shared<TText>(deltaZ.first, deltaZ.first * tan(theta), fmt::sprintf("%2.1f", eta).c_str()));
       lines.back().second->SetTextFont(42);
       lines.back().second->SetTextSize(text_size);
       lines.back().second->SetTextAlign(33);
       lines.emplace_back(
           std::make_shared<TLine>(-deltaZ.first, deltaZ.first * tan(theta), -deltaZ.second, deltaZ.second * tan(theta)),
           std::make_shared<TText>(-deltaZ.first, deltaZ.first * tan(theta), fmt::sprintf("-%2.1f", eta).c_str()));
       lines.back().second->SetTextFont(42);
       lines.back().second->SetTextSize(text_size);
       lines.back().second->SetTextAlign(13);
     } else {
       lines.emplace_back(
           std::make_shared<TLine>(deltaR.first / tan(theta), deltaR.first, deltaR.second / tan(theta), deltaR.second),
           std::make_shared<TText>(deltaR.first / tan(theta), deltaR.first, fmt::sprintf("%2.1f", eta).c_str()));
       lines.back().second->SetTextFont(42);
       lines.back().second->SetTextSize(text_size);
       lines.back().second->SetTextAlign(23);
       if (eta != 0) {
         lines.emplace_back(
             std::make_shared<TLine>(
                 -deltaR.first / tan(theta), deltaR.first, -deltaR.second / tan(theta), deltaR.second),
             std::make_shared<TText>(-deltaR.first / tan(theta), deltaR.first, fmt::sprintf("-%2.1f", eta).c_str()));
         lines.back().second->SetTextFont(42);
         lines.back().second->SetTextSize(text_size);
         lines.back().second->SetTextAlign(23);
       }
     }
   }
   return lines;
 }

◆ produceAndSaveSummaryPlot()

void DD4hep_ListGroups::produceAndSaveSummaryPlot ( const cms::DDCompactView & cpv )

private

Definition at line 80 of file DD4hep_ListGroups.cc.

References svgfig::canvas(), g, createfilelist::int, mps_splice::line, groupFilesInBlocks::lines, m_color, m_diff, m_gradient, m_group_names, m_groups, m_plots, m_values, dqmiodumpmetadata::n, overlayEtaReferences(), and pfClustersFromCombinedCaloHF_cfi::scale.

Referenced by analyze().

                                                                              {
   const double scale = 10.;
 
   static int markerStyles[10] = {kFullCircle,
                                  kFullSquare,
                                  kFullTriangleUp,
                                  kFullTriangleDown,
                                  kOpenCircle,
                                  kOpenSquare,
                                  kOpenTriangleUp,
                                  kOpenDiamond,
                                  kOpenCross,
                                  kFullStar};
 
   for (auto n : m_group_names) {
     m_groups.emplace_back(new DD4hep_MaterialAccountingGroup(n.data(), cpv));
   }
 
   auto canvas = std::make_unique<TCanvas>(
       "Grouping_rz", "Grouping - RZ view", (int)(600 * scale * 1.25), (int)(120 * scale * 1.50));
   canvas->GetFrame()->SetFillColor(kWhite);
   gStyle->SetOptStat(0);
 
   unsigned int color_index = 1;
 
   auto leg = std::make_unique<TLegend>(0.1, 0.1, 0.23, 0.34);
   leg->SetHeader("Tracker Material Grouping");
   leg->SetTextFont(42);
   leg->SetTextSize(0.008);
   leg->SetNColumns(3);
   auto radlen = std::make_unique<TProfile2D>("OverallRadLen", "OverallRadLen", 600., -300., 300, 120., 0., 120.);
   auto eneloss =
       std::make_unique<TProfile2D>("OverallEnergyLoss", "OverallEnergyLoss", 600., -300., 300, 120., 0., 120.);
   auto radlen_diff = std::make_unique<TProfile2D>(
       "OverallDifferencesRadLen", "OverallDifferencesRadLen", 600., -300., 300, 120., 0., 120.);
   auto eneloss_diff = std::make_unique<TProfile2D>(
       "OverallDifferencesEnergyLoss", "OverallDifferencesEnergyLoss", 600., -300., 300, 120., 0., 120.);
 
   for (auto g : m_groups) {
     m_plots.push_back(
         new TH2F(g->name().c_str(), g->name().c_str(), 6000., -300., 300, 1200., 0., 120.));  // 10x10 points per cm2
     TH2F &current = *m_plots.back();
     current.SetMarkerColor(m_color[color_index]);
     current.SetMarkerStyle(markerStyles[color_index % 10]);
     current.SetMarkerSize(0.8);
     current.SetLineWidth(1);
     for (const auto &element : g->elements()) {
       current.Fill(element.z(), element.perp());
       radlen->Fill(element.z(), element.perp(), m_values[g->name()].first);
       eneloss->Fill(element.z(), element.perp(), m_values[g->name()].second);
       radlen_diff->Fill(element.z(), element.perp(), m_diff[g->name()].first);
       eneloss_diff->Fill(element.z(), element.perp(), m_diff[g->name()].second);
     }
 
     if (color_index == 1)
       current.Draw();
     else
       current.Draw("SAME");
 
     leg->AddEntry(&current, g->name().c_str(), "lp")->SetTextColor(m_color[color_index]);
     color_index++;
 
     color_index = color_index % m_color.size();
   }
   leg->Draw();
   canvas->SaveAs("Grouping.png");
 
   std::vector<std::pair<std::shared_ptr<TLine>, std::shared_ptr<TText>>> lines = overlayEtaReferences();
 
   canvas->Clear();
   radlen->SetMinimum(0);
   radlen->SetMaximum(0.25);
   radlen->Draw("COLZ");
   for (const auto &line : lines) {
     line.first->SetLineWidth(5);
     line.first->Draw();
     line.second->Draw();
   }
   canvas->SaveAs("RadLenValues.png");
 
   canvas->Clear();
   eneloss->SetMinimum(0.00001);
   eneloss->SetMaximum(0.0005);
   eneloss->Draw("COLZ");
   for (const auto &line : lines) {
     line.first->SetLineWidth(5);
     line.first->Draw();
     line.second->Draw();
   }
   canvas->SaveAs("EnergyLossValues.png");
 
   canvas->Clear();
   gStyle->SetPalette(m_gradient.size(), &m_gradient.front());
   gStyle->SetNumberContours(m_gradient.size());
   radlen_diff->SetMinimum(-100);
   radlen_diff->SetMaximum(100);
   radlen_diff->Draw("COLZ");
   for (const auto &line : lines) {
     line.first->SetLineWidth(5);
     line.first->Draw();
     line.second->Draw();
   }
   canvas->SaveAs("RadLenChanges.png");
 
   canvas->Clear();
   eneloss_diff->SetMinimum(-100);
   eneloss_diff->SetMaximum(100);
   eneloss_diff->Draw("COLZ");
   for (const auto &line : lines) {
     line.first->SetLineWidth(5);
     line.first->Draw();
     line.second->Draw();
   }
   canvas->SaveAs("EnergyLossChanges.png");
 }

Member Data Documentation

◆ ddToken_

const edm::ESGetToken<cms::DDCompactView, IdealGeometryRecord> DD4hep_ListGroups::ddToken_

private

Definition at line 48 of file DD4hep_ListGroups.cc.

Referenced by analyze().

◆ m_color

std::vector<unsigned int> DD4hep_ListGroups::m_color

private

Definition at line 52 of file DD4hep_ListGroups.cc.

Referenced by fillColor(), and produceAndSaveSummaryPlot().

◆ m_diff

std::map<std::string, std::pair<float, float> > DD4hep_ListGroups::m_diff

private

Definition at line 60 of file DD4hep_ListGroups.cc.

Referenced by produceAndSaveSummaryPlot().

◆ m_gradient

std::vector<int> DD4hep_ListGroups::m_gradient

private

Definition at line 53 of file DD4hep_ListGroups.cc.

Referenced by fillGradient(), and produceAndSaveSummaryPlot().

◆ m_group_names

std::set<std::string_view> DD4hep_ListGroups::m_group_names

private

Definition at line 51 of file DD4hep_ListGroups.cc.

Referenced by analyze(), and produceAndSaveSummaryPlot().

◆ m_groups

std::vector<DD4hep_MaterialAccountingGroup *> DD4hep_ListGroups::m_groups

private

Definition at line 54 of file DD4hep_ListGroups.cc.

Referenced by DD4hep_ListGroups(), and produceAndSaveSummaryPlot().

◆ m_plots

std::vector<TH2F *> DD4hep_ListGroups::m_plots

private

Definition at line 50 of file DD4hep_ListGroups.cc.

Referenced by DD4hep_ListGroups(), and produceAndSaveSummaryPlot().

◆ m_saveSummaryPlot

const bool DD4hep_ListGroups::m_saveSummaryPlot

private

Definition at line 47 of file DD4hep_ListGroups.cc.

Referenced by analyze().

◆ m_tag

const edm::ESInputTag DD4hep_ListGroups::m_tag

private

Definition at line 46 of file DD4hep_ListGroups.cc.

◆ m_values

std::map<std::string, std::pair<float, float> > DD4hep_ListGroups::m_values

private

Definition at line 61 of file DD4hep_ListGroups.cc.

Referenced by produceAndSaveSummaryPlot().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DD4hep_ListGroups()

◆ ~DD4hep_ListGroups()

Member Function Documentation

◆ analyze()

◆ beginJob()

◆ endJob()

◆ fillColor()

◆ fillGradient()

◆ fillMaterialDifferences()

◆ overlayEtaReferences()

◆ produceAndSaveSummaryPlot()

Member Data Documentation

◆ ddToken_

◆ m_color

◆ m_diff

◆ m_gradient

◆ m_group_names

◆ m_groups

◆ m_plots

◆ m_saveSummaryPlot

◆ m_tag

◆ m_values