FastCaloSimCaloTransportation Class Reference

#include <FastCaloSimCaloTransportation.h>

Inheritance diagram for FastCaloSimCaloTransportation:

Collaboration diagram for FastCaloSimCaloTransportation:

Public Member Functions
	FastCaloSimCaloTransportation (const std::string &t, const std::string &n, const IInterface *p)
	~FastCaloSimCaloTransportation ()=default
virtual StatusCode	initialize () override final
virtual StatusCode	finalize () override final
virtual std::vector< G4FieldTrack >	transport (const TFCSTruthState *truth, bool forceNeutral=false) const override final

Protected Member Functions
std::vector< G4FieldTrack >	convertToFieldTrack (const std::vector< Trk::HitInfo > &vec) const

Protected Attributes
PublicToolHandle< Trk::ITimedExtrapolator >	m_extrapolator {this, "Extrapolator", "TimedExtrapolator"}
CxxUtils::CachedPointer< const Trk::TrackingVolume >	m_caloEntrance
StringProperty	m_caloEntranceName {this, "CaloEntrance", ""}
Trk::PdgToParticleHypothesis	m_pdgToParticleHypothesis

Detailed Description

Definition at line 20 of file FastCaloSimCaloTransportation.h.

Constructor & Destructor Documentation

FastCaloSimCaloTransportation()

FastCaloSimCaloTransportation::FastCaloSimCaloTransportation	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 32 of file FastCaloSimCaloTransportation.cxx.

  : base_class(t,n,p)
{
 
}

~FastCaloSimCaloTransportation()

FastCaloSimCaloTransportation::~FastCaloSimCaloTransportation ( )

default

Member Function Documentation

convertToFieldTrack()

std::vector< G4FieldTrack > FastCaloSimCaloTransportation::convertToFieldTrack ( const std::vector< Trk::HitInfo > & vec ) const

protected

Definition at line 214 of file FastCaloSimCaloTransportation.cxx.

                                                                                                                {
 
  std::vector<G4FieldTrack> caloSteps;
  for (auto& step : vec){
    G4FieldTrack track = G4FieldTrack(' ');
    track.SetPosition(Amg::EigenToHep3Vector(step.trackParms->position()));
    track.SetMomentum(Amg::EigenToHep3Vector(step.trackParms->momentum()));
    track.SetChargeAndMoments(step.trackParms->charge());
    caloSteps.push_back(track);
  }
 
  return caloSteps;
 
}

finalize()

StatusCode FastCaloSimCaloTransportation::finalize ( )

finaloverridevirtual

Definition at line 53 of file FastCaloSimCaloTransportation.cxx.

                                                  {
  ATH_MSG_INFO( "Finalizing FastCaloSimCaloTransportation" );
  return StatusCode::SUCCESS;
}

initialize()

StatusCode FastCaloSimCaloTransportation::initialize ( )

finaloverridevirtual

Definition at line 38 of file FastCaloSimCaloTransportation.cxx.

{
  ATH_MSG_INFO( "Initializing FastCaloSimCaloTransportation" );
 
  // Get TimedExtrapolator
  if(!m_extrapolator.empty()){
      ATH_CHECK(m_extrapolator.retrieve());
      ATH_MSG_INFO("Extrapolator retrieved "<< m_extrapolator);
  }
 
  return StatusCode::SUCCESS;
 
}

transport()

std::vector< G4FieldTrack > FastCaloSimCaloTransportation::transport ( const TFCSTruthState * truth, bool forceNeutral = false ) const

finaloverridevirtual

