#include <MaterialBudgetAction.h>

Inheritance diagram for MaterialBudgetAction:

Public Member Functions
	MaterialBudgetAction (const edm::ParameterSet &)

	~MaterialBudgetAction () override

Public Member Functions inherited from SimWatcher
	SimWatcher ()

virtual	~SimWatcher ()

Public Member Functions inherited from Observer< const BeginOfRun * >
	Observer ()

void	slotForUpdate (const BeginOfRun * iT)

virtual	~Observer ()

Public Member Functions inherited from Observer< const BeginOfTrack * >
	Observer ()

void	slotForUpdate (const BeginOfTrack * iT)

virtual	~Observer ()

Public Member Functions inherited from Observer< const G4Step * >
	Observer ()

void	slotForUpdate (const G4Step * iT)

virtual	~Observer ()

Public Member Functions inherited from Observer< const EndOfTrack * >
	Observer ()

void	slotForUpdate (const EndOfTrack * iT)

virtual	~Observer ()

Public Member Functions inherited from Observer< const EndOfRun * >
	Observer ()

void	slotForUpdate (const EndOfRun * iT)

virtual	~Observer ()

Private Member Functions
bool	CheckTouchableInSelectedVolumes (const G4VTouchable *touch)

std::string	getPartName (G4StepPoint *aStepPoint)

std::string	getSubDetectorName (G4StepPoint *aStepPoint)

	MaterialBudgetAction (const MaterialBudgetAction &)

const MaterialBudgetAction &	operator= (const MaterialBudgetAction &)

void	save (const G4Step *aStep)

bool	StopAfterProcess (const G4Step *aStep)

void	update (const BeginOfRun *) override
	This routine will be called when the appropriate signal arrives. More...

void	update (const BeginOfTrack *) override
	This routine will be called when the appropriate signal arrives. More...

void	update (const EndOfRun *) override
	This routine will be called when the appropriate signal arrives. More...

void	update (const EndOfTrack *) override
	This routine will be called when the appropriate signal arrives. More...

void	update (const G4Step *) override
	This routine will be called when the appropriate signal arrives. More...

Private Attributes
double	Ekin

bool	firstParticle

bool	saveToHistos

bool	saveToTree

bool	saveToTxt

bool	storeDecay

std::shared_ptr< MaterialBudgetData >	theData

std::string	theHistoList

std::shared_ptr< TestHistoMgr >	theHistoMgr

std::shared_ptr< MaterialBudgetFormat >	theHistos

G4String	theProcessToStop

std::shared_ptr< MaterialBudgetTree >	theTree

std::shared_ptr< MaterialBudgetTxt >	theTxt

std::vector< G4String >	theVolumeList

Additional Inherited Members

Detailed Description

Definition at line 33 of file MaterialBudgetAction.h.

Constructor & Destructor Documentation

◆ MaterialBudgetAction() [1/2]

MaterialBudgetAction::MaterialBudgetAction ( const edm::ParameterSet & iPSet )

