G4UA::RadLengthAction Class Reference

#include <RadLengthAction.h>

Inheritance diagram for G4UA::RadLengthAction:

Collaboration diagram for G4UA::RadLengthAction:

Classes
struct	Config

Public Member Functions
	RadLengthAction (const Config &config)
virtual void	BeginOfRunAction (const G4Run *) override
virtual void	EndOfRunAction (const G4Run *) override
virtual void	BeginOfEventAction (const G4Event *) override
virtual void	EndOfEventAction (const G4Event *) override
virtual void	UserSteppingAction (const G4Step *) override

Private Member Functions
void	fillVariables (const std::vector< double > &varvec, const std::string &name)

Private Attributes
Config	m_config
bool	MuChamberPassed = false
bool	MuTriggerPassed = false
double	etaPrimary = 0.0
double	phiPrimary = 0.0
double	chargePrimary = 0.0
std::map< std::string, G4VPhysicalVolume * >	topvolmap
std::map< std::string, TTree * >	treeMap
std::map< std::string, std::vector< double > >	variables
G4VSensitiveDetector *	m_SDMDT
G4VSensitiveDetector *	m_SDTGC
G4VSensitiveDetector *	m_SDCSC
G4VSensitiveDetector *	m_SDRPC
ServiceHandle< ITHistSvc >	m_hSvc

Detailed Description

Definition at line 25 of file RadLengthAction.h.

Constructor & Destructor Documentation

RadLengthAction()

G4UA::RadLengthAction::RadLengthAction

(

const Config &

config

)

Definition at line 37 of file RadLengthAction.cxx.

    : m_config(config)
    , m_SDMDT(nullptr)
    , m_SDTGC(nullptr)
    , m_SDCSC(nullptr)
    , m_SDRPC(nullptr)
    , m_hSvc("THistSvc", "RadLengthAction")
  {
  }

Member Function Documentation

BeginOfEventAction()

void G4UA::RadLengthAction::BeginOfEventAction ( const G4Event *  anEvent )

overridevirtual

Definition at line 169 of file RadLengthAction.cxx.

  {
 
    // getting variables of the primary particle
    G4PrimaryVertex *vert=anEvent->GetPrimaryVertex(0);
    //     vert->SetPosition(0.0,0.0,0.0);
    G4PrimaryParticle *part=vert->GetPrimary();
    G4ThreeVector mom=part->GetMomentum();
    etaPrimary=mom.eta();
    phiPrimary=mom.phi();
    chargePrimary=part->GetCharge();
    G4cout<<"Begin Of Event"<<" "<<(double)vert->GetX0()<<" "<<(double)vert->GetY0()<<" "<<(double)vert->GetZ0()<< G4endl;
    G4cout<<"Begin Of Event"<<" "<<(double)mom[0]<<" "<<(double)mom[1]<<" "<<(double)mom[2]<< G4endl;
 
    // putting passflags for muon chambers/trigger (back) to false
    MuChamberPassed = false;
    MuTriggerPassed = false;
 
    // reinitialize the variables vector for this event
    for (auto& p : variables) {
      for(unsigned int i=0; i< variables[p.first].size(); i++) variables[p.first].at(i)=0;
    }
  }

BeginOfRunAction()

void G4UA::RadLengthAction::BeginOfRunAction ( const G4Run *  )

overridevirtual

