iFatras::PhotonConversionTool Class Reference

The photon conversion tool, to be called by the MaterialUpdator. More...

#include <PhotonConversionTool.h>

Inheritance diagram for iFatras::PhotonConversionTool:

Collaboration diagram for iFatras::PhotonConversionTool:

Public Member Functions
	PhotonConversionTool (const std::string &, const std::string &, const IInterface *)
	AlgTool constructor for PhotonConversionTool.
virtual	~PhotonConversionTool ()
	Destructor.
StatusCode	initialize ()
	AlgTool initailize method.
StatusCode	finalize ()
	AlgTool finalize method.
bool	pairProduction (const Trk::MaterialProperties &mprop, double pathCorrection, double p) const
	interface for processing of the pair production
bool	doConversion (double time, const Trk::NeutralParameters &parm, const Trk::ExtendedMaterialProperties *extMatProp=0) const
	interface for processing of the presampled pair production
ISF::ISFParticleVector	doConversionOnLayer (const ISF::ISFParticle *parent, double time, const Trk::NeutralParameters &parm, const Trk::ExtendedMaterialProperties *ematprop=0) const
	interface for processing of the presampled nuclear interactions on layer

Private Member Functions
void	recordChilds (double time, const Amg::Vector3D &vertex, const Amg::Vector3D &photonDirection, double childEnergy, double photonEnergy, const Amg::Vector3D &childDirection, Trk::ParticleHypothesis childType=Trk::electron) const
	record childs - create interface already for mu-/mu+ pair production
ISF::ISFParticleVector	getChilds (const ISF::ISFParticle *parent, double time, const Amg::Vector3D &vertex, const Amg::Vector3D &photonDirection, double childEnergy, double photonEnergy, const Amg::Vector3D &childDirection, Trk::ParticleHypothesis childType) const
	get childs - for layer update
double	childEnergyFraction (const Trk::MaterialProperties &mprop, double gammaMom) const
	simulate the child energy
double	childEnergyFraction (double gammaMom) const
Amg::Vector3D	childDirection (const Amg::Vector3D &gammaMom, double childE) const
	simulate the one child direction - the second one is given clear then
double	phi1 (double delta) const
	helper functions for the Phi1/phi2
double	phi2 (double delta) const
	helper functions for the Phi1/phi2

Private Attributes
ServiceHandle< ISF::IParticleBroker >	m_particleBroker
	ISF services & Tools.
ServiceHandle< ISF::ITruthSvc >	m_truthRecordSvc
int	m_processCode
	MCTruth process code for TruthIncidents created by this tool.
bool	m_referenceMaterial
	Switch to use reference material.
double	m_minChildEnergy
	The cut from which on the child products are followed.
double	m_childEnergyScaleFactor
double	m_conversionProbScaleFactor
ServiceHandle< IAtRndmGenSvc >	m_rndGenSvc
	Random Generator service.
CLHEP::HepRandomEngine *	m_randomEngine
std::string	m_randomEngineName
	Name of the random number stream.
int	m_recordedConversions
	debug output - count the conversions
int	m_droppedConversions
bool	m_validationMode
std::string	m_validationTreeName
	validation tree name - to be acessed by this from root
std::string	m_validationTreeDescription
	validation tree description - second argument in TTree
std::string	m_validationTreeFolder
	stream/folder to for the TTree to be written out
TTree *	m_validationTree
	Root Validation Tree.
ToolHandle< IPhysicsValidationTool >	m_validationTool
float	m_conversionPointX
float	m_conversionPointY
float	m_conversionPointR
float	m_conversionPointZ
float	m_conversionPhotonEnergy
float	m_conversionChildEnergy
float	m_conversionChildAngle

Static Private Attributes
static const Trk::PdgToParticleHypothesis	s_pdgToHypo

Detailed Description

The photon conversion tool, to be called by the MaterialUpdator.

Author

Sarka.nosp@m..Tod.nosp@m.orova.nosp@m.@cer.nosp@m.n.ch

Definition at line 48 of file PhotonConversionTool.h.

Constructor & Destructor Documentation

PhotonConversionTool()

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

AlgTool constructor for PhotonConversionTool.

Definition at line 60 of file PhotonConversionTool.cxx.

                                                                                                             :
  base_class(t,n,p),
  m_particleBroker("ISF_ParticleParticleBroker", n),
  m_truthRecordSvc("ISF_TruthRecordSvc", n),
  m_processCode(14),
  m_referenceMaterial(true),
  m_minChildEnergy(50.*CLHEP::MeV),
  m_childEnergyScaleFactor(1.),
  m_conversionProbScaleFactor(0.98),
  m_rndGenSvc("AtDSFMTGenSvc", n),
  m_randomEngine(nullptr),
  m_randomEngineName("FatrasRnd"),
  m_recordedConversions(0),
  m_droppedConversions(0),
  m_validationMode(false),
  m_validationTreeName("FatrasPhotonConversions"),
  m_validationTreeDescription("Validation output from the PhotonConversionTool"),
  m_validationTreeFolder("/val/FatrasPhotonConversions"),
  m_validationTree(nullptr),
  m_validationTool(""),
  m_conversionPointX(0.),
  m_conversionPointY(0.),
  m_conversionPointR(0.),
  m_conversionPointZ(0.),
  m_conversionPhotonEnergy(0.),
  m_conversionChildEnergy(0.),
  m_conversionChildAngle(0.)
{
      // ISF Services and Tools
      declareProperty("ParticleBroker"                      , m_particleBroker        , "ISF ParticleBroker Svc"  );
      declareProperty("TruthRecordSvc"                      , m_truthRecordSvc        , "ISF Particle Truth Svc"  );      
      // MC Truth Properties
      declareProperty("PhysicsProcessCode"                  , m_processCode           , "MCTruth Physics Process Code");
      // the steering - general things
      declareProperty("ReferenceMaterial"                   , m_referenceMaterial);
      declareProperty("MinimumChildEnergy"                  , m_minChildEnergy);
      // NB: ChildEnergyScaling=1 corresponds to energy sharing formulas of GEANT4
      declareProperty("ChildEnergyScaling"                  , m_childEnergyScaleFactor);
      declareProperty("ConversionProbScaling"               , m_conversionProbScaleFactor);
      declareProperty("RandomNumberService"                 , m_rndGenSvc               , "Random number generator");
      declareProperty("RandomStreamName"                    , m_randomEngineName        , "Name of the random number stream");
      // validation   --------------------------------------------------------------
      declareProperty("ValidationMode"                      , m_validationMode);      
      declareProperty("PhysicsValidationTool"               , m_validationTool);
}

~PhotonConversionTool()

iFatras::PhotonConversionTool::~PhotonConversionTool ( )

virtualdefault

Destructor.

Member Function Documentation

childDirection()

Amg::Vector3D iFatras::PhotonConversionTool::childDirection ( const Amg::Vector3D & gammaMom, double childE ) const

private

simulate the one child direction - the second one is given clear then

Definition at line 558 of file PhotonConversionTool.cxx.

{
    // --------------------------------------------------
    // Following the Geant4 approximation from L. Urban
    // the azimutal angle
    double psi    =  2.*M_PI*CLHEP::RandFlat::shoot(m_randomEngine);
    
    // the start of the equation
    double theta = Trk::ParticleMasses::mass[Trk::electron]/childE;
    // follow 
    double a = 0.625; // 5/8
    //double d = 27.;
 
    double r1 = CLHEP::RandFlat::shoot(m_randomEngine);
    double r2 = CLHEP::RandFlat::shoot(m_randomEngine);
    double r3 = CLHEP::RandFlat::shoot(m_randomEngine);
 
    double u =  -log(r2*r3)/a;
    
    theta *= (r1 < 0.25 ) ? u : u*s_oneOverThree; // 9./(9.+27) = 0.25
 
     ATH_MSG_VERBOSE( "[ conv ] Simulated angle to photon    = " << theta << "." );
 
    // more complex but "more true"
    CLHEP::Hep3Vector gammaMomHep( gammaMom.x(), gammaMom.y(), gammaMom.z() );
    CLHEP::Hep3Vector newDirectionHep(gammaMomHep.unit());
    double x = -newDirectionHep.y();
    double y = newDirectionHep.x();
    double z = 0.;
    // if it runs along the z axis - no good ==> take the x axis
    if (newDirectionHep.z()*newDirectionHep.z() > 0.999999)       
        x = 1.;
    // deflector direction
    CLHEP::Hep3Vector deflectorHep(x,y,z);
    // rotate the new direction for scattering
    newDirectionHep.rotate(theta, deflectorHep);
    // and arbitrarily in psi             
    newDirectionHep.rotate(psi,gammaMomHep);
 
    // record for the validation mode
    if (m_validationMode){
       // child energy and direction
       m_conversionChildEnergy = float(childE);  
       m_conversionChildAngle  = float(theta);
    }
 
    // assign the new values
    Amg::Vector3D newDirection( newDirectionHep.x(), newDirectionHep.y(), newDirectionHep.z() );
    return newDirection;
 
}

childEnergyFraction() [1/2]

double iFatras::PhotonConversionTool::childEnergyFraction ( const Trk::MaterialProperties & mprop, double gammaMom ) const

private

simulate the child energy

Definition at line 449 of file PhotonConversionTool.cxx.

                                                                               {
 
  // the fraction
  double epsilon0      = Trk::ParticleMasses::mass[Trk::electron]/gammaMom;
  // some needed manipolations
  double Z             = mprop.averageZ();
  double oneOverZpow   = 1./pow(Z,s_oneOverThree);
  double alphaZsquare  = (s_alpha*s_alpha*Z*Z);
  // now f(Z) - from Z and s_alpha
  double fZ            = alphaZsquare*(1./(1.+alphaZsquare)+0.20206-0.0369*alphaZsquare+0.0083*alphaZsquare*alphaZsquare);
  double FZ = (8./3)*log(Z)+8.*fZ;
  // delta_max
  double deltaMax      = exp((42.24-FZ)*.1195)-0.952;
  // delta_min
  double deltaMin      = 4.*epsilon0*136.*oneOverZpow; 
  // the minimum fraction
  double epsilon1      = 0.5-0.5*sqrt(1.-deltaMin/deltaMax);
  double epsilonMin    = epsilon1 > epsilon0 ? epsilon1 : epsilon0;
  // calculate phi1 / phi2 - calculate from deltaMin
  double Phi1          = phi1(deltaMin);
  double Phi2          = phi2(deltaMin);
  // then calculate F10/F20
  double F10           = 3.*Phi1 - Phi2 - FZ;
  double F20           = 1.5*Phi1 + 0.5*Phi2 - FZ;
  // and finally calucate N1, N2
  double N1            = (0.25-epsilonMin+epsilonMin*epsilonMin)*F10;
  double N2            = 1.5*F20;
  // ------------ decide which one to take 
  if ( CLHEP::RandFlat::shoot(m_randomEngine) <  N1/(N1+N2) ) {  
    // sample from f1,g1 distribution
    for ( ; ; ){
      double epsilon = 0.5 - (0.5 - epsilonMin)*pow(CLHEP::RandFlat::shoot(m_randomEngine),s_oneOverThree);
      // prepare for the rejection check
      double delta   = 136.*epsilon0*oneOverZpow/(epsilon-epsilon*epsilon);
      double F1 = 3.*phi1(delta)-phi2(delta)-FZ;   
      // reject ? - or redo the exercise 
      if (F1/F10 > CLHEP::RandFlat::shoot(m_randomEngine)) return m_childEnergyScaleFactor*epsilon;
    }
  } else {
    // sample from f2,g2 distribution
    for ( ; ; ){
      double epsilon = epsilonMin + (0.5-epsilonMin)*CLHEP::RandFlat::shoot(m_randomEngine);
      // prepare for the rejection check
      double delta   = 136.*epsilon0*oneOverZpow/(epsilon-epsilon*epsilon);
      double F2 = 1.5*phi1(delta)-0.5*phi2(delta)-FZ;   
     // reject ? - or redo the exercise 
     if (F2/F20 > CLHEP::RandFlat::shoot(m_randomEngine)) return m_childEnergyScaleFactor*epsilon;  
    }
  }
 
}

childEnergyFraction() [2/2]

double iFatras::PhotonConversionTool::childEnergyFraction ( double gammaMom ) const

private

Definition at line 504 of file PhotonConversionTool.cxx.

                                                                             {
 
  // the fraction
  double epsilon0      = Trk::ParticleMasses::mass[Trk::electron]/gammaMom;
  // some needed manipolations
  //double Z             = mprop.averageZ();
  double Z             = 13.;
  double oneOverZpow   = 1./pow(Z,s_oneOverThree);
  double alphaZsquare  = (s_alpha*s_alpha*Z*Z);
  // now f(Z) - from Z and s_alpha
  double fZ            = alphaZsquare*(1./(1.+alphaZsquare)+0.20206-0.0369*alphaZsquare+0.0083*alphaZsquare*alphaZsquare);
  double FZ = (8./3)*log(Z)+8.*fZ;
  // delta_max
  double deltaMax      = exp((42.24-FZ)*.1195)-0.952;
  // delta_min
  double deltaMin      = 4.*epsilon0*136.*oneOverZpow; 
  // the minimum fraction
  double epsilon1      = 0.5-0.5*sqrt(1.-deltaMin/deltaMax);
  double epsilonMin    = epsilon1 > epsilon0 ? epsilon1 : epsilon0;
  // calculate phi1 / phi2 - calculate from deltaMin
  double Phi1          = phi1(deltaMin);
  double Phi2          = phi2(deltaMin);
  // then calculate F10/F20
  double F10           = 3.*Phi1 - Phi2 - FZ;
  double F20           = 1.5*Phi1 + 0.5*Phi2 - FZ;
  // and finally calucate N1, N2
  double N1            = (0.25-epsilonMin+epsilonMin*epsilonMin)*F10;
  double N2            = 1.5*F20;
  // ------------ decide which one to take 
  if ( CLHEP::RandFlat::shoot(m_randomEngine) <  N1/(N1+N2)) {  
    // sample from f1,g1 distribution
    for ( ; ; ){
      double epsilon = 0.5 - (0.5 - epsilonMin)*pow(CLHEP::RandFlat::shoot(m_randomEngine),s_oneOverThree);
      // prepare for the rejection check
      double delta   = 136.*epsilon0*oneOverZpow/(epsilon-epsilon*epsilon);
      double F1 = 3.*phi1(delta)-phi2(delta)-FZ;   
      // reject ? - or redo the exercise
      if (F1/F10 > CLHEP::RandFlat::shoot(m_randomEngine)) return m_childEnergyScaleFactor*epsilon;
    }
  } else {
    // sample from f2,g2 distribution
    for ( ; ; ){
      double epsilon = epsilonMin + (0.5-epsilonMin)*CLHEP::RandFlat::shoot(m_randomEngine);
      // prepare for the rejection check
      double delta   = 136.*epsilon0*oneOverZpow/(epsilon-epsilon*epsilon);
      double F2 = 1.5*phi1(delta)-0.5*phi2(delta)-FZ;   
     // reject ? - or redo the exercise 
     if (F2/F20 > CLHEP::RandFlat::shoot(m_randomEngine)) return m_childEnergyScaleFactor*epsilon;  
    }
  }
 
}

doConversion()

bool iFatras::PhotonConversionTool::doConversion	(	double	time,
		const Trk::NeutralParameters &	parm,
		const Trk::ExtendedMaterialProperties *	extMatProp = 0 ) const

interface for processing of the presampled pair production

Definition at line 611 of file PhotonConversionTool.cxx.

                                                                      {
 
  // Called by McMaterialEffectsUpdator::interact
  double p = parm.momentum().mag();
 
  // get the energy
  double efrac = childEnergyFraction(p);
  double childEnergy = p*efrac;
 
  // count the conversion 
  ++m_recordedConversions;
 
  // now get the deflection
  Amg::Vector3D childDir(childDirection(parm.momentum(), childEnergy));
  // verbose output
  ATH_MSG_VERBOSE(  "[ conv ] Child energy simulated as : " << childEnergy << " MeV" );
  // calculate the second child direction
  recordChilds(time,
           parm.position(),
               parm.momentum().unit(),
           childEnergy, p,
           childDir,
           Trk::electron); // Registers TruthIncident internally
  // fill the TTree ----------------------------
  if (m_validationTree)
    m_validationTree->Fill();
  
  return true;
}

doConversionOnLayer()

ISF::ISFParticleVector iFatras::PhotonConversionTool::doConversionOnLayer	(	const ISF::ISFParticle *	parent,
		double	time,
		const Trk::NeutralParameters &	parm,
		const Trk::ExtendedMaterialProperties *	ematprop = 0 ) const

interface for processing of the presampled nuclear interactions on layer

Definition at line 643 of file PhotonConversionTool.cxx.

                                                                                   {
  // Called by McMaterialEffectsUpdator::interactLay
  double p = parm.momentum().mag();
 
  // get the energy
  double efrac = childEnergyFraction(p);
  double childEnergy = p*efrac;
 
  // count the conversion 
  ++m_recordedConversions;
 
  // now get the deflection
  Amg::Vector3D childDir(childDirection(parm.momentum(), childEnergy));
  // verbose output
  ATH_MSG_VERBOSE(  "[ conv ] Child energy simulated as : " << childEnergy << " MeV" );
  // fill the TTree ----------------------------
  if (m_validationTree)
    m_validationTree->Fill();
  // calculate the second child direction and return
  return getChilds(parent,
           time,
           parm.position(),
           parm.momentum().unit(),
           childEnergy, p,
           childDir,
           Trk::electron); // Registers TruthIncident internally
 
}

finalize()

StatusCode iFatras::PhotonConversionTool::finalize

(

)

AlgTool finalize method.

Definition at line 173 of file PhotonConversionTool.cxx.

{
 
    ATH_MSG_INFO( " ---------- Statistics output -------------------------- " );
    ATH_MSG_INFO( "                     Minimum energy cut of conversions into e+e-  : " <<   m_minChildEnergy << " [MeV] " );
    ATH_MSG_INFO( "                     Conversions into e+e-  (above cut, recorded) : " <<   m_recordedConversions );
    ATH_MSG_INFO( "                     Conversions into e+e-  (below cut, dropped)  : " <<   m_droppedConversions );
    ATH_MSG_DEBUG( "finalize() successful" );
 
    return StatusCode::SUCCESS;
}

getChilds()

ISF::ISFParticleVector iFatras::PhotonConversionTool::getChilds ( const ISF::ISFParticle * parent, double time, const Amg::Vector3D & vertex, const Amg::Vector3D & photonDirection, double childEnergy, double photonEnergy, const Amg::Vector3D & childDirection, Trk::ParticleHypothesis childType ) const

private

get childs - for layer update

Definition at line 315 of file PhotonConversionTool.cxx.

{
  // Called by PhotonConversionTool::doConversionOnLayer
    // calculate the child momentum
    double p1 = sqrt(childEnergy*childEnergy-Trk::ParticleMasses::mass[childType]*Trk::ParticleMasses::mass[childType]);    
 
    // now properly : energy-momentum conservation
    CLHEP::HepLorentzVector vtmp;
    CLHEP::Hep3Vector photonDirectionHep( photonDirection.x(), photonDirection.y(), photonDirection.z() );
    CLHEP::Hep3Vector childDirectionHep( childDirection.x(), childDirection.y(), childDirection.z() );
    vtmp = CLHEP::HepLorentzVector(photonEnergy*photonDirectionHep, photonEnergy) 
      - CLHEP::HepLorentzVector(p1*childDirectionHep, childEnergy);
 
    double p2 = vtmp.vect().mag();
    //Amg::Vector3D secondChildDir(vtmp.vect().unit());
 
    // charge sampling
    double charge1, charge2;
    charge1 = charge2 = 0.;
    if (CLHEP::RandFlat::shoot(m_randomEngine)>0.5) {
      charge1 = -1.;
      charge2 =  1.;
    }
    else {
      charge1 =  1.;
      charge2 = -1.;
    }
 
    double mass = Trk::ParticleMasses::mass[childType];
    int    pdg1  = s_pdgToHypo.convert(childType, charge1, false);
    int    pdg2  = s_pdgToHypo.convert(childType, charge2, false);
 
    // removal of soft children to be done in layer mat updator
    const int status = 1 + HepMC::SIM_STATUS_THRESHOLD;
    const int id = HepMC::UNDEFINED_ID; // This will be set if the child particle is saved to the GenEvent
    std::unique_ptr<ISF::ISFParticle> ch1(new ISF::ISFParticle(vertex,
                                                               p1*childDirection,
                                                               mass,
                                                               charge1,
                                                               pdg1,
                                                               status,
                                                               time,
                                                               *parent,
                                                               id
                                                               ));
    
    std::unique_ptr<ISF::ISFParticle> ch2(new ISF::ISFParticle(vertex,
                                                               p2*childDirection,
                                                               mass,
                                                               charge2,
                                                               pdg2,
                                                               status,
                                                               time,
                                                               *parent,
                                                               id
                                                               ));
 
    ISF::ISFParticleVector children{ch1.release(),
                                    ch2.release()};
 
    // register TruthIncident
    ISF::ISFTruthIncident truth( const_cast<ISF::ISFParticle&>(*parent),
                                 children,
                                 m_processCode,
                                 parent->nextGeoID(),
                                 ISF::fKillsPrimary );
    m_truthRecordSvc->registerTruthIncident( truth);
    // At this point we need to update the properties of the
    // ISFParticles produced in the interaction
    truth.updateChildParticleProperties();
 
    // Check that the new ISFParticles have a valid TruthBinding
    for (auto *childParticle : children) {
      if (!childParticle->getTruthBinding()) {
        ATH_MSG_ERROR("Could not retrieve TruthBinding from child ISFParticle "<< *childParticle);
      }
    }
 
    return children;
}

initialize()

StatusCode iFatras::PhotonConversionTool::initialize

(

)

AlgTool initailize method.

Definition at line 112 of file PhotonConversionTool.cxx.

{
    ATH_MSG_DEBUG( "initialize()" );
 
    // ISF Services
    if (m_particleBroker.retrieve().isFailure()){
        ATH_MSG_FATAL( "Could not retrieve ISF Particle Broker: " << m_particleBroker );
        return StatusCode::FAILURE;
    }
    if (m_truthRecordSvc.retrieve().isFailure()){
        ATH_MSG_FATAL( "Could not retrieve ISF Truth Record Service: " << m_truthRecordSvc );
        return StatusCode::FAILURE;
    }
 
    // the random service
    if ( m_rndGenSvc.retrieve().isFailure() ){
        ATH_MSG_FATAL( "Could not retrieve " << m_rndGenSvc );
        return StatusCode::FAILURE;
    }
    //Get own engine with own seeds:
    m_randomEngine = m_rndGenSvc->GetEngine(m_randomEngineName);
    if (!m_randomEngine) {
        ATH_MSG_FATAL( "Could not get random engine '" << m_randomEngineName << "'" );
        return StatusCode::FAILURE;
    }
     
    // the validation setup ----------------------------------------------------------------------------------
    ATH_CHECK( m_validationTool.retrieve( DisableTool{ m_validationTool.empty() || !m_validationMode } ) );
    if (m_validationMode){
      ATH_MSG_VERBOSE(  "Booking conversion validation TTree ... " );
      
      // create the new Tree
      m_validationTree = new TTree(m_validationTreeName.c_str(), m_validationTreeDescription.c_str());
      
      // conversion positions and information
      m_validationTree->Branch("ConversionPositionX"    ,  &m_conversionPointX, "convX/F");
      m_validationTree->Branch("ConversionPositionY"    ,  &m_conversionPointY, "convY/F");
      m_validationTree->Branch("ConversionPositionR"    ,  &m_conversionPointR, "convR/F");
      m_validationTree->Branch("ConversionPositionZ"    ,  &m_conversionPointZ, "convZ/F");
      m_validationTree->Branch("ConversionPhotonEnergy" ,  &m_conversionPhotonEnergy, "convPhotonE/F");
      m_validationTree->Branch("ConversionChildEnergy"  ,  &m_conversionChildEnergy,  "convChildE/F");
      m_validationTree->Branch("ConversionChildAngle  " ,  &m_conversionChildAngle,   "convChildA/F");
    
      // now register the Tree
      SmartIF<ITHistSvc> tHistSvc{Gaudi::svcLocator()->service("THistSvc")};
      if (!tHistSvc) {
    ATH_MSG_ERROR( "initialize() Could not find Hist Service -> Switching ValidationMode Off !" );
    delete m_validationTree; m_validationTree = nullptr;
      }
      if ((tHistSvc->regTree(m_validationTreeFolder, m_validationTree)).isFailure()) {
    ATH_MSG_ERROR( "initialize() Could not register the validation Tree -> Switching ValidationMode Off !" );
    delete m_validationTree; m_validationTree = nullptr;
      }
 
    } // ------------- end of validation mode -----------------------------------------------------------------
    ATH_MSG_DEBUG( "finalize() successful" );
 
    return StatusCode::SUCCESS;
}

pairProduction()

bool iFatras::PhotonConversionTool::pairProduction	(	const Trk::MaterialProperties &	mprop,
		double	pathCorrection,
		double	p ) const

interface for processing of the pair production

Definition at line 402 of file PhotonConversionTool.cxx.

{
 
 // use for the moment only Al data - Yung Tsai - Rev.Mod.Particle Physics Vol. 74, No.4, October 1974
 // optainef from a fit given in the momentum range 100 10 6 2 1 0.6 0.4 0.2 0.1 GeV

 //  Double_t fitFunction(Double_t *x, Double_t *par) {
 //  return par[0] + par[1]*pow(x[0],par[2]);
 // }
 
 // EXT PARAMETER                                   STEP         FIRST
 // NO.   NAME      VALUE            ERROR          SIZE      DERIVATIVE
 //  1  p0          -7.01612e-03   8.43478e-01   1.62766e-04   1.11914e-05
 //  2  p1           7.69040e-02   1.00059e+00   8.90718e-05  -8.41167e-07
 //  3  p2          -6.07682e-01   5.13256e+00   6.07228e-04  -9.44448e-07
 
 double  p0  =       -7.01612e-03;
 double  p1  =        7.69040e-02;
 double  p2  =       -6.07682e-01;
 // calculate xi
 double xi = p0 + p1*pow(p/1000.,p2);
 // now calculate what's left
 double attenuation = exp( -7.777e-01*pathCorrection*mprop.thicknessInX0()*(1.-xi) );
 
  ATH_MSG_VERBOSE(  "[ conv ] Propability of conversion    = " << (1.-attenuation) * 100. << " %." );
  /* ST do when the actual conversion happens */
  /*
  // record for the validation mode
  if (m_validationMode){
     // spatical information
     m_conversionPointX = float(vertex.x());     
     m_conversionPointY = float(vertex.y());     
     m_conversionPointR = float(vertex.perp());     
     m_conversionPointZ = float(vertex.z());     
     // photon energyEnergy
     m_conversionPhotonEnergy = float(p);
  }
  */
 
  return m_conversionProbScaleFactor*CLHEP::RandFlat::shoot(m_randomEngine) > attenuation;
 
}

phi1()

double iFatras::PhotonConversionTool::phi1 ( double delta ) const

inlineprivate

helper functions for the Phi1/phi2

Definition at line 157 of file PhotonConversionTool.h.

                                                           {
  if (delta <= 1.)
     return 20.867 - 3.242 * delta  + 0.625*delta*delta;
  else
    return 21.12 - 4.184*log(delta+0.952);
}

phi2()

double iFatras::PhotonConversionTool::phi2 ( double delta ) const

inlineprivate

helper functions for the Phi1/phi2

Definition at line 164 of file PhotonConversionTool.h.

                                                           {
  if (delta <= 1.)
     return 20.209 - 1.930 * delta  + 0.086*delta*delta;
   return 21.12 - 4.184*log(delta+0.952);
}

recordChilds()

void iFatras::PhotonConversionTool::recordChilds ( double time, const Amg::Vector3D & vertex, const Amg::Vector3D & photonDirection, double childEnergy, double photonEnergy, const Amg::Vector3D & childDirection, Trk::ParticleHypothesis childType = Trk::electron ) const

private

record childs - create interface already for mu-/mu+ pair production

Definition at line 186 of file PhotonConversionTool.cxx.

{
    // get parent particle
    // @TODO: replace by Fatras internal bookkeeping
    const ISF::ISFParticle *parent = ISF::ParticleClipboard::getInstance().getParticle();
    // something is seriously wrong if there is no parent particle
    assert(parent);
 
    // calculate the child momentum
    double p1 = sqrt(childEnergy*childEnergy-Trk::ParticleMasses::mass[childType]*Trk::ParticleMasses::mass[childType]);    
 
    // now properly : energy-momentum conservation
    CLHEP::HepLorentzVector vtmp;
    CLHEP::Hep3Vector photonDirectionHep( photonDirection.x(), photonDirection.y(), photonDirection.z() );
    CLHEP::Hep3Vector childDirectionHep( childDirection.x(), childDirection.y(), childDirection.z() );
    vtmp = CLHEP::HepLorentzVector(photonEnergy*photonDirectionHep, photonEnergy) 
      - CLHEP::HepLorentzVector(p1*childDirectionHep, childEnergy);
 
    double p2 = vtmp.vect().mag();
    //Amg::Vector3D secondChildDir(vtmp.vect().unit());
 
    // charge sampling
    double charge1, charge2;
    charge1 = charge2 = 0.;
    if (CLHEP::RandFlat::shoot(m_randomEngine)>0.5) {
      charge1 = -1.;
      charge2 =  1.;
    }
    else {
      charge1 =  1.;
      charge2 = -1.;
    }
 
    // add the new secondary states to the ISF particle stack
    double mass = Trk::ParticleMasses::mass[childType];
    int    pdg1  = s_pdgToHypo.convert(childType, charge1, false);
    int    pdg2  = s_pdgToHypo.convert(childType, charge2, false);
 
    // remove soft children
    int nchild = 0;
    if ( p1 > m_minChildEnergy ) nchild++;
    if ( p2 > m_minChildEnergy ) nchild++;
 
    ISF::ISFParticleVector children(nchild);
 
    int ichild = 0;
    const int status = 1 + HepMC::SIM_STATUS_THRESHOLD;
    const int id = HepMC::UNDEFINED_ID; // This will be set if the child particle is saved to the GenEvent
    if (  p1 > m_minChildEnergy ) {
      ISF::ISFParticle* ch1 = new ISF::ISFParticle( vertex,
                                                    p1*childDirection,
                                                    mass,
                                                    charge1,
                                                    pdg1,
                                                    status,
                                                    time,
                                                    *parent,
                                                    id
                                                    );
      // in the validation mode, add process info
      if (m_validationMode) {
        ISF::ParticleUserInformation* validInfo = new ISF::ParticleUserInformation();
        validInfo->setProcess(14);
        if (parent->getUserInformation()) validInfo->setGeneration(parent->getUserInformation()->generation()+1);
        else validInfo->setGeneration(1);     // assume parent is a primary track
        ch1->setUserInformation(validInfo);
      }
      children[ichild] = ch1;
      ichild++;
    }
 
    if (  p2 > m_minChildEnergy ) {
      ISF::ISFParticle* ch2  = new ISF::ISFParticle( vertex,
                                                     p2*childDirection,
                                                     mass,
                                                     charge2,
                                                     pdg2,
                                                     status,
                                                     time,
                                                     *parent,
                                                     id
                                                     );
      
      // in the validation mode, add process info
      if (m_validationMode) {
        ISF::ParticleUserInformation* validInfo = new ISF::ParticleUserInformation();
        validInfo->setProcess(14);
    if (parent->getUserInformation()) validInfo->setGeneration(parent->getUserInformation()->generation()+1);
        else validInfo->setGeneration(1);     // assume parent is a primary track
        ch2->setUserInformation(validInfo);
      }
      children[ichild] = ch2;
    }
 
    // register TruthIncident
    ISF::ISFTruthIncident truth( const_cast<ISF::ISFParticle&>(*parent),
                                 children,
                                 m_processCode,
                                 parent->nextGeoID(),
                                 ISF::fKillsPrimary );
    m_truthRecordSvc->registerTruthIncident( truth);
    // At this point we need to update the properties of the
    // ISFParticles produced in the interaction
    truth.updateChildParticleProperties();
 
    // push onto ParticleStack
    if (!children.empty() ) {
      for (auto *childParticle : children) {
        //Check that the new ISFParticles have a valid TruthBinding
        if (!childParticle->getTruthBinding()) {
          ATH_MSG_ERROR("Could not retrieve TruthBinding from child ISFParticle "<< *childParticle);
        }
        m_particleBroker->push(childParticle, parent);
      }
    }
 
    // save info for validation
    if (m_validationMode && m_validationTool.isEnabled()) {
      Amg::Vector3D* nPrim=nullptr;
      m_validationTool->saveISFVertexInfo(14,vertex,*parent,parent->momentum(),nPrim,children);
    }
 
}

Member Data Documentation

m_childEnergyScaleFactor

double iFatras::PhotonConversionTool::m_childEnergyScaleFactor

private

Definition at line 121 of file PhotonConversionTool.h.

m_conversionChildAngle

float iFatras::PhotonConversionTool::m_conversionChildAngle

mutableprivate

Definition at line 150 of file PhotonConversionTool.h.

m_conversionChildEnergy

float iFatras::PhotonConversionTool::m_conversionChildEnergy

mutableprivate

Definition at line 149 of file PhotonConversionTool.h.

m_conversionPhotonEnergy

float iFatras::PhotonConversionTool::m_conversionPhotonEnergy

mutableprivate

Definition at line 148 of file PhotonConversionTool.h.

m_conversionPointR

float iFatras::PhotonConversionTool::m_conversionPointR

mutableprivate

Definition at line 146 of file PhotonConversionTool.h.

m_conversionPointX

float iFatras::PhotonConversionTool::m_conversionPointX

mutableprivate

Definition at line 144 of file PhotonConversionTool.h.

m_conversionPointY

float iFatras::PhotonConversionTool::m_conversionPointY

mutableprivate

Definition at line 145 of file PhotonConversionTool.h.

m_conversionPointZ

float iFatras::PhotonConversionTool::m_conversionPointZ

mutableprivate

Definition at line 147 of file PhotonConversionTool.h.

m_conversionProbScaleFactor

double iFatras::PhotonConversionTool::m_conversionProbScaleFactor

private

Definition at line 122 of file PhotonConversionTool.h.

m_droppedConversions

int iFatras::PhotonConversionTool::m_droppedConversions

mutableprivate

Definition at line 132 of file PhotonConversionTool.h.

m_minChildEnergy

double iFatras::PhotonConversionTool::m_minChildEnergy

private

The cut from which on the child products are followed.

Definition at line 120 of file PhotonConversionTool.h.

m_particleBroker

ServiceHandle<ISF::IParticleBroker> iFatras::PhotonConversionTool::m_particleBroker

private

ISF services & Tools.

Definition at line 110 of file PhotonConversionTool.h.

m_processCode

int iFatras::PhotonConversionTool::m_processCode

private

MCTruth process code for TruthIncidents created by this tool.

Definition at line 114 of file PhotonConversionTool.h.

m_randomEngine

CLHEP::HepRandomEngine* iFatras::PhotonConversionTool::m_randomEngine

private

Definition at line 127 of file PhotonConversionTool.h.

m_randomEngineName

std::string iFatras::PhotonConversionTool::m_randomEngineName

private

Name of the random number stream.

Definition at line 128 of file PhotonConversionTool.h.

m_recordedConversions

int iFatras::PhotonConversionTool::m_recordedConversions

mutableprivate

debug output - count the conversions

Definition at line 131 of file PhotonConversionTool.h.

m_referenceMaterial

bool iFatras::PhotonConversionTool::m_referenceMaterial

private

Switch to use reference material.

Definition at line 117 of file PhotonConversionTool.h.

m_rndGenSvc

ServiceHandle<IAtRndmGenSvc> iFatras::PhotonConversionTool::m_rndGenSvc

private

Random Generator service.

Definition at line 126 of file PhotonConversionTool.h.

m_truthRecordSvc

ServiceHandle<ISF::ITruthSvc> iFatras::PhotonConversionTool::m_truthRecordSvc

private

Definition at line 111 of file PhotonConversionTool.h.

m_validationMode

bool iFatras::PhotonConversionTool::m_validationMode

private

Definition at line 135 of file PhotonConversionTool.h.

m_validationTool

ToolHandle<IPhysicsValidationTool> iFatras::PhotonConversionTool::m_validationTool

private

Definition at line 141 of file PhotonConversionTool.h.

m_validationTree

TTree* iFatras::PhotonConversionTool::m_validationTree

private

Root Validation Tree.

Definition at line 140 of file PhotonConversionTool.h.

m_validationTreeDescription

std::string iFatras::PhotonConversionTool::m_validationTreeDescription

private

validation tree description - second argument in TTree

Definition at line 137 of file PhotonConversionTool.h.

m_validationTreeFolder

std::string iFatras::PhotonConversionTool::m_validationTreeFolder

private

stream/folder to for the TTree to be written out

Definition at line 138 of file PhotonConversionTool.h.

m_validationTreeName

std::string iFatras::PhotonConversionTool::m_validationTreeName

private

validation tree name - to be acessed by this from root

Definition at line 136 of file PhotonConversionTool.h.

s_pdgToHypo

const Trk::PdgToParticleHypothesis iFatras::PhotonConversionTool::s_pdgToHypo

staticprivate

Definition at line 153 of file PhotonConversionTool.h.

---

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

• PhotonConversionTool.h
• PhotonConversionTool.cxx