ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
ALFA_BeamTransport Class Reference

#include <ALFA_BeamTransport.h>

Inheritance diagram for ALFA_BeamTransport:
Collaboration diagram for ALFA_BeamTransport:

Public Member Functions

 ALFA_BeamTransport (const std::string &name, ISvcLocator *pSvcLocator)
 Standard Athena-Algorithm Constructor. More...
 
 ~ALFA_BeamTransport ()
 Default Destructor. More...
 
StatusCode initialize ()
 standard Athena-Algorithm method More...
 
StatusCode execute ()
 standard Athena-Algorithm method More...
 
StatusCode finalize ()
 standard Athena-Algorithm method More...
 
void MeVToGeV (HepMC::GenEvent &evt)
 convert unit MeV to GeV for energy and momenta More...
 
void GeVToMeV (HepMC::GenEvent &evt)
 convert GeV to MeV for HepMC event record More...
 
int SelectParticles (HepMC::GenEvent *evt)
 Selects particles for beam transported Sets event status code of outgoing particles from generator to status != 1. More...
 
int DoBeamTracking (int evt_number)
 Function which calls BeamTrack class to calcualte Position at RPs. More...
 
int TransportSelectedParticle (HepMC::GenEvent &evt, int evt_number)
 This function is event selection, tracking and HepMC save ine one function. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

SG::ReadHandleKey< McEventCollectionm_MCKey
 
SG::ReadHandleKey< xAOD::EventInfom_eventInfoKey
 
FPConfig m_FPConfig
 
FPTracker::Particle m_Particle1
 
FPTracker::Particle m_Particle2
 
ALFA_BeamTrack m_BeamTracker
 
FPTracker::Point m_PosRP1
 
FPTracker::Point m_PosRP3
 
FPTracker::Point m_MomRP1
 
FPTracker::Point m_MomRP3
 
double m_EnergyRP1 = 0.0
 
double m_EnergyRP3 = 0.0
 
std::string m_FPOutputBeam1
 
std::string m_FPOutputBeam2
 
int m_pcount = 0
 
int m_pint = 0
 
double m_EtaCut
 
double m_XiCut
 
std::ofstream m_FileBeam1
 
std::ofstream m_FileBeam2
 
bool m_WriteDebugOutput
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

This is the ALFA Beam Transport package. It is an interface which uses FPTracker for beamtransportation. Getting from the HepMC eventrecord the particle data at the IP it calculates the particle porition at the first RP.

Author
Daniel Pelikan danie.nosp@m.l.pe.nosp@m.likan.nosp@m.@cer.nosp@m.n.ch

Definition at line 45 of file ALFA_BeamTransport.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ALFA_BeamTransport()

ALFA_BeamTransport::ALFA_BeamTransport ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Standard Athena-Algorithm Constructor.

Definition at line 35 of file ALFA_BeamTransport.cxx.

36  :
37  AthAlgorithm(name,pSvcLocator)
38 {
39  declareProperty("ConfDir", m_FPConfig.ConfDir="./config");
40  declareProperty("UseALFA", m_FPConfig.UseALFA=true);
41  declareProperty("Debug", m_WriteDebugOutput=false);
42  declareProperty("IP",m_FPConfig.IP = 1);
43  declareProperty("UseAper",m_FPConfig.useaper = true);
44  declareProperty("apermb",m_FPConfig.apermb = 0.);
45  declareProperty("xcol1",m_FPConfig.xcol1 = 999.);//999e-4 but we need open collimators
46  declareProperty("xcol2",m_FPConfig.xcol2 = 999.);//999e-4
47  declareProperty("BeamEnergy",m_FPConfig.pbeam0 = 7000.);//beam energy
48  declareProperty("RPDistance",m_FPConfig.RPDistance = 237.398);
49  declareProperty("absZMagMax",m_FPConfig.absZMagMax = 500.);//dont read magnets after this value
50 
51  //Cuts for production
52  declareProperty("EtaCut",m_EtaCut = 8.);
53  declareProperty("XiCut",m_XiCut = 0.2);
54 
55  declareProperty("FPOutputBeam1", m_FPOutputBeam1="Beam1");
56  declareProperty("FPOutputBeam2", m_FPOutputBeam2="Beam2");
57 
58 }

◆ ~ALFA_BeamTransport()

ALFA_BeamTransport::~ALFA_BeamTransport ( )

Default Destructor.

Definition at line 60 of file ALFA_BeamTransport.cxx.

60 {}

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyArrayType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  t,
const SG::NotHandleType  
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ DoBeamTracking()

int ALFA_BeamTransport::DoBeamTracking ( int  evt_number)

Function which calls BeamTrack class to calcualte Position at RPs.

Definition at line 205 of file ALFA_BeamTransport.cxx.

206 {
207  //do particle tracking for beam 1
208 
209  //tracking funktion
210  m_BeamTracker.ALFA_BeamTrack::CalculatePosRP(m_Particle1);//calculates position and momentum at RP1
211  //Position at RP
212  m_PosRP1=m_BeamTracker.ALFA_BeamTrack::PosRP();
213  //Momentum at RP
214  m_MomRP1=m_BeamTracker.ALFA_BeamTrack::MomRP();
215 
216  //do particle tracking for beam 2
217 
218  //tracking funktion
219  m_BeamTracker.ALFA_BeamTrack::CalculatePosRP(m_Particle2);//gives position and momentum at RP3
220  //Position at RP
221  m_PosRP3=m_BeamTracker.ALFA_BeamTrack::PosRP();
222  //Momentum at RP
223  m_MomRP3=m_BeamTracker.ALFA_BeamTrack::MomRP();
224 
225  //Write Output
227  {
228  m_FileBeam1 << evt_number << "\t" << std::setprecision(17)
229  << m_PosRP1.x() << std::setprecision(17) << "\t"
230  << m_PosRP1.y() << "\t" << std::setprecision(17)
231  << m_PosRP1.z() << "\t" << std::setprecision(17)
232  << m_MomRP1.x() << std::setprecision(17) << "\t"
233  << m_MomRP1.y() << "\t" << std::setprecision(17)
234  << m_MomRP1.z() << "\t" << std::setprecision(17)
235  << m_EnergyRP1 << std::endl;
236  m_FileBeam2 << evt_number << "\t" << std::setprecision(17)
237  << m_PosRP3.x() << std::setprecision(17) << "\t"
238  << m_PosRP3.y() << "\t" << std::setprecision(17)
239  << m_PosRP3.z() << "\t" << std::setprecision(17)
240  << m_MomRP3.x() << std::setprecision(17) << "\t"
241  << m_MomRP3.y() << "\t" << std::setprecision(17)
242  << m_MomRP3.z() << "\t" << std::setprecision(17)
243  << m_EnergyRP3 << std::endl;
244  }
245 
246  return true;
247 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode ALFA_BeamTransport::execute ( )

standard Athena-Algorithm method

Definition at line 108 of file ALFA_BeamTransport.cxx.

109 {
110  // Code entered here will be executed once per event
111  ATH_MSG_DEBUG ("Executing " << name() << "...");
112  //-----------------------------------------------------------------------------------------
113  int run_number;
114  uint64_t evt_number;
115 
116  //Set particles counter to zero!
117  //counter for particles marked as outgoing in event record
118  m_pcount=0;
119  //counter for particles marked as incomming in event record
120  m_pint=0;
121 
122  //Load event info
123  SG::ReadHandle<xAOD::EventInfo> eventInfo (m_eventInfoKey,getContext());
124  if(!eventInfo.isValid()) {
125  ATH_MSG_ERROR("Could not retrieve EventInfo");
126  return StatusCode::FAILURE;
127  }
128  else {
129  run_number=eventInfo->runNumber();
130  evt_number=eventInfo->eventNumber();
131 
132  ATH_MSG_DEBUG("run: " << run_number << " event: " << evt_number);
133  }
134 
135  SG::ReadHandle<McEventCollection> mcColl(m_MCKey, getContext());
136  if (!mcColl.isValid()) {
137  ATH_MSG_WARNING("Could not retrieve McEventCollection: " << m_MCKey);
138  return StatusCode::SUCCESS;
139  }
140  // Loop over all events in McEventCollectio
141  ATH_MSG_INFO("successful load of HepMC info");
142  for (const HepMC::GenEvent* itr : *mcColl){
143  HepMC::GenEvent evt = (*itr);
144  // convert unit MeV to GeV for energy and momenta
145  MeVToGeV(evt);
146 
147  HepMC::Print::line(std::cout, evt);
148 
149  // Select final state particle from event generator
150  // set event status !=1 (final state)
151  // fill member variables with particle data
152  // ALFA_BeamTransport::SelectParticles(evt);
153 
154  // There should be a check if the first particle is really the
155  // particle for beam 1!!!!
156 
157  // run Funktion which does the beamtracking
158  // ALFA_BeamTransport::DoBeamTracking(evt_number);
159 
160 
161  TransportSelectedParticle(evt, evt_number);
162 
163  // Print new data collection on screen
164  HepMC::Print::line(std::cout, evt);
165  }
166 
167  ATH_MSG_INFO("after running the process function");
168 
169  //-----------------------------------------------------------------------------------------
170 
171  return StatusCode::SUCCESS;
172 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

StatusCode ALFA_BeamTransport::finalize ( )

standard Athena-Algorithm method

Definition at line 95 of file ALFA_BeamTransport.cxx.

96 {
97  // close outputfiles for FPTracker
98  if (m_WriteDebugOutput) {
99  m_FileBeam1.close();
100  m_FileBeam2.close();
101  }
102  // Code entered here will be executed once at the end of the program run.
103  return StatusCode::SUCCESS;
104 }

◆ GeVToMeV()

void ALFA_BeamTransport::GeVToMeV ( HepMC::GenEvent &  evt)

convert GeV to MeV for HepMC event record

Definition at line 191 of file ALFA_BeamTransport.cxx.

192 {
193  for (const HepMC::GenParticlePtr& p : evt) {
194  const HepMC::FourVector fv(p->momentum().px() * 1000.,
195  p->momentum().py() * 1000.,
196  p->momentum().pz() * 1000.,
197  p->momentum().e() * 1000.);
198 
199  p->set_momentum(fv);
200  }
201 }

◆ initialize()

StatusCode ALFA_BeamTransport::initialize ( )

standard Athena-Algorithm method

Definition at line 63 of file ALFA_BeamTransport.cxx.

64 {
65  ATH_MSG_INFO("Initializing " << name() << "...");
68  // open files for beamtracking output
69  // string in char
70  char* cBeam1Name = new char[m_FPOutputBeam1.length()];
71  strcpy(cBeam1Name, m_FPOutputBeam1.c_str());
72  char* cBeam2Name = new char[m_FPOutputBeam2.length()];
73  strcpy(cBeam2Name, m_FPOutputBeam2.c_str());
74 
75  if (m_WriteDebugOutput) {
76  m_FileBeam1.open(cBeam1Name);
77  m_FileBeam2.open(cBeam2Name);
78  }
79 
80  //delete char arrays
81  delete[] cBeam1Name;
82  delete[] cBeam2Name;
83 
84  //Initialisation of FPTracker
85  m_BeamTracker.ALFA_BeamTrack::initialize(m_FPConfig);
86 
87  //-----------------------------------------------------------------------------------------
88  ATH_MSG_INFO( name() << " initialize()" );
89  ATH_MSG_INFO( "initialize() successful in " << name() );
90  return StatusCode::SUCCESS;
91 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ MeVToGeV()

void ALFA_BeamTransport::MeVToGeV ( HepMC::GenEvent &  evt)

convert unit MeV to GeV for energy and momenta

Definition at line 177 of file ALFA_BeamTransport.cxx.

178 {
179  for (const HepMC::GenParticlePtr& p: evt) {
180  const HepMC::FourVector fv(p->momentum().px() / 1000.,
181  p->momentum().py() / 1000.,
182  p->momentum().pz() / 1000.,
183  p->momentum().e() / 1000.);
184 
185  p->set_momentum(fv);
186  }
187 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ SelectParticles()

int ALFA_BeamTransport::SelectParticles ( HepMC::GenEvent *  evt)

Selects particles for beam transported Sets event status code of outgoing particles from generator to status != 1.

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ TransportSelectedParticle()

int ALFA_BeamTransport::TransportSelectedParticle ( HepMC::GenEvent &  evt,
int  evt_number 
)

This function is event selection, tracking and HepMC save ine one function.

Definition at line 249 of file ALFA_BeamTransport.cxx.

249  {
250  HepMC::GenParticlePtr p1{nullptr};
251  HepMC::GenParticlePtr p2{nullptr};
252 
253  std::vector<FPTracker::Point> PosAtRP1;
254  std::vector<FPTracker::Point> PosAtRP3;
255  std::vector<FPTracker::Point> MomAtPR1;
256  std::vector<FPTracker::Point> MomAtPR3;
257  std::vector<double> EnergyRP1;
258  std::vector<double> EnergyRP3;
259 
260 
261  double mom=0.;
262  double eta=0.;
263  double theta=0.;
264 
265  // First we have to select the final state particles from the MC
266  for (const HepMC::GenParticlePtr& p : evt) {
267 
268  // Simple Eta Pt cut to remove particles from BeamTransportation which
269  // have no chance to reach RP plane
270  mom = std::sqrt(std::pow(p->momentum().px(), 2) +
271  std::pow(p->momentum().py(), 2) +
272  std::pow(p->momentum().pz(), 2));
273  theta = std::acos(std::abs(p->momentum().pz()) / mom);
274  eta = -std::log(std::tan(theta / 2));
275 
276  if (MC::isStable(p) && (!p->end_vertex())) {
277 
278  int pid = p->pdg_id();
279  if (eta > m_EtaCut && 1 - std::abs(mom / m_FPConfig.pbeam0) < m_XiCut) {
280 
281  // save a copy of the particles which passed the cut
282  HepMC::FourVector Position = p->production_vertex()->position();
283  HepMC::FourVector Momentum = p->momentum();
284  HepMC::GenVertexPtr Vertex = HepMC::newGenVertexPtr(Position); // copy of the vertex
286 
287  Vertex->add_particle_out(std::move(Particle));
288  evt.add_vertex(std::move(Vertex));
289 
290  // select direction of particle
291  if (p->momentum().pz() > 0. && pid == 2212) { // Beam1 TODO Tracking only works for protons!!!!
292  p1 = p;
293  // now we want to track the final particle if it's a protons
294  // Positions are given in mm FPTracker needs them in meter
296  p1->production_vertex()->position().x() / 1000.,
297  p1->production_vertex()->position().y() / 1000.,
298  p1->production_vertex()->position().z() / 1000.,
299  p1->momentum().px(),
300  p1->momentum().py(),
301  p1->momentum().pz());
302 
303  // do particle tracking for beam 1
304 
305  // tracking funktion
306  m_BeamTracker.ALFA_BeamTrack::CalculatePosRP(m_Particle1); // calculates position and momentum at RP1
307  // Position at RP
308  m_PosRP1 = m_BeamTracker.ALFA_BeamTrack::PosRP();
309  PosAtRP1.push_back(m_PosRP1);
310  // Momentum at RP
311  m_MomRP1 = m_BeamTracker.ALFA_BeamTrack::MomRP();
312  MomAtPR1.push_back(m_MomRP1);
313  // no Energy change between IP and RP
314  m_EnergyRP1 = p1->momentum().e();
315  EnergyRP1.push_back(m_EnergyRP1);
316  if (m_WriteDebugOutput) {
317  m_FileBeam1 << evt_number << "\t" << std::setprecision(17)
318  << m_PosRP1.x() << std::setprecision(17) << "\t"
319  << m_PosRP1.y() << "\t" << std::setprecision(17)
320  << m_PosRP1.z() << "\t" << std::setprecision(17)
321  << m_MomRP1.x() << std::setprecision(17) << "\t"
322  << m_MomRP1.y() << "\t" << std::setprecision(17)
323  << m_MomRP1.z() << "\t" << std::setprecision(17)
324  << m_EnergyRP1 << std::endl;
325  }
326 
327  } else if (p->momentum().pz() < 0. && pid == 2212) { // beam 2
328  p2 = p;
329 
331  p2->production_vertex()->position().x() / 1000.,
332  p2->production_vertex()->position().y() / 1000.,
333  p2->production_vertex()->position().z() / 1000.,
334  p2->momentum().px(),
335  p2->momentum().py(),
336  p2->momentum().pz());
337  // tracking funktion
338  m_BeamTracker.ALFA_BeamTrack::CalculatePosRP(m_Particle2); // gives position and momentum at RP3
339  // Position at RP
340  m_PosRP3 = m_BeamTracker.ALFA_BeamTrack::PosRP();
341  PosAtRP3.push_back(m_PosRP3);
342  // Momentum at RP
343  m_MomRP3 = m_BeamTracker.ALFA_BeamTrack::MomRP();
344  MomAtPR3.push_back(m_MomRP3);
345 
346  m_EnergyRP3 = p2->momentum().e();
347  EnergyRP3.push_back(m_EnergyRP3);
348  // Write Output
349  if (m_WriteDebugOutput) {
350  m_FileBeam2 << evt_number << "\t" << std::setprecision(17)
351  << m_PosRP3.x() << std::setprecision(17) << "\t"
352  << m_PosRP3.y() << "\t" << std::setprecision(17)
353  << m_PosRP3.z() << "\t" << std::setprecision(17)
354  << m_MomRP3.x() << std::setprecision(17) << "\t"
355  << m_MomRP3.y() << "\t" << std::setprecision(17)
356  << m_MomRP3.z() << "\t" << std::setprecision(17)
357  << m_EnergyRP3 << std::endl;
358  }
359 
360  } else {
361  ATH_MSG_ERROR("Strange: Particle rests at IP");
362  }
363 
364  if (pid == 2212) { // Find the protons
365  m_pcount++;
366  if (m_pcount > 2) {
367  ATH_MSG_ERROR("Strange: More than two protons in this event!");
368  }
369  }
370  }
371  }
372  }
373 
374  //from here the transported particles are added to HepMC
375 
376  ATH_MSG_INFO("Add transproted particle into HepMC event record Beam 1");
377  //Add Data for HepMC Collection
378 
379  for(int i=0;i<(int)PosAtRP1.size();i++){//Beam1
380  //The factor 1000 comes from the fact that HepMC saves length in mm
381  HepMC::FourVector PositionVectorRP1 = HepMC::FourVector(PosAtRP1.at(i).x()*1000.,PosAtRP1.at(i).y()*1000.,PosAtRP1.at(i).z()*1000.,0.*1000.);
382  HepMC::FourVector MomentumVectorRP1 = HepMC::FourVector(MomAtPR1.at(i).x(),MomAtPR1.at(i).y(),MomAtPR1.at(i).z(),EnergyRP1.at(i));
383 
384  HepMC::GenVertexPtr VertexRP1 = HepMC::newGenVertexPtr(PositionVectorRP1);
385  HepMC::GenParticlePtr ParticleRP1 = HepMC::newGenParticlePtr(MomentumVectorRP1,2212,1); //save the transported particle with status code 1 (added 120124) preview was 201
386  //Add particle to vertex
387  VertexRP1->add_particle_out(std::move(ParticleRP1));
388  //add new vertex to HepMC event record
389  if(m_PosRP1.x()!=-99){ // add vertex to event record if the particle in the first beam was not lost
390  evt.add_vertex(std::move(VertexRP1));
391  }
392  }
393  ATH_MSG_INFO ("Add transproted particle into HepMC event record Beam 2" );
394  for(int i=0;i<(int)PosAtRP3.size();i++){
395  HepMC::FourVector PositionVectorRP3 = HepMC::FourVector(PosAtRP3.at(i).x()*1000.,PosAtRP3.at(i).y()*1000.,PosAtRP3.at(i).z()*1000.,0.*1000.);
396  HepMC::FourVector MomentumVectorRP3 = HepMC::FourVector(MomAtPR3.at(i).x(),MomAtPR3.at(i).y(),MomAtPR3.at(i).z(),EnergyRP3.at(i));
397  HepMC::GenVertexPtr VertexRP3 = HepMC::newGenVertexPtr(PositionVectorRP3);
398  HepMC::GenParticlePtr ParticleRP3 = HepMC::newGenParticlePtr(MomentumVectorRP3,2212,1);//save the transported particle with status code 1 (added 120124) preview was 201
399  VertexRP3->add_particle_out(std::move(ParticleRP3));
400  if (m_PosRP3.x() != -99) { // add vertex to event record if the // particle in the second beam was not lost
401  evt.add_vertex(std::move(VertexRP3));
402  }
403  }
404 
405  //convert HepMC data back to HepMC standart ( momentum and energy in MeV)
407  return true;
408 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_BeamTracker

ALFA_BeamTrack ALFA_BeamTransport::m_BeamTracker
private

Definition at line 95 of file ALFA_BeamTransport.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_EnergyRP1

double ALFA_BeamTransport::m_EnergyRP1 = 0.0
private

Definition at line 103 of file ALFA_BeamTransport.h.

◆ m_EnergyRP3

double ALFA_BeamTransport::m_EnergyRP3 = 0.0
private

Definition at line 104 of file ALFA_BeamTransport.h.

◆ m_EtaCut

double ALFA_BeamTransport::m_EtaCut
private

Definition at line 116 of file ALFA_BeamTransport.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> ALFA_BeamTransport::m_eventInfoKey
private
Initial value:
{ this,
"EvtInfo",
"EventInfo",
"EventInfo name" }

Definition at line 83 of file ALFA_BeamTransport.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_FileBeam1

std::ofstream ALFA_BeamTransport::m_FileBeam1
private

Definition at line 120 of file ALFA_BeamTransport.h.

◆ m_FileBeam2

std::ofstream ALFA_BeamTransport::m_FileBeam2
private

Definition at line 121 of file ALFA_BeamTransport.h.

◆ m_FPConfig

FPConfig ALFA_BeamTransport::m_FPConfig
private

Definition at line 90 of file ALFA_BeamTransport.h.

◆ m_FPOutputBeam1

std::string ALFA_BeamTransport::m_FPOutputBeam1
private

Definition at line 106 of file ALFA_BeamTransport.h.

◆ m_FPOutputBeam2

std::string ALFA_BeamTransport::m_FPOutputBeam2
private

Definition at line 107 of file ALFA_BeamTransport.h.

◆ m_MCKey

SG::ReadHandleKey<McEventCollection> ALFA_BeamTransport::m_MCKey
private
Initial value:
{
this,
"McEventCollectionName",
"GEN_EVENT",
"MC Event Collection name"
}

Definition at line 76 of file ALFA_BeamTransport.h.

◆ m_MomRP1

FPTracker::Point ALFA_BeamTransport::m_MomRP1
private

Definition at line 100 of file ALFA_BeamTransport.h.

◆ m_MomRP3

FPTracker::Point ALFA_BeamTransport::m_MomRP3
private

Definition at line 101 of file ALFA_BeamTransport.h.

◆ m_Particle1

FPTracker::Particle ALFA_BeamTransport::m_Particle1
private

Definition at line 93 of file ALFA_BeamTransport.h.

◆ m_Particle2

FPTracker::Particle ALFA_BeamTransport::m_Particle2
private

Definition at line 94 of file ALFA_BeamTransport.h.

◆ m_pcount

int ALFA_BeamTransport::m_pcount = 0
private

Definition at line 112 of file ALFA_BeamTransport.h.

◆ m_pint

int ALFA_BeamTransport::m_pint = 0
private

Definition at line 114 of file ALFA_BeamTransport.h.

◆ m_PosRP1

FPTracker::Point ALFA_BeamTransport::m_PosRP1
private

Definition at line 97 of file ALFA_BeamTransport.h.

◆ m_PosRP3

FPTracker::Point ALFA_BeamTransport::m_PosRP3
private

Definition at line 98 of file ALFA_BeamTransport.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_WriteDebugOutput

bool ALFA_BeamTransport::m_WriteDebugOutput
private

Definition at line 123 of file ALFA_BeamTransport.h.

◆ m_XiCut

double ALFA_BeamTransport::m_XiCut
private

Definition at line 117 of file ALFA_BeamTransport.h.


The documentation for this class was generated from the following files:
HepMC::GenVertexPtr
HepMC::GenVertex * GenVertexPtr
Definition: GenVertex.h:59
ALFA_BeamTransport::m_BeamTracker
ALFA_BeamTrack m_BeamTracker
Definition: ALFA_BeamTransport.h:95
FPConfig::IP
int IP
Definition: ALFA_FPConfig.h:17
ALFA_BeamTransport::m_FileBeam1
std::ofstream m_FileBeam1
Definition: ALFA_BeamTransport.h:120
ALFA_BeamTransport::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: ALFA_BeamTransport.h:83
FPConfig::UseALFA
bool UseALFA
Definition: ALFA_FPConfig.h:12
ALFA_BeamTransport::m_WriteDebugOutput
bool m_WriteDebugOutput
Definition: ALFA_BeamTransport.h:123
ALFA_BeamTransport::m_FPOutputBeam1
std::string m_FPOutputBeam1
Definition: ALFA_BeamTransport.h:106
ALFA_BeamTransport::m_FPOutputBeam2
std::string m_FPOutputBeam2
Definition: ALFA_BeamTransport.h:107
plotting.plot_kinematics.run_number
run_number
Definition: plot_kinematics.py:29
FPTracker::Point::x
double x() const
Definition: FPTracker/src/Point.cxx:17
xAOD::Vertex
Vertex_v1 Vertex
Define the latest version of the vertex class.
Definition: Event/xAOD/xAODTracking/xAODTracking/Vertex.h:16
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ALFA_BeamTransport::m_FileBeam2
std::ofstream m_FileBeam2
Definition: ALFA_BeamTransport.h:121
ALFA_BeamTransport::m_MomRP3
FPTracker::Point m_MomRP3
Definition: ALFA_BeamTransport.h:101
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
FPConfig::ConfDir
std::string ConfDir
Definition: ALFA_FPConfig.h:13
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
ALFA_BeamTransport::m_EnergyRP3
double m_EnergyRP3
Definition: ALFA_BeamTransport.h:104
HepMC::GenParticlePtr
GenParticle * GenParticlePtr
Definition: GenParticle.h:37
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
ALFA_BeamTransport::m_pint
int m_pint
Definition: ALFA_BeamTransport.h:114
FPTracker::Point::y
double y() const
Definition: FPTracker/src/Point.cxx:18
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
ALFA_BeamTransport::m_Particle1
FPTracker::Particle m_Particle1
Definition: ALFA_BeamTransport.h:93
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
ALFA_BeamTransport::GeVToMeV
void GeVToMeV(HepMC::GenEvent &evt)
convert GeV to MeV for HepMC event record
Definition: ALFA_BeamTransport.cxx:191
ALFA_BeamTransport::m_EnergyRP1
double m_EnergyRP1
Definition: ALFA_BeamTransport.h:103
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
HepMC::Print::line
void line(std::ostream &os, const GenEvent &e)
Definition: GenEvent.h:676
ALFA_BeamTransport::m_MomRP1
FPTracker::Point m_MomRP1
Definition: ALFA_BeamTransport.h:100
xAOD::Particle
Particle_v1 Particle
Define the latest version of the particle class.
Definition: Event/xAOD/xAODParticleEvent/xAODParticleEvent/Particle.h:17
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
ALFA_BeamTransport::m_MCKey
SG::ReadHandleKey< McEventCollection > m_MCKey
Definition: ALFA_BeamTransport.h:76
FPConfig::xcol2
double xcol2
Definition: ALFA_FPConfig.h:22
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
ParticleGun_EoverP_Config.mom
mom
Definition: ParticleGun_EoverP_Config.py:63
FPConfig::apermb
double apermb
Definition: ALFA_FPConfig.h:20
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
HepMC::newGenVertexPtr
GenVertexPtr newGenVertexPtr(const HepMC::FourVector &pos=HepMC::FourVector(0.0, 0.0, 0.0, 0.0), const int i=0)
Definition: GenVertex.h:64
lumiFormat.i
int i
Definition: lumiFormat.py:85
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
ALFA_BeamTransport::TransportSelectedParticle
int TransportSelectedParticle(HepMC::GenEvent &evt, int evt_number)
This function is event selection, tracking and HepMC save ine one function.
Definition: ALFA_BeamTransport.cxx:249
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
FPConfig::xcol1
double xcol1
Definition: ALFA_FPConfig.h:21
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
ALFA_BeamTransport::m_PosRP1
FPTracker::Point m_PosRP1
Definition: ALFA_BeamTransport.h:97
FPConfig::absZMagMax
float absZMagMax
Definition: ALFA_FPConfig.h:28
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
ALFA_BeamTransport::m_EtaCut
double m_EtaCut
Definition: ALFA_BeamTransport.h:116
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
FPTracker::Point::z
double z() const
Definition: FPTracker/src/Point.cxx:19
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
FPConfig::RPDistance
float RPDistance
Definition: ALFA_FPConfig.h:25
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
FPConfig::pbeam0
double pbeam0
Definition: ALFA_FPConfig.h:23
MC::isStable
bool isStable(const T &p)
Identify if the particle is stable, i.e. has not decayed.
Definition: HepMCHelpers.h:45
a
TList * a
Definition: liststreamerinfos.cxx:10
HepMC::newGenParticlePtr
GenParticlePtr newGenParticlePtr(const HepMC::FourVector &mom=HepMC::FourVector(0.0, 0.0, 0.0, 0.0), int pid=0, int status=0)
Definition: GenParticle.h:39
FPConfig::useaper
bool useaper
Definition: ALFA_FPConfig.h:19
h
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ALFA_BeamTransport::m_Particle2
FPTracker::Particle m_Particle2
Definition: ALFA_BeamTransport.h:94
ALFA_BeamTransport::MeVToGeV
void MeVToGeV(HepMC::GenEvent &evt)
convert unit MeV to GeV for energy and momenta
Definition: ALFA_BeamTransport.cxx:177
ALFA_BeamTransport::m_XiCut
double m_XiCut
Definition: ALFA_BeamTransport.h:117
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
ALFA_BeamTransport::m_FPConfig
FPConfig m_FPConfig
Definition: ALFA_BeamTransport.h:90
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
ALFA_BeamTransport::m_PosRP3
FPTracker::Point m_PosRP3
Definition: ALFA_BeamTransport.h:98
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
fitman.k
k
Definition: fitman.py:528
ALFA_BeamTransport::m_pcount
int m_pcount
Definition: ALFA_BeamTransport.h:112
ServiceHandle< ICondSvc >