ListGroups Class Reference

Inheritance diagram for ListGroups:

Public Member Functions
	ListGroups (const edm::ParameterSet &)
	~ListGroups () override
Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
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
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Private 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 edm::EventSetup &)

Private Attributes
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 >	m_group_names
std::vector< MaterialAccountingGroup * >	m_groups
std::vector< TH2F * >	m_plots
bool	m_saveSummaryPlot
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)
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<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)

Detailed Description

Definition at line 77 of file ListGroups.cc.

Constructor & Destructor Documentation

ListGroups::ListGroups

(

const edm::ParameterSet &

iPSet

)

Definition at line 111 of file ListGroups.cc.

References fillColor(), fillGradient(), fillMaterialDifferences(), edm::ParameterSet::getUntrackedParameter(), m_groups, m_plots, and m_saveSummaryPlot.

                                                   {
  m_saveSummaryPlot = iPSet.getUntrackedParameter<bool>("SaveSummaryPlot");
  m_plots.clear();
  m_groups.clear();
  TColor::InitializeColors();
  fillColor();
  fillMaterialDifferences();
  fillGradient();
}

ListGroups::~ListGroups ( )

override

Definition at line 121 of file ListGroups.cc.

References g, m_groups, m_plots, and plotFactory::plot.

                        {
  for (auto plot : m_plots)
    delete plot;

  if (!m_groups.empty())
    for (auto g : m_groups)
      delete g;
}

Member Function Documentation

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

overrideprivate

Definition at line 560 of file ListGroups.cc.

References gather_cfg::cout, dddGetString(), ALCARECOTkAlBeamHalo_cff::filter, DDFilteredView::geoHistory(), edm::EventSetup::get(), h, m_group_names, m_saveSummaryPlot, DDFilteredView::next(), position, produceAndSaveSummaryPlot(), and DDFilteredView::translation().

                                                                        {
  edm::ESTransientHandle<DDCompactView> hDdd;
  setup.get<IdealGeometryRecord>().get(hDdd);

  DDSpecificsHasNamedValueFilter filter{"TrackingMaterialGroup"};
  DDFilteredView fv(*hDdd, filter);

  while (fv.next()) {
    // print the group name and full hierarchy of all items
    std::cout << dddGetString("TrackingMaterialGroup", fv) << '\t';
    m_group_names.insert(dddGetString("TrackingMaterialGroup", fv));

    // start from 2 to skip the leading /OCMS[0]/CMSE[1] part
    const DDGeoHistory &history = fv.geoHistory();
    std::cout << '/';
    for (unsigned int h = 2; h < history.size(); ++h)
      std::cout << '/' << history[h].logicalPart().name().name() << '[' << history[h].copyno() << ']';

    // DD3Vector and DDTranslation are the same type as math::XYZVector
    math::XYZVector position = fv.translation() / 10.;  // mm -> cm
    std::cout << "\t(" << position.x() << ", " << position.y() << ", " << position.z() << ") "
              << "[rho] " << position.Rho() << std::endl;
  };
  std::cout << std::endl;

  if (m_saveSummaryPlot)
    produceAndSaveSummaryPlot(setup);
}

void ListGroups::beginJob ( void  )

inlineoverrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 84 of file ListGroups.cc.

References endJob(), fillColor(), fillGradient(), fillMaterialDifferences(), overlayEtaReferences(), and produceAndSaveSummaryPlot().

{}

void ListGroups::endJob ( void  )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 589 of file ListGroups.cc.

References DEFINE_FWK_MODULE.

Referenced by beginJob().

{}

void ListGroups::fillColor ( void  )

private

Definition at line 297 of file ListGroups.cc.

References m_color.