Definition at line 59 of file FastCaloSimCaloTransportation.cxx.

                                                                                                                    {
  if (auto* eventInfo = AtlasG4EventUserInfo::GetEventUserInfo()) {
    Gaudi::Hive::setCurrentContext(eventInfo->GetEventContext());
  }
 
  // Start calo extrapolation
  ATH_MSG_DEBUG ("[ fastCaloSim transport ] processing particle "<<truth->pdgid() );
 
  auto hitVector = std::make_unique<std::vector<Trk::HitInfo>>();
 
  int     pdgId    = truth->pdgid();
  double  charge   = MC::charge(pdgId);
  if (forceNeutral) charge   = 0.;
 
  // particle Hypothesis for the extrapolation
  Trk::ParticleHypothesis pHypothesis = m_pdgToParticleHypothesis.convert(pdgId, charge);
 
  ATH_MSG_DEBUG ("particle hypothesis "<< pHypothesis);
 
  // geantinos not handled by PdgToParticleHypothesis - fix there
  if (pdgId == 999) pHypothesis = Trk::geantino;
 
  Amg::Vector3D pos = Amg::Vector3D(truth->vertex().X(), truth->vertex().Y(), truth->vertex().Z());
 
  Amg::Vector3D mom(truth->X(), truth->Y(), truth->Z());
 
  ATH_MSG_DEBUG( "[ fastCaloSim transport ] x from position eta="<<pos.eta()<<" phi="<<pos.phi()<<" d="<<pos.mag()<<" pT="<<mom.perp() );
 
  // input parameters : curvilinear parameters
  Trk::CurvilinearParameters inputPar(pos,mom,charge);
 
  double freepath = -1.;
  double tDec = freepath > 0. ? freepath : -1.;
  int decayProc = 0;
  
  Trk::TimeLimit timeLim(tDec, 0., decayProc);       
  Trk::PathLimit pathLim(-1., 0);
  Trk::GeometrySignature nextGeoID=Trk::Calo;
 
  // first extrapolation to reach the ID boundary
  ATH_MSG_DEBUG( "[ fastCaloSim transport ] before calo entrance ");
 
  // get CaloEntrance if not done already
  if(!m_caloEntrance.get()){
    m_caloEntrance.set(m_extrapolator->trackingGeometry()->trackingVolume(m_caloEntranceName));
    if(!m_caloEntrance.get())
      ATH_MSG_WARNING("CaloEntrance not found");
    else
      ATH_MSG_DEBUG("CaloEntrance found");
  }
 
  ATH_MSG_DEBUG( "[ fastCaloSim transport ] after calo entrance ");
 
  std::unique_ptr<const Trk::TrackParameters> caloEntry = nullptr;
 
  if(m_caloEntrance.get() && m_caloEntrance.get()->inside(pos, 0.001) && !m_extrapolator->trackingGeometry()->atVolumeBoundary(pos,m_caloEntrance.get(), 0.001)){
      std::vector<Trk::HitInfo>* dummyHitVector = nullptr;
      if (charge == 0){
        caloEntry =
          m_extrapolator->transportNeutralsWithPathLimit(inputPar,
                                                         pathLim,
                                                         timeLim,
                                                         Trk::alongMomentum,
                                                         pHypothesis,
                                                         dummyHitVector,
                                                         nextGeoID,
                                                         m_caloEntrance.get());
      }else{
        caloEntry = m_extrapolator->extrapolateWithPathLimit(inputPar,
                                                             pathLim,
                                                             timeLim,
                                                             Trk::alongMomentum,
                                                             pHypothesis,
                                                             dummyHitVector,
                                                             nextGeoID,
                                                             m_caloEntrance.get());
      }
  } else
    caloEntry = inputPar.uniqueClone();
 
  ATH_MSG_DEBUG( "[ fastCaloSim transport ] after calo caloEntry ");
 
  if(caloEntry){
    std::unique_ptr<const Trk::TrackParameters> eParameters = nullptr;
 
      // save Calo entry hit (fallback info)
      hitVector->push_back(Trk::HitInfo(caloEntry->uniqueClone(), timeLim.time, nextGeoID, 0.));
 
      ATH_MSG_DEBUG(
        "[ fastCaloSim transport ] starting Calo transport from position eta="
        << caloEntry->position().eta() << " phi=" << caloEntry->position().phi()
        << " d=" << caloEntry->position().mag());
 
      std::vector<Trk::HitInfo>* rawHitVector = hitVector.get();
      if (charge == 0){
        eParameters =
          m_extrapolator->transportNeutralsWithPathLimit(*caloEntry,
                                                         pathLim,
                                                         timeLim,
                                                         Trk::alongMomentum,
                                                         pHypothesis,
                                                         rawHitVector,
                                                         nextGeoID);
      }else{
        eParameters =
          m_extrapolator->extrapolateWithPathLimit(*caloEntry,
                                                   pathLim,
                                                   timeLim,
                                                   Trk::alongMomentum,
                                                   pHypothesis,
                                                   rawHitVector,
                                                   nextGeoID);
      }
      // save Calo exit hit (fallback info)
      if(eParameters) hitVector->push_back(Trk::HitInfo(std::move(eParameters), timeLim.time, nextGeoID, 0.));
    } //if caloEntry
 
  //used to identify ID-Calo boundary in tracking tools
  int IDCaloBoundary = 3000;
 
  if(msgLvl(MSG::DEBUG)){
    std::vector<Trk::HitInfo>::iterator it = hitVector->begin();
    while (it < hitVector->end()){
        int sample=(*it).detID;
        Amg::Vector3D hitPos = (*it).trackParms->position();
        ATH_MSG_DEBUG(" HIT: layer="<<sample<<" sample="<<sample-IDCaloBoundary<<" eta="<<hitPos.eta()<<" phi="<<hitPos.phi()<<" d="<<hitPos.mag());
        ++it;
    }
  }
 
  std::vector<Trk::HitInfo>::iterator it2 = hitVector->begin();
  while(it2 < hitVector->end()){
    int sample=(*it2).detID;
    Amg::Vector3D hitPos = (*it2).trackParms->position();
    ATH_MSG_DEBUG(" HIT: layer="<<sample<<" sample="<<sample-IDCaloBoundary<<" eta="<<hitPos.eta()<<" phi="<<hitPos.phi()<<" r="<<hitPos.perp()<<" z="<<hitPos[Amg::z]);
    ++it2;
  }
 
  // Extrapolation may fail for very low pT charged particles. Enforce charge 0 to prevent this 
  if (!forceNeutral && hitVector->empty()){
      ATH_MSG_DEBUG("forcing neutral charge in FastCaloSimCaloTransportation::caloHits");
      transport(truth, true);
  }
  // Don't expect this ever to happen. Nevertheless, error handling should be improved. 
  // This may require changes in periphery (adjustments after setting function type to StatusCode)
  else if(hitVector->empty()) ATH_MSG_ERROR("Empty hitVector even after forcing neutral charge. This may cause a segfault soon.");
 
 
  std::vector<G4FieldTrack> caloSteps = convertToFieldTrack(*hitVector);
  
  return caloSteps;
 
}

Member Data Documentation

m_caloEntrance

CxxUtils::CachedPointer<const Trk::TrackingVolume> FastCaloSimCaloTransportation::m_caloEntrance

protected

Definition at line 40 of file FastCaloSimCaloTransportation.h.

m_caloEntranceName

StringProperty FastCaloSimCaloTransportation::m_caloEntranceName {this, "CaloEntrance", ""}

protected

Definition at line 41 of file FastCaloSimCaloTransportation.h.

{this, "CaloEntrance", ""};

m_extrapolator

PublicToolHandle<Trk::ITimedExtrapolator> FastCaloSimCaloTransportation::m_extrapolator {this, "Extrapolator", "TimedExtrapolator"}

protected

Definition at line 38 of file FastCaloSimCaloTransportation.h.

{this, "Extrapolator", "TimedExtrapolator"};

m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis FastCaloSimCaloTransportation::m_pdgToParticleHypothesis

protected

Definition at line 42 of file FastCaloSimCaloTransportation.h.

---

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

• FastCaloSimCaloTransportation.h
• FastCaloSimCaloTransportation.cxx