LArFastShower Class Reference

NEEDS DOCUMENTATION. More...

#include <LArFastShower.h>

Inheritance diagram for LArFastShower:

Collaboration diagram for LArFastShower:

Public Member Functions
	LArFastShower (const std::string &name, G4Region *region, const FastShowerConfigStruct &config, IFastSimDedicatedSD *fastSimDedicatedSD)
	Constructor.
virtual	~LArFastShower ()
	Destructor.
G4bool	IsApplicable (const G4ParticleDefinition &) override
	Determines the applicability of the fast sim model to this particle type Called once for each track picked up by Geant as it enters a region with the fast sim assigned to it.
virtual G4bool	ModelTrigger (const G4FastTrack &) override
	Determines the applicability of the fast sim model to this particular track.
virtual G4bool	ForcedAccept (const G4FastTrack &)
	If it returns true, the particle will be parameterized without further checks.
virtual G4bool	ForcedDeny (const G4FastTrack &)
	If it returns true, the particle will be returned to G4 without further checks.
void	DoIt (const G4FastTrack &, G4FastStep &) override
	Assigns the track to the appropriate method for application of the fast simulation.

Protected Member Functions
IFastSimDedicatedSD *	fastShowerSD ()
ILArG4ShowerLibSvc *	showerLibSvc ()
void	KillParticle (const G4FastTrack &, G4FastStep &)
	Method to kill a particle and deposit its energy using exponential decay function.
void	UseShowerLib (const G4FastTrack &, G4FastStep &)
	Function for the application of shower library.
virtual G4bool	CheckContainment (const G4FastTrack &fastTrack)
	Function to check the containment of a shower within a regular detector region.
std::unique_ptr< const HepMC::GenEvent >	GetGenEvent (const G4FastTrack &fastTrack)
bool	flagToShowerLib (const G4ParticleDefinition &particleType) const
	get switch for frozen showers
double	maxEneToShowerLib (const G4ParticleDefinition &particleType) const
	get lower energy limit for frozen showers
double	minEneToShowerLib (const G4ParticleDefinition &particleType) const
	get upper energy limit for frozen showers
bool	generateFSStartingPoint (std::unique_ptr< const HepMC::GenEvent > &ge) const

Private Attributes
const FastShowerConfigStruct	m_configuration
IFastSimDedicatedSD *	m_fastSimDedicatedSD {}
	Shower library sensitive detector for this shower.
ILArG4ShowerLibSvc *	m_showerLibSvc {}
	Pointer to the shower library service.
bool	m_generate_starting_points
std::shared_ptr< HepMC3::WriterAscii >	m_starting_points_file
std::string	m_detector_tag_str
std::map< std::string, int >	m_detmap
int	m_eventNum
std::map< int, bool >	m_applicableMap

Detailed Description

NEEDS DOCUMENTATION.

Definition at line 27 of file LArFastShower.h.

Constructor & Destructor Documentation

LArFastShower()

LArFastShower::LArFastShower	(	const std::string &	name,
		G4Region *	region,
		const FastShowerConfigStruct &	config,
		IFastSimDedicatedSD *	fastSimDedicatedSD )

Constructor.

Definition at line 38 of file LArFastShower.cxx.

                                                                     :
  G4VFastSimulationModel(name, region),
  m_configuration(config),
  m_fastSimDedicatedSD(fastSimDedicatedSD),
  m_showerLibSvc(nullptr),
  m_generate_starting_points(false),
  m_starting_points_file(),
  m_eventNum(0)
{
  /* Starting points, i.e. vertex coordinates, are needed to create 
   * the Frozen Shower library, so they are saved in a hepmc file. 
   * Frozen showers are then simulated from these starting points 
   * in a separate job. To speed up the simulation, 
   * showers will be read from the library instead of being simulated.*/
  m_generate_starting_points = (!m_configuration.m_generated_starting_points_file.empty());
  if (m_generate_starting_points) {
    std::string hepmcFileName = m_configuration.m_generated_starting_points_file;
    
    // In multi-thread run, multiple hepmc files are created.
    // To distinguish between them we add thread_id in their name. 
    if (Gaudi::Concurrency::ConcurrencyFlags::numThreads() > 1)
      {
    auto threadId = std::this_thread::get_id();
    std::stringstream ss;
    ss << threadId;
    hepmcFileName += "."+ss.str();
      }
    m_starting_points_file  = std::make_shared<HepMC3::WriterAscii>(hepmcFileName);
  }
 
  enum DETECTOR { EMB=100000, EMEC=200000, FCAL1=300000, FCAL2=400000,
                  FCAL3=500000, HECLOC=600000, HEC=700000 };
 
  m_detmap["EMB"]=EMB;
  m_detmap["EMEC"]=EMEC;
  m_detmap["FCAL1"]=FCAL1;
  m_detmap["FCAL2"]=FCAL2;
  m_detmap["FCAL3"]=FCAL3;
  m_detmap["HECLOC"]=HECLOC;
  m_detmap["HEC"]=HEC;
}

