#include <DD4hep_MaterialAccountingGroup.h>

Public Member Functions
bool	addDetector (const MaterialAccountingDetector &detector)

MaterialAccountingStep	average (void) const

double	averageEnergyLoss (void) const

double	averageLength (void) const

double	averageRadiationLengths (void) const

	DD4hep_MaterialAccountingGroup (const DD4hep_MaterialAccountingGroup &layer)=delete

	DD4hep_MaterialAccountingGroup (const std::string &name, const cms::DDCompactView &geometry)

const std::vector< GlobalPoint > &	elements (void) const

void	endOfTrack (void)

std::pair< double, double >	getBoundingR () const

std::pair< double, double >	getBoundingZ () const

std::string	info (void) const

bool	isInside (const MaterialAccountingDetector &detector) const

const std::string &	name (void) const

DD4hep_MaterialAccountingGroup &	operator= (const DD4hep_MaterialAccountingGroup &layer)=delete

void	savePlots (void)

double	sigmaEnergyLoss (void) const

double	sigmaLength (void) const

double	sigmaRadiationLengths (void) const

unsigned int	tracks (void) const

	~DD4hep_MaterialAccountingGroup (void)

Private Member Functions
void	savePlot (std::shared_ptr< TH1F > &plot, const std::string &name)

void	savePlot (std::shared_ptr< TProfile > &plot, float average, const std::string &name)

Private Attributes
MaterialAccountingStep	m_accounting

BoundingBox	m_boundingbox

MaterialAccountingStep	m_buffer

bool	m_counted

std::shared_ptr< TH1F >	m_dedx_spectrum

std::shared_ptr< TProfile >	m_dedx_vs_eta

std::shared_ptr< TProfile >	m_dedx_vs_r

std::shared_ptr< TProfile >	m_dedx_vs_z

std::vector< GlobalPoint >	m_elements

MaterialAccountingStep	m_errors

std::unique_ptr< TFile >	m_file

std::string	m_name

std::shared_ptr< TH1F >	m_radlen_spectrum

std::shared_ptr< TProfile >	m_radlen_vs_eta

std::shared_ptr< TProfile >	m_radlen_vs_r

std::shared_ptr< TProfile >	m_radlen_vs_z

unsigned int	m_tracks

Static Private Attributes
static constexpr double	s_tolerance = 0.01

Detailed Description

Definition at line 23 of file DD4hep_MaterialAccountingGroup.h.

Constructor & Destructor Documentation

◆ DD4hep_MaterialAccountingGroup() [1/2]

DD4hep_MaterialAccountingGroup::DD4hep_MaterialAccountingGroup ( const DD4hep_MaterialAccountingGroup & layer )

delete

◆ DD4hep_MaterialAccountingGroup() [2/2]

DD4hep_MaterialAccountingGroup::DD4hep_MaterialAccountingGroup	(	const std::string &	name,
		const cms::DDCompactView &	geometry
	)