Definition at line 32 of file MaterialBudgetAction.cc.

                                                                        {
   theData = std::make_shared<MaterialBudgetData>();
  
   edm::ParameterSet m_Anal = iPSet.getParameter<edm::ParameterSet>("MaterialBudgetAction");
  
   //---- Accumulate material budget only inside selected volumes
   std::string theHistoList = m_Anal.getParameter<std::string>("HistogramList");
   std::vector<std::string> volList = m_Anal.getParameter<std::vector<std::string> >("SelectedVolumes");
  
   edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: List of the selected volumes:";
   for (const auto& it : volList) {
     if (it != "None") {
       theVolumeList.push_back(it);
       edm::LogInfo("MaterialBudget") << it;
     }
   }
  
   // log
   if (theHistoList == "Tracker") {
     edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: running in Tracker Mode";
   } else if (theHistoList == "ECAL") {
     edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: running in Ecal Mode";
   } else if (theHistoList == "Mtd") {
     edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: running in Mtd Mode";
   } else if (theHistoList == "HGCal") {
     edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: running in HGCal Mode";
   } else {
     edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: running in General Mode";
   }
  
   //---- Stop track when a process occurs
   theProcessToStop = m_Anal.getParameter<std::string>("StopAfterProcess");
   LogDebug("MaterialBudget") << "MaterialBudgetAction: stop at process " << theProcessToStop;
  
   //---- Save histos to ROOT file
   std::string saveToHistosFile = m_Anal.getParameter<std::string>("HistosFile");
   if (saveToHistosFile != "None") {
     saveToHistos = true;
     edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: saving histograms to " << saveToHistosFile;
     theHistoMgr = std::make_shared<TestHistoMgr>();
     if (theHistoList == "Tracker") {
       theHistos = std::make_shared<MaterialBudgetTrackerHistos>(theData, theHistoMgr, saveToHistosFile);
     } else if (theHistoList == "ECAL") {
       theHistos = std::make_shared<MaterialBudgetEcalHistos>(theData, theHistoMgr, saveToHistosFile);
     } else if (theHistoList == "Mtd") {
       theHistos = std::make_shared<MaterialBudgetMtdHistos>(theData, theHistoMgr, saveToHistosFile);
       theData->setMtdmode(true);
     } else if (theHistoList == "HGCal") {
       theHistos = std::make_shared<MaterialBudgetHGCalHistos>(theData,
                                                               theHistoMgr,
                                                               saveToHistosFile,
                                                               m_Anal.getParameter<double>("minZ"),
                                                               m_Anal.getParameter<double>("maxZ"),
                                                               m_Anal.getParameter<int>("nintZ"),
                                                               m_Anal.getParameter<double>("rMin"),
                                                               m_Anal.getParameter<double>("rMax"),
                                                               m_Anal.getParameter<int>("nrbin"),
                                                               m_Anal.getParameter<double>("etaMin"),
                                                               m_Anal.getParameter<double>("etaMax"),
                                                               m_Anal.getParameter<int>("netabin"),
                                                               m_Anal.getParameter<double>("phiMin"),
                                                               m_Anal.getParameter<double>("phiMax"),
                                                               m_Anal.getParameter<int>("nphibin"),
                                                               m_Anal.getParameter<double>("RMin"),
                                                               m_Anal.getParameter<double>("RMax"),
                                                               m_Anal.getParameter<int>("nRbin"));
       //In HGCal mode, so tell data class
       theData->setHGCalmode(true);
     } else {
       theHistos = std::make_shared<MaterialBudgetHistos>(theData, theHistoMgr, saveToHistosFile);
     }
   } else {
     edm::LogWarning("MaterialBudget") << "MaterialBudgetAction: No histograms file specified";
     saveToHistos = false;
   }
  
   //---- Save material budget info to TEXT file
   std::string saveToTxtFile = m_Anal.getParameter<std::string>("TextFile");
   if (saveToTxtFile != "None") {
     saveToTxt = true;
     edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: saving text info to " << saveToTxtFile;
     theTxt = std::make_shared<MaterialBudgetTxt>(theData, saveToTxtFile);
   } else {
     saveToTxt = false;
   }
  
   //---- Compute all the steps even if not stored on file
   bool allSteps = m_Anal.getParameter<bool>("AllStepsToTree");
   edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: all steps are computed " << allSteps;
   if (allSteps)
     theData->SetAllStepsToTree();
  
   //---- Save tree to ROOT file
   std::string saveToTreeFile = m_Anal.getParameter<std::string>("TreeFile");
   if (saveToTreeFile != "None") {
     saveToTree = true;
     theTree = std::make_shared<MaterialBudgetTree>(theData, saveToTreeFile);
   } else {
     saveToTree = false;
   }
   edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: saving ROOT TTree to " << saveToTreeFile;
  
   //---- Track the first decay products of the main particle
   // if their kinetic energy is greater than  Ekin
   storeDecay = m_Anal.getUntrackedParameter<bool>("storeDecay", false);
   Ekin = m_Anal.getUntrackedParameter<double>("EminDecayProd", 1000.0);  // MeV
   edm::LogInfo("MaterialBudget") << "MaterialBudgetAction: decay products steps are stored (" << storeDecay
                                  << ") if their kinetic energy is greater than " << Ekin << " MeV";
   firstParticle = false;
 }

References Ekin, firstParticle, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), LogDebug, saveToHistos, saveToTree, saveToTxt, storeDecay, AlCaHLTBitMon_QueryRunRegistry::string, theData, theHistoList, theHistoMgr, theHistos, theProcessToStop, theTree, theTxt, and theVolumeList.

◆ ~MaterialBudgetAction()

MaterialBudgetAction::~MaterialBudgetAction ( )

override

Definition at line 144 of file MaterialBudgetAction.cc.

144 {}

◆ MaterialBudgetAction() [2/2]

MaterialBudgetAction::MaterialBudgetAction ( const MaterialBudgetAction & )

private

Member Function Documentation

◆ CheckTouchableInSelectedVolumes()

bool MaterialBudgetAction::CheckTouchableInSelectedVolumes ( const G4VTouchable * touch )

private

