gar::garg4::AuxDetAction Class Reference

list of energy deposits from Geant4 More...

#include <AuxDetAction.h>

Inheritance diagram for gar::garg4::AuxDetAction:

Public Member Functions
	AuxDetAction (CLHEP::HepRandomEngine *engine, fhicl::ParameterSet const &pset)
virtual	~AuxDetAction ()
void	reconfigure (fhicl::ParameterSet const &pset)
void	BeginOfEventAction (const G4Event *)
void	EndOfEventAction (const G4Event *)
void	PreTrackingAction (const G4Track *)
void	PostTrackingAction (const G4Track *)
void	SteppingAction (const G4Step *)
std::vector< gar::sdp::LArDeposit > const &	LArDeposits () const
std::vector< gar::sdp::CaloDeposit > const &	CaloDeposits () const
std::vector< gar::sdp::CaloDeposit > const &	TrackerScDeposits () const
std::vector< gar::sdp::CaloDeposit > const &	MuIDDeposits () const

Private Member Functions
void	LArSteppingAction (const G4Step *)
void	ECALSteppingAction (const G4Step *)
void	TrackerScSteppingAction (const G4Step *)
void	MuIDSteppingAction (const G4Step *)
void	AddHits (const std::map< gar::raw::CellID_t, std::vector< gar::sdp::CaloDeposit > > m_hits, std::vector< gar::sdp::CaloDeposit > &fDeposits)
std::string	GetVolumeName (const G4Track *track)
unsigned int	GetDetNumber (std::string volname)
unsigned int	GetStaveNumber (std::string volname)
unsigned int	GetModuleNumber (std::string volname)
unsigned int	GetLayerNumber (std::string volname)
unsigned int	GetSliceNumber (std::string volname)
G4ThreeVector	globalToLocal (const G4Step *step, const G4ThreeVector &glob)
G4ThreeVector	localToGlobal (const G4Step *step, const G4ThreeVector &loc)
float	GetStepEnergy (const G4Step *step, bool birks)
float	birksAttenuation (const G4Step *step)

Private Attributes
double	fLArEnergyCut
	The minimum energy in GeV for a particle to be included in the list. More...
std::string	fLArMaterial
	Material for the LArTPC. More...
std::vector< std::string >	fLArVolumeName
	volume we will record energy depositions in More...
std::string	fECALMaterial
	Material for the ECAL. More...
std::vector< std::string >	fECALVolumeName
	volume we will record energy depositions in More...
std::string	fTrackerScMaterial
	Material for the TrackerSc (GArLite) More...
std::vector< std::string >	fTrackerScVolumeName
	volume we will record energy depositions in More...
std::string	fMuIDMaterial
	Material for the MuID. More...
std::vector< std::string >	fMuIDVolumeName
	volume we will record energy depositions in More...
bool	fApplyBirksLaw
std::vector< gar::sdp::LArDeposit >	fLArDeposits
	energy fDeposits for the LArTPC More...
std::map< gar::raw::CellID_t, std::vector< gar::sdp::CaloDeposit > >	m_ECALDeposits
std::vector< gar::sdp::CaloDeposit >	fECALDeposits
	energy fDeposits for the ECAL More...
std::map< gar::raw::CellID_t, std::vector< gar::sdp::CaloDeposit > >	m_TrackerScDeposits
std::vector< gar::sdp::CaloDeposit >	fTrackerScDeposits
	energy fDeposits for the TrackerSc More...
std::map< gar::raw::CellID_t, std::vector< gar::sdp::CaloDeposit > >	m_MuIDDeposits
std::vector< gar::sdp::CaloDeposit >	fMuIDDeposits
	energy fDeposits for the MuID More...
const gar::geo::GeometryCore *	fGeo
	geometry information More...
const detinfo::DetectorProperties *	fDetProp
	detector properties More...
const gar::geo::seg::MinervaSegmentationAlg *	fMinervaSegAlg

Detailed Description

list of energy deposits from Geant4

Definition at line 39 of file AuxDetAction.h.

Constructor & Destructor Documentation

gar::garg4::AuxDetAction::AuxDetAction	(	CLHEP::HepRandomEngine *	engine,
		fhicl::ParameterSet const &	pset
	)

Definition at line 45 of file AuxDetAction.cxx.

        {
            fGeo = gar::providerFrom<geo::GeometryGAr>();
            fDetProp = gar::providerFrom<detinfo::DetectorPropertiesService>();

            this->reconfigure(pset);
        }