~LArFastShower()

virtual LArFastShower::~LArFastShower ( )

inlinevirtual

Destructor.

Definition at line 36 of file LArFastShower.h.

{}

Member Function Documentation

CheckContainment()

G4bool LArFastShower::CheckContainment ( const G4FastTrack & fastTrack )

protectedvirtual

Function to check the containment of a shower within a regular detector region.

Definition at line 272 of file LArFastShower.cxx.

{
 
  G4ThreeVector showerDirection = fastTrack.GetPrimaryTrack()->GetMomentumDirection();
  G4ThreeVector initialShowerPosition = fastTrack.GetPrimaryTrack()->GetPosition();
  G4ThreeVector orthoShower = showerDirection.orthogonal();
  G4ThreeVector crossShower = showerDirection.cross(orthoShower);
 
#ifdef _TRACE_FSM_
  G4cout << "LArFastShower::CheckContainment() orthoShower: " << orthoShower << G4endl;
  G4cout << "LArFastShower::CheckContainment() crossShower: " << crossShower << G4endl;
#endif
 
  //Build 5 points at the shower max. edges and far end
  //this picks the points where 99% of the particle energy was already deposited
  /* Short history of containment check:
   * First, it was magic numbers from ShowerParams class
   G4double Zmx    = myParameterisation()->GetAveZmx();
   G4double  R     = myParameterisation()->GetAveR90(); // Easy - just multiply
   G4double  Z     = myParameterisation()->GetAveZ90(); // More convoluted
   * Then, after ShowerParams class was sent to code heaven, the magic numbers were saved from it
   * and stored right here:
   G4double Zmx = 22*mm;
   G4double R   = 1.5*4*cm;
   G4double Z   = 22*2.5*mm;
   * Now, we take it directly from the library
   */
  G4double Z = showerLibSvc()->getContainmentZ(fastTrack,m_configuration.m_detector_tag);
  G4double R = showerLibSvc()->getContainmentR(fastTrack,m_configuration.m_detector_tag);
 
  if (Z == 0.0 && R == 0.0) {
    // no containment check
    return true;
  }
 
  // Here is OUR magic number. Looking on the hit distribution plot,
  // it seems that that way most of hits will be inside
  G4double Zmx = Z / 3;
 
  G4int cosPhi[4] = {1,0,-1,0};
  G4int sinPhi[4] = {0,1,0,-1};
 
#ifdef _TRACE_FSM_
  G4cout << "LArFastShower::CheckContainment() R =          " << R   << G4endl;
  G4cout << "LArFastShower::CheckContainment() Z =          " << Z   << G4endl;
#endif
 
  G4ThreeVector position;
 
  G4VSolid* caloSolid = fastTrack.GetEnvelopeSolid();
  const G4AffineTransform* affineTransformation = fastTrack.GetAffineTransformation();
 
  //Startpoint
  position = initialShowerPosition;
  affineTransformation->ApplyPointTransform(position);
  if(caloSolid->Inside(position) == kOutside)
    return false;
 
  //Longitudinal Endpoint
  position = initialShowerPosition + Z*showerDirection;
  affineTransformation->ApplyPointTransform(position);
  if(caloSolid->Inside(position) == kOutside)
    return false;
 
  //Lateral Spread
  for(int i=0; i<4 ;i++)
    {
      position = initialShowerPosition + Zmx*showerDirection +
                 R*cosPhi[i]*orthoShower + R*sinPhi[i]*crossShower;
      affineTransformation->ApplyPointTransform(position);
      if(caloSolid->Inside(position) == kOutside)
        return false;
    }
 
#ifdef _TRACE_FSM_
  G4cout << "LArFastShower::CheckContainment()  Shower is contained " << G4endl;
#endif
 
  return true;
 
}