Definition at line 50 of file RadLengthAction.cxx.

  {
    // getting level of depth from jobOptions
    // depth = atof( theProperties["VolumeDepthLevel"].c_str() );
 
    // creating reference to sensitive detectors of muonsystem
    // later on used for comparison in Stepping
    G4SDManager *SDM=G4SDManager::GetSDMpointer();
    m_SDMDT = (G4VSensitiveDetector*) SDM->FindSensitiveDetector("AMS");
    m_SDTGC = (G4VSensitiveDetector*) SDM->FindSensitiveDetector("TMS");
    m_SDCSC = (G4VSensitiveDetector*) SDM->FindSensitiveDetector("CMS");
    m_SDRPC = (G4VSensitiveDetector*) SDM->FindSensitiveDetector("RMS");
 
 
    // clearing the maps with comparison volumes, trees and variables
    topvolmap.clear();
    treeMap.clear();
    variables.clear();
 
    // creating volume store
    G4LogicalVolumeStore *store = G4LogicalVolumeStore::GetInstance();
    // getting most top volume "Atlas::Atlas" by hand
    G4LogicalVolume* atlas = store->GetVolume("Atlas::Atlas");
 
    // logical volume vector, initialized with atlas only
    // later on filled with all logicals of depth level
    std::vector<G4LogicalVolume*> logvec;
    logvec.push_back(atlas);
 
    // physical volume vector later on used for topvolmap and names
    std::vector<G4VPhysicalVolume*> physvec;
 
    // counter for loop up to depth level
    int counter = 0;
 
    // loop to fill physvec with all physical volumes of depth level
    while(counter != m_config.VolumeDepthLevel){
      // counter increase up to depth
      counter++;
 
      // create tmplogvec to be filled with (logical) daughters of counter depth level
      std::vector<G4LogicalVolume*> tmplogvec;
 
      // looping on logical vector of previous depth level
      for(G4LogicalVolume* logvol : logvec) {
        for(unsigned int k=0; k<logvol->GetNoDaughters();k++){
          // dumping all logical daughters for next level
          tmplogvec.push_back(logvol->GetDaughter(k)->GetLogicalVolume());
          // dumping the corresponding physical if not made of gas or last depth level where all are dumped
          if((logvol->GetDaughter(k)->GetLogicalVolume()->GetMaterial()->GetRadlen()<100*CLHEP::cm) || (counter == m_config.VolumeDepthLevel)){
            physvec.push_back(logvol->GetDaughter(k));
          }
        }
      }
 
      // logical vector is put to the tmplogvec (with daughters) for next stage
      // to physvec all not gas daughters of this level where already added
      logvec=std::move(tmplogvec);
 
    }
 
    // loop on physvec to put the volumes in the topvolmap using their name
    // for comparison in Stepping and initializing all other maps
    for (G4VPhysicalVolume* physvol : physvec) {
      std::string fulldaughtername = physvol->GetName();
      std::string daughtername;
      std::string::size_type npos;
      npos=fulldaughtername.find("::");
      // nicer naming for depth level =1
      if(npos!=std::string::npos && m_config.VolumeDepthLevel==1) daughtername = fulldaughtername.substr(0,npos);
      else daughtername = std::move(fulldaughtername);
      topvolmap[daughtername]=physvol;
    }
 
    // adding by hand two additional names to topvolmap (without volume)
    // due to initialization purpose of topvolmap
    topvolmap["ToMuChamber"] = 0;
    topvolmap["ToMuTrigger"] = 0;
 
    // using topvolmap to initialize treemap (trees with volumenames)
    // and variables map of vectors with FIXED SIZE TO NUMBER OF VARIABLES TO BE DUMPED
    for (auto& p : topvolmap) {
      treeMap[p.first]=new TTree(TString(p.first), TString(p.first));
      variables[p.first].resize(12);
    }
 
    // get the THistoSvc
    if(m_hSvc.retrieve().isFailure()) return;
 
    // using already initialized treeMap to register the trees with volname
    // and branches which are REFERENCED to the components of the corresponding
    // entry in variables map
    for (auto& p : treeMap) {
      std::string filename= "/RadLengthAction/";
      std::string treepath= filename+p.first;
      m_hSvc->regTree(treepath.c_str(), treeMap[p.first]).ignore();
      //if (!hSvc) log()<< MSG::ERROR << "Cannot register Tree!" << p.first << endreq;
      treeMap[p.first]->Branch("EnergyLoss",  &variables[p.first].at(0), "EnergyLoss/D");
      treeMap[p.first]->Branch("RadLength",   &variables[p.first].at(1),  "RadLength/D");
      treeMap[p.first]->Branch("Intlength",   &variables[p.first].at(2),  "Intlength/D");
      treeMap[p.first]->Branch("InitialEta",  &variables[p.first].at(3), "InitialEta/D");
      treeMap[p.first]->Branch("InitialPhi",  &variables[p.first].at(4), "InitialPhi/D");
      treeMap[p.first]->Branch("PointEta",    &variables[p.first].at(5),   "PointEta/D");
      treeMap[p.first]->Branch("PointPhi",    &variables[p.first].at(6),   "PointPhi/D");
      treeMap[p.first]->Branch("PointX",      &variables[p.first].at(7),     "PointX/D");
      treeMap[p.first]->Branch("PointY",      &variables[p.first].at(8),     "PointY/D");
      treeMap[p.first]->Branch("PointZ",      &variables[p.first].at(9),     "PointZ/D");
      treeMap[p.first]->Branch("PointR",     &variables[p.first].at(10),     "PointR/D");
      treeMap[p.first]->Branch("Charge",     &variables[p.first].at(11),     "Charge/D");
    }
  }