Definition at line 21 of file DD4hep_MaterialAccountingGroup.cc.

     : m_name(name),
       m_elements(),
       m_boundingbox(),
       m_accounting(),
       m_errors(),
       m_tracks(0),
       m_counted(false),
       m_file(nullptr) {
   cms::DDFilter filter("TrackingMaterialGroup", {name.data(), name.size()});
   cms::DDFilteredView fv(geometry, filter);
   bool firstChild = fv.firstChild();
  
   edm::LogVerbatim("TrackingMaterialAnalysis") << "Elements within: " << name;
  
   for (const auto& j : fv.specpars()) {
     for (const auto& k : j.second->paths) {
       if (firstChild) {
         std::vector<std::vector<cms::Node*>> children = fv.children(k);
         for (auto const& path : children) {
           cms::Translation trans = fv.translation(path);
           GlobalPoint gp = GlobalPoint(trans.x(), trans.y(), trans.z());
           m_elements.emplace_back(gp);
           edm::LogVerbatim("TrackerMaterialAnalysis")
               << "MaterialAccountingGroup:\t"
               << "Adding element at (r,z) " << gp.perp() << "," << gp.z() << std::endl;
         }
       }
     }
   }
  
   for (unsigned int i = 0; i < m_elements.size(); ++i) {
     m_boundingbox.grow(m_elements[i].perp(), m_elements[i].z());
   }
  
   m_boundingbox.grow(s_tolerance);
  
   edm::LogVerbatim("TrackerMaterialAnalysis")
       << "MaterialAccountingGroup:\t"
       << "Final BBox r_range: " << m_boundingbox.range_r().first << ", " << m_boundingbox.range_r().second << std::endl
       << "Final BBox z_range: " << m_boundingbox.range_z().first << ", " << m_boundingbox.range_z().second << std::endl;
  
   m_dedx_spectrum = std::make_shared<TH1F>((m_name + "_dedx_spectrum").c_str(), "Energy loss spectrum", 1000, 0., 1.);
   m_radlen_spectrum =
       std::make_shared<TH1F>((m_name + "_radlen_spectrum").c_str(), "Radiation lengths spectrum", 1000, 0., 1.);
   m_dedx_vs_eta = std::make_shared<TProfile>((m_name + "_dedx_vs_eta").c_str(), "Energy loss vs. eta", 600, -3., 3.);
   m_dedx_vs_z = std::make_shared<TProfile>((m_name + "_dedx_vs_z").c_str(), "Energy loss vs. Z", 6000, -300., 300.);
   m_dedx_vs_r = std::make_shared<TProfile>((m_name + "_dedx_vs_r").c_str(), "Energy loss vs. R", 1200, 0., 120.);
   m_radlen_vs_eta =
       std::make_shared<TProfile>((m_name + "_radlen_vs_eta").c_str(), "Radiation lengths vs. eta", 600, -3., 3.);
   m_radlen_vs_z =
       std::make_shared<TProfile>((m_name + "_radlen_vs_z").c_str(), "Radiation lengths vs. Z", 6000, -300., 300.);
   m_radlen_vs_r =
       std::make_shared<TProfile>((m_name + "_radlen_vs_r").c_str(), "Radiation lengths vs. R", 1200, 0., 120.);
  
   m_dedx_spectrum->SetDirectory(nullptr);
   m_radlen_spectrum->SetDirectory(nullptr);
   m_dedx_vs_eta->SetDirectory(nullptr);
   m_dedx_vs_z->SetDirectory(nullptr);
   m_dedx_vs_r->SetDirectory(nullptr);
   m_radlen_vs_eta->SetDirectory(nullptr);
   m_radlen_vs_z->SetDirectory(nullptr);
   m_radlen_vs_r->SetDirectory(nullptr);
 }

References class-composition::children, ALCARECOTkAlBeamHalo_cff::filter, runTauDisplay::gp, BoundingBox::grow(), mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, m_boundingbox, m_dedx_spectrum, m_dedx_vs_eta, m_dedx_vs_r, m_dedx_vs_z, m_elements, m_name, m_radlen_spectrum, m_radlen_vs_eta, m_radlen_vs_r, m_radlen_vs_z, name(), castor_dqm_sourceclient_file_cfg::path, perp(), BoundingBox::range_r(), BoundingBox::range_z(), s_tolerance, and z.

◆ ~DD4hep_MaterialAccountingGroup()

DD4hep_MaterialAccountingGroup::~DD4hep_MaterialAccountingGroup ( void )

Member Function Documentation

◆ addDetector()

bool DD4hep_MaterialAccountingGroup::addDetector ( const MaterialAccountingDetector & detector )

Definition at line 117 of file DD4hep_MaterialAccountingGroup.cc.

                                                                                            {
   if (!isInside(detector))
     return false;
  
   m_buffer += detector.material();
   m_counted = true;
  
   return true;
 }

References hgcalTestNeighbor_cfi::detector, isInside(), m_buffer, and m_counted.

◆ average()

MaterialAccountingStep DD4hep_MaterialAccountingGroup::average ( void ) const

Definition at line 208 of file DD4hep_MaterialAccountingGroup.cc.

                                                                          {
   return m_tracks ? m_accounting / m_tracks : MaterialAccountingStep();
 }

References m_accounting, and m_tracks.

Referenced by endOfTrack().

◆ averageEnergyLoss()

double DD4hep_MaterialAccountingGroup::averageEnergyLoss ( void ) const

Definition at line 216 of file DD4hep_MaterialAccountingGroup.cc.

                                                                    {
   return m_tracks ? m_accounting.energyLoss() / m_tracks : 0.;
 }

References MaterialAccountingStep::energyLoss(), m_accounting, and m_tracks.