DoIt()

void LArFastShower::DoIt ( const G4FastTrack & fastTrack, G4FastStep & fastStep )

override

Assigns the track to the appropriate method for application of the fast simulation.

Only called if ModelTrigger returns true.

Definition at line 181 of file LArFastShower.cxx.

{
#ifdef _TRACE_FSM_
  G4cout << "LArFastShower::Doit()" << G4endl;
#endif
 
  if ( m_generate_starting_points ) {
    if (CLHEP::RandFlat::shoot(G4Random::getTheEngine()) <= m_configuration.m_generated_starting_points_ratio) {
      std::unique_ptr<const HepMC::GenEvent> ge = GetGenEvent(fastTrack);
      generateFSStartingPoint(ge);
    }
    KillParticle( fastTrack, fastStep );
    return;
  }
  this->UseShowerLib( fastTrack, fastStep );
 
#ifdef _TRACE_FSM_
  G4cout << "LArFastShower::Doit() done" << G4endl;
#endif
 
}

fastShowerSD()

IFastSimDedicatedSD * LArFastShower::fastShowerSD ( )

protected

Definition at line 81 of file LArFastShower.cxx.

{
  if ( !m_fastSimDedicatedSD ) {
    throw std::runtime_error("LArFastShower: no pointer to IFastSimDedicatedSD!");
  }
  return m_fastSimDedicatedSD;
}

flagToShowerLib()

bool LArFastShower::flagToShowerLib ( const G4ParticleDefinition & particleType ) const

protected

get switch for frozen showers

Definition at line 393 of file LArFastShower.cxx.

{
  if ( &particleType == G4Electron::ElectronDefinition() ||
       &particleType == G4Positron::PositronDefinition() ) {
    return m_configuration.m_e_FlagShowerLib;
  } else if ( &particleType == G4Gamma::GammaDefinition() ) {
    return m_configuration.m_g_FlagShowerLib;
  } else if ( &particleType == G4Neutron::NeutronDefinition() ) {
    return m_configuration.m_Neut_FlagShowerLib;
  } else if ( &particleType == G4PionPlus::PionPlusDefinition() ||
              &particleType == G4PionMinus::PionMinusDefinition() ) {
    return m_configuration.m_Pion_FlagShowerLib;
  }
  return false;
}

ForcedAccept()

G4bool LArFastShower::ForcedAccept ( const G4FastTrack & fastTrack )

virtual

If it returns true, the particle will be parameterized without further checks.

Definition at line 446 of file LArFastShower.cxx.

{
  G4ThreeVector initialShowerPosition = fastTrack.GetPrimaryTrack()->GetPosition();
 
  // if ( !m_configuration.m_containHigh &&
  //     ( initialShowerPosition.eta()>=m_configuration.m_absHighEta ||
  //       initialShowerPosition.eta()<=-m_configuration.m_absHighEta ) ) return true;
 
  if ( !m_configuration.m_containHigh &&
      ( initialShowerPosition.eta()>m_configuration.m_absHighEta ||
        initialShowerPosition.eta()<-m_configuration.m_absHighEta ) ) return true;
 
  if ( !m_configuration.m_containCrack &&
      ( ( initialShowerPosition.eta()>m_configuration.m_absCrackEta1 &&
          initialShowerPosition.eta()<m_configuration.m_absCrackEta2 ) ||
        ( initialShowerPosition.eta()<-m_configuration.m_absCrackEta1 &&
          initialShowerPosition.eta()>-m_configuration.m_absCrackEta2 ) ) ) return true;
 
  if ( !m_configuration.m_containLow &&
      ( initialShowerPosition.eta()<m_configuration.m_absLowEta ||
        initialShowerPosition.eta()>-m_configuration.m_absLowEta ) ) return true;
  return false;
}

ForcedDeny()

G4bool LArFastShower::ForcedDeny ( const G4FastTrack & )

virtual

If it returns true, the particle will be returned to G4 without further checks.

Definition at line 470 of file LArFastShower.cxx.

{
  return false;
}

generateFSStartingPoint()