Definition at line 324 of file MaterialBudgetAction.cc.

                                                                                     {
   size_t volh = touch->GetHistoryDepth();
   for (int ii = volh; ii >= 0; ii--) {
     if (std::find(theVolumeList.begin(), theVolumeList.end(), touch->GetVolume(ii)->GetName()) != theVolumeList.end())
       return true;
   }
   return false;
 }

References spr::find(), cuy::ii, and theVolumeList.

Referenced by update().

◆ getPartName()

std::string MaterialBudgetAction::getPartName ( G4StepPoint * aStepPoint )

private

Definition at line 284 of file MaterialBudgetAction.cc.

                                                                    {
   const G4TouchableHistory* theTouchable = (const G4TouchableHistory*)(aStepPoint->GetTouchable());
   G4int num_levels = theTouchable->GetHistoryDepth();
  
   if (theTouchable->GetVolume()) {
     return theTouchable->GetVolume(num_levels - 3)->GetName();
   } else {
     return "OutOfWorld";
   }
 }

◆ getSubDetectorName()

std::string MaterialBudgetAction::getSubDetectorName ( G4StepPoint * aStepPoint )

private

Definition at line 272 of file MaterialBudgetAction.cc.

                                                                           {
   const G4TouchableHistory* theTouchable = (const G4TouchableHistory*)(aStepPoint->GetTouchable());
   G4int num_levels = theTouchable->GetHistoryDepth();
  
   if (theTouchable->GetVolume()) {
     return theTouchable->GetVolume(num_levels - 1)->GetName();
   } else {
     return "OutOfWorld";
   }
 }

◆ operator=()

const MaterialBudgetAction& MaterialBudgetAction::operator= ( const MaterialBudgetAction & )

private

◆ save()

void MaterialBudgetAction::save ( const G4Step * aStep )

private

◆ StopAfterProcess()

bool MaterialBudgetAction::StopAfterProcess ( const G4Step * aStep )

private

Definition at line 334 of file MaterialBudgetAction.cc.

                                                                {
   if (theProcessToStop.empty())
     return false;
  
   if (aStep->GetPostStepPoint()->GetProcessDefinedStep() == nullptr)
     return false;
   if (aStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName() == theProcessToStop) {
     edm::LogInfo("MaterialBudget") << "MaterialBudgetAction :"
                                    << aStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
     return true;
   } else {
     return false;
   }
 }

References theProcessToStop.

Referenced by update().

◆ update() [1/5]

void MaterialBudgetAction::update ( const BeginOfRun * )

overrideprivatevirtual

This routine will be called when the appropriate signal arrives.

Implements Observer< const BeginOfRun * >.

Definition at line 147 of file MaterialBudgetAction.cc.

                                                    {
   //----- Check that selected volumes are indeed part of the geometry
   const G4LogicalVolumeStore* lvs = G4LogicalVolumeStore::GetInstance();
  
   for (const auto& volcite : theVolumeList) {
     bool volFound = false;
     for (const auto& lvcite : *lvs) {
       if (lvcite->GetName() == volcite) {
         volFound = true;
         break;
       }
     }
     if (!volFound) {
       edm::LogWarning("MaterialBudget") << "MaterialBudgetAction: selected volume not found in geometry " << volcite;
     }
   }
  
   //----- Check process selected is one of the available ones
   bool procFound = false;
   if (theProcessToStop == "None") {
     procFound = true;
   } else {
     G4ParticleTable* partTable = G4ParticleTable::GetParticleTable();
     int siz = partTable->size();
     for (int ii = 0; ii < siz; ii++) {
       G4ParticleDefinition* particle = partTable->GetParticle(ii);
  
       //--- All processes of this particle
       G4ProcessManager* pmanager = particle->GetProcessManager();
       G4ProcessVector* pvect = pmanager->GetProcessList();
       int sizproc = pvect->size();
       for (int jj = 0; jj < sizproc; jj++) {
         if ((*pvect)[jj]->GetProcessName() == theProcessToStop) {
           procFound = true;
           break;
         }
       }
     }
   }
  
   if (!procFound) {
     edm::LogWarning("MaterialBudget") << "MaterialBudgetAction: selected process to stop tracking not found "
                                       << theProcessToStop;
   }
 }

References cuy::ii, findQualityFiles::jj, theProcessToStop, and theVolumeList.

Referenced by MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), and MatrixUtil.Steps::overwrite().

◆ update() [2/5]

void MaterialBudgetAction::update ( const BeginOfTrack * )

overrideprivatevirtual

This routine will be called when the appropriate signal arrives.

Implements Observer< const BeginOfTrack * >.