Referenced by DD4hep_TrackingMaterialAnalyser::saveParameters(), savePlots(), DD4hep_TrackingMaterialAnalyser::saveXml(), and sigmaEnergyLoss().

◆ averageLength()

double DD4hep_MaterialAccountingGroup::averageLength ( void ) const

Definition at line 212 of file DD4hep_MaterialAccountingGroup.cc.

                                                                {
   return m_tracks ? m_accounting.length() / m_tracks : 0.;
 }

References MaterialAccountingStep::length(), m_accounting, and m_tracks.

Referenced by DD4hep_TrackingMaterialAnalyser::saveParameters(), and sigmaLength().

◆ averageRadiationLengths()

double DD4hep_MaterialAccountingGroup::averageRadiationLengths ( void ) const

Definition at line 234 of file DD4hep_MaterialAccountingGroup.cc.

                                                                          {
   return m_tracks ? m_accounting.radiationLengths() / m_tracks : 0.;
 }

References m_accounting, m_tracks, and MaterialAccountingStep::radiationLengths().

Referenced by DD4hep_TrackingMaterialAnalyser::saveParameters(), savePlots(), DD4hep_TrackingMaterialAnalyser::saveXml(), and sigmaRadiationLengths().

◆ elements()

const std::vector<GlobalPoint>& DD4hep_MaterialAccountingGroup::elements ( void ) const

inline

Definition at line 75 of file DD4hep_MaterialAccountingGroup.h.

75 { return m_elements; }

References m_elements.

◆ endOfTrack()

void DD4hep_MaterialAccountingGroup::endOfTrack ( void )

Definition at line 127 of file DD4hep_MaterialAccountingGroup.cc.

                                                     {
   if (m_counted) {
     m_accounting += m_buffer;
     m_errors += m_buffer * m_buffer;
     ++m_tracks;
  
     GlobalPoint average((m_buffer.in().x() + m_buffer.out().x()) / 2.,
                         (m_buffer.in().y() + m_buffer.out().y()) / 2.,
                         (m_buffer.in().z() + m_buffer.out().z()) / 2.);
     m_dedx_spectrum->Fill(m_buffer.energyLoss());
     m_radlen_spectrum->Fill(m_buffer.radiationLengths());
     m_dedx_vs_eta->Fill(average.eta(), m_buffer.energyLoss(), 1.);
     m_dedx_vs_z->Fill(average.z(), m_buffer.energyLoss(), 1.);
     m_dedx_vs_r->Fill(average.perp(), m_buffer.energyLoss(), 1.);
     m_radlen_vs_eta->Fill(average.eta(), m_buffer.radiationLengths(), 1.);
     m_radlen_vs_z->Fill(average.z(), m_buffer.radiationLengths(), 1.);
     m_radlen_vs_r->Fill(average.perp(), m_buffer.radiationLengths(), 1.);
   }
   m_counted = false;
   m_buffer = MaterialAccountingStep();
 }