Referenced by beginJob(), and 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.push_back(kBlack);  // unassigned

  m_color.push_back(kAzure);      // PixelBarrelLayer0_Z0
  m_color.push_back(kAzure - 1);  // PixelBarrelLayer0_Z20
  m_color.push_back(kAzure + 1);  // Layer1_Z0
  m_color.push_back(kAzure + 2);  // Layer1_Z20

  m_color.push_back(kGreen);       // EndCapDisk1_R0
  m_color.push_back(kGreen + 2);   // EndcapDisk1_R11
  m_color.push_back(kGreen + 4);   // EndcapDisk1_R7
  m_color.push_back(kSpring + 9);  // EndcapDisk2_R0
  m_color.push_back(kSpring + 4);  // EndcapDisk2_R7
  m_color.push_back(kSpring);      // EndcapDisk2_R7

  m_color.push_back(kRed);          // TECDisk0_R20
  m_color.push_back(kRed + 2);      // TECDisk0_R40
  m_color.push_back(kRed - 7);      // TECDisk0_R50
  m_color.push_back(kRed - 5);      // TECDisk0_R60
  m_color.push_back(kRed - 10);     // TECDisk0_R90
  m_color.push_back(kRed - 1);      // TECDisk1_Inner
  m_color.push_back(kRed - 2);      // TECDisk1_Outer
  m_color.push_back(kRed - 3);      // TECDisk1_R20
  m_color.push_back(kPink - 2);     // TECDisk2_Inner
  m_color.push_back(kPink - 3);     // TECDisk2_Outer
  m_color.push_back(kPink - 4);     // TECDisk2_R20
  m_color.push_back(kPink + 9);     // TECDisk3_Inner
  m_color.push_back(kPink + 8);     // TECDisk3_Outer
  m_color.push_back(kPink + 7);     // TECDisk3
  m_color.push_back(kMagenta - 2);  // TECDisk4_Inner
  m_color.push_back(kMagenta - 3);  // TECDisk4_Outer
  m_color.push_back(kMagenta - 4);  // TECDisk4_R33
  m_color.push_back(kMagenta - 5);  // TECDisk5_Inner
  m_color.push_back(kMagenta - 6);  // TECDisk5_Outer
  m_color.push_back(kMagenta - 7);  // TECDisk5_R33
  m_color.push_back(kRed);          // TECDisk6
  m_color.push_back(kMagenta - 9);  // TECDisk7_R40
  m_color.push_back(kViolet);       // TECDisk8

  m_color.push_back(kOrange + 9);   // TIBLayer0_Z0
  m_color.push_back(kOrange + 7);   // TIBLayer0_Z20
  m_color.push_back(kOrange + 5);   // TIBLayer0_Z40
  m_color.push_back(kOrange - 2);   // TIBLayer1_Z0
  m_color.push_back(kOrange - 3);   // TIBLayer1_Z30
  m_color.push_back(kOrange - 6);   // TIBLayer1_Z60
  m_color.push_back(kOrange + 4);   // TIBLayer2_Z0
  m_color.push_back(kOrange - 7);   // TIBLayer2_Z40
  m_color.push_back(kOrange);       // TIBLayer3_Z0
  m_color.push_back(kOrange + 10);  // TIBLayer3_Z50

  m_color.push_back(kViolet + 10);  // TIDDisk1_R0
  m_color.push_back(kViolet + 6);   // TIDDisk1_R30
  m_color.push_back(kViolet + 3);   // TIDDisk1_R40
  m_color.push_back(kViolet - 7);   // TIDDisk2_R25
  m_color.push_back(kViolet - 1);   // TIDDisk2_R30
  m_color.push_back(kViolet + 9);   // TIDDisk2_R40
  m_color.push_back(kViolet - 5);   // TIDDisk3_R24
  m_color.push_back(kViolet - 3);   // TIDDisk3_R30
  m_color.push_back(kViolet);       // TIDDisk3_R40

  m_color.push_back(kAzure);      // TOBLayer0_Z0
  m_color.push_back(kAzure + 8);  // TOBLayer0_Z20
  m_color.push_back(kAzure + 2);  // TOBLayer0_Z70
  m_color.push_back(kAzure + 4);  // TOBLayer0_Z80
  m_color.push_back(kCyan + 1);   // TOBLayer1_Z0
  m_color.push_back(kCyan - 9);   // TOBLayer1_Z20
  m_color.push_back(kCyan + 3);   // TOBLayer1_Z80
  m_color.push_back(kCyan + 4);   // TOBLayer1_Z90
  m_color.push_back(kAzure);      // TOBLayer2_Z0
  m_color.push_back(kAzure + 8);  // TOBLayer2_Z25
  m_color.push_back(kAzure + 2);  // TOBLayer2_Z80
  m_color.push_back(kAzure + 5);  // TOBLayer2_Z90
  m_color.push_back(kCyan + 1);   // TOBLayer3_Z0
  m_color.push_back(kCyan - 9);   // TOBLayer3_Z25
  m_color.push_back(kCyan + 3);   // TOBLayer3_Z80
  m_color.push_back(kCyan + 4);   // TOBLayer3_Z90
  m_color.push_back(kAzure);      // TOBLayer4_Z0
  m_color.push_back(kAzure + 8);  // TOBLayer4_Z25
  m_color.push_back(kAzure + 2);  // TOBLayer4_Z80
  m_color.push_back(kAzure + 5);  // TOBLayer4_Z90
  m_color.push_back(kCyan + 1);   // TOBLayer5_Z0
  m_color.push_back(kCyan - 9);   // TOBLayer5_Z25
  m_color.push_back(kCyan + 3);   // TOBLayer5_Z80
  m_color.push_back(kCyan + 4);   // TOBLayer5_Z90
}