gar::garg4::AuxDetAction::~AuxDetAction ( )

virtual

Definition at line 56 of file AuxDetAction.cxx.

        {
            // Delete anything that we created with "new'.
        }

Member Function Documentation

void gar::garg4::AuxDetAction::AddHits ( const std::map< gar::raw::CellID_t, std::vector< gar::sdp::CaloDeposit > >  m_hits, std::vector< gar::sdp::CaloDeposit > &  fDeposits  )

private

Definition at line 659 of file AuxDetAction.cxx.

        {
            //Loop over the hits in the map and add them together
            for(auto const &it : m_hits) {

                raw::CellID_t cellID = it.first;
                std::vector<gar::sdp::CaloDeposit> vechit = it.second;
                std::sort(vechit.begin(), vechit.end()); //sort per time

                float esum = 0.;
                float time = vechit.at(0).Time();
                int trackID = vechit.at(0).TrackID();
                double pos[3] = { vechit.at(0).X(), vechit.at(0).Y(), vechit.at(0).Z() };

                for(auto const &hit : vechit) {
                    esum += hit.Energy();
                }

                fDeposits.emplace_back( trackID, time, esum, pos, cellID );
            }
        }

void gar::garg4::AuxDetAction::BeginOfEventAction

(

const G4Event *

)

Definition at line 89 of file AuxDetAction.cxx.

        {
            // Clear any previous information.
            m_ECALDeposits.clear();
            fECALDeposits.clear();
            
            m_TrackerScDeposits.clear();
            fTrackerScDeposits.clear();

            m_MuIDDeposits.clear();
            fMuIDDeposits.clear();
            
            fLArDeposits.clear();
        }

float gar::garg4::AuxDetAction::birksAttenuation ( const G4Step *  step )

private

Definition at line 627 of file AuxDetAction.cxx.

        {
            #if G4VERSION_NUMBER >= 1001
            static G4EmSaturation s_emSaturation(1);
            #else
            static G4EmSaturation s_emSaturation();
            s_emSaturation.SetVerbose(1);
            #endif

            #if G4VERSION_NUMBER >= 1030
            static bool s_initialised = false;
            if(not s_initialised) {
                s_emSaturation.InitialiseG4Saturation();
                s_initialised = true;
            }
            #endif

            double energyDeposition = step->GetTotalEnergyDeposit();
            double length = step->GetStepLength();
            double niel   = step->GetNonIonizingEnergyDeposit();
            const G4Track* trk = step->GetTrack();
            const G4ParticleDefinition* particle = trk->GetDefinition();
            const G4MaterialCutsCouple* couple = trk->GetMaterialCutsCouple();
            double engyVis = s_emSaturation.VisibleEnergyDeposition(particle,
            couple,
            length,
            energyDeposition,
            niel);
            return engyVis;
        }

std::vector<gar::sdp::CaloDeposit> const& gar::garg4::AuxDetAction::CaloDeposits ( ) const

inline

Definition at line 60 of file AuxDetAction.h.

{ return fECALDeposits; }

void gar::garg4::AuxDetAction::ECALSteppingAction ( const G4Step *  step )

private