EndOfEventAction()

void G4UA::RadLengthAction::EndOfEventAction ( const G4Event *  )

overridevirtual

Definition at line 194 of file RadLengthAction.cxx.

  {
 
    //for the case there was never a chamber passed set eloss to 1 radlength/intlength to -1
    if(!MuChamberPassed){
      variables["ToMuChamber"].at(0) =  1.;
      variables["ToMuChamber"].at(1) = -1.;
      variables["ToMuChamber"].at(2) = -1.;
    }
 
    //for the case there was never a trigger passed set eloss to 1 radlength/intlength to -1
    if(!MuChamberPassed){
      variables["ToMuTrigger"].at(0) =  1.;
      variables["ToMuTrigger"].at(1) = -1.;
      variables["ToMuTrigger"].at(2) = -1.;
    }
 
 
    for (auto& p : treeMap) {
      treeMap[p.first]->Fill();
    }
  }

EndOfRunAction()

void G4UA::RadLengthAction::EndOfRunAction ( const G4Run *  )

overridevirtual

Definition at line 163 of file RadLengthAction.cxx.

  {
 
  }

fillVariables()

void G4UA::RadLengthAction::fillVariables ( const std::vector< double > &  varvec, const std::string &  name  )

private

Definition at line 284 of file RadLengthAction.cxx.

                                                                                           {
    // first three components should be added (deltaenergy, radlength, intlength)
    for(unsigned int i = 0; i<3; i++) variables[name].at(i) += varvec.at(i);
    // other components should be overwritten
    // (last value inside the volume will be kept by change and dumped in EndOfEvent)
    for(unsigned int j = 3; j<12; j++) variables[name].at(j) = varvec.at(j);
  }

UserSteppingAction()

void G4UA::RadLengthAction::UserSteppingAction ( const G4Step *  aStep )

overridevirtual

Definition at line 218 of file RadLengthAction.cxx.

  {
 
    // killing secondaries to save computing time, perhaps
    if(TrackHelper(aStep->GetTrack()).IsSecondary()) aStep->GetTrack()->SetTrackStatus(fStopAndKill);
 
    // entering primary particle
    if(TrackHelper(aStep->GetTrack()).IsPrimary()) {
 
      // get touchable history since used often
      const G4TouchableHistory* touchHist =
        static_cast<const G4TouchableHistory*>(aStep->GetPreStepPoint()->GetTouchable());
 
      // get point before Stepping was started
      G4ThreeVector xyz = (G4ThreeVector) aStep->GetPreStepPoint()->GetPosition();
 
      // get radlength and intlength of volumes passed with this Stepping
      // double radl=touchHist->GetVolume()->GetLogicalVolume()->GetMaterial()->GetRadlen();
      // double intl=touchHist->GetVolume()->GetLogicalVolume()->GetMaterial()->GetNuclearInterLength();
      double radl=aStep->GetPreStepPoint()->GetMaterial()->GetRadlen();
      double intl=aStep->GetPreStepPoint()->GetMaterial()->GetNuclearInterLength();
 
      // get the steplength for calculation X0 and intlength
      double stepl=aStep->GetStepLength();
      G4cout<<aStep->GetPreStepPoint()->GetMaterial()->GetName()<<" "<<radl<<" "<<stepl<<" "<<stepl/radl<<" "<<(double) xyz[0]<<" "<<(double) xyz[1]<<" "<< (double) xyz[2]<<G4endl;
      // define and fill vector for the FIXED NUMBER of variables which should be dumped later on
      const unsigned int nVariablesToSave(12);
      std::vector<double> varvec(nVariablesToSave);
      varvec.at(0)  = (double) aStep->GetDeltaEnergy();
      varvec.at(1)  = (double) stepl/radl;
      varvec.at(2)  = (double) stepl/intl;
      varvec.at(3)  = (double) etaPrimary;
      varvec.at(4)  = (double) phiPrimary;
      varvec.at(5)  = (double) xyz.pseudoRapidity();
      varvec.at(6)  = (double) xyz.phi();
      varvec.at(7)  = (double) xyz[0];
      varvec.at(8)  = (double) xyz[1];
      varvec.at(9)  = (double) xyz[2];
      varvec.at(10) = (double) sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
      varvec.at(11) = (double) chargePrimary;
 
      // loop on topvolmap to search for mother of current volume on volume depth level
      // dump the variables in corresponding component of variables map
      for (auto& p : topvolmap) {
        if(p.second == touchHist->GetVolume(touchHist->GetHistoryDepth()-m_config.VolumeDepthLevel) ){
          this->fillVariables(varvec, p.first);
        }
      }
 
      // get sensitive detector of current volume
      G4VSensitiveDetector* SD = (G4VSensitiveDetector*) touchHist->GetVolume()->GetLogicalVolume()->GetSensitiveDetector();
 
      // set muon chamber pass flag true up to end of event and dump
      // variables collected up to this point in variables map
      if(SD==m_SDCSC || SD==m_SDMDT) MuChamberPassed = true;
      if(!MuChamberPassed) this->fillVariables(varvec, "ToMuChamber");
 
      // set muon trigger pass flag true up to end of event and dump
      // variables collected up to this point in variables map
      if(SD==m_SDRPC || SD==m_SDTGC) MuTriggerPassed = true;
      if(!MuTriggerPassed) this->fillVariables(varvec, "ToMuTrigger");
 
    }//end primary particle
  }

Member Data Documentation

chargePrimary

double G4UA::RadLengthAction::chargePrimary = 0.0

private

Definition at line 55 of file RadLengthAction.h.

etaPrimary

double G4UA::RadLengthAction::etaPrimary = 0.0

private

Definition at line 55 of file RadLengthAction.h.

m_config

Config G4UA::RadLengthAction::m_config

private

Definition at line 47 of file RadLengthAction.h.

m_hSvc

ServiceHandle<ITHistSvc> G4UA::RadLengthAction::m_hSvc

private

Definition at line 78 of file RadLengthAction.h.

m_SDCSC

G4VSensitiveDetector* G4UA::RadLengthAction::m_SDCSC

private

Definition at line 74 of file RadLengthAction.h.

m_SDMDT

G4VSensitiveDetector* G4UA::RadLengthAction::m_SDMDT

private

Definition at line 72 of file RadLengthAction.h.

m_SDRPC

G4VSensitiveDetector* G4UA::RadLengthAction::m_SDRPC

private

Definition at line 75 of file RadLengthAction.h.

m_SDTGC

G4VSensitiveDetector* G4UA::RadLengthAction::m_SDTGC

private

Definition at line 73 of file RadLengthAction.h.

MuChamberPassed

bool G4UA::RadLengthAction::MuChamberPassed = false

private

Definition at line 51 of file RadLengthAction.h.

MuTriggerPassed

bool G4UA::RadLengthAction::MuTriggerPassed = false

private

Definition at line 52 of file RadLengthAction.h.

phiPrimary

double G4UA::RadLengthAction::phiPrimary = 0.0

private

Definition at line 55 of file RadLengthAction.h.

topvolmap

std::map<std::string,G4VPhysicalVolume*> G4UA::RadLengthAction::topvolmap

private

Definition at line 59 of file RadLengthAction.h.

treeMap

std::map<std::string,TTree*> G4UA::RadLengthAction::treeMap

private

Definition at line 63 of file RadLengthAction.h.

variables

std::map<std::string,std::vector<double> > G4UA::RadLengthAction::variables

private

Definition at line 68 of file RadLengthAction.h.

---

The documentation for this class was generated from the following files:

• RadLengthAction.h
• RadLengthAction.cxx