ATLAS Offline Software
Classes | Enumerations | Functions
ForwardTracker Namespace Reference

Classes

class  Beamline
 
class  BenderDipole
 
class  BenderQuadrupole
 
class  Collimator
 
struct  CollimatorData
 
class  ConfigData
 
class  ForwardTrackerConstants
 
class  IBeamElement
 
class  IBender
 
class  IParticle
 
class  Magnet
 
class  Particle
 
class  ParticleTracker
 
class  Plane
 
class  Point
 
class  Spacer
 
class  Stringer
 
class  TransversePoint
 
class  zPosNextElement
 

Enumerations

enum  Bendplane { hBendplane = 0, vBendplane = 1 }
 
enum  Side { beam1 = 1, beam2 = 0 }
 

Functions

std::ostream & operator<< (std::ostream &, const Beamline &)
 
Beamline BeamlineSetup (const ConfigData &, const Side &)
 
std::ostream & operator<< (std::ostream &, const Collimator &)
 
Collimator::Container_t CollimatorSet (const ConfigData &, const Side &side)
 
std::ostream & operator<< (std::ostream &, const ConfigData &)
 
std::ostream & operator<< (std::ostream &, const Side &side)
 
std::ostream & operator<< (std::ostream &os, const IBeamElement &be)
 
std::ostream & operator<< (std::ostream &, const IParticle &)
 
std::ostream & operator<< (std::ostream &, const Magnet &)
 
Magnet::ConstPtr_t MagnetFactory (double x, double y, double z, double strength, double length, const std::string &aperType, double A1, double A2, double A3, double A4, double beamEnergy, Side side, Magnet::Type type)
 
Magnet::Container_t MagnetSet (const ConfigData &, const Side &)
 
std::ostream & operator<< (std::ostream &, const Plane &)
 
Point operator* (double scalar, const Point &p)
 
Point operator+ (const Point &lhs, const Point &rhs)
 
Point operator- (const Point &lhs, const Point &rhs)
 
Point operator+ (const Point &lhs, const TransversePoint &rhs)
 
Point operator- (const Point &lhs, const TransversePoint &rhs)
 
std::ostream & operator<< (std::ostream &, const Point &)
 
template<class PtrType >
bool absZGreater (const PtrType rhs, const PtrType lhs)
 
template<class streamptr >
void openFile (const std::string &fname, streamptr &strm)
 
TransversePoint operator* (double, const TransversePoint &)
 
TransversePoint operator+ (const TransversePoint &, const TransversePoint &)
 
TransversePoint operator- (const TransversePoint &, const TransversePoint &)
 
std::ostream & operator<< (std::ostream &, const TransversePoint &)
 
TransversePoint TransverseShift (double z)
 
std::shared_ptr< std::ifstream > TwissFile (const ConfigData &, const Side &)
 
double GetBeamEnergy (std::ifstream &)
 
void TwissFilePrint (std::ifstream &, double endMarker)
 
bool isEndMarker (const IBeamElement::ConstPtr_t &be)
 
IBeamElement::Iter_t findBeamLineEnd (IBeamElement::Container_t &container)
 
std::string label (Magnet::Type type)
 
IBender::ConstPtr_t benderFactory (Magnet::Type type, Side side, double length, double strength, double beamEnergy)
 

Enumeration Type Documentation

◆ Bendplane

enum ForwardTracker::Bendplane
Enumerator
hBendplane 
vBendplane 

Definition at line 12 of file ForwardTrackerConstants.h.

12 {hBendplane = 0, vBendplane = 1};

◆ Side

enum ForwardTracker::Side
Enumerator
beam1 
beam2 

Definition at line 13 of file ForwardTrackerConstants.h.

13 {beam1 = 1, beam2 = 0};

Function Documentation

◆ absZGreater()

template<class PtrType >
bool ForwardTracker::absZGreater ( const PtrType  rhs,
const PtrType  lhs 
)

Definition at line 14 of file ForwardTracker/ForwardTracker/STLHelpers.h.

14 { return std::fabs(lhs->position().z()) > std::fabs(rhs->position().z()); }

◆ BeamlineSetup()

Beamline ForwardTracker::BeamlineSetup ( const ConfigData &  cData,
const Side &  side 
)

Definition at line 16 of file BeamlineSetup.cxx.

16  {
17 
18  Magnet::Container_t magnets = MagnetSet (cData, side);
19  Collimator::Container_t collimators = CollimatorSet(cData, side);
20  Plane::ConstPtr_t endPlane(new Plane(cData.endMarker, side));
21 
22  IBeamElement::List_t elements;
23 
24  elements.assign(magnets.begin(), magnets.end());
25  elements.insert(elements.end(), collimators.begin(), collimators.end());
26  elements.push_back(endPlane);
27  elements.sort(absZGreater<IBeamElement::ConstPtr_t>);
28 
29  IBeamElement::ListIter_t current = elements.begin();
30  IBeamElement::ListIter_t last = elements.end();
31 
32  elements.push_front(Spacer::ConstPtr_t(new Spacer(0., (*current)->frontFace(), (*current)->side())));
33 
34  ++current;
35 
36  for(; current != last; ++current) {
37 
38  IBeamElement::ListIter_t previous = current;
39 
40  --previous;
41 
42  elements.insert(current, Spacer::ConstPtr_t(new Spacer(*previous, *current)));
43  }
44 
45  Beamline beamline(elements.begin(), elements.end());
46 
47  return beamline;
48  }

◆ benderFactory()

IBender::ConstPtr_t ForwardTracker::benderFactory ( Magnet::Type  type,
Side  side,
double  length,
double  strength,
double  beamEnergy 
)

Definition at line 25 of file MagnetFactory.cxx.

29  {
30 
31  if (type == Magnet::hbDipole) return IBender::ConstPtr_t(new BenderDipole (side, length, strength, beamEnergy, hBendplane));
32  if (type == Magnet::vbDipole) return IBender::ConstPtr_t(new BenderDipole (side, length, strength, beamEnergy, vBendplane));
33  if (type == Magnet::hfQuadrupole) return IBender::ConstPtr_t(new BenderQuadrupole(side, length, strength, beamEnergy, hBendplane));
34  if (type == Magnet::vfQuadrupole) return IBender::ConstPtr_t(new BenderQuadrupole(side, length, strength, beamEnergy, vBendplane));
35 
36  throw std::logic_error("unknown magnet type");
37  }

◆ CollimatorSet()

Collimator::Container_t ForwardTracker::CollimatorSet ( const ConfigData &  cData,
const Side &  side 
)

Definition at line 13 of file CollimatorSet.cxx.

13  {
14  Collimator::Container_t collimators;
15  const CollimatorData& collData(cData);
16  for (int i =0; i<collData.coll_n; ++i) {
17  Collimator::ConstPtr_t col(new Collimator(collData.coll_z[side][i]*ForwardTrackerConstants::aside[side],
18  collData.coll_a[side][i],
19  side));
20  collimators.push_back(std::move(col));
21  }
22  std::sort(collimators.begin(), collimators.end(), absZGreater<Collimator::ConstPtr_t>);
23  return collimators;
24  }

◆ findBeamLineEnd()

IBeamElement::Iter_t ForwardTracker::findBeamLineEnd ( IBeamElement::Container_t &  container)

Definition at line 21 of file ForwardTracker/src/Beamline.cxx.

21  {
22 
23  IBeamElement::Iter_t ei = std::find_if(container.begin(), container.end(), isEndMarker);
24 
25  if (ei != container.end()) ++ei;
26  else throw std::runtime_error("Could not find the end of the beamline.");
27 
28  return ei;
29  }

◆ GetBeamEnergy()

double ForwardTracker::GetBeamEnergy ( std::ifstream &  pfile)

Definition at line 112 of file TwissFile.cxx.

112  {
113 
114  double beamEnergy = -1;
115  std::string dummy;
116 
117  while (pfile >> dummy) { if (dummy == "ENERGY") { pfile >> dummy; pfile >> beamEnergy; break; } }
118 
119  if (beamEnergy == -1) throw std::runtime_error("Could not read beamEnergy from twiss file");
120 
121  pfile.clear();
122  pfile.seekg(0, std::ios::beg);
123 
124  return beamEnergy;
125  }

◆ isEndMarker()

bool ForwardTracker::isEndMarker ( const IBeamElement::ConstPtr_t &  be)

Definition at line 19 of file ForwardTracker/src/Beamline.cxx.

19 { return be->isEndElement(); }

◆ label()

std::string ForwardTracker::label ( Magnet::Type  type)

Definition at line 15 of file MagnetFactory.cxx.

15  {
16 
17  if (type == Magnet::hbDipole) return "hbDipole";
18  if (type == Magnet::vbDipole) return "vbDipole";
19  if (type == Magnet::hfQuadrupole) return "hfQuadrupole";
20  if (type == Magnet::vfQuadrupole) return "vfQuadrupole";
21 
22  return "NONE";
23  }

◆ MagnetFactory()

Magnet::ConstPtr_t ForwardTracker::MagnetFactory ( double  x,
double  y,
double  z,
double  strength,
double  length,
const std::string &  aperType,
double  A1,
double  A2,
double  A3,
double  A4,
double  beamEnergy,
Side  side,
Magnet::Type  type 
)

Definition at line 39 of file MagnetFactory.cxx.

51  {
52 
53  IBender::ConstPtr_t bender(benderFactory(type, side, length, strength, beamEnergy));
54 
55  return Magnet::ConstPtr_t(new Magnet(x, y, z, length, aperType, aper1, aper2, aper3, aper4, side, bender.get(), label(type)));
56  }

◆ MagnetSet()

Magnet::Container_t ForwardTracker::MagnetSet ( const ConfigData &  cData,
const Side &  side 
)

Definition at line 18 of file MagnetSet.cxx.

18  {
19 
20  Magnet::Container_t magnets; // (x, y, z) = (left, up, forward)
21 
22  std::shared_ptr<std::ifstream> twissFile = TwissFile(cData, side);
23 
24  std::ifstream& pfile = *twissFile;
25 
26  double beamEnergy = ForwardTracker::GetBeamEnergy(pfile);
27 
28  std::cout << "beamEnergy[GeV] = " << beamEnergy << std::endl;
29 
30  while (pfile.peek() == '@' || pfile.peek() == '*' || pfile.peek() == '$') pfile.ignore(1000, '\n');
31 
32  std::ios::fmtflags cout_flags = std::cout.flags();
33 
34  std::cout << std::left
35  << std::setw(15) << "magName"
36  << std::setw(15) << "magSort"
37  << std::right
38  << std::setw(10) << "magType"
39  << std::setw(15) << "magEndPos"
40  << std::setw(15) << "magLength"
41  << std::setw(15) << "magStrength"
42  << std::setw(15) << "magAperType"
43  << std::setw(10) << "magAper1"
44  << std::setw(10) << "magAper2"
45  << std::setw(10) << "magAper3"
46  << std::setw(10) << "magAper4"
47  << std::endl;
48 
49  while (true) { // Read the magnet data from twiss_b1.txt for beam 1 (side 1) and twiss_b2.txt for beam 2 (side 0).
50 
51  std::string magName, magSort, magBasic;
52  double magEndPos, magLength;
53  double HKICK, VKICK;
54  double K0L, K1L, K2L, K3L;
55  double X, PX, BETX, ALFX, MUX, DX, DPX;
56  double Y, PY, BETY, ALFY, MUY, DY, DPY;
57  std::string magAperType;
58  double magAper1, magAper2, magAper3, magAper4;
59 
60  pfile >> magName >> magSort >> magBasic >> magEndPos >> magLength
61  >> HKICK >> VKICK
62  >> K0L >> K1L >> K2L >> K3L
63  >> X >> Y >> PX >> PY
64  >> BETX >> BETY >> ALFX >> ALFY >> MUX >> MUY
65  >> DX >> DY >> DPX >> DPY
66  >> magAperType
67  >> magAper1 >> magAper2 >> magAper3 >> magAper4;
68 
69  if (magEndPos < 0) throw std::runtime_error("Magnet End Position cannot be negative.");
70  else if (magEndPos > cData.endMarker) break;
71 
72  Magnet::Type magType = Magnet::notAMagnet;
73  double magStrength = 0;
74 
75  if (K0L != 0) { magType = Magnet::hbDipole; magStrength = K0L; }
76  else if (K1L != 0) { magType = (K1L > 0) ? Magnet::hfQuadrupole : Magnet::vfQuadrupole; magStrength = K1L; }
77  else if (HKICK != 0) { magType = Magnet::hbDipole; magStrength = -HKICK; }
78  else if (VKICK != 0) { magType = Magnet::vbDipole; magStrength = +VKICK; }
79 
80  if (magType == Magnet::notAMagnet) continue;
81 
82  std::cout.precision(6);
83  if (magName.find("DRIFT") != 1)
84  std::cout << std::fixed
85  << std::left
86  << std::setw(15) << magName
87  << std::setw(15) << magSort
88  << std::right
89  << std::setw(10) << magType
90  << std::setw(15) << magEndPos
91  << std::setw(15) << magLength
92  << std::setw(15) << magStrength
93  << std::setw(15) << magAperType
94  << std::setw(10) << magAper1
95  << std::setw(10) << magAper2
96  << std::setw(10) << magAper3
97  << std::setw(10) << magAper4
98  << std::endl;
99 
100  if (magLength < 0) throw std::runtime_error("magLength must be positive.");
101  else if (magLength == 0) {
102  if (magType == Magnet::hfQuadrupole) throw std::runtime_error("magLength cannot be zero for hfQuadrupole.");
103  if (magType == Magnet::vfQuadrupole) throw std::runtime_error("magLength cannot be zero for vfQuadrupole.");
104  }
105 
106  double z = (magEndPos - 0.5*magLength)*ForwardTrackerConstants::aside[side];
107 
108  Magnet::ConstPtr_t mptr = MagnetFactory(TransverseShift(z)[0], // account of beam splitting around 155 m
109  TransverseShift(z)[1],
110  z,
111  magStrength,
112  magLength,
113  magAperType,
114  magAper1,
115  magAper2,
116  magAper3,
117  magAper4,
118  beamEnergy,
119  side,
120  magType);
121 
122  magnets.push_back(std::move(mptr));
123  }
124 
125  std::sort(magnets.begin(), magnets.end(), absZGreater<Magnet::ConstPtr_t>);
126 
127  std::cout.flags(cout_flags);
128 
129  return magnets;
130  }

◆ openFile()

template<class streamptr >
void ForwardTracker::openFile ( const std::string &  fname,
streamptr &  strm 
)
inline

Definition at line 17 of file ForwardTracker/ForwardTracker/STLHelpers.h.

17  {
18 
19  strm->open(fname.c_str());
20 
21  if (strm->good()) std::cout << "Open file: " << fname << std::endl;
22  else {
23 
24  std::string msg = "Error opening file " + fname;
25  throw std::runtime_error(msg);
26  }
27  }

◆ operator*() [1/2]

Point ForwardTracker::operator* ( double  scalar,
const Point &  p 
)

Definition at line 34 of file ForwardTracker/src/Point.cxx.

34 { Point point(p); return point *= scalar; }

◆ operator*() [2/2]

TransversePoint ForwardTracker::operator* ( double  scalar,
const TransversePoint &  p 
)

Definition at line 27 of file ForwardTracker/src/TransversePoint.cxx.

27 { TransversePoint point(p); return point *= scalar; }

◆ operator+() [1/3]

Point ForwardTracker::operator+ ( const Point &  lhs,
const Point &  rhs 
)

Definition at line 35 of file ForwardTracker/src/Point.cxx.

35 { Point point(lhs); return point += rhs; }

◆ operator+() [2/3]

Point ForwardTracker::operator+ ( const Point &  lhs,
const TransversePoint &  rhs 
)

Definition at line 37 of file ForwardTracker/src/Point.cxx.

37 { Point point(lhs); return point += rhs; }

◆ operator+() [3/3]

TransversePoint ForwardTracker::operator+ ( const TransversePoint &  lhs,
const TransversePoint &  rhs 
)

Definition at line 28 of file ForwardTracker/src/TransversePoint.cxx.

28 { TransversePoint point(lhs); return point += rhs; }

◆ operator-() [1/3]

Point ForwardTracker::operator- ( const Point &  lhs,
const Point &  rhs 
)

Definition at line 36 of file ForwardTracker/src/Point.cxx.

36 { Point point(lhs); return point -= rhs; }

◆ operator-() [2/3]

Point ForwardTracker::operator- ( const Point &  lhs,
const TransversePoint &  rhs 
)

Definition at line 38 of file ForwardTracker/src/Point.cxx.

38 { Point point(lhs); return point -= rhs; }

◆ operator-() [3/3]

TransversePoint ForwardTracker::operator- ( const TransversePoint &  lhs,
const TransversePoint &  rhs 
)

Definition at line 29 of file ForwardTracker/src/TransversePoint.cxx.

29 { TransversePoint point(lhs); return point -= rhs; }

◆ operator<<() [1/10]

std::ostream & ForwardTracker::operator<< ( std::ostream &  os,
const Beamline &  bl 
)

Definition at line 105 of file ForwardTracker/src/Beamline.cxx.

105 { os << bl.str(); return os; }

◆ operator<<() [2/10]

std::ostream & ForwardTracker::operator<< ( std::ostream &  os,
const Collimator &  coll 
)

Definition at line 49 of file ForwardTracker/src/Collimator.cxx.

49 { os << coll.str(); return os; }

◆ operator<<() [3/10]

std::ostream & ForwardTracker::operator<< ( std::ostream &  os,
const ConfigData &  cd 
)

Definition at line 39 of file ForwardTracker/src/ConfigData.cxx.

39 { os << cd.str(); return os; }

◆ operator<<() [4/10]

std::ostream & ForwardTracker::operator<< ( std::ostream &  os,
const IParticle &  p 
)

Definition at line 9 of file ForwardDetectors/ForwardTracker/src/IParticle.cxx.

9 { os << p.str(); return os; }

◆ operator<<() [5/10]

std::ostream & ForwardTracker::operator<< ( std::ostream &  os,
const Magnet &  mag 
)

Definition at line 181 of file ForwardTracker/src/Magnet.cxx.

181 { os << mag.str(); return os; }

◆ operator<<() [6/10]

std::ostream& ForwardTracker::operator<< ( std::ostream &  ,
const Plane &   
)

◆ operator<<() [7/10]

std::ostream & ForwardTracker::operator<< ( std::ostream &  os,
const Point &  p 
)

Definition at line 40 of file ForwardTracker/src/Point.cxx.

40 { os << p.str(); return os; }

◆ operator<<() [8/10]

std::ostream & ForwardTracker::operator<< ( std::ostream &  os,
const Side &  side 
)

Definition at line 17 of file ForwardTrackerConstants.cxx.

17 { if (side == beam1) os << " beam1 "; else os << " beam2 "; return os; }

◆ operator<<() [9/10]

std::ostream & ForwardTracker::operator<< ( std::ostream &  os,
const TransversePoint &  p 
)

Definition at line 31 of file ForwardTracker/src/TransversePoint.cxx.

31 { os << p.str(); return os; }

◆ operator<<() [10/10]

std::ostream & ForwardTracker::operator<< ( std::ostream &  os,
const IBeamElement &  be 
)

Definition at line 11 of file ForwardTracker/src/IBeamElement.cxx.

11 { os << be.str(); return os; }

◆ TransverseShift()

TransversePoint ForwardTracker::TransverseShift ( double  z)

Definition at line 13 of file TransverseShift.cxx.

13  { // account of beam splitting around 155 m
14 
15  if (std::fabs(z) > ForwardTrackerConstants::zOfBeamSeparation)
16  return TransversePoint(-ForwardTrackerConstants::xdis, ForwardTrackerConstants::ydis);
17 
18  return TransversePoint(0., 0.);
19  }

◆ TwissFile()

std::shared_ptr< std::ifstream > ForwardTracker::TwissFile ( const ConfigData &  cData,
const Side &  side 
)

Definition at line 14 of file TwissFile.cxx.

14  {
15 
16  if (side != beam1 && side != beam2) throw std::runtime_error("Allowed side values are beam1 or beam2.");
17 
18  std::string fn = (side == beam1) ? cData.twissFile1 : cData.twissFile2;
19 
20  std::shared_ptr<std::ifstream> twissFile(new std::ifstream);
21 
22  ForwardTracker::openFile(fn, twissFile);
23 
24  ForwardTracker::TwissFilePrint(*twissFile, cData.endMarker);
25 
26  return twissFile;
27  }

◆ TwissFilePrint()

void ForwardTracker::TwissFilePrint ( std::ifstream &  pfile,
double  endMarker 
)

Definition at line 29 of file TwissFile.cxx.

29  {
30 
31  std::ios::fmtflags cout_flags = std::cout.flags();
32 
33  std::cout << std::left
34  << std::setw(15) << "NAME"
35  << std::setw(15) << "KEYWORD"
36  << std::right
37  << std::setw( 8) << "S"
38  << std::setw( 8) << "L"
39  << std::setw( 8) << "BETX"
40  << std::setw( 8) << "BETY"
41  << std::setw(10) << "HKICK"
42  << std::setw(10) << "VKICK"
43  << std::setw(10) << "K0L"
44  << std::setw(10) << "K1L"
45  << std::setw(10) << "K2L"
46  << std::setw(10) << "K3L"
47  << std::setw(15) << "APERTYPE"
48  << std::setw( 8) << "APER_1"
49  << std::setw( 8) << "APER_2"
50  << std::setw( 8) << "APER_3"
51  << std::setw( 8) << "APER_4"
52  << std::endl;
53 
54  while (pfile.peek() == '@' || pfile.peek() == '*' || pfile.peek() == '$') pfile.ignore(1000, '\n');
55 
56  while (true) {
57 
58  std::string NAME, KEYWORD, PARENT;
59  double ENDPOS, LENGTH;
60  double HKICK, VKICK;
61  double K0L, K1L, K2L, K3L;
62  double X, PX, BETX, ALFX, MUX, DX, DPX;
63  double Y, PY, BETY, ALFY, MUY, DY, DPY;
64  std::string APERTYPE;
65  double APER_1, APER_2, APER_3, APER_4;
66 
67  pfile >> NAME >> KEYWORD >> PARENT >> ENDPOS >> LENGTH
68  >> HKICK >> VKICK
69  >> K0L >> K1L >> K2L >> K3L
70  >> X >> Y >> PX >> PY
71  >> BETX >> BETY >> ALFX >> ALFY >> MUX >> MUY
72  >> DX >> DY >> DPX >> DPY
73  >> APERTYPE
74  >> APER_1 >> APER_2 >> APER_3 >> APER_4;
75 
76  if (ENDPOS > endMarker) break;
77 
78  if (NAME.find("DRIFT") == 1) continue;
79 
80  std::cout.precision(2);
81  std::cout << std::fixed
82  << std::left
83  << std::setw(15) << NAME
84  << std::setw(15) << KEYWORD
85  << std::right
86  << std::setw( 8) << ENDPOS
87  << std::setw( 8) << LENGTH
88  << std::setw( 8) << BETX
89  << std::setw( 8) << BETY;
90  std::cout.precision(6);
91  std::cout << std::setw(10) << HKICK
92  << std::setw(10) << VKICK
93  << std::setw(10) << K0L
94  << std::setw(10) << K1L
95  << std::setw(10) << K2L
96  << std::setw(10) << K3L;
97  std::cout.precision(4);
98  std::cout << std::setw(15) << APERTYPE
99  << std::setw( 8) << APER_1
100  << std::setw( 8) << APER_2
101  << std::setw( 8) << APER_3
102  << std::setw( 8) << APER_4
103  << std::endl;
104  }
105 
106  std::cout.flags(cout_flags);
107 
108  pfile.clear();
109  pfile.seekg(0, std::ios::beg);
110  }
fillPileUpNoiseLumi.current
current
Definition: fillPileUpNoiseLumi.py:52
ForwardTracker::vBendplane
@ vBendplane
Definition: ForwardTrackerConstants.h:12
ForwardTracker::beam1
@ beam1
Definition: ForwardTrackerConstants.h:13
ForwardTracker::TransverseShift
TransversePoint TransverseShift(double z)
Definition: TransverseShift.cxx:13
ForwardTracker::beam2
@ beam2
Definition: ForwardTrackerConstants.h:13
LArNewCalib_Delay_OFC_Cali.pfile
string pfile
Definition: LArNewCalib_Delay_OFC_Cali.py:183
x
#define x
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
Monitored::X
@ X
Definition: HistogramFillerUtils.h:24
TRT::Hit::side
@ side
Definition: HitInfo.h:83
ForwardTracker::openFile
void openFile(const std::string &fname, streamptr &strm)
Definition: ForwardTracker/ForwardTracker/STLHelpers.h:17
Type
RootType Type
Definition: TrigTSerializer.h:30
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
python.getCurrentFolderTag.fn
fn
Definition: getCurrentFolderTag.py:79
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
ForwardTracker::TwissFile
std::shared_ptr< std::ifstream > TwissFile(const ConfigData &, const Side &)
Definition: TwissFile.cxx:14
ForwardTracker::hBendplane
@ hBendplane
Definition: ForwardTrackerConstants.h:12
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
ForwardTracker::benderFactory
IBender::ConstPtr_t benderFactory(Magnet::Type type, Side side, double length, double strength, double beamEnergy)
Definition: MagnetFactory.cxx:25
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
ForwardTracker::CollimatorSet
Collimator::Container_t CollimatorSet(const ConfigData &, const Side &side)
Definition: CollimatorSet.cxx:13
Monitored::Y
@ Y
Definition: HistogramFillerUtils.h:24
ForwardTracker::label
std::string label(Magnet::Type type)
Definition: MagnetFactory.cxx:15
WriteBchToCool.beg
beg
Definition: WriteBchToCool.py:69
ChargedTracksWeightFilter::Spline::Point
Linear spline representation of a function used to calculate weights.
Definition: ChargedTracksWeightFilter.h:28
ForwardTracker::TwissFilePrint
void TwissFilePrint(std::ifstream &, double endMarker)
Definition: TwissFile.cxx:29
RunTileTBMonitoring.beamEnergy
beamEnergy
Definition: RunTileTBMonitoring.py:248
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:66
y
#define y
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ForwardTracker::isEndMarker
bool isEndMarker(const IBeamElement::ConstPtr_t &be)
Definition: ForwardTracker/src/Beamline.cxx:19
calibdata.cd
cd
Definition: calibdata.py:50
ForwardTracker::GetBeamEnergy
double GetBeamEnergy(std::ifstream &)
Definition: TwissFile.cxx:112
ForwardTracker::MagnetSet
Magnet::Container_t MagnetSet(const ConfigData &, const Side &)
Definition: MagnetSet.cxx:18
xAOD::Plane
@ Plane
Definition: TrackingPrimitives.h:557
PlotCalibFromCool.be
be
Definition: PlotCalibFromCool.py:398
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
mag
Scalar mag() const
mag method
Definition: AmgMatrixBasePlugin.h:26
ForwardTracker::MagnetFactory
Magnet::ConstPtr_t MagnetFactory(double x, double y, double z, double strength, double length, const std::string &aperType, double A1, double A2, double A3, double A4, double beamEnergy, Side side, Magnet::Type type)
Definition: MagnetFactory.cxx:39
Trk::previous
@ previous
Definition: BinningData.h:32
Generated on Thu Oct 30 2025 21:54:47 for ATLAS Offline Software by   doxygen 1.8.18