Definition at line 194 of file MaterialBudgetAction.cc.

                                                          {
   const G4Track* aTrack = (*trk)();  // recover G4 pointer if wanted
  
   // that was a temporary action while we're sorting out
   // about # of secondaries (produced if CutsPerRegion=true)
  
   LogDebug("MaterialBudget") << "MaterialBudgetAction: Track ID " << aTrack->GetTrackID() << "Track parent ID "
                              << aTrack->GetParentID() << "PDG Id. = " << aTrack->GetDefinition()->GetPDGEncoding()
                              << "Ekin = " << aTrack->GetKineticEnergy() << " MeV";
  
   if (aTrack->GetCreatorProcess())
     LogDebug("MaterialBudget") << "MaterialBudgetAction: produced through "
                                << aTrack->GetCreatorProcess()->GetProcessType();
  
   if (aTrack->GetTrackID() == 1) {
     firstParticle = true;
   } else {
     firstParticle = false;
   }
  
   if (storeDecay) {  // if record of the decay is requested
     if (aTrack->GetCreatorProcess()) {
       if (aTrack->GetParentID() == 1 &&
           //      aTrack->GetCreatorProcess()->GetProcessType() == 6
           //      &&
           aTrack->GetKineticEnergy() > Ekin) {
         // continue
       } else {
         G4Track* aTracknc = const_cast<G4Track*>(aTrack);
         aTracknc->SetTrackStatus(fStopAndKill);
         return;
       }
     }       // particles produced from a decay (type=6) of the main particle (ID=1) with Kinetic Energy [MeV] > Ekin
   } else {  // kill all the other particles (take only the main one until it disappears) if decay not stored
     if (aTrack->GetParentID() != 0) {
       G4Track* aTracknc = const_cast<G4Track*>(aTrack);
       aTracknc->SetTrackStatus(fStopAndKill);
       return;
     }
   }
  
   theData->dataStartTrack(aTrack);
  
   if (saveToTree)
     theTree->fillStartTrack();
   if (saveToHistos)
     theHistos->fillStartTrack();
   if (saveToTxt)
     theTxt->fillStartTrack();
 }

References Ekin, firstParticle, LogDebug, saveToHistos, saveToTree, saveToTxt, storeDecay, theData, theHistos, theTree, and theTxt.

Referenced by MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), and MatrixUtil.Steps::overwrite().

◆ update() [3/5]

void MaterialBudgetAction::update ( const EndOfRun * )

overrideprivatevirtual

This routine will be called when the appropriate signal arrives.

Implements Observer< const EndOfRun * >.

Definition at line 309 of file MaterialBudgetAction.cc.

                                                  {
   // endOfRun calls TestHistoMgr::save() allowing to write
   // the ROOT files containing the histograms
  
   if (saveToHistos)
     theHistos->endOfRun();
   if (saveToTxt)
     theHistos->endOfRun();
   if (saveToTree)
     theTree->endOfRun();
  
   return;
 }

References saveToHistos, saveToTree, saveToTxt, theHistos, and theTree.

Referenced by MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), and MatrixUtil.Steps::overwrite().

◆ update() [4/5]

void MaterialBudgetAction::update ( const EndOfTrack * )

overrideprivatevirtual

This routine will be called when the appropriate signal arrives.

Implements Observer< const EndOfTrack * >.

Definition at line 296 of file MaterialBudgetAction.cc.

                                                        {
   const G4Track* aTrack = (*trk)();  // recover G4 pointer if wanted
   theData->dataEndTrack(aTrack);
  
   if (saveToTree)
     theTree->fillEndTrack();
   if (saveToHistos)
     theHistos->fillEndTrack();
   if (saveToTxt)
     theTxt->fillEndTrack();
 }

References saveToHistos, saveToTree, saveToTxt, theData, theHistos, theTree, and theTxt.

Referenced by MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), and MatrixUtil.Steps::overwrite().

◆ update() [5/5]

void MaterialBudgetAction::update ( const G4Step * )

overrideprivatevirtual

This routine will be called when the appropriate signal arrives.

Implements Observer< const G4Step * >.

Definition at line 246 of file MaterialBudgetAction.cc.

                                                      {
   //----- Check it is inside one of the volumes selected
   if (!theVolumeList.empty()) {
     if (!CheckTouchableInSelectedVolumes(aStep->GetTrack()->GetTouchable()))
       return;
   }
  
   //---------- each step
   theData->dataPerStep(aStep);
   if (saveToTree)
     theTree->fillPerStep();
   if (saveToHistos)
     theHistos->fillPerStep();
   if (saveToTxt)
     theTxt->fillPerStep();
  
   //----- Stop tracking after selected process
   if (StopAfterProcess(aStep)) {
     G4Track* track = aStep->GetTrack();
     track->SetTrackStatus(fStopAndKill);
   }
  
   return;
 }