void ListGroups::fillGradient ( void  )

private

Definition at line 263 of file ListGroups.cc.

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

Referenced by beginJob(), and 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.push_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.push_back(index + ii);
  }

  m_gradient.push_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.push_back(index + ii);
  }
  m_gradient.push_back(kRed);  // Overflow highest bin
}

void ListGroups::fillMaterialDifferences ( )

private

Definition at line 130 of file ListGroups.cc.

References m_diff, and m_values.

Referenced by beginJob(), and ListGroups().

                                         {
  m_diff["TrackerRecMaterialTIBLayer0_Z20"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk0_R60"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer1_Z80"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer4_Z0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer2_Z0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer0_Z70"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk0_R20"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer5_Z80"] = std::make_pair<float, float>(338.028085, 425.909863);
  m_diff["TrackerRecMaterialPixelEndcapDisk1Fw_Outer"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk1_R20"] = std::make_pair<float, float>(19.426752, 17.294518);
  m_diff["TrackerRecMaterialTOBLayer5_Z0"] = std::make_pair<float, float>(510.125226, 651.305054);
  m_diff["TrackerRecMaterialTECDisk8"] = std::make_pair<float, float>(1098.073793, 778.542517);
  m_diff["TrackerRecMaterialTIDDisk3_R24"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk4_R33"] = std::make_pair<float, float>(51.925713, 42.900250);
  m_diff["TrackerRecMaterialTIBLayer1_Z0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelEndcapDisk1Bw_Outer"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIDDisk2_R25"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIBLayer0_Z0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer3_Z25"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIBLayer1_Z30"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIDDisk2_R40"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIBLayer2_Z40"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer1_Z20"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelEndcapDisk2Bw_Inner"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer0_Z0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelBarrelLayer0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelBarrelLayer3"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIBLayer3_Z0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer3_Z80"] = std::make_pair<float, float>(118.048766, 116.983451);
  m_diff["TrackerRecMaterialTOBLayer4_Z80"] = std::make_pair<float, float>(210.657923, 218.401623);
  m_diff["TrackerRecMaterialTECDisk5_R33"] = std::make_pair<float, float>(69.556218, 54.695749);
  m_diff["TrackerRecMaterialTOBLayer0_Z20"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIBLayer2_Z0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk2_R20"] = std::make_pair<float, float>(43.042551, 39.124220);
  m_diff["TrackerRecMaterialPixelEndcapDisk1Bw_Inner"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIDDisk1_R30"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk0_R50"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer5_Z25"] = std::make_pair<float, float>(308.073141, 389.306637);
  m_diff["TrackerRecMaterialPixelEndcapDisk2Bw_Outer"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIBLayer3_Z50"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk3"] = std::make_pair<float, float>(40.109901, 34.382246);
  m_diff["TrackerRecMaterialPixelBarrelLayer1"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelBarrelLayer2_External"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelEndcapDisk2Fw_Inner"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk7_R40"] = std::make_pair<float, float>(219.144902, 162.590326);
  m_diff["TrackerRecMaterialPixelEndcapDisk3Bw_Inner"] = std::make_pair<float, float>(594.908414, 558.979032);
  m_diff["TrackerRecMaterialPixelEndcapDisk2Fw_Outer"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelEndcapDisk3Fw_Outer"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk6"] = std::make_pair<float, float>(85.692825, 67.990698);
  m_diff["TrackerRecMaterialTOBLayer3_Z0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelBarrelLayer2"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelBarrelLayer3_External"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelEndcapDisk3Fw_Inner"] = std::make_pair<float, float>(607.142137, 570.407286);
  m_diff["TrackerRecMaterialTOBLayer2_Z25"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelEndcapDisk3Bw_Outer"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelBarrelLayer0_External"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk0_R90"] = std::make_pair<float, float>(59.694180, 74.636115);
  m_diff["TrackerRecMaterialTOBLayer1_Z0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIDDisk1_R0"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialPixelBarrelLayer1_External"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer4_Z25"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTOBLayer2_Z80"] = std::make_pair<float, float>(2.291492, 2.290657);
  m_diff["TrackerRecMaterialPixelEndcapDisk1Fw_Inner"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTECDisk0_R40"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_diff["TrackerRecMaterialTIDDisk2_R30"] = std::make_pair<float, float>(0.000000, 0.000000);
  m_values["TrackerRecMaterialTIBLayer0_Z20"] = std::make_pair<float, float>(0.076264, 0.000162);
  m_values["TrackerRecMaterialTECDisk0_R60"] = std::make_pair<float, float>(0.199482, 0.000368);
  m_values["TrackerRecMaterialTOBLayer1_Z80"] = std::make_pair<float, float>(0.075550, 0.000145);
  m_values["TrackerRecMaterialTOBLayer4_Z0"] = std::make_pair<float, float>(0.014804, 0.000033);
  m_values["TrackerRecMaterialTOBLayer2_Z0"] = std::make_pair<float, float>(0.014947, 0.000033);
  m_values["TrackerRecMaterialTOBLayer0_Z70"] = std::make_pair<float, float>(0.104496, 0.000208);
  m_values["TrackerRecMaterialTECDisk0_R20"] = std::make_pair<float, float>(0.177496, 0.000419);
  m_values["TrackerRecMaterialTOBLayer5_Z80"] = std::make_pair<float, float>(0.095700, 0.000224);
  m_values["TrackerRecMaterialPixelEndcapDisk1Fw_Outer"] = std::make_pair<float, float>(0.063054, 0.000139);
  m_values["TrackerRecMaterialTECDisk1_R20"] = std::make_pair<float, float>(0.086704, 0.000189);
  m_values["TrackerRecMaterialTOBLayer5_Z0"] = std::make_pair<float, float>(0.060576, 0.000155);
  m_values["TrackerRecMaterialTECDisk8"] = std::make_pair<float, float>(0.329777, 0.000532);
  m_values["TrackerRecMaterialTIDDisk3_R24"] = std::make_pair<float, float>(0.154447, 0.000366);
  m_values["TrackerRecMaterialTECDisk4_R33"] = std::make_pair<float, float>(0.072594, 0.000158);
  m_values["TrackerRecMaterialTIBLayer1_Z0"] = std::make_pair<float, float>(0.049604, 0.000102);
  m_values["TrackerRecMaterialPixelEndcapDisk1Bw_Outer"] = std::make_pair<float, float>(0.065873, 0.000145);
  m_values["TrackerRecMaterialTIDDisk2_R25"] = std::make_pair<float, float>(0.067206, 0.000166);
  m_values["TrackerRecMaterialTIBLayer0_Z0"] = std::make_pair<float, float>(0.056395, 0.000125);
  m_values["TrackerRecMaterialTOBLayer3_Z25"] = std::make_pair<float, float>(0.035290, 0.000071);
  m_values["TrackerRecMaterialTIBLayer1_Z30"] = std::make_pair<float, float>(0.068299, 0.000137);
  m_values["TrackerRecMaterialTIDDisk2_R40"] = std::make_pair<float, float>(0.143121, 0.000310);
  m_values["TrackerRecMaterialTIBLayer2_Z40"] = std::make_pair<float, float>(0.077840, 0.000155);
  m_values["TrackerRecMaterialTOBLayer1_Z20"] = std::make_pair<float, float>(0.051913, 0.000103);
  m_values["TrackerRecMaterialPixelEndcapDisk2Bw_Inner"] = std::make_pair<float, float>(0.039093, 0.000090);
  m_values["TrackerRecMaterialTOBLayer0_Z0"] = std::make_pair<float, float>(0.029002, 0.000069);
  m_values["TrackerRecMaterialPixelBarrelLayer0"] = std::make_pair<float, float>(0.018043, 0.000038);
  m_values["TrackerRecMaterialPixelBarrelLayer3"] = std::make_pair<float, float>(0.020661, 0.000042);
  m_values["TrackerRecMaterialTIBLayer3_Z0"] = std::make_pair<float, float>(0.048101, 0.000110);
  m_values["TrackerRecMaterialTOBLayer3_Z80"] = std::make_pair<float, float>(0.093979, 0.000181);
  m_values["TrackerRecMaterialTOBLayer4_Z80"] = std::make_pair<float, float>(0.101240, 0.000203);
  m_values["TrackerRecMaterialTECDisk5_R33"] = std::make_pair<float, float>(0.092564, 0.000201);
  m_values["TrackerRecMaterialTOBLayer0_Z20"] = std::make_pair<float, float>(0.063558, 0.000138);
  m_values["TrackerRecMaterialTIBLayer2_Z0"] = std::make_pair<float, float>(0.036854, 0.000078);
  m_values["TrackerRecMaterialTECDisk2_R20"] = std::make_pair<float, float>(0.107900, 0.000237);
  m_values["TrackerRecMaterialPixelEndcapDisk1Bw_Inner"] = std::make_pair<float, float>(0.039143, 0.000086);
  m_values["TrackerRecMaterialTIDDisk1_R30"] = std::make_pair<float, float>(0.167774, 0.000321);
  m_values["TrackerRecMaterialTECDisk0_R50"] = std::make_pair<float, float>(0.108277, 0.000255);
  m_values["TrackerRecMaterialTOBLayer5_Z25"] = std::make_pair<float, float>(0.086612, 0.000209);
  m_values["TrackerRecMaterialPixelEndcapDisk2Bw_Outer"] = std::make_pair<float, float>(0.070143, 0.000165);
  m_values["TrackerRecMaterialTIBLayer3_Z50"] = std::make_pair<float, float>(0.063872, 0.000138);
  m_values["TrackerRecMaterialTECDisk3"] = std::make_pair<float, float>(0.064126, 0.000139);
  m_values["TrackerRecMaterialPixelBarrelLayer1"] = std::make_pair<float, float>(0.016379, 0.000028);
  m_values["TrackerRecMaterialPixelBarrelLayer2_External"] = std::make_pair<float, float>(0.026687, 0.000046);
  m_values["TrackerRecMaterialPixelEndcapDisk2Fw_Inner"] = std::make_pair<float, float>(0.039737, 0.000091);
  m_values["TrackerRecMaterialTECDisk7_R40"] = std::make_pair<float, float>(0.126225, 0.000235);
  m_values["TrackerRecMaterialPixelEndcapDisk3Bw_Inner"] = std::make_pair<float, float>(0.674984, 0.001356);
  m_values["TrackerRecMaterialPixelEndcapDisk2Fw_Outer"] = std::make_pair<float, float>(0.065935, 0.000151);
  m_values["TrackerRecMaterialPixelEndcapDisk3Fw_Outer"] = std::make_pair<float, float>(0.100139, 0.000205);
  m_values["TrackerRecMaterialTECDisk6"] = std::make_pair<float, float>(0.078988, 0.000163);
  m_values["TrackerRecMaterialTOBLayer3_Z0"] = std::make_pair<float, float>(0.015009, 0.000033);
  m_values["TrackerRecMaterialPixelBarrelLayer2"] = std::make_pair<float, float>(0.017219, 0.000030);
  m_values["TrackerRecMaterialPixelBarrelLayer3_External"] = std::make_pair<float, float>(0.036152, 0.000066);
  m_values["TrackerRecMaterialPixelEndcapDisk3Fw_Inner"] = std::make_pair<float, float>(0.673782, 0.001357);
  m_values["TrackerRecMaterialTOBLayer2_Z25"] = std::make_pair<float, float>(0.034917, 0.000069);
  m_values["TrackerRecMaterialPixelEndcapDisk3Bw_Outer"] = std::make_pair<float, float>(0.100143, 0.000204);
  m_values["TrackerRecMaterialPixelBarrelLayer0_External"] = std::make_pair<float, float>(0.031128, 0.000062);
  m_values["TrackerRecMaterialTECDisk0_R90"] = std::make_pair<float, float>(0.309342, 0.000539);
  m_values["TrackerRecMaterialTOBLayer1_Z0"] = std::make_pair<float, float>(0.023489, 0.000050);
  m_values["TrackerRecMaterialTIDDisk1_R0"] = std::make_pair<float, float>(0.175180, 0.000349);
  m_values["TrackerRecMaterialPixelBarrelLayer1_External"] = std::make_pair<float, float>(0.022508, 0.000036);
  m_values["TrackerRecMaterialTOBLayer4_Z25"] = std::make_pair<float, float>(0.036056, 0.000073);
  m_values["TrackerRecMaterialTOBLayer2_Z80"] = std::make_pair<float, float>(0.062072, 0.000117);
  m_values["TrackerRecMaterialPixelEndcapDisk1Fw_Inner"] = std::make_pair<float, float>(0.039127, 0.000086);
  m_values["TrackerRecMaterialTECDisk0_R40"] = std::make_pair<float, float>(0.084231, 0.000209);
  m_values["TrackerRecMaterialTIDDisk2_R30"] = std::make_pair<float, float>(0.065109, 0.000143);
}

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

private

Definition at line 389 of file ListGroups.cc.

References boostedElectronIsolation_cff::deltaR, PVValHelper::eta, JetChargeProducer_cfi::exp, cmsPerfStripChart::format, groupFilesInBlocks::lines, str, funct::tan(), and theta().

Referenced by beginJob(), and 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.push_back(std::make_pair<std::shared_ptr<TLine>, std::shared_ptr<TText> >(
          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), str(boost::format("%2.1f") % eta).c_str())));
      lines.back().second->SetTextFont(42);
      lines.back().second->SetTextSize(text_size);
      lines.back().second->SetTextAlign(33);
      lines.push_back(std::make_pair<std::shared_ptr<TLine>, std::shared_ptr<TText> >(
          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), str(boost::format("-%2.1f") % eta).c_str())));
      lines.back().second->SetTextFont(42);
      lines.back().second->SetTextSize(text_size);
      lines.back().second->SetTextAlign(13);
    } else {
      lines.push_back(std::make_pair<std::shared_ptr<TLine>, std::shared_ptr<TText> >(
          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, str(boost::format("%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.push_back(std::make_pair<std::shared_ptr<TLine>, std::shared_ptr<TText> >(
            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, str(boost::format("-%2.1f") % eta).c_str())));
        lines.back().second->SetTextFont(42);
        lines.back().second->SetTextSize(text_size);
        lines.back().second->SetTextAlign(23);
      }
    }
  }
  return lines;
}

void ListGroups::produceAndSaveSummaryPlot ( const edm::EventSetup &  setup )

private

Definition at line 435 of file ListGroups.cc.

References svgfig::canvas(), g, edm::EventSetup::get(), create_public_lumi_plots::leg, mps_splice::line, groupFilesInBlocks::lines, m_color, m_diff, m_gradient, m_group_names, m_groups, m_plots, m_values, gen::n, overlayEtaReferences(), and Scenarios_cff::scale.

Referenced by analyze(), and beginJob().

                                                                     {
  const double scale = 10.;
  std::vector<TText *> nukem_text;
  static int markerStyles[10] = {kFullCircle,
                                 kFullSquare,
                                 kFullTriangleUp,
                                 kFullTriangleDown,
                                 kOpenCircle,
                                 kOpenSquare,
                                 kOpenTriangleUp,
                                 kOpenDiamond,
                                 kOpenCross,
                                 kFullStar};

  edm::ESTransientHandle<DDCompactView> hDdd;
  setup.get<IdealGeometryRecord>().get(hDdd);

  for (auto n : m_group_names) {
    m_groups.push_back(new MaterialAccountingGroup(n, *hDdd));
  };

  std::unique_ptr<TCanvas> canvas(
      new 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;
  // Setup the legend
  std::unique_ptr<TLegend> leg(new TLegend(0.1, 0.1, 0.23, 0.34));
  leg->SetHeader("Tracker Material Grouping");
  leg->SetTextFont(42);
  leg->SetTextSize(0.008);
  leg->SetNColumns(3);
  std::unique_ptr<TProfile2D> radlen(
      new TProfile2D("OverallRadLen", "OverallRadLen", 600., -300., 300, 120., 0., 120.));
  std::unique_ptr<TProfile2D> eneloss(
      new TProfile2D("OverallEnergyLoss", "OverallEnergyLoss", 600., -300., 300, 120., 0., 120.));
  std::unique_ptr<TProfile2D> radlen_diff(
      new TProfile2D("OverallDifferencesRadLen", "OverallDifferencesRadLen", 600., -300., 300, 120., 0., 120.));
  std::unique_ptr<TProfile2D> eneloss_diff(
      new 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 (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++;

    // Loop over the same chromatic scale in case the number of
    // allocated colors is not big enough.
    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 (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 (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 (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 (auto line : lines) {
    line.first->SetLineWidth(5);
    line.first->Draw();
    line.second->Draw();
  }
  canvas->SaveAs("EnergyLossChanges.png");

  for (auto g : nukem_text)
    delete g;
}

Member Data Documentation

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

private

Definition at line 95 of file ListGroups.cc.

Referenced by fillColor(), and produceAndSaveSummaryPlot().

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

private

Definition at line 107 of file ListGroups.cc.

Referenced by fillMaterialDifferences(), and produceAndSaveSummaryPlot().

std::vector<int> ListGroups::m_gradient

private

Definition at line 96 of file ListGroups.cc.

Referenced by fillGradient(), and produceAndSaveSummaryPlot().

std::set<std::string> ListGroups::m_group_names

private

Definition at line 93 of file ListGroups.cc.

Referenced by analyze(), and produceAndSaveSummaryPlot().

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

private

Definition at line 94 of file ListGroups.cc.

Referenced by ListGroups(), produceAndSaveSummaryPlot(), and ~ListGroups().

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

private

Definition at line 92 of file ListGroups.cc.

Referenced by ListGroups(), produceAndSaveSummaryPlot(), and ~ListGroups().

bool ListGroups::m_saveSummaryPlot

private

Definition at line 91 of file ListGroups.cc.

Referenced by analyze(), and ListGroups().

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

private

Definition at line 108 of file ListGroups.cc.

Referenced by fillMaterialDifferences(), and produceAndSaveSummaryPlot().