References average(), MaterialAccountingStep::energyLoss(), MaterialAccountingStep::in(), m_accounting, m_buffer, m_counted, m_dedx_spectrum, m_dedx_vs_eta, m_dedx_vs_r, m_dedx_vs_z, m_errors, m_radlen_spectrum, m_radlen_vs_eta, m_radlen_vs_r, m_radlen_vs_z, m_tracks, MaterialAccountingStep::out(), MaterialAccountingStep::radiationLengths(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

◆ getBoundingR()

std::pair<double, double> DD4hep_MaterialAccountingGroup::getBoundingR ( ) const

inline

Definition at line 61 of file DD4hep_MaterialAccountingGroup.h.

61 { return m_boundingbox.range_r(); };

References m_boundingbox, and BoundingBox::range_r().

◆ getBoundingZ()

std::pair<double, double> DD4hep_MaterialAccountingGroup::getBoundingZ ( ) const

inline

Definition at line 62 of file DD4hep_MaterialAccountingGroup.h.

62 { return m_boundingbox.range_z(); };

References m_boundingbox, and BoundingBox::range_z().

◆ info()

std::string DD4hep_MaterialAccountingGroup::info ( void ) const

Definition at line 196 of file DD4hep_MaterialAccountingGroup.cc.

                                                          {
   std::stringstream out;
   out << std::setw(48) << std::left << m_name << std::right << std::fixed;
  
   out << "BBox: " << std::setprecision(1) << std::setw(6) << m_boundingbox.range_z().first << " < Z < "
       << std::setprecision(1) << std::setw(6) << m_boundingbox.range_z().second;
   out << ", " << std::setprecision(1) << std::setw(5) << m_boundingbox.range_r().first << " < R < "
       << std::setprecision(1) << std::setw(5) << m_boundingbox.range_r().second;
   out << "   Elements: " << std::setw(6) << m_elements.size();
   return out.str();
 }

References alignBH_cfg::fixed, m_boundingbox, m_elements, m_name, MillePedeFileConverter_cfg::out, BoundingBox::range_r(), and BoundingBox::range_z().

◆ isInside()

bool DD4hep_MaterialAccountingGroup::isInside ( const MaterialAccountingDetector & detector ) const

Definition at line 87 of file DD4hep_MaterialAccountingGroup.cc.

                                                                                               {
   const GlobalPoint& position = detector.position();
  
   edm::LogVerbatim("MaterialAccountingGroup")
       << "Testing position: (x, y, z, r) = " << position.x() << ", " << position.y() << ", " << position.z() << ", "
       << position.perp() << std::endl;
  
   if (not m_boundingbox.inside(position.perp(), position.z())) {
     edm::LogVerbatim("MaterialAccountingGroup")
         << "r outside of: (" << m_boundingbox.range_r().first << ", " << m_boundingbox.range_r().second
         << "), Z ouside of: (" << m_boundingbox.range_z().first << ", " << m_boundingbox.range_z().second << ")"
         << std::endl;
     return false;
   } else {
     edm::LogVerbatim("MaterialAccountingGroup")
         << "r within: (" << m_boundingbox.range_r().first << ", " << m_boundingbox.range_r().second << "), Z within: ("
         << m_boundingbox.range_z().first << ", " << m_boundingbox.range_z().second << ")" << std::endl;
  
     for (unsigned int i = 0; i < m_elements.size(); ++i) {
       edm::LogVerbatim("MaterialAccountingGroup")
           << "Closest testing agains(x, y, z, r): (" << m_elements[i].x() << ", " << m_elements[i].y() << ", "
           << m_elements[i].z() << ", " << m_elements[i].perp() << ") --> " << (position - m_elements[i]).mag()
           << " vs tolerance: " << s_tolerance << std::endl;
       if ((position - m_elements[i]).mag2() < (s_tolerance * s_tolerance))
         return true;
     }
     return false;
   }
 }

References hgcalTestNeighbor_cfi::detector, mps_fire::i, BoundingBox::inside(), m_boundingbox, m_elements, mag(), position, BoundingBox::range_r(), BoundingBox::range_z(), and s_tolerance.

Referenced by addDetector().

◆ name()

const std::string& DD4hep_MaterialAccountingGroup::name ( void ) const

inline

Definition at line 71 of file DD4hep_MaterialAccountingGroup.h.

71 { return m_name; }

References m_name.

Referenced by config.CFG::__str__(), DD4hep_MaterialAccountingGroup(), validation.Sample::digest(), DD4hep_TrackingMaterialAnalyser::saveParameters(), savePlot(), and DD4hep_TrackingMaterialAnalyser::saveXml().

◆ operator=()

DD4hep_MaterialAccountingGroup& DD4hep_MaterialAccountingGroup::operator= ( const DD4hep_MaterialAccountingGroup & layer )

delete

◆ savePlot() [1/2]

void DD4hep_MaterialAccountingGroup::savePlot	(	std::shared_ptr< TH1F > &	plot,
		const std::string &	name
	)

private

Definition at line 163 of file DD4hep_MaterialAccountingGroup.cc.

                                                                                               {
   TCanvas canvas(name.c_str(), plot->GetTitle(), 1280, 1024);
   plot->SetFillColor(15);  // grey
   plot->SetLineColor(1);   // black
   plot->Draw("c e");
   canvas.GetFrame()->SetFillColor(kWhite);
   canvas.Draw();
   canvas.SaveAs((name + ".png").c_str(), "");
   plot->SetDirectory(m_file.get());
 }

References svgfig::canvas(), m_file, name(), and plotFactory::plot.

Referenced by savePlots().

◆ savePlot() [2/2]

void DD4hep_MaterialAccountingGroup::savePlot	(	std::shared_ptr< TProfile > &	plot,
		float	average,
		const std::string &	name
	)

private

Definition at line 174 of file DD4hep_MaterialAccountingGroup.cc.

                                                                                                                  {
   std::unique_ptr<TH1F> line = std::make_unique<TH1F>(
       (name + "_par").c_str(), "Parametrization", 1, plot->GetXaxis()->GetXmin(), plot->GetXaxis()->GetXmax());
  
   line->SetBinContent(1, average);
  
   TCanvas canvas(name.c_str(), plot->GetTitle(), 1280, 1024);
   plot->SetFillColor(15);  // grey
   plot->SetLineColor(1);   // black
   plot->SetLineWidth(2);
   plot->Draw("c e6");
   line->SetLineColor(2);  // red
   line->SetLineWidth(2);
   line->Draw("same");
   canvas.GetFrame()->SetFillColor(kWhite);
   canvas.Draw();
   canvas.SaveAs((name + ".png").c_str(), "");
   plot->SetDirectory(m_file.get());
   line->SetDirectory(m_file.get());
   line->Write();
 }

References svgfig::canvas(), mps_splice::line, m_file, name(), and plotFactory::plot.

◆ savePlots()

void DD4hep_MaterialAccountingGroup::savePlots ( void )

Definition at line 149 of file DD4hep_MaterialAccountingGroup.cc.

                                                    {
   m_file = std::make_unique<TFile>((m_name + ".root").c_str(), "RECREATE");
   savePlot(m_dedx_spectrum, m_name + "_dedx_spectrum");
   savePlot(m_radlen_spectrum, m_name + "_radlen_spectrum");
   savePlot(m_dedx_vs_eta, averageEnergyLoss(), m_name + "_dedx_vs_eta");
   savePlot(m_dedx_vs_z, averageEnergyLoss(), m_name + "_dedx_vs_z");
   savePlot(m_dedx_vs_r, averageEnergyLoss(), m_name + "_dedx_vs_r");
   savePlot(m_radlen_vs_eta, averageRadiationLengths(), m_name + "_radlen_vs_eta");
   savePlot(m_radlen_vs_z, averageRadiationLengths(), m_name + "_radlen_vs_z");
   savePlot(m_radlen_vs_r, averageRadiationLengths(), m_name + "_radlen_vs_r");
   m_file->Write();
   m_file->Close();
 }

References averageEnergyLoss(), averageRadiationLengths(), m_dedx_spectrum, m_dedx_vs_eta, m_dedx_vs_r, m_dedx_vs_z, m_file, m_name, m_radlen_spectrum, m_radlen_vs_eta, m_radlen_vs_r, m_radlen_vs_z, and savePlot().

Referenced by DD4hep_TrackingMaterialAnalyser::saveLayerPlots().

◆ sigmaEnergyLoss()

double DD4hep_MaterialAccountingGroup::sigmaEnergyLoss ( void ) const

Definition at line 230 of file DD4hep_MaterialAccountingGroup.cc.

                                                                  {
   return m_tracks ? std::sqrt(m_errors.energyLoss() / m_tracks - averageEnergyLoss() * averageEnergyLoss()) : 0.;
 }

References averageEnergyLoss(), MaterialAccountingStep::energyLoss(), m_errors, m_tracks, and mathSSE::sqrt().

Referenced by DD4hep_TrackingMaterialAnalyser::saveParameters().

◆ sigmaLength()

double DD4hep_MaterialAccountingGroup::sigmaLength ( void ) const

Definition at line 220 of file DD4hep_MaterialAccountingGroup.cc.

                                                              {
   return m_tracks ? std::sqrt(m_errors.length() / m_tracks - averageLength() * averageLength()) : 0.;
 }

References averageLength(), MaterialAccountingStep::length(), m_errors, m_tracks, and mathSSE::sqrt().

Referenced by DD4hep_TrackingMaterialAnalyser::saveParameters().

◆ sigmaRadiationLengths()

double DD4hep_MaterialAccountingGroup::sigmaRadiationLengths ( void ) const

Definition at line 224 of file DD4hep_MaterialAccountingGroup.cc.

                                                                        {
   return m_tracks
              ? std::sqrt(m_errors.radiationLengths() / m_tracks - averageRadiationLengths() * averageRadiationLengths())
              : 0.;
 }