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 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 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 l1tEGammaCrystalsEmulatorProducer_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