bool LArFastShower::generateFSStartingPoint ( std::unique_ptr< const HepMC::GenEvent > & ge ) const

protected

Definition at line 439 of file LArFastShower.cxx.

{
  if (!m_generate_starting_points)
    return false;
  m_starting_points_file->write_event(*ge);
  return true;
}

GetGenEvent()

std::unique_ptr< const HepMC::GenEvent > LArFastShower::GetGenEvent ( const G4FastTrack & fastTrack )

protected

Definition at line 354 of file LArFastShower.cxx.

{
  const G4ThreeVector showerPos = fastTrack.GetPrimaryTrack()->GetPosition();
  const G4ThreeVector showerMom = fastTrack.GetPrimaryTrack()->GetMomentum();
  const G4double energy = fastTrack.GetPrimaryTrack()->GetKineticEnergy();
 
  G4int pdgcode = fastTrack.GetPrimaryTrack()->GetDefinition()->GetPDGEncoding();
  if (pdgcode < 0) pdgcode = -pdgcode; // hack for positrons. let it be electrons.
 
  HepMC3::Units::MomentumUnit momentumUnit = HepMC3::Units::MEV;
  HepMC3::Units::LengthUnit lengthUnit = HepMC3::Units::MM;
  // new event. Signal processing = 0, event number "next"
  std::unique_ptr<HepMC::GenEvent> ge = std::make_unique<HepMC::GenEvent>(momentumUnit,lengthUnit);
 
  ge->set_event_number(++m_eventNum);
 
  // starting point from which the shower develops, time = 0. 
  HepMC::GenVertexPtr gv = HepMC::newGenVertexPtr(
      HepMC::FourVector(showerPos.x(), showerPos.y(), showerPos.z(), 0) );
  ge->add_vertex(gv);
 
  // input particle (status=4) is always required by HepMC.
  // make it a dummy geantino with 4-mom=0. pdg_id=999.
  HepMC::GenParticlePtr gpi = HepMC::newGenParticlePtr(
      HepMC::FourVector(0.,0.,0.,0.),
      999, 4 );
  gv->add_particle_in(std::move(gpi));
 
  // output particle (status=1) is the FourVector of the shower.
  HepMC::GenParticlePtr gpo = HepMC::newGenParticlePtr(
      HepMC::FourVector(showerMom.x(), showerMom.y(), showerMom.z(), energy),
      pdgcode, 1 );
  gv->add_particle_out(std::move(gpo));
 
  // return auto_pointer. will be deleted automatically
  return ge;
}

IsApplicable()

G4bool LArFastShower::IsApplicable ( const G4ParticleDefinition & particleType )

override

Determines the applicability of the fast sim model to this particle type Called once for each track picked up by Geant as it enters a region with the fast sim assigned to it.

Currently returns false for all but photons and electrons.

Definition at line 103 of file LArFastShower.cxx.

{
#ifdef _TRACE_FSM_
  G4cout << "LArFastShower::IsApplicable" << G4endl;
#endif
 
  /*
   * if ( flag to parameterize is set )
   * && ( (we want to record SPs) || (ShowerLibSvc has a library for this particle) )
   */
  if (m_applicableMap.find(particleType.GetPDGEncoding()) != m_applicableMap.end()) {
    return m_applicableMap.find(particleType.GetPDGEncoding())->second;
  }
  bool rez = false;
  if ( flagToShowerLib(particleType) &&
       ( m_generate_starting_points ||
         showerLibSvc()->checkLibrary( particleType.GetPDGEncoding(),
                                       m_configuration.m_detector_tag ) ))
    rez = true;
  m_applicableMap[particleType.GetPDGEncoding()] = rez;
  return rez;
}

KillParticle()

void LArFastShower::KillParticle ( const G4FastTrack & , G4FastStep & fastStep )

protected

Method to kill a particle and deposit its energy using exponential decay function.

Definition at line 206 of file LArFastShower.cxx.

{
 
#ifdef _TRACE_DOIT_
  G4cout << "Low energy particle is being killed: " << fastTrack.GetPrimaryTrack()->GetKineticEnergy() << G4endl;
#endif
 
  // Kill the particle
  fastStep.KillPrimaryTrack();
  fastStep.ProposePrimaryTrackPathLength(0.0);
 
  return;
}