Definition at line 233 of file AuxDetAction.cxx.

        {
            MF_LOG_DEBUG("AuxDetAction")
            << "AuxDetAction::ECALSteppingAction";

            // Get the pointer to the track
            G4Track *track = step->GetTrack();

            const CLHEP::Hep3Vector &start = step->GetPreStepPoint()->GetPosition();
            const CLHEP::Hep3Vector &stop  = track->GetPosition();

            // If it's a null step, don't use it.
            if(start == stop) return;
            if(step->GetTotalEnergyDeposit() == 0) return;

            // check that we are in the correct material to record a hit
            const std::string VolumeName = this->GetVolumeName(track);

            if (std::find_if(fECALVolumeName.begin(), fECALVolumeName.end(), [&VolumeName](std::string s) { return VolumeName.find(s) != std::string::npos; }) == fECALVolumeName.end())
                return;

            // check the material
            auto pos = 0.5 * (start + stop);
            TGeoNode *node = fGeo->FindNode(pos.x()/CLHEP::cm, pos.y()/CLHEP::cm, pos.z()/CLHEP::cm);//Node in cm...

            if(nullptr == node){
                MF_LOG_DEBUG("AuxDetAction::ECALSteppingAction")
                << "Node not found in "
                << pos.x() << " mm "
                << pos.y() << " mm "
                << pos.z() << " mm";
                return;
            }

            std::string volmaterial = node->GetMedium()->GetMaterial()->GetName();
            if ( ! std::regex_match(volmaterial, std::regex(fECALMaterial)) ) return;

            // only worry about energy depositions larger than the minimum required
            MF_LOG_DEBUG("AuxDetAction::ECALSteppingAction")
            << "In volume "
            << VolumeName
            << " Material is "
            << volmaterial
            << " step size is "
            << step->GetStepLength() / CLHEP::cm
            << " cm and deposited "
            << step->GetTotalEnergyDeposit()
            << " MeV of energy";

            // the step mid point is used for the position of the deposit
            G4ThreeVector G4Global = 0.5 * (step->GetPreStepPoint()->GetPosition() + step->GetPostStepPoint()->GetPosition() );

            //get layer and slice number from the volume name (easier for segmentation later)
            unsigned int layer = this->GetLayerNumber(VolumeName); //get layer number
            unsigned int slice = this->GetSliceNumber(VolumeName); // get slice number
            unsigned int det_id = this->GetDetNumber(VolumeName); // 1 == Barrel, 2 = Endcap
            unsigned int stave = this->GetStaveNumber(VolumeName); //get the stave number
            unsigned int module = this->GetModuleNumber(VolumeName); //get the module number

            MF_LOG_DEBUG("AuxDetAction::ECALSteppingAction")
            << "det_id " << det_id
            << " stave " << stave
            << " module " << module
            << " layer " << layer
            << " slice " << slice;

            //Transform from global coordinates to local coordinates in mm
            G4ThreeVector G4Local = this->globalToLocal(step, G4Global);
            //Transform in cm
            std::array<double, 3> G4Localcm = {G4Local.x() / CLHEP::cm, G4Local.y() / CLHEP::cm, G4Local.z() / CLHEP::cm};
            //Get cellID
            raw::CellID_t cellID = fGeo->GetCellID(node, det_id, stave, module, layer, slice, G4Localcm);//encoding the cellID on 64 bits

            //Don't correct for the strip or tile position yet
            double G4Pos[3] = {0., 0., 0.}; // in cm
            G4Pos[0] = G4Global.x() / CLHEP::cm;
            G4Pos[1] = G4Global.y() / CLHEP::cm;
            G4Pos[2] = G4Global.z() / CLHEP::cm;

            // get the track id for this step
            auto trackID = ParticleListAction::GetCurrentTrackID();
            float time = step->GetPreStepPoint()->GetGlobalTime();

            float edep = this->GetStepEnergy(step, true) * CLHEP::MeV / CLHEP::GeV;

            MF_LOG_DEBUG("AuxDetAction::ECALSteppingAction")
            << "Energy deposited "
            << step->GetTotalEnergyDeposit() * CLHEP::MeV / CLHEP::GeV
            << " GeV in cellID "
            << cellID
            << " after Birks "
            << edep
            << " GeV";

            //Create a map of cellID to SimHit
            gar::sdp::CaloDeposit hit( trackID, time, edep, G4Pos, cellID );
            if(m_ECALDeposits.find(cellID) != m_ECALDeposits.end())
            m_ECALDeposits[cellID].push_back(hit);
            else {
                std::vector<gar::sdp::CaloDeposit> vechit;
                vechit.push_back(hit);
                m_ECALDeposits.emplace(cellID, vechit);
            }
        }

void gar::garg4::AuxDetAction::EndOfEventAction

(

const G4Event *

)

Definition at line 136 of file AuxDetAction.cxx.

        {
            //sort per time the hits
            if (fGeo->HasLArTPCDetector()) {
                std::sort(fLArDeposits.begin(), fLArDeposits.end());
            }

            if(fGeo->HasECALDetector()) {
                this->AddHits(m_ECALDeposits, fECALDeposits);
                std::sort(fECALDeposits.begin(), fECALDeposits.end());
            }

            if(fGeo->HasTrackerScDetector() && nullptr != fMinervaSegAlg) {
                fMinervaSegAlg->AddHitsMinerva(m_TrackerScDeposits, fTrackerScDeposits);
                std::sort(fTrackerScDeposits.begin(), fTrackerScDeposits.end());
            }

            if(fGeo->HasMuonDetector()) {
                this->AddHits(m_MuIDDeposits, fMuIDDeposits);
                std::sort(fMuIDDeposits.begin(), fMuIDDeposits.end());
            }
        }

unsigned int gar::garg4::AuxDetAction::GetDetNumber ( std::string  volname )

private

Definition at line 568 of file AuxDetAction.cxx.

        {
            unsigned int det_id = 0;

            if( volname.find("ECal") !=  std::string::npos )
            {
                if( volname.find("Barrel") !=  std::string::npos )
                det_id = 1;
                if( volname.find("Endcap") !=  std::string::npos )
                det_id = 2;
            }

            if( volname.find("Yoke") !=  std::string::npos )
            {
                if( volname.find("Barrel") !=  std::string::npos )
                det_id = 4;
                if( volname.find("Endcap") !=  std::string::npos )
                det_id = 4;
            }

            return det_id;
        }

unsigned int gar::garg4::AuxDetAction::GetLayerNumber ( std::string  volname )

private

Definition at line 556 of file AuxDetAction.cxx.

        {
            return std::atoi( (volname.substr( volname.find("layer_") + 6, 2)).c_str() );
        }

unsigned int gar::garg4::AuxDetAction::GetModuleNumber ( std::string  volname )

private

Definition at line 598 of file AuxDetAction.cxx.

        {
            return std::atoi( (volname.substr( volname.find("_module") + 7, 2)).c_str() );
        }

unsigned int gar::garg4::AuxDetAction::GetSliceNumber ( std::string  volname )

private

Definition at line 562 of file AuxDetAction.cxx.

        {
            return std::atoi( (volname.substr( volname.find("slice") + 5, 1)).c_str() );
        }

unsigned int gar::garg4::AuxDetAction::GetStaveNumber ( std::string  volname )

private

Definition at line 592 of file AuxDetAction.cxx.

        {
            return std::atoi( (volname.substr( volname.find("_stave") + 6, 2)).c_str() );
        }

float gar::garg4::AuxDetAction::GetStepEnergy ( const G4Step *  step, bool  birks  )

private

Definition at line 616 of file AuxDetAction.cxx.

        {
            if(birks){
                return this->birksAttenuation(step);
            }
            else{
                return step->GetTotalEnergyDeposit();
            }
        }

std::string gar::garg4::AuxDetAction::GetVolumeName ( const G4Track *  track )

private

Definition at line 548 of file AuxDetAction.cxx.

        {
            std::string VolName = track->GetVolume()->GetName();
            VolName.erase(VolName.length()-3, 3);
            return VolName;
        }

G4ThreeVector gar::garg4::AuxDetAction::globalToLocal ( const G4Step *  step, const G4ThreeVector &  glob  )

private

Definition at line 604 of file AuxDetAction.cxx.

        {
            return step->GetPreStepPoint()->GetTouchable()->GetHistory()->GetTopTransform().TransformPoint(glob);
        }

std::vector<gar::sdp::LArDeposit> const& gar::garg4::AuxDetAction::LArDeposits ( ) const

inline

Definition at line 58 of file AuxDetAction.h.

{ return fLArDeposits; }

void gar::garg4::AuxDetAction::LArSteppingAction ( const G4Step *  step )

private

Definition at line 160 of file AuxDetAction.cxx.

        {
            MF_LOG_DEBUG("AuxDetAction")
            << "AuxDetAction::LArSteppingAction";

            // Get the pointer to the track
            G4Track *track = step->GetTrack();

            const CLHEP::Hep3Vector &start = step->GetPreStepPoint()->GetPosition();
            const CLHEP::Hep3Vector &stop  = track->GetPosition();

            // If it's a null step, don't use it.
            if(start == stop) return;
            if(step->GetTotalEnergyDeposit() == 0) return;

            // check that we are in the correct material to record a hit
            const std::string VolumeName = this->GetVolumeName(track);
            if( std::find_if( fLArVolumeName.begin(), fLArVolumeName.end(), [&VolumeName](std::string s) { return VolumeName.find(s) != std::string::npos; } ) == fLArVolumeName.end() )
            return;

            // check the material
            auto pos = 0.5 * (start + stop);
            TGeoNode *node = fGeo->FindNode(pos.x()/CLHEP::cm, pos.y()/CLHEP::cm, pos.z()/CLHEP::cm);//Node in cm...

            if(nullptr == node){
                MF_LOG_DEBUG("AuxDetAction::LArSteppingAction")
                << "Node not found in "
                << pos.x() << " mm "
                << pos.y() << " mm "
                << pos.z() << " mm";
                return;
            }

            std::string volmaterial = node->GetMedium()->GetMaterial()->GetName();
            if ( ! std::regex_match(volmaterial, std::regex(fLArMaterial)) ) return;

            // only worry about energy depositions larger than the minimum required
            if(step->GetTotalEnergyDeposit() * CLHEP::MeV / CLHEP::GeV > fLArEnergyCut){

                MF_LOG_DEBUG("AuxDetAction::LArSteppingAction")
                << "In volume "
                << VolumeName
                << " Material is "
                << volmaterial
                << " step size is "
                << step->GetStepLength() / CLHEP::cm
                << " cm and deposited "
                << step->GetTotalEnergyDeposit()
                << " MeV of energy with a minimum of "
                << fLArEnergyCut
                << " required.";

                // the step mid point is used for the position of the deposit
                auto midPoint = 0.5 * (step->GetPreStepPoint()->GetPosition() +
                step->GetPostStepPoint()->GetPosition() );

                // get the track id for this step
                auto trackID  = ParticleListAction::GetCurrentTrackID();
                float time = step->GetPreStepPoint()->GetGlobalTime();

                fLArDeposits.emplace_back(trackID,
                time,//get the time of the first subhit
                step->GetTotalEnergyDeposit() * CLHEP::MeV / CLHEP::GeV,
                midPoint.x() / CLHEP::cm,
                midPoint.y() / CLHEP::cm,
                midPoint.z() / CLHEP::cm,
                step->GetStepLength() / CLHEP::cm,
                (trackID > 0));

            } // end if enough energy to worry about this step
        }

G4ThreeVector gar::garg4::AuxDetAction::localToGlobal ( const G4Step *  step, const G4ThreeVector &  loc  )

private

Definition at line 610 of file AuxDetAction.cxx.

        {
            return step->GetPreStepPoint()->GetTouchable()->GetHistory()->GetTopTransform().Inverse().TransformPoint(loc);
        }

std::vector<gar::sdp::CaloDeposit> const& gar::garg4::AuxDetAction::MuIDDeposits ( ) const

inline

Definition at line 64 of file AuxDetAction.h.

{ return fMuIDDeposits; }

void gar::garg4::AuxDetAction::MuIDSteppingAction ( const G4Step *  step )

private

Definition at line 441 of file AuxDetAction.cxx.

        {
            MF_LOG_DEBUG("AuxDetAction")
            << "AuxDetAction::MuIDSteppingAction";

            // Get the pointer to the track
            G4Track *track = step->GetTrack();

            const CLHEP::Hep3Vector &start = step->GetPreStepPoint()->GetPosition();
            const CLHEP::Hep3Vector &stop  = track->GetPosition();

            // If it's a null step, don't use it.
            if(start == stop) return;
            if(step->GetTotalEnergyDeposit() == 0) return;

            // check that we are in the correct material to record a hit
            const std::string VolumeName = this->GetVolumeName(track);

            if (std::find_if(fMuIDVolumeName.begin(), fMuIDVolumeName.end(), [&VolumeName](std::string s) { return VolumeName.find(s) != std::string::npos; }) == fMuIDVolumeName.end())
                return;

            // check the material
            auto pos = 0.5 * (start + stop);
            TGeoNode *node = fGeo->FindNode(pos.x()/CLHEP::cm, pos.y()/CLHEP::cm, pos.z()/CLHEP::cm);//Node in cm...

            if (nullptr == node)
            {
                MF_LOG_DEBUG("AuxDetAction::MuIDSteppingAction")
                << "Node not found in "
                << pos.x() << " mm "
                << pos.y() << " mm "
                << pos.z() << " mm";
                return;
            }

            std::string volmaterial = node->GetMedium()->GetMaterial()->GetName();
            if ( ! std::regex_match(volmaterial, std::regex(fMuIDMaterial)) ) return;

            // only worry about energy depositions larger than the minimum required
            MF_LOG_DEBUG("AuxDetAction::MuIDSteppingAction")
            << "In volume "
            << VolumeName
            << " Material is "
            << volmaterial
            << " step size is "
            << step->GetStepLength() / CLHEP::cm
            << " cm and deposited "
            << step->GetTotalEnergyDeposit()
            << " MeV of energy";

            // the step mid point is used for the position of the deposit
            G4ThreeVector G4Global = 0.5 * (step->GetPreStepPoint()->GetPosition() + step->GetPostStepPoint()->GetPosition() );

            //get layer and slice number from the volume name (easier for segmentation later)
            unsigned int layer = this->GetLayerNumber(VolumeName); //get layer number
            unsigned int slice = this->GetSliceNumber(VolumeName); // get slice number
            unsigned int det_id = this->GetDetNumber(VolumeName); // 1 == Barrel, 2 = Endcap
            unsigned int stave = this->GetStaveNumber(VolumeName); //get the stave number
            unsigned int module = this->GetModuleNumber(VolumeName); //get the module number

            MF_LOG_DEBUG("AuxDetAction::MuIDSteppingAction")
            << "det_id " << det_id
            << " stave " << stave
            << " module " << module
            << " layer " << layer
            << " slice " << slice;

            //Transform from global coordinates to local coordinates in mm
            G4ThreeVector G4Local = this->globalToLocal(step, G4Global);
            //Transform in cm
            std::array<double, 3> G4Localcm = {G4Local.x() / CLHEP::cm, G4Local.y() / CLHEP::cm, G4Local.z() / CLHEP::cm};
            //Get cellID
            raw::CellID_t cellID = fGeo->GetCellID(node, det_id, stave, module, layer, slice, G4Localcm);//encoding the cellID on 64 bits

            //Don't correct for the strip or tile position yet
            double G4Pos[3] = {0., 0., 0.}; // in cm
            G4Pos[0] = G4Global.x() / CLHEP::cm;
            G4Pos[1] = G4Global.y() / CLHEP::cm;
            G4Pos[2] = G4Global.z() / CLHEP::cm;

            // get the track id for this step
            auto trackID = ParticleListAction::GetCurrentTrackID();
            float time = step->GetPreStepPoint()->GetGlobalTime();

            float edep = this->GetStepEnergy(step, true) * CLHEP::MeV / CLHEP::GeV;

            MF_LOG_DEBUG("AuxDetAction::MuIDSteppingAction")
            << "Energy deposited "
            << step->GetTotalEnergyDeposit() * CLHEP::MeV / CLHEP::GeV
            << " GeV in cellID "
            << cellID
            << " after Birks "
            << edep
            << " GeV";

            //Create a map of cellID to SimHit
            gar::sdp::CaloDeposit hit( trackID, time, edep, G4Pos, cellID );
            if(m_MuIDDeposits.find(cellID) != m_MuIDDeposits.end())
            m_MuIDDeposits[cellID].push_back(hit);
            else {
                std::vector<gar::sdp::CaloDeposit> vechit;
                vechit.push_back(hit);
                m_MuIDDeposits.emplace(cellID, vechit);
            }
        }

void gar::garg4::AuxDetAction::PostTrackingAction

(

const G4Track *

)

Definition at line 111 of file AuxDetAction.cxx.

        {
        }

void gar::garg4::AuxDetAction::PreTrackingAction

(

const G4Track *

)

Definition at line 105 of file AuxDetAction.cxx.

        {

        }

void gar::garg4::AuxDetAction::reconfigure

(

fhicl::ParameterSet const &

pset

)

Definition at line 62 of file AuxDetAction.cxx.

        {
            fLArEnergyCut = pset.get<double>("LArEnergyCut", 0.);
            fLArVolumeName = pset.get<std::vector<std::string>>("LArVolumeName");
            fLArMaterial = pset.get<std::string>("LArMaterial", "LAr");

            fECALMaterial = pset.get<std::string>("ECALMaterial", "Scintillator");
            fECALVolumeName = pset.get<std::vector<std::string>>("ECALVolumeName");

            fTrackerScMaterial = pset.get<std::string>("TrackerScMaterial", "Scintillator");
            fTrackerScVolumeName = pset.get<std::vector<std::string>>("TrackerScVolumeName");

            fMuIDMaterial = pset.get<std::string>("MuIDMaterial", "Scintillator");
            fMuIDVolumeName = pset.get<std::vector<std::string>>("MuIDVolumeName");

            fApplyBirksLaw = pset.get<bool>("ApplyBirksLaw", true);

            // std::cout << "AuxDetAction: Name of the Volumes to track for the LArTPC" << std::endl;
            // for(unsigned int i = 0; i < fLArVolumeName.size(); i++) std::cout << fLArVolumeName.at(i) << " ";
            // std::cout << std::endl;

            fMinervaSegAlg = (gar::geo::seg::MinervaSegmentationAlg*)fGeo->MinervaSegmentationAlg();

            return;
        }

void gar::garg4::AuxDetAction::SteppingAction

(

const G4Step *

step

)

Definition at line 117 of file AuxDetAction.cxx.

        {
            MF_LOG_DEBUG("AuxDetAction")
            << "AuxDetAction::SteppingAction";

            if(fGeo->HasLArTPCDetector())
            this->LArSteppingAction(step);

            if(fGeo->HasECALDetector())
            this->ECALSteppingAction(step);

            if(fGeo->HasTrackerScDetector())
            this->TrackerScSteppingAction(step);

            if(fGeo->HasMuonDetector())
            this->MuIDSteppingAction(step);
        }// end of AuxDetAction::SteppingAction

std::vector<gar::sdp::CaloDeposit> const& gar::garg4::AuxDetAction::TrackerScDeposits ( ) const

inline

Definition at line 62 of file AuxDetAction.h.

{ return fTrackerScDeposits; }

void gar::garg4::AuxDetAction::TrackerScSteppingAction ( const G4Step *  step )

private

Definition at line 339 of file AuxDetAction.cxx.

        {
            MF_LOG_DEBUG("AuxDetAction")
            << "AuxDetAction::TrackerScSteppingAction";

            // Get the pointer to the track
            G4Track *track = step->GetTrack();

            const CLHEP::Hep3Vector &start = step->GetPreStepPoint()->GetPosition();
            const CLHEP::Hep3Vector &stop  = track->GetPosition();

            // If it's a null step, don't use it.
            if(start == stop) return;
            if(step->GetTotalEnergyDeposit() == 0) return;

            // check that we are in the correct material to record a hit
            const std::string VolumeName = this->GetVolumeName(track);
            if( std::find_if( fTrackerScVolumeName.begin(), fTrackerScVolumeName.end(), [&VolumeName](std::string s) { return VolumeName.find(s) != std::string::npos; } ) == fTrackerScVolumeName.end() )
            return;

            // check the material
            auto pos = 0.5 * (start + stop);
            TGeoNode *node = fGeo->FindNode(pos.x()/CLHEP::cm, pos.y()/CLHEP::cm, pos.z()/CLHEP::cm);//Node in cm...

            if (nullptr == node)
            {
                MF_LOG_DEBUG("AuxDetAction::TrackerScSteppingAction")
                << "Node not found in "
                << pos.x()/CLHEP::cm << " cm "
                << pos.y()/CLHEP::cm << " cm "
                << pos.z()/CLHEP::cm << " cm in volume "
                << VolumeName; 
                return;
            }

            std::string volmaterial = node->GetMedium()->GetMaterial()->GetName();
            if ( ! std::regex_match(volmaterial, std::regex(fTrackerScMaterial)) ) return;

            // only worry about energy depositions larger than the minimum required
            MF_LOG_DEBUG("AuxDetAction::TrackerScSteppingAction")
            << "In volume "
            << VolumeName
            << " Material is "
            << volmaterial
            << " step size is "
            << step->GetStepLength() / CLHEP::cm
            << " cm and deposited "
            << step->GetTotalEnergyDeposit()
            << " MeV of energy";

            // the step mid point is used for the position of the deposit
            G4ThreeVector G4Global = 0.5 * (step->GetPreStepPoint()->GetPosition() + step->GetPostStepPoint()->GetPosition() );

            //get layer and slice number from the volume name (easier for segmentation later)
            unsigned int layer = this->GetLayerNumber(VolumeName); //get layer number
            unsigned int slice = this->GetSliceNumber(VolumeName); // get slice number
            unsigned int det_id = 3;

            MF_LOG_DEBUG("AuxDetAction::TrackerScSteppingAction")
            << "det_id " << det_id
            << " layer " << layer
            << " slice " << slice;

            //Transform from global coordinates to local coordinates in mm
            G4ThreeVector G4Local = this->globalToLocal(step, G4Global);
            //Transform in cm
            std::array<double, 3> G4Localcm = {G4Local.x() / CLHEP::cm, G4Local.y() / CLHEP::cm, G4Local.z() / CLHEP::cm};
            //Get cellID
            raw::CellID_t cellID = fGeo->GetCellID(node, det_id, 0, 0, layer, slice, G4Localcm);//encoding the cellID on 64 bits

            //Don't correct for the strip or tile position yet
            double G4Pos[3] = {0., 0., 0.}; // in cm
            G4Pos[0] = G4Global.x() / CLHEP::cm;
            G4Pos[1] = G4Global.y() / CLHEP::cm;
            G4Pos[2] = G4Global.z() / CLHEP::cm;

            // get the track id for this step
            auto trackID = ParticleListAction::GetCurrentTrackID();
            float time = step->GetPreStepPoint()->GetGlobalTime();
            float edep = this->GetStepEnergy(step, true) * CLHEP::MeV / CLHEP::GeV;

            MF_LOG_DEBUG("AuxDetAction::TrackerScSteppingAction")
                << "Energy deposited "
                << step->GetTotalEnergyDeposit() * CLHEP::MeV / CLHEP::GeV
                << " GeV in cellID "
                << cellID
                << " after Birks "
                << edep
                << " GeV";

            //Create a map of cellID to SimHit
            gar::sdp::CaloDeposit hit( trackID, time, edep, G4Pos, cellID );
            if(m_TrackerScDeposits.find(cellID) != m_TrackerScDeposits.end())
            m_TrackerScDeposits[cellID].push_back(hit);
            else {
                std::vector<gar::sdp::CaloDeposit> vechit;
                vechit.push_back(hit);
                m_TrackerScDeposits.emplace(cellID, vechit);
            }
        }

Member Data Documentation

bool gar::garg4::AuxDetAction::fApplyBirksLaw

private

Definition at line 99 of file AuxDetAction.h.

const detinfo::DetectorProperties* gar::garg4::AuxDetAction::fDetProp

private

detector properties

Definition at line 113 of file AuxDetAction.h.

std::vector<gar::sdp::CaloDeposit> gar::garg4::AuxDetAction::fECALDeposits

private

energy fDeposits for the ECAL

Definition at line 104 of file AuxDetAction.h.

std::string gar::garg4::AuxDetAction::fECALMaterial

private

Material for the ECAL.

Definition at line 91 of file AuxDetAction.h.

std::vector<std::string> gar::garg4::AuxDetAction::fECALVolumeName

private

volume we will record energy depositions in

Definition at line 92 of file AuxDetAction.h.

const gar::geo::GeometryCore* gar::garg4::AuxDetAction::fGeo

private

geometry information

Definition at line 112 of file AuxDetAction.h.

std::vector<gar::sdp::LArDeposit> gar::garg4::AuxDetAction::fLArDeposits

private

energy fDeposits for the LArTPC

Definition at line 101 of file AuxDetAction.h.

double gar::garg4::AuxDetAction::fLArEnergyCut

private

The minimum energy in GeV for a particle to be included in the list.

Definition at line 87 of file AuxDetAction.h.

std::string gar::garg4::AuxDetAction::fLArMaterial

private

Material for the LArTPC.

Definition at line 88 of file AuxDetAction.h.

std::vector<std::string> gar::garg4::AuxDetAction::fLArVolumeName

private

volume we will record energy depositions in

Definition at line 89 of file AuxDetAction.h.

const gar::geo::seg::MinervaSegmentationAlg* gar::garg4::AuxDetAction::fMinervaSegAlg

private

Definition at line 114 of file AuxDetAction.h.

std::vector<gar::sdp::CaloDeposit> gar::garg4::AuxDetAction::fMuIDDeposits

private

energy fDeposits for the MuID

Definition at line 110 of file AuxDetAction.h.

std::string gar::garg4::AuxDetAction::fMuIDMaterial

private

Material for the MuID.

Definition at line 97 of file AuxDetAction.h.

std::vector<std::string> gar::garg4::AuxDetAction::fMuIDVolumeName

private

volume we will record energy depositions in

Definition at line 98 of file AuxDetAction.h.

std::vector<gar::sdp::CaloDeposit> gar::garg4::AuxDetAction::fTrackerScDeposits

private

energy fDeposits for the TrackerSc

Definition at line 107 of file AuxDetAction.h.

std::string gar::garg4::AuxDetAction::fTrackerScMaterial

private

Material for the TrackerSc (GArLite)

Definition at line 94 of file AuxDetAction.h.

std::vector<std::string> gar::garg4::AuxDetAction::fTrackerScVolumeName

private

volume we will record energy depositions in

Definition at line 95 of file AuxDetAction.h.

std::map< gar::raw::CellID_t, std::vector<gar::sdp::CaloDeposit> > gar::garg4::AuxDetAction::m_ECALDeposits

private

Definition at line 103 of file AuxDetAction.h.

std::map< gar::raw::CellID_t, std::vector<gar::sdp::CaloDeposit> > gar::garg4::AuxDetAction::m_MuIDDeposits

private

Definition at line 109 of file AuxDetAction.h.

std::map< gar::raw::CellID_t, std::vector<gar::sdp::CaloDeposit> > gar::garg4::AuxDetAction::m_TrackerScDeposits

private

Definition at line 106 of file AuxDetAction.h.

---

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

• garsoft/GArG4/AuxDetAction.h
• garsoft/GArG4/AuxDetAction.cxx