Simulation::CrabKissingVertexPositioner Class Reference

This AthenaTool computes geometrical shifts for the initial GenEvent vertices. More...

#include <CrabKissingVertexPositioner.h>

Inheritance diagram for Simulation::CrabKissingVertexPositioner:

Collaboration diagram for Simulation::CrabKissingVertexPositioner:

Public Member Functions
	CrabKissingVertexPositioner (const std::string &t, const std::string &n, const IInterface *p)
	Constructor with parameters.
virtual	~CrabKissingVertexPositioner ()=default
	Destructor.
StatusCode	initialize () override final
	Athena algtool's Hooks.
StatusCode	finalize () override final
	Athena algtool's Hooks.
CLHEP::HepLorentzVector *	generate (const EventContext &ctx) const override final
	computes the vertex displacement

Private Types
enum	BunchShape { GAUSS , FLAT , NSHAPES }

Private Member Functions
double	heaviside (double val) const
double	getDisplacement (double bunchSize, double angle1, double angle2, CLHEP::HepRandomEngine *rng) const
double	beamspotFunction (double displacement, double angle1, double angle2) const
void	BunchShapeHandler (Gaudi::Details::PropertyBase &)

Private Attributes
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
ServiceHandle< IAthRNGSvc >	m_rndGenSvc {this, "RandomSvc", "AthRNGSvc"}
ATHRNG::RNGWrapper *m_randomEngine	ATLAS_THREAD_SAFE {}
	Slot-local RNG.
Gaudi::Property< std::string >	m_randomEngineName {this, "RandomStream", "VERTEX", "Name of the random number stream"}
Gaudi::Property< std::string >	m_bunchShapeProp {this, "BunchShape", "GAUSS", "GAUSS or FLAT"}
BunchShape	m_bunchShape {BunchShape::GAUSS}
Gaudi::Property< double >	m_bunchLength {this, "BunchLength", 75., "75.0 mm"}
	Parameter in the Z distribution of the beamspot.
Gaudi::Property< double >	m_betaStar {this, "BetaStar", 150., "beta* in the parallel (kissing) plane, we assume betax=betay, units: mm"}
	parameters according to S.Fartoukh Phys.Rev.ST Accel.Beams 17 (2014) no.11, 111001 -------------------------—
Gaudi::Property< double >	m_epsilon {this, "Epsilon", 2.5e-3, "Normalized emittance, unit: mm"}
Gaudi::Property< double >	m_alphaPar {this, "AlfasParallel", 0., "Kissing angle (Radians)"}
Gaudi::Property< double >	m_alphaX {this, "AlfaX", 295e-6}
Gaudi::Property< double >	m_thetaX {this, "ThetaX", 295e-6}

Detailed Description

This AthenaTool computes geometrical shifts for the initial GenEvent vertices.

based on function from S.Fartoukh Phys.Rev.ST Accel.Beams 17 (2014) no.11, 111001

Author

John.Chapman -at- cern.ch, Elmar.Ritsch -at- cern.ch, Daniele.Ruini -at- poltechnique.edu

Definition at line 43 of file CrabKissingVertexPositioner.h.

Member Enumeration Documentation

BunchShape

enum Simulation::CrabKissingVertexPositioner::BunchShape

private

Enumerator
GAUSS
FLAT
NSHAPES

Definition at line 73 of file CrabKissingVertexPositioner.h.

{GAUSS,FLAT,NSHAPES};

Constructor & Destructor Documentation

CrabKissingVertexPositioner()

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

Constructor with parameters.

Constructor.

Definition at line 25 of file CrabKissingVertexPositioner.cxx.

    : base_class(t,n,p)
  {
    m_bunchShapeProp.declareUpdateHandler(&CrabKissingVertexPositioner::BunchShapeHandler, this);
  }

~CrabKissingVertexPositioner()

virtual Simulation::CrabKissingVertexPositioner::~CrabKissingVertexPositioner ( )

virtualdefault

Destructor.

Member Function Documentation

beamspotFunction()

double Simulation::CrabKissingVertexPositioner::beamspotFunction ( double displacement, double angle1, double angle2 ) const

private

Definition at line 78 of file CrabKissingVertexPositioner.cxx.

  {
    if ( angle1<1e-10 ) angle1 = 1e-10; // to avoid divide_by_zero errors
    double temp(1.0-std::fabs(displacement)/m_bunchLength);
    return 1.0/M_2_SQRTPI * std::erf(angle1*temp)/angle1 *
           std::exp( -pow(angle2*displacement/m_bunchLength, 2) ) *
           heaviside(temp);
  }

BunchShapeHandler()

void Simulation::CrabKissingVertexPositioner::BunchShapeHandler ( Gaudi::Details::PropertyBase & )

private

Definition at line 33 of file CrabKissingVertexPositioner.cxx.

  {
    if(m_bunchShapeProp.value() == "GAUSS") m_bunchShape = BunchShape::GAUSS;
    else if(m_bunchShapeProp.value() == "FLAT") m_bunchShape = BunchShape::FLAT;
    else m_bunchShape=BunchShape::NSHAPES;
  }

finalize()

StatusCode Simulation::CrabKissingVertexPositioner::finalize ( )

finaloverride

Athena algtool's Hooks.

Definition at line 69 of file CrabKissingVertexPositioner.cxx.

  {
    ATH_MSG_VERBOSE("Finalizing ...");
    return StatusCode::SUCCESS;
  }

generate()

CLHEP::HepLorentzVector * Simulation::CrabKissingVertexPositioner::generate ( const EventContext & ctx ) const

finaloverride

computes the vertex displacement

Definition at line 103 of file CrabKissingVertexPositioner.cxx.

  {
    // Prepare the random engine
    m_randomEngine->setSeed( name(), ctx );
    CLHEP::HepRandomEngine* randomEngine(m_randomEngine->getEngine(ctx));
    SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
    // See jira issue ATLASSIM-497 for an explanation of why calling
    // shoot outside the CLHEP::HepLorentzVector constructor is
    // necessary/preferable.
    double vertexX = CLHEP::RandGaussZiggurat::shoot(randomEngine)*beamSpotHandle->beamSigma(0);
    double vertexY = CLHEP::RandGaussZiggurat::shoot(randomEngine)*beamSpotHandle->beamSigma(1);
    double piwinski_phi = std::fabs(m_thetaX - m_alphaX) * m_bunchLength/std::sqrt(m_epsilon * m_betaStar);
    double piwinski_psi = m_alphaPar * m_bunchLength / std::sqrt( m_epsilon * m_betaStar);
    double vertexZ = 0;
    double vertexT = 0;
    // Time should be set in units of distance, the following methods generate c*t
    if ( m_bunchShape == BunchShape::GAUSS) {
      double zWidth    = m_bunchLength / std::sqrt(2*(1+pow(piwinski_phi,2)));
      double timeWidth = m_bunchLength / std::sqrt(2*(1+pow(piwinski_psi,2)));
      vertexZ = CLHEP::RandGaussZiggurat::shoot(randomEngine, 0., zWidth);
      vertexT = CLHEP::RandGaussZiggurat::shoot(randomEngine, 0., timeWidth);
    }
    else if ( m_bunchShape == BunchShape::FLAT ) {
      vertexZ = getDisplacement(m_bunchLength, piwinski_psi, piwinski_phi, randomEngine);
      vertexT = getDisplacement(m_bunchLength, piwinski_phi, piwinski_psi, randomEngine);
    }
    else {
      ATH_MSG_WARNING("Invalid BunchShape ("<<m_bunchShapeProp.value()<<"). Vertex smearing disabled");
      return new CLHEP::HepLorentzVector(0.,0.,0.,0.);
    }
    ATH_MSG_VERBOSE("m_bunchLength = " << m_bunchLength <<
                    ", Zvertex = " << vertexZ << ", Tvertex = " << vertexT);
 
    // calculate the vertexSmearing
    CLHEP::HepLorentzVector *vertexSmearing =
      new CLHEP::HepLorentzVector( vertexX, vertexY, vertexZ, 0. );
 
    // (1) code from: Simulation/G4Atlas/G4AtlasUtilities/VertexPositioner.cxx
    const double tx = tan( beamSpotHandle->beamTilt(1) );
    const double ty = tan( beamSpotHandle->beamTilt(0) );
 
    const double sqrt_abc = std::sqrt(1. + tx*tx + ty*ty);
    const double sqrt_fgh = std::sqrt(1. + ty*ty);
 
    const double a = ty/sqrt_abc;
    const double b = tx/sqrt_abc;
    const double c = 1./sqrt_abc;
 
    HepGeom::Point3D<double> from1(0,0,1);
    HepGeom::Point3D<double> to1(a,b,c);
 
    const double f = 1./sqrt_fgh;
    const double g = 0.;
    const double h = -(ty)/sqrt_fgh;
 
    HepGeom::Point3D<double> from2(1,0,0);
    HepGeom::Point3D<double> to2(f,g,h);
 
    // first rotation, then translation
    HepGeom::Transform3D transform(
        HepGeom::Rotate3D(from1, from2, to1, to2).getRotation(),
        CLHEP::Hep3Vector( beamSpotHandle->beamPos().x(),
                           beamSpotHandle->beamPos().y(),
                           beamSpotHandle->beamPos().z() )
        );
 
    ATH_MSG_VERBOSE("BeamSpotSvc reported beam position as " << beamSpotHandle->beamPos());
    ATH_MSG_VERBOSE("Width is (" << beamSpotHandle->beamSigma(0) << ", " <<
                    beamSpotHandle->beamSigma(1) << ", " << m_bunchLength << ")");
    ATH_MSG_VERBOSE("Tilts are " << beamSpotHandle->beamTilt(0) << " and " <<
                    beamSpotHandle->beamTilt(1));
    ATH_MSG_VERBOSE("Vertex Position before transform: " << *vertexSmearing);
 
    // update with the tilt
    *vertexSmearing = transform * HepGeom::Point3D<double>(*vertexSmearing);
    vertexSmearing->setT(vertexT);
 
    // and return it
    return vertexSmearing;
  }

getDisplacement()

double Simulation::CrabKissingVertexPositioner::getDisplacement ( double bunchSize, double angle1, double angle2, CLHEP::HepRandomEngine * rng ) const

private

Definition at line 87 of file CrabKissingVertexPositioner.cxx.

  {
    size_t ntries(0);
    double yval(CLHEP::RandFlat::shoot(randomEngine, 0.0, 1.0));
    double displ(CLHEP::RandFlat::shoot(randomEngine, -bunchSize, bunchSize));
    while (this->beamspotFunction(displ, angle1, angle2)<yval) {
      if(ntries>1000000) return 0.0; //just so we don't sit in this loop forever
      yval = CLHEP::RandFlat::shoot(randomEngine, 0.0, 1.0);
      displ = CLHEP::RandFlat::shoot(randomEngine, -bunchSize, bunchSize);
      ++ntries;
    }
    return displ;
  }

heaviside()

double Simulation::CrabKissingVertexPositioner::heaviside ( double val ) const

inlineprivate

Definition at line 62 of file CrabKissingVertexPositioner.h.

{return (val >= 0.0) ? 1.0 : 0.0;};

initialize()

StatusCode Simulation::CrabKissingVertexPositioner::initialize ( )

finaloverride

Athena algtool's Hooks.

Definition at line 41 of file CrabKissingVertexPositioner.cxx.

  {
    ATH_MSG_VERBOSE("Initializing ...");
 
    // prepare the RandonNumber generation
    ATH_CHECK(m_rndGenSvc.retrieve());
    ATH_CHECK(m_beamSpotKey.initialize());
 
    m_randomEngine = m_rndGenSvc->getEngine(this, m_randomEngineName);
    if (!m_randomEngine) {
      ATH_MSG_ERROR("Could not get random number engine from RandomNumberService. Abort.");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_DEBUG("BunchShape = " << m_bunchShapeProp.value());
    ATH_MSG_DEBUG("BunchLength = " << m_bunchLength);
    ATH_MSG_DEBUG("Epsilon (normalized emittance) = " << m_epsilon);
    ATH_MSG_DEBUG("BetaStar = " << m_betaStar);
    ATH_MSG_DEBUG("AlfaParallel (kissing angle) = " << m_alphaPar);
    ATH_MSG_DEBUG("AlfaX (crabbing angle) = " << m_alphaX);
    ATH_MSG_DEBUG("ThetaX (half crossing angle) = " << m_thetaX);
 
    // everything set up properly
    return StatusCode::SUCCESS;
  }

Member Data Documentation

ATLAS_THREAD_SAFE

ATHRNG::RNGWrapper* m_randomEngine Simulation::CrabKissingVertexPositioner::ATLAS_THREAD_SAFE {}

private

Slot-local RNG.

Definition at line 69 of file CrabKissingVertexPositioner.h.

{};  

m_alphaPar

Gaudi::Property<double> Simulation::CrabKissingVertexPositioner::m_alphaPar {this, "AlfasParallel", 0., "Kissing angle (Radians)"}

private

Definition at line 79 of file CrabKissingVertexPositioner.h.

{this, "AlfasParallel", 0., "Kissing angle (Radians)"}; // Kissing angle

m_alphaX

Gaudi::Property<double> Simulation::CrabKissingVertexPositioner::m_alphaX {this, "AlfaX", 295e-6}

private

Definition at line 80 of file CrabKissingVertexPositioner.h.

{this, "AlfaX", 295e-6};

m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> Simulation::CrabKissingVertexPositioner::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }

private

Definition at line 67 of file CrabKissingVertexPositioner.h.

{ this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };

m_betaStar

Gaudi::Property<double> Simulation::CrabKissingVertexPositioner::m_betaStar {this, "BetaStar", 150., "beta* in the parallel (kissing) plane, we assume betax=betay, units: mm"}

private

parameters according to S.Fartoukh Phys.Rev.ST Accel.Beams 17 (2014) no.11, 111001 -------------------------—

Definition at line 77 of file CrabKissingVertexPositioner.h.

{this, "BetaStar", 150., "beta* in the parallel (kissing) plane, we assume betax=betay, units: mm"};

m_bunchLength

Gaudi::Property<double> Simulation::CrabKissingVertexPositioner::m_bunchLength {this, "BunchLength", 75., "75.0 mm"}

private

Parameter in the Z distribution of the beamspot.

Definition at line 75 of file CrabKissingVertexPositioner.h.

{this, "BunchLength", 75., "75.0 mm"}; 

m_bunchShape

BunchShape Simulation::CrabKissingVertexPositioner::m_bunchShape {BunchShape::GAUSS}

private

Definition at line 74 of file CrabKissingVertexPositioner.h.

{BunchShape::GAUSS}; // GAUSS or FLAT

m_bunchShapeProp

Gaudi::Property<std::string> Simulation::CrabKissingVertexPositioner::m_bunchShapeProp {this, "BunchShape", "GAUSS", "GAUSS or FLAT"}

private

Definition at line 71 of file CrabKissingVertexPositioner.h.

{this, "BunchShape", "GAUSS", "GAUSS or FLAT"};

m_epsilon

Gaudi::Property<double> Simulation::CrabKissingVertexPositioner::m_epsilon {this, "Epsilon", 2.5e-3, "Normalized emittance, unit: mm"}

private

Definition at line 78 of file CrabKissingVertexPositioner.h.

{this, "Epsilon", 2.5e-3, "Normalized emittance, unit: mm"};

m_randomEngineName

Gaudi::Property<std::string> Simulation::CrabKissingVertexPositioner::m_randomEngineName {this, "RandomStream", "VERTEX", "Name of the random number stream"}

private

Definition at line 70 of file CrabKissingVertexPositioner.h.

{this, "RandomStream", "VERTEX", "Name of the random number stream"};

m_rndGenSvc

ServiceHandle<IAthRNGSvc> Simulation::CrabKissingVertexPositioner::m_rndGenSvc {this, "RandomSvc", "AthRNGSvc"}

private

Definition at line 68 of file CrabKissingVertexPositioner.h.

{this, "RandomSvc", "AthRNGSvc"};

m_thetaX

Gaudi::Property<double> Simulation::CrabKissingVertexPositioner::m_thetaX {this, "ThetaX", 295e-6}

private

Definition at line 81 of file CrabKissingVertexPositioner.h.

{this, "ThetaX", 295e-6};

---

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

• CrabKissingVertexPositioner.h
• CrabKissingVertexPositioner.cxx