maxEneToShowerLib()

double LArFastShower::maxEneToShowerLib ( const G4ParticleDefinition & particleType ) const

protected

get lower energy limit for frozen showers

Definition at line 424 of file LArFastShower.cxx.

{
  if ( &particleType == G4Electron::ElectronDefinition() ||
       &particleType == G4Positron::PositronDefinition() ) {
    return m_configuration.m_e_MaxEneShowerLib;
  } else if ( &particleType == G4Gamma::GammaDefinition() ) {
    return m_configuration.m_g_MaxEneShowerLib;
  } else if ( &particleType == G4Neutron::NeutronDefinition() ) {
    return m_configuration.m_Neut_MaxEneShowerLib;
  } else if ( &particleType == G4PionPlus::PionPlusDefinition() ||
              &particleType == G4PionMinus::PionMinusDefinition() ) {
    return m_configuration.m_Pion_MaxEneShowerLib;
  }
  return 0.0;
}

minEneToShowerLib()

double LArFastShower::minEneToShowerLib ( const G4ParticleDefinition & particleType ) const

protected

get upper energy limit for frozen showers

Definition at line 408 of file LArFastShower.cxx.

{
  if ( &particleType == G4Electron::ElectronDefinition() ||
       &particleType == G4Positron::PositronDefinition() ) {
    return m_configuration.m_e_MinEneShowerLib;
  } else if ( &particleType == G4Gamma::GammaDefinition() ) {
    return m_configuration.m_g_MinEneShowerLib;
  } else if ( &particleType == G4Neutron::NeutronDefinition() ) {
    return m_configuration.m_Neut_MinEneShowerLib;
  } else if ( &particleType == G4PionPlus::PionPlusDefinition() ||
              &particleType == G4PionMinus::PionMinusDefinition() ) {
    return m_configuration.m_Pion_MinEneShowerLib;
  }
  return 0.0;
}

ModelTrigger()

G4bool LArFastShower::ModelTrigger ( const G4FastTrack & fastTrack )

overridevirtual

Determines the applicability of the fast sim model to this particular track.

Checks that geometric location, energy, and particle type are within bounds. Also checks for containment of the particle's shower within a specific detector region.

Definition at line 126 of file LArFastShower.cxx.

{
  /* ==========================================================================
     Determine if the particle is to be returned to full Geant4 simulation.
     In the event where the particle is EITHER killed and parameterised OR
     simply killed, this must be done in the appropriate LArFastShower DoIt method.
     This method Checks: 1) Geometry; 2) Energy; 3) (for e+/e-) Containment
     ========================================================================== */
 
#ifdef _TRACE_FSM_
  G4cout << "LArFastShower::commonTrigger" << G4endl;
#endif
 
  // We are in a parameterized volume
 
  // Check if the particle is within energy bounds
  G4double particleEnergy = fastTrack.GetPrimaryTrack()->GetKineticEnergy();
  const G4ParticleDefinition& particleType = *(fastTrack.GetPrimaryTrack()->GetDefinition());
 
  if ( flagToShowerLib(particleType) == true &&
       particleEnergy > minEneToShowerLib(particleType) &&
       particleEnergy < maxEneToShowerLib(particleType) ) {
 
#ifdef _TRACE_FSM_
    G4cout << "Particle has energy (" << particleEnergy << ") for shower lib and shower lib is on! Accept particle!" << G4endl;
#endif
  }  else {
 
#ifdef _TRACE_FSM_
    G4cout << "Particle has energy (" << particleEnergy << ") outside killing, shower lib and parametrisation "
           << "or some features are switched off ... returning it to Geant  " << G4endl;
#endif
 
    return false;
  }
 
  if (ForcedAccept(fastTrack)) return true;
  if (ForcedDeny(fastTrack)) return false;
 
  if (CheckContainment(fastTrack)==false) {
#ifdef _TRACE_FSM_
    G4cout << "LArFastShower::ModelTrigger() particle failed CheckContainment()... will not be parameterised: " << G4endl;
#endif
    return false;
  }
 
#ifdef _TRACE_FSM_
  G4cout << "LArFastShower::ModelTrigger() direction: " << fastTrack.GetPrimaryTrackLocalDirection() << G4endl;
  G4cout << "LArFastShower::ModelTrigger() mom dir:   " << fastTrack.GetPrimaryTrack()->GetMomentumDirection() << G4endl;
#endif
 
  return true;
}

showerLibSvc()

ILArG4ShowerLibSvc * LArFastShower::showerLibSvc ( )

protected

Definition at line 90 of file LArFastShower.cxx.

{
  if ( !m_showerLibSvc ) {
    SmartIF<ILArG4ShowerLibSvc> smartShowerLibSvc{Gaudi::svcLocator()->service(m_configuration.m_showerLibSvcName)};
    if ( smartShowerLibSvc ) { m_showerLibSvc = smartShowerLibSvc.get(); }
    if ( !m_showerLibSvc ) {
      throw std::runtime_error("LArFastShower: cannot retrieve LArG4ShowerLibSvc");
    }
  }
  return m_showerLibSvc;
}

UseShowerLib()

void LArFastShower::UseShowerLib ( const G4FastTrack & fastTrack, G4FastStep & fastStep )

protected

Function for the application of shower library.

Definition at line 221 of file LArFastShower.cxx.

{
  try {
#ifdef _TRACE_DOIT_
    G4cout << "LArFastShower::UseShowerLib()" << G4endl;
#endif
 
    // kill the electron to be parametrised
    KillParticle(fastTrack, fastStep);
 
    // -----------------------------
    // Get Shower from ShowerLibSvc
    // -----------------------------
    const std::vector<EnergySpot> shower =
      showerLibSvc()->getShower(fastTrack, m_configuration.m_detector_tag);
 
#ifdef _TRACE_DOIT_
    G4cout << "Got shower (" << shower.size() << ") from shower lib" << G4endl;
#endif
    const double weight = (m_configuration.m_applyRRWeights) ? fastTrack.GetPrimaryTrack()->GetWeight() : 1.0;
    // loop over hits in shower
    for (const auto& a_spot : shower) {
 
#ifdef _TRACE_DOIT_
      G4cout << "Make Spot: " << a_spot.GetPosition().x() << " "
             << a_spot.GetPosition().y() << " " << a_spot.GetPosition().z()
             << " " << a_spot.GetEnergy() << " " << a_spot.GetTime() << G4endl;
#endif
      fastShowerSD()->ProcessSpot(a_spot, weight);
 
#ifdef _TRACE_DOIT_
      G4cout << "Made Spot" << G4endl;
#endif
 
    }
 
#ifdef _TRACE_FSM_
    G4cout << "LArFastShower::UseShowerLib() Done" << G4endl;
#endif
 
    return;
  }
 
  // FIXME: Catching all exceptions and suppressing them? That's awful!!
  catch (const std::exception & e) {
    G4cout << "FastShower::UseShowerLib ERROR Handling an exception in LArFastShower::" << e.what() << G4endl;
    return;
  }
 
}

Member Data Documentation

m_applicableMap

std::map<int,bool> LArFastShower::m_applicableMap

private

Definition at line 94 of file LArFastShower.h.

m_configuration

const FastShowerConfigStruct LArFastShower::m_configuration

private

Definition at line 80 of file LArFastShower.h.

m_detector_tag_str

std::string LArFastShower::m_detector_tag_str

private

Definition at line 90 of file LArFastShower.h.

m_detmap

std::map<std::string,int> LArFastShower::m_detmap

private

Definition at line 91 of file LArFastShower.h.

m_eventNum

int LArFastShower::m_eventNum

private

Definition at line 93 of file LArFastShower.h.

m_fastSimDedicatedSD

IFastSimDedicatedSD* LArFastShower::m_fastSimDedicatedSD {}

private

Shower library sensitive detector for this shower.

Definition at line 83 of file LArFastShower.h.

{};

m_generate_starting_points

bool LArFastShower::m_generate_starting_points

private

Definition at line 88 of file LArFastShower.h.

m_showerLibSvc

ILArG4ShowerLibSvc* LArFastShower::m_showerLibSvc {}

private

Pointer to the shower library service.

Definition at line 85 of file LArFastShower.h.

{};

m_starting_points_file

std::shared_ptr<HepMC3::WriterAscii> LArFastShower::m_starting_points_file

private

Definition at line 89 of file LArFastShower.h.

---

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

• LArFastShower.h
• LArFastShower.cxx