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

#include <LArWheelSliceSolid.h>

Inheritance diagram for LArWheelSliceSolid:
Collaboration diagram for LArWheelSliceSolid:

Public Types

enum  pos_t { Inner, Outer }
 
enum  type_t { Absorber, Electrode, Glue, Lead }
 

Public Member Functions

 LArWheelSliceSolid (const G4String &name, pos_t pos, type_t type, size_t slice, G4int zside=1, const LArWheelCalculator *calc=0, const EMECData *emecData=0)
 
 LArWheelSliceSolid (const G4String &name, const EMECData *emecData)
 
virtual ~LArWheelSliceSolid ()
 
EInside Inside (const G4ThreeVector &) const
 
G4double DistanceToIn (const G4ThreeVector &, const G4ThreeVector &) const
 
G4double DistanceToIn (const G4ThreeVector &) const
 
G4double DistanceToOut (const G4ThreeVector &, const G4ThreeVector &, const G4bool calcNorm=false, G4bool *validNorm=0, G4ThreeVector *n=0) const
 
G4double DistanceToOut (const G4ThreeVector &) const
 
G4ThreeVector SurfaceNormal (const G4ThreeVector &) const
 
G4bool CalculateExtent (const EAxis, const G4VoxelLimits &, const G4AffineTransform &, G4double &, G4double &) const
 
G4GeometryType GetEntityType () const
 
void DescribeYourselfTo (G4VGraphicsScene &) const
 
G4VisExtent GetExtent () const
 
G4Polyhedron * CreatePolyhedron () const
 
virtual std::ostream & StreamInfo (std::ostream &os) const
 
G4ThreeVector GetPointOnSurface (void) const
 
G4double GetCubicVolume (void)
 
G4double GetSurfaceArea (void)
 
const G4VSolid * GetBoundingShape (void) const
 
const LArWheelCalculator * GetCalculator (void) const
 
bool msgLvl (const MSG::Level lvl) const
 Test the output level. More...
 
MsgStream & msg () const
 The standard message stream. More...
 
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream. More...
 
void setLevel (MSG::Level lvl)
 Change the current logging level. More...
 

Protected Attributes

TF1 * m_f_area
 
TF1 * m_f_vol
 
TF1 * m_f_area_on_pc
 
TF1 * m_f_length
 
TF1 * m_f_side_area
 
double m_test_index
 

Private Member Functions

void inner_solid_init (const G4String &, size_t slice)
 
void outer_solid_init (const G4String &, size_t slice)
 
void fill_zsect (std::vector< G4double > &, G4double zMid=0.) const
 
virtual G4double distance_to_in (G4ThreeVector &, const G4ThreeVector &, int) const
 
G4double in_iteration_process (const G4ThreeVector &, G4double, G4ThreeVector &, int) const
 
G4double search_for_nearest_point (const G4ThreeVector &, const G4double, const G4ThreeVector &, int) const
 
G4bool search_for_most_remoted_point (const G4ThreeVector &, const G4ThreeVector &, G4ThreeVector &, const int) const
 
G4double out_iteration_process (const G4ThreeVector &, G4ThreeVector &, const int) const
 
EInside Inside_accordion (const G4ThreeVector &) const
 
void get_point_on_accordion_surface (G4ThreeVector &) const
 
void get_point_on_polycone_surface (G4ThreeVector &) const
 
void get_point_on_flat_surface (G4ThreeVector &) const
 
void set_failover_point (G4ThreeVector &p, const char *m=0) const
 
G4double get_area_on_polycone (void) const
 
G4double get_area_on_face (void) const
 
G4double get_area_on_side (void) const
 
G4double get_area_at_r (G4double r) const
 
G4double get_length_at_r (G4double r) const
 
void test (void)
 
void clean_tests (void)
 
void init_tests (void)
 
G4String TypeStr (void) const
 
void createSolid (const G4String &name, G4int zside, size_t slice, const EMECData *emecData)
 
void check_slice (size_t size, size_t slice) const
 
void initMessaging () const
 Initialize our message level and MessageSvc. More...
 

Private Attributes

pos_t m_Pos {}
 
type_t m_Type {}
 
const LArWheelCalculator * m_Calculator {}
 
G4VSolid * m_BoundingShape {}
 
G4double m_FanHalfThickness {}
 
G4double m_FHTplusT {}
 
G4double m_FHTminusT {}
 
G4double m_Xmin {}
 
G4double m_Xmax {}
 
G4double m_Ymin {}
 
G4double m_Zmin {}
 
G4double m_Zmax {}
 
G4double m_Rmin {}
 
G4double m_Rmax {}
 
std::string m_nm
 Message source name. More...
 
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels) More...
 
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer. More...
 
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level. More...
 
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging) More...
 

Static Private Attributes

static const G4double s_Tolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance() / 2
 
static const G4double s_AngularTolerance = G4GeometryTolerance::GetInstance()->GetAngularTolerance() / 2
 
static const G4double s_IterationPrecision = 0.001*CLHEP::mm
 
static const G4double s_IterationPrecision2 = s_IterationPrecision * s_IterationPrecision
 
static const unsigned int s_IterationsLimit = 50
 

Friends

double LArWheelSliceSolid_fcn_area (double *, double *)
 
double LArWheelSliceSolid_fcn_vol (double *, double *)
 
double LArWheelSliceSolid_fcn_area_on_pc (double *, double *)
 
double LArWheelSliceSolid_get_dl (double *, double *, G4int)
 
double LArWheelSliceSolid_fcn_side_area (double *, double *)
 

Detailed Description

Definition at line 42 of file LArWheelSliceSolid.h.

Member Enumeration Documentation

◆ pos_t

enum LArWheelSliceSolid::pos_t
Enumerator
Inner 
Outer 

Definition at line 48 of file LArWheelSliceSolid.h.

48 { Inner, Outer } pos_t;

◆ type_t

enum LArWheelSliceSolid::type_t
Enumerator
Absorber 
Electrode 
Glue 
Lead 

Definition at line 49 of file LArWheelSliceSolid.h.

49 { Absorber, Electrode, Glue, Lead } type_t;

Constructor & Destructor Documentation

◆ LArWheelSliceSolid() [1/2]

LArWheelSliceSolid::LArWheelSliceSolid ( const G4String &  name,
pos_t  pos,
type_t  type,
size_t  slice,
G4int  zside = 1,
const LArWheelCalculator *  calc = 0,
const EMECData *  emecData = 0 
)

Definition at line 47 of file LArWheelSliceSolidInit.cxx.

53  : G4VSolid(name)
54 #ifndef PORTABLE_LAR_SHAPE
55  , AthMessaging("LArWSS")
56 #endif
57  , m_Pos(pos), m_Type(type), m_Calculator(calc)
58 {
59  createSolid(name, zside, slice, emecData);
60 }

◆ LArWheelSliceSolid() [2/2]

LArWheelSliceSolid::LArWheelSliceSolid ( const G4String &  name,
const EMECData *  emecData 
)

Definition at line 62 of file LArWheelSliceSolidInit.cxx.

63  : G4VSolid(name)
64 #ifndef PORTABLE_LAR_SHAPE
65  , AthMessaging("LArWSS")
66 #endif
67  , m_Calculator(0)
68 {
69  if(name.find("::Inner") != G4String::npos) m_Pos = Inner;
70  else if(name.find("::Outer") != G4String::npos) m_Pos = Outer;
71  else G4Exception(
72  "LArWheelSliceSolid", "NoPos", FatalException,
73  (std::string("Constructor: can't get Inner/Outer from ") + name).c_str()
74  );
75 
76  if(name.find("::Absorber") != G4String::npos) m_Type = Absorber;
77  else if(name.find("::Electrode") != G4String::npos) m_Type = Electrode;
78  else if(name.find("::Glue") != G4String::npos) m_Type = Glue;
79  else if(name.find("::Lead") != G4String::npos) m_Type = Lead;
80  else G4Exception(
81  "LArWheelSliceSolid", "NoType", FatalException,
82  (std::string("Constructor: can't get Type from ") + name).c_str()
83  );
84 
85  size_t s = name.find("Slice");
86  size_t slice = 0;
87  if(G4String::npos != s){
88  slice = (size_t) atoi(name.substr(s + 5, 2).c_str());
89  } else G4Exception(
90  "LArWheelSliceSolid", "NoSlice", FatalException,
91  (std::string("Constructor: can't get Slice from ") + name).c_str()
92  );
93 
94  G4int zside = 0;
95  if(name.find("::Pos::") != G4String::npos) zside = 1;
96  else if(name.find("::Neg::") != G4String::npos) zside = -1;
97  else G4Exception(
98  "LArWheelSliceSolid", "NoSide", FatalException,
99  (std::string("Constructor: can't get zSide from ") + name).c_str()
100  );
101  createSolid(name, zside, slice, emecData);
102 }

◆ ~LArWheelSliceSolid()

virtual LArWheelSliceSolid::~LArWheelSliceSolid ( )
inlinevirtual

Definition at line 59 of file LArWheelSliceSolid.h.

59 {}

Member Function Documentation

◆ CalculateExtent()

G4bool LArWheelSliceSolid::CalculateExtent ( const EAxis  a,
const G4VoxelLimits &  vl,
const G4AffineTransform &  t,
G4double &  p,
G4double &  q 
) const

Definition at line 58 of file LArWheelSliceSolid.cxx.

63 {
64  return m_BoundingShape->CalculateExtent(a, vl, t, p, q);
65 }

◆ check_slice()

void LArWheelSliceSolid::check_slice ( size_t  size,
size_t  slice 
) const
inlineprivate

Definition at line 183 of file LArWheelSliceSolidInit.cxx.

184 {
185  if(size <= slice + 1){
186  G4Exception(
187  "LArWheelSliceSolid", "WrongSlice", FatalException,
188  std::string("Constructor: Slice number too big: " + GetName()).c_str()
189  );
190  }
191 }

◆ clean_tests()

void LArWheelSliceSolid::clean_tests ( void  )
private

Definition at line 484 of file LArWheelSliceSolidTests.cxx.

484  {
485  if(m_f_area) {
486  delete m_f_area;
487  m_f_area = 0;
488  }
489  if(m_f_vol) {
490  delete m_f_vol;
491  m_f_vol = 0;
492  }
493 
494  if(m_f_area_on_pc) {
495  delete m_f_area_on_pc;
496  m_f_area_on_pc = 0;
497  }
498 
499  if(m_f_length) {
500  delete m_f_length;
501  m_f_length = 0;
502  }
503  if(m_f_side_area) {
504  delete m_f_side_area;
505  m_f_side_area = 0;
506  }
507 }

◆ CreatePolyhedron()

G4Polyhedron * LArWheelSliceSolid::CreatePolyhedron ( ) const

Definition at line 101 of file LArWheelSliceSolid.cxx.

102 {
103  return m_BoundingShape->CreatePolyhedron();
104 }

◆ createSolid()

void LArWheelSliceSolid::createSolid ( const G4String &  name,
G4int  zside,
size_t  slice,
const EMECData *  emecData 
)
private

Definition at line 104 of file LArWheelSliceSolidInit.cxx.

105 {
106 #ifndef PORTABLE_LAR_SHAPE
107  m_f_area = m_f_vol = m_f_area_on_pc = m_f_length = m_f_side_area = 0;
108 #endif
109 
110  LArG4::LArWheelCalculator_t calc_type = LArG4::LArWheelCalculator_t(0);
111  switch(m_Pos){
112  case Inner:
113  switch(m_Type){
114  case Absorber: calc_type = LArG4::InnerAbsorberWheel; break;
115  case Electrode: calc_type = LArG4::InnerElectrodWheel; break;
116  case Glue: calc_type = LArG4::InnerGlueWheel; break;
117  case Lead: calc_type = LArG4::InnerLeadWheel; break;
118  }
119  break;
120  case Outer:
121  switch(m_Type){
122  case Absorber: calc_type = LArG4::OuterAbsorberWheel; break;
123  case Electrode: calc_type = LArG4::OuterElectrodWheel; break;
124  case Glue: calc_type = LArG4::OuterGlueWheel; break;
125  case Lead: calc_type = LArG4::OuterLeadWheel; break;
126  }
127  break;
128  }
129  if(m_Calculator == 0) {
130  m_Calculator = new LArWheelCalculator(*emecData, calc_type, zside);
131 
132  }
133  else if(m_Calculator->type() != calc_type){
134  G4Exception(
135  "LArWheelSliceSolid", "WrongCalculatorType", FatalException,
136  "Constructor: external LArWheelCalculator of wrong type provided"
137  );
138  }
139 
140  const G4String bs_name = name + "-Bounding";
141 
142 #ifdef DEBUG_LARWHEELSLICESOLID
143  const char *venv = getenv("LARWHEELSLICESOLID_VERBOSE");
144  if(venv) Verbose = atoi(venv);
145  static bool first = true;
146  if(first){
147  std::cout << "The LArWheelSliceSolid build "
148  << __DATE__ << " " << __TIME__ << std::endl
149  << "LArWheelSliceSolid verbosity level is "
150  << Verbose << std::endl;
151  first = false;
152  }
153 #endif
154 
155  m_FanHalfThickness = GetCalculator()->GetFanHalfThickness();
156  m_FHTplusT = m_FanHalfThickness + s_Tolerance;
157  m_FHTminusT = m_FanHalfThickness - s_Tolerance;
158 
159  switch(m_Pos){
160  case Inner: inner_solid_init(bs_name, slice); break;
161  case Outer: outer_solid_init(bs_name, slice); break;
162  }
163 #ifndef PORTABLE_LAR_SHAPE
164  ATH_MSG_DEBUG(m_BoundingShape->GetName() + " is the m_BoundingShape");
165 
166  init_tests();
167  test(); // activated by env. variable
168  clean_tests();
169 
170  ATH_MSG_DEBUG("slice " << m_Pos << " " << m_Type
171  << " " << slice << " initialized" << endmsg);
172 
173 #endif
174 
175  #ifdef DEBUG_LARWHEELSLICESOLID
176  std::cout << "LArWSS(" << m_Pos << ", " << m_Type
177  << "): slice " << slice << ", Zmin = " << m_Zmin
178  << ", Zmax = " << m_Zmax << std::endl
179  << GetName() << std::endl;
180 #endif
181 }

◆ DescribeYourselfTo()

void LArWheelSliceSolid::DescribeYourselfTo ( G4VGraphicsScene &  scene) const

Definition at line 91 of file LArWheelSliceSolid.cxx.

92 {
93  scene.AddSolid(*this);
94 }

◆ distance_to_in()

G4double LArWheelSliceSolid::distance_to_in ( G4ThreeVector &  p,
const G4ThreeVector &  v,
int  p_fan 
) const
privatevirtual

Definition at line 121 of file LArWheelSliceSolidDisToIn.cxx.

122 {
123  LWSDBG(4, std::cout << "dti: " << MSG_VECTOR(p) << " "
124  << MSG_VECTOR(v) << std::endl);
125 
126  G4double distance = 0.;
127 
128  if(p.x() > m_Xmax) {
129  if(v.x() >= 0.) return kInfinity;
130  const G4double b = (m_Xmax - p.x()) / v.x();
131  const G4double y2 = p.y() + v.y() * b;
132  const G4double z2 = p.z() + v.z() * b;
133  p.set(m_Xmax, y2, z2);
134  distance += b;
135  } else if(p.x() < m_Xmin) {
136  if(v.x() <= 0.) return kInfinity;
137  const G4double b = (m_Xmin - p.x()) / v.x();
138  const G4double y2 = p.y() + v.y() * b;
139  const G4double z2 = p.z() + v.z() * b;
140  p.set(m_Xmin, y2, z2);
141  distance += b;
142  }
143 
144 // here p is on surface of or inside the "FanBound",
145 // distance corrected, misses are accounted for
146  LWSDBG(5, std::cout << "dti corrected: " << MSG_VECTOR(p) << std::endl);
147 
148  G4double dist_p = GetCalculator()->DistanceToTheNeutralFibre(p, p_fan);
149  if(fabs(dist_p) < m_FHTminusT) {
150  LWSDBG(5, std::cout << "hit fan dist_p=" << dist_p << ", m_FHTminusT=" << m_FHTminusT << std::endl);
151  return distance;
152  }
153 
154  G4ThreeVector q;
155  q = p + v * m_BoundingShape->DistanceToOut(p, v);
156  G4double dist_q = GetCalculator()->DistanceToTheNeutralFibre(q, p_fan);
157  LWSDBG(5, std::cout << "dti exit point: " << MSG_VECTOR(q) << " "
158  << dist_q << std::endl);
159  G4double dd = kInfinity;
160  if(dist_p * dist_q < 0.){// it certanly cross current half-wave
161  dd = in_iteration_process(p, dist_p, q, p_fan);
162  }
163  G4double d2 = search_for_nearest_point(p, dist_p, q, p_fan);
164  if(d2 < kInfinity){
165  return distance + d2; // this half-wave is intersected
166  } else if(dd < kInfinity){
167  return distance + dd;
168  }
169  return kInfinity;
170 }

◆ DistanceToIn() [1/2]

G4double LArWheelSliceSolid::DistanceToIn ( const G4ThreeVector &  inputP) const

Definition at line 15 of file LArWheelSliceSolidDisToIn.cxx.

16 {
17  LWSDBG(1, std::cout << TypeStr() << " DisToIn" << MSG_VECTOR(inputP) << std::endl);
18  if(m_BoundingShape->Inside(inputP) == kOutside) {
19  // here is an approximation - for the point outside m_BoundingShape
20  // the solid looks like a m_BoundingShape
21  // it's okay since the result could be underestimated
22  LWSDBG(2, std::cout << "Outside BS" << std::endl);
23  return m_BoundingShape->DistanceToIn(inputP);
24  }
25  G4ThreeVector p(inputP);
26 
27  //
28  // DistanceToTheNearestFan:
29  // rotates point p to the localFan coordinates and returns fan number to out_fan_number parameter
30  // returns distance to fan as result
31  //
32 
33  int p_fan = 0;
34  const G4double d = fabs(GetCalculator()->DistanceToTheNearestFan(p, p_fan));
35  if(d > m_FHTplusT){
36  const G4double result = d - m_FanHalfThickness;
37  LWSDBG(2, std::cout << "dti result = " << result << std::endl);
38  return result;
39  }
40  LWSDBG(2, std::cout << "already inside, return 0" << MSG_VECTOR(p) << std::endl);
41  return 0.;
42 }

◆ DistanceToIn() [2/2]

G4double LArWheelSliceSolid::DistanceToIn ( const G4ThreeVector &  inputP,
const G4ThreeVector &  inputV 
) const

Definition at line 44 of file LArWheelSliceSolidDisToIn.cxx.

46 {
47  LWSDBG(1, std::cout << TypeStr() << " DisToIn" << MSG_VECTOR(inputP)
48  << MSG_VECTOR(inputV) << std::endl);
49 
50  G4double distance = 0.;
51  const EInside inside_BS = m_BoundingShape->Inside(inputP);
52  G4ThreeVector p(inputP);
53  if(inside_BS == kOutside) {
54  distance = m_BoundingShape->DistanceToIn(inputP, inputV);
55  if(distance == kInfinity) {
56  LWSDBG(2, std::cout << "Infinity distance to m_BoundingShape"
57  << MSG_VECTOR(inputP) << MSG_VECTOR(inputV)
58  << std::endl);
59  return kInfinity;
60  }
61  p += inputV * distance;
62  assert(m_BoundingShape->Inside(p) != kOutside);
63  LWSDBG(2, std::cout << "shift" << MSG_VECTOR(inputP) << std::endl);
64  }
65 
66  const G4double phi0 = p.phi();
67  int p_fan = 0;
68  const G4double d = GetCalculator()->DistanceToTheNearestFan(p, p_fan);
69  if(fabs(d) < m_FHTminusT){
70  LWSDBG(2, std::cout << "already inside fan" << MSG_VECTOR(p) << std::endl);
71  // if initial point is on BS surface and inside fan volume it is a real surface
72  if(inside_BS == kSurface) {
73  LWSDBG(2, std::cout << "On BS surface" << std::endl);
74  return m_BoundingShape->DistanceToIn(inputP, inputV);
75  }
76  return distance;
77  }
78  G4ThreeVector v(inputV);
79  v.rotateZ(p.phi() - phi0);
80 
81  const G4double d0 = distance_to_in(p, v, p_fan);
82  distance += d0;
83 
84 #ifdef DEBUG_LARWHEELSLICESOLID
85  if(Verbose > 2){
86  if(Verbose > 3){
87  std::cout << MSG_VECTOR(inputP)
88  << " " << MSG_VECTOR(inputV) << std::endl;
89  }
90  std::cout << "dti: " << d0 << ", DTI: " << distance << std::endl;
91  }
92  if(Verbose > 3){
93  if(d0 < kInfinity){
94  G4ThreeVector p2 = inputP + inputV*distance;
95  EInside i = Inside(p2);
96  std::cout << "DTI hit at dist. " << distance << ", point "
97  << MSG_VECTOR(p2) << ", "
98  << inside(i) << std::endl;
99  } else {
100  std::cout << "got infinity from dti" << std::endl;
101  }
102  }
103 #ifdef LWS_HARD_TEST_DTI
104  if(test_dti(inputP, inputV, distance)){
105  if(Verbose == 1){
106  std::cout << TypeStr() << " DisToIn" << MSG_VECTOR(inputP)
107  << MSG_VECTOR(inputV) << std::endl;
108  }
109  }
110  if(Verbose == 1){
111  std::cout << TypeStr() << " DisToIn" << MSG_VECTOR(inputP)
112  << MSG_VECTOR(inputV) << " " << distance << std::endl;
113  }
114 #endif // ifdef LWS_HARD_TEST_DTI
115 
116 #endif // ifdef DEBUG_LARWHEELSLICESOLID
117 
118  return distance;
119 }

◆ DistanceToOut() [1/2]

G4double LArWheelSliceSolid::DistanceToOut ( const G4ThreeVector &  inputP) const

Definition at line 10 of file LArWheelSliceSolidDisToOut.cxx.

11 {
12  LWSDBG(1, std::cout << TypeStr() << " DisToOut" << MSG_VECTOR(inputP) << std::endl);
13  if(m_BoundingShape->Inside(inputP) != kInside){
14  LWSDBG(2, std::cout << "DistanceToOut(p):"
15  << " point " << MSG_VECTOR(inputP)
16  << " is not inside of the m_BoundingShape."
17  << std::endl);
18  return 0.;
19  }
20  G4ThreeVector p(inputP);
21  int p_fan = 0;
22  const G4double d = m_FanHalfThickness - fabs(GetCalculator()->DistanceToTheNearestFan(p, p_fan));
23  if(d < s_Tolerance){
24  LWSDBG(2, std::cout << "already not inside " << MSG_VECTOR(p) << std::endl);
25  return 0.;
26  }
27  const G4double d0 = m_BoundingShape->DistanceToOut(inputP);
28  LWSDBG(2, std::cout << "dto " << d << " " << d0 << std::endl);
29  if(d > d0) return d0;
30  else return d;
31 }

◆ DistanceToOut() [2/2]

G4double LArWheelSliceSolid::DistanceToOut ( const G4ThreeVector &  inputP,
const G4ThreeVector &  inputV,
const G4bool  calcNorm = false,
G4bool *  validNorm = 0,
G4ThreeVector *  n = 0 
) const

Definition at line 33 of file LArWheelSliceSolidDisToOut.cxx.

38 {
39  LWSDBG(1, std::cout << TypeStr() << " DisToOut" << MSG_VECTOR(inputP)
40  << MSG_VECTOR(inputV) << std::endl);
41 
42  const EInside inside_BS = m_BoundingShape->Inside(inputP);
43  if(inside_BS == kOutside){
44  LWSDBG(2, std::cout << "DistanceToOut(p):"
45  << " point " << MSG_VECTOR(inputP)
46  << " is outside of m_BoundingShape." << std::endl);
47  if(calcNorm) *validNorm = false;
48  return 0.;
49  }
50 
51  // If here inside or on surface of BS
52  G4ThreeVector p(inputP);
53  int p_fan = 0;
54  const G4double adtnf_p = fabs(GetCalculator()->DistanceToTheNearestFan(p, p_fan));
55  if(adtnf_p >= m_FHTplusT) {
56  LWSDBG(2, std::cout << "DistanceToOut(p, v): point "
57  << MSG_VECTOR(inputP)
58  << " is outside of solid." << std::endl);
59  if(calcNorm) *validNorm = false;
60  return 0.;
61  }
62 
63  G4ThreeVector v(inputV);
64  const G4double phi0 = p.phi() - inputP.phi();
65  v.rotateZ(phi0);
66 
67 // former distance_to_out starts here
68  LWSDBG(4, std::cout << "dto: " << MSG_VECTOR(p) << " "
69  << MSG_VECTOR(v) << std::endl);
70 
71  G4ThreeVector q(p);
72 
73  const G4double dto_bs = m_BoundingShape->DistanceToOut(
74  inputP, inputV, calcNorm, validNorm, sn
75  );
76  q = p + v * dto_bs;
77  if(q.y() < m_Ymin){
78  LWSDBG(5, std::cout << "dto exit point too low " << MSG_VECTOR(q) << std::endl);
79  const G4double dy = (m_Ymin - p.y()) / v.y();
80  q.setX(p.x() + v.x() * dy);
81  q.setY(m_Ymin);
82  q.setZ(p.z() + v.z() * dy);
83  }
84  LWSDBG(5, std::cout << "dto exit point " << MSG_VECTOR(q) << std::endl);
85 
86  G4double tmp;
87  G4double distance = 0.;
88  if(fabs(GetCalculator()->DistanceToTheNeutralFibre(q, p_fan)) > m_FHTplusT){
89  LWSDBG(5, std::cout << "q=" << MSG_VECTOR(q)
90  << " outside fan cur distance="
91  << distance << ", m_FHTplusT="
92  << m_FHTplusT << std::endl);
93  tmp = out_iteration_process(p, q, p_fan);
94  } else {
95  tmp = (q - p).mag();
96  }
97  G4ThreeVector C;
98  if(search_for_most_remoted_point(p, q, C, p_fan)){
99  tmp = out_iteration_process(p, C, p_fan);
100  }
101  distance += tmp;
102 
103  LWSDBG(5, std::cout << "At end_dto distance=" << distance << std::endl);
104  if(calcNorm && distance < dto_bs) *validNorm = false;
105 
106 #ifdef DEBUG_LARWHEELSLICESOLID
107  if(Verbose > 2){
108  std::cout << "DTO: " << distance << " ";
109  if (*validNorm) {
110  std::cout << *validNorm << " " << MSG_VECTOR((*sn));
111  } else {
112  std::cout << "Norm is not valid";
113  }
114  std::cout << std::endl;
115  if(Verbose > 3){
116  G4ThreeVector p2 = inputP + inputV * distance;
117  EInside i = Inside(p2);
118  std::cout << "DTO hit at " << MSG_VECTOR(p2) << ", "
119  << inside(i) << std::endl;
120  }
121  }
122 #ifdef LWS_HARD_TEST_DTO
123  if(test_dto(inputP, inputV, distance)){
124  if(Verbose == 1){
125  std::cout << TypeStr() << " DisToOut" << MSG_VECTOR(inputP)
126  << MSG_VECTOR(inputV) << std::endl;
127  }
128  }
129 #endif
130 #endif
131  return distance;
132 }

◆ fill_zsect()

void LArWheelSliceSolid::fill_zsect ( std::vector< G4double > &  zsect,
G4double  zMid = 0. 
) const
private

Definition at line 263 of file LArWheelSliceSolidInit.cxx.

264 {
265  const G4double half_wave_length = GetCalculator()->GetHalfWaveLength();
266  const G4double sss = GetCalculator()->GetStraightStartSection();
267  const G4int num_fs = GetCalculator()->GetNumberOfHalfWaves() + 1;
268  const G4double wheel_thickness = GetCalculator()->GetWheelThickness();
269 
270  zsect.push_back(0.);
271  zsect.push_back(sss + half_wave_length * 0.25);
272  for(G4int i = 2; i < num_fs; i ++){
273  const G4double zi = half_wave_length * (i - 1) + sss;
274  if(m_Pos == Outer && zsect.back() < zMid && zi > zMid){
275  zsect.push_back(zMid);
276  }
277  zsect.push_back(zi);
278  }
279  zsect.push_back(wheel_thickness - sss - half_wave_length * 0.25);
280  zsect.push_back(wheel_thickness);
281 }

◆ get_area_at_r()

G4double LArWheelSliceSolid::get_area_at_r ( G4double  r) const
private

Definition at line 509 of file LArWheelSliceSolidTests.cxx.

510 {
511  m_f_area->SetParameter(0, r);
512 
513  double zmin = m_BoundingShape->DistanceToIn(
514  G4ThreeVector(0., r, m_Zmin), G4ThreeVector(0., 0., 1.)
515  );
516  double zmax = m_BoundingShape->DistanceToIn(
517  G4ThreeVector(0., r, m_Zmax), G4ThreeVector(0., 0., -1.)
518  );
519  zmax = m_Zmax - zmax;
520 
521  double result = m_f_area->Integral(zmin, zmax);
522 
523  return result;
524 }

◆ get_area_on_face()

G4double LArWheelSliceSolid::get_area_on_face ( void  ) const
private

Definition at line 334 of file LArWheelSliceSolidTests.cxx.

335 {
336  G4double result = 0.;
337  G4double rmin, rmax;
338  get_r(m_BoundingShape, m_Zmin, rmin, rmax);
339  result += rmax - rmin;
340  get_r(m_BoundingShape, m_Zmax, rmin, rmax);
341  result += rmax - rmin;
342  result *= GetCalculator()->GetFanHalfThickness() * 2.;
343  return result;
344 }

◆ get_area_on_polycone()

G4double LArWheelSliceSolid::get_area_on_polycone ( void  ) const
private

Definition at line 329 of file LArWheelSliceSolidTests.cxx.

330 {
331  return m_f_area_on_pc->Integral(m_Zmin, m_Zmax);
332 }

◆ get_area_on_side()

G4double LArWheelSliceSolid::get_area_on_side ( void  ) const
private

Definition at line 362 of file LArWheelSliceSolidTests.cxx.

363 {
364  return m_f_side_area->Integral(m_Rmin, m_Rmax, IntPrecision);
365 }

◆ get_length_at_r()

G4double LArWheelSliceSolid::get_length_at_r ( G4double  r) const
private

Definition at line 346 of file LArWheelSliceSolidTests.cxx.

347 {
348  m_f_length->SetParameter(0, r);
349 
350  double zmin = m_BoundingShape->DistanceToIn(
351  G4ThreeVector(0., r, -m_Zmin), G4ThreeVector(0., 0., 1.)
352  );
353  zmin -= m_Zmin * 2.;
354  double zmax = m_BoundingShape->DistanceToIn(
355  G4ThreeVector(0., r, m_Zmax), G4ThreeVector(0., 0., -1.)
356  );
357  zmax = m_Zmax - zmax;
358  double result = m_f_length->Integral(zmin, zmax);
359  return result;
360 }

◆ get_point_on_accordion_surface()

void LArWheelSliceSolid::get_point_on_accordion_surface ( G4ThreeVector &  p) const
private

Definition at line 101 of file LArWheelSliceSolidTests.cxx.

102 {
103  p[0] = 0.; p[1] = 0.; p[2] = rnd->Uniform(m_Zmin, m_Zmax);
104 
105  G4double rmin, rmax;
106  get_r(m_BoundingShape, p[2], rmin, rmax);
107 
108  p[1] = rnd->Uniform(rmin, rmax);
109  p.setPhi(rnd->Uniform(0., CLHEP::twopi));
110  G4double dphi = p.phi();
111  int p_fan = 0;
112  G4double d = GetCalculator()->DistanceToTheNearestFan(p, p_fan);
113  dphi -= p.phi();
114 
115  G4int side = 0;
116  if(d < 0.) side = -1;
117  if(d >= 0.) side = 1;
118 
119  G4double a = GetCalculator()->AmplitudeOfSurface(p, side, p_fan);
120  p[0] = a;
121 
122  p.rotateZ(dphi);
123 
124  if(m_BoundingShape->Inside(p) == kOutside){
125  G4ThreeVector D = p; D[2] = 0.;
126  G4double d1 = m_BoundingShape->DistanceToIn(p, D);
127  if(d1 > 10.*CLHEP::m){
128  D *= -1;
129  d1 = m_BoundingShape->DistanceToIn(p, D);
130  }
131  if(d1 > 10.*CLHEP::m){
132  set_failover_point(p, "acc fail0");
133  return;
134  }
135  d1 *= 2.;
136 
137  G4ThreeVector B = p + D * d1;
138  G4double dphi = B.phi();
139  int B_fan = 0;
140  GetCalculator()->DistanceToTheNearestFan(B, B_fan);
141  dphi -= B.phi();
142 
143  B[0] = GetCalculator()->AmplitudeOfSurface(B, side, B_fan);
144  B.rotateZ(dphi);
145  EInside Bi = m_BoundingShape->Inside(B);
146  if(Bi == kSurface){
147  p = B;
148  return;
149  }
150  if(Bi == kOutside){
151  set_failover_point(p, "acc fail1");
152  return;
153  }
154  G4ThreeVector D1 = (p - B).unit();
155  G4ThreeVector X = B + D1 * m_BoundingShape->DistanceToOut(B, D1);
156  if(Inside(X) == kSurface){
157  p = X;
158  } else { // failed
159  set_failover_point(p, "acc fail2");
160  return;
161  }
162  }
163 }

◆ get_point_on_flat_surface()

void LArWheelSliceSolid::get_point_on_flat_surface ( G4ThreeVector &  p) const
private

Definition at line 288 of file LArWheelSliceSolidTests.cxx.

289 {
290  p[0] = 0.;
291  p[1] = 0.;
292  p[2] = rnd->Uniform() > 0.5? m_Zmin: m_Zmax;
293 
294  G4double rmin, rmax;
295  get_r(m_BoundingShape, p[2], rmin, rmax);
296 
297  p[1] = rnd->Uniform(rmin, rmax);
298  p.setPhi(rnd->Uniform(0., CLHEP::twopi));
299  G4double dphi = p.phi();
300  int p_fan = 0;
301  GetCalculator()->DistanceToTheNearestFan(p, p_fan);
302  dphi -= p.phi();
303 
304  p[0] = rnd->Uniform(
305  GetCalculator()->AmplitudeOfSurface(p, -1, p_fan),
306  GetCalculator()->AmplitudeOfSurface(p, 1, p_fan)
307  );
308 
309  p.rotateZ(dphi);
310 
311  if(m_BoundingShape->Inside(p) != kSurface){
312  set_failover_point(p, "flat fail");
313  }
314 }

◆ get_point_on_polycone_surface()

void LArWheelSliceSolid::get_point_on_polycone_surface ( G4ThreeVector &  p) const
private

Definition at line 165 of file LArWheelSliceSolidTests.cxx.

166 {
167  const G4double z = rnd->Uniform(m_Zmin, m_Zmax);
168  G4double rmin, rmax;
169  get_r(m_BoundingShape, z, rmin, rmax);
170  const bool inner = rnd->Uniform() > 0.5? true: false;
171 
172  p[0] = 0.; p[1] = inner? rmin: rmax; p[2] = z;
173  p.setPhi(rnd->Uniform(0., CLHEP::twopi));
174  G4double dphi = p.phi();
175  int p_fan = 0;
176  GetCalculator()->DistanceToTheNearestFan(p, p_fan);
177  dphi -= p.phi();
178 
179  const G4double r = p[1];
180 
181  G4ThreeVector A1(0., r, z);
182  A1[0] = GetCalculator()->AmplitudeOfSurface(A1, -1, p_fan);
183  A1.rotateZ(dphi);
184  EInside A1i = m_BoundingShape->Inside(A1);
185  // EInside A1a = Inside_accordion(A1);
186  //std::cout << "A1: " << A1i << " " << A1a << std::endl;
187  if(A1i == kSurface){
188  //std::cout << "got A1" << std::endl;
189  p = A1;
190  return;
191  }
192 
193  G4ThreeVector A2(0., r, z);
194  A2[0] = GetCalculator()->AmplitudeOfSurface(A2, 1, p_fan);
195  A2.rotateZ(dphi);
196  EInside A2i = m_BoundingShape->Inside(A2);
197  // EInside A2a = Inside_accordion(A2);
198  //std::cout << "A2: " << A2i << " " << A2a << std::endl;
199  if(A2i == kSurface){
200  //std::cout << "got A2" << std::endl;
201  p = A2;
202  return;
203  }
204 
205  if(A1i != A2i){
206  if(A2i == kOutside){
207  std::swap(A1, A2);
208  std::swap(A1i, A2i);
209  }
210  // here A1 is outside BP, A2 is inside BP
211  G4ThreeVector d = (A2 - A1).unit();
212  p = A1 + d * m_BoundingShape->DistanceToIn(A1, d);
213  //std::cout << "got A1<->A2" << std::endl;
214  return;
215  }
216  // here A1i == A2i
217 
218  G4double step;
219  if(A1i == kInside){
220  G4double d1 = m_BoundingShape->DistanceToOut(A1);
221  G4double d2 = m_BoundingShape->DistanceToOut(A2);
222  step = d1 > d2? d1 : d2;
223  if(inner) step *= -2;
224  else step *= 2;
225  } else {
226  G4double d1 = m_BoundingShape->DistanceToIn(A1);
227  G4double d2 = m_BoundingShape->DistanceToIn(A2);
228  step = d1 > d2? d1 : d2;
229  if(inner) step *= 2;
230  else step *= -2;
231  }
232 
233  G4ThreeVector B1(0., r + step, z);
234  B1[0] = GetCalculator()->AmplitudeOfSurface(B1, -1, p_fan);
235  B1.rotateZ(dphi);
236  EInside B1i = m_BoundingShape->Inside(B1);
237  // EInside B1a = Inside_accordion(B1);
238  //std::cout << "B1: " << B1i << " " << B1a << std::endl;
239  if(B1i == kSurface){
240  //std::cout << "got B1" << std::endl;
241  p = B1;
242  return;
243  }
244  G4ThreeVector B2(0., r + step, z);
245  B2[0] = GetCalculator()->AmplitudeOfSurface(B2, 1, p_fan);
246  B2.rotateZ(dphi);
247  EInside B2i = m_BoundingShape->Inside(B2);
248  // EInside B2a = Inside_accordion(B2);
249  //std::cout << "B2: " << B2i << " " << B2a << std::endl;
250  if(B2i == kSurface){
251  //std::cout << "got B2" << std::endl;
252  p = B2;
253  return;
254  }
255 
256  if(B1i == A1i || B2i == A1i){ // failed
257  set_failover_point(p, "pol fail1");
258  return;
259  }
260  if(A1i == kInside){
261  std::swap(A1, B1);
262  std::swap(A2, B2);
263  std::swap(A1i, B1i);
264  std::swap(A2i, B2i);
265  }
266  // here A* outside, B* inside, all on accordion surface
267 
268  G4ThreeVector d1 = (A1 - B1).unit();
269  G4ThreeVector X1 = B1 + d1 * m_BoundingShape->DistanceToOut(B1, d1);
270  G4ThreeVector d2 = (A2 - B2).unit();
271  G4ThreeVector X2 = B2 + d2 * m_BoundingShape->DistanceToOut(B2, d2);
272 
273  G4ThreeVector X = X1;
274  G4double phi1 = X1.phi(), phi2 = X2.phi();
275  // X1 corresponds to side = -, X2 to side = +
276  if(phi1 > 0. && phi2 < 0.) phi2 += CLHEP::twopi;
277  G4double phiX = rnd->Uniform(phi1, phi2);
278  if(phiX > CLHEP::pi) phiX -= CLHEP::twopi;
279  X.setPhi(phiX);
280 
281  if(Inside(X) == kSurface){
282  p = X;
283  } else { // failed
284  set_failover_point(p, "pol fail2");
285  }
286 }

◆ GetBoundingShape()

const G4VSolid* LArWheelSliceSolid::GetBoundingShape ( void  ) const
inline

Definition at line 91 of file LArWheelSliceSolid.h.

91 { return m_BoundingShape; }

◆ GetCalculator()

const LArWheelCalculator* LArWheelSliceSolid::GetCalculator ( void  ) const
inline

Definition at line 92 of file LArWheelSliceSolid.h.

92 { return m_Calculator; }

◆ GetCubicVolume()

G4double LArWheelSliceSolid::GetCubicVolume ( void  )

Definition at line 316 of file LArWheelSliceSolidTests.cxx.

317 {
318  // sagging ignored, effect should be negligible
319  double result =
320  m_f_vol->Integral(m_Rmin, m_Rmax, IntPrecision)
321 
322 #ifndef LOCAL_DEBUG
323  * GetCalculator()->GetNumberOfFans()
324 #endif
325  ;
326  return result;
327 }

◆ GetEntityType()

G4GeometryType LArWheelSliceSolid::GetEntityType ( ) const
inline

Definition at line 78 of file LArWheelSliceSolid.h.

78 { return TypeStr(); }

◆ GetExtent()

G4VisExtent LArWheelSliceSolid::GetExtent ( ) const

Definition at line 96 of file LArWheelSliceSolid.cxx.

97 {
98  return m_BoundingShape->GetExtent();
99 }

◆ GetPointOnSurface()

G4ThreeVector LArWheelSliceSolid::GetPointOnSurface ( void  ) const

Definition at line 69 of file LArWheelSliceSolidTests.cxx.

70 {
71  if(rnd == 0) rnd = new TRandom3(0);
72  G4double r = rnd->Uniform();
73  G4ThreeVector p(0., 0., 0.);
74 
75  G4double level1 = .980;
76  G4double level2 = .993;
77  const char *v = getenv("LARWHEELSLICESOLID_TEST_MODE_LEVEL1");
78  if(v) level1 = atof(v);
79  const char *v1 = getenv("LARWHEELSLICESOLID_TEST_MODE_LEVEL2");
80  if(v1) level2 = atof(v1);
81 
82 #if LOCAL_DEBUG > 1
83  std::cout << "LWS::GPOS " << r << std::endl;
84 #endif
85 
86  if(r <= level1){
87  get_point_on_accordion_surface(p);
88  } else if(r <= level2){
89  get_point_on_polycone_surface(p);
90  } else if(r <= 1.){
91  get_point_on_flat_surface(p);
92  } else {
93  G4Exception(
94  "LArWheelSliceSolid", "Rnd generator error",
95  FatalException, "GetPointOnSurface: Wrong data from rnd generator"
96  );
97  }
98  return p;
99 }

◆ GetSurfaceArea()

G4double LArWheelSliceSolid::GetSurfaceArea ( void  )

Definition at line 367 of file LArWheelSliceSolidTests.cxx.

368 {
369  double result = 0.;
370 
371  double a1 = get_area_on_polycone();
372  result += a1;
373 #ifdef LOCAL_DEBUG
374  std::cout << "get_area_on_polycone: " << a1/mm2 << std::endl;
375 #endif
376 
377  double a2 = get_area_on_face();
378  result += a2;
379 #ifdef LOCAL_DEBUG
380  std::cout << "get_area_on_face: " << a2/mm2 << std::endl;
381 #endif
382 
383  double a3 = get_area_on_side();
384  result += a3;
385 #ifdef LOCAL_DEBUG
386  std::cout << "get_area_on_side: " << a3/mm2 << std::endl;
387 #endif
388 
389  // sagging ignored, effect should be negligible
390  return result
391 #ifndef LOCAL_DEBUG
392  * GetCalculator()->GetNumberOfFans()
393 #endif
394  ;
395 }

◆ in_iteration_process()

G4double LArWheelSliceSolid::in_iteration_process ( const G4ThreeVector &  p,
G4double  dist_p,
G4ThreeVector &  B,
int  p_fan 
) const
private

Definition at line 177 of file LArWheelSliceSolidDisToIn.cxx.

180 {
181  LWSDBG(6, std::cout << "iip from " << p << " to " << B
182  << " dir " << (B - p).unit()
183  << std::endl);
184 
185  G4ThreeVector A, C, diff;
186  A = p;
187  G4double dist_c;
188  unsigned int niter = 0;
189  // assert(fabs(GetCalculator()->DistanceToTheNeutralFibre(A)) > m_FHTplusT);
190  // assert(GetCalculator()->DistanceToTheNeutralFibre(A) == dist_p);
191  do {
192  C = A + B;
193  C *= 0.5;
194  dist_c = GetCalculator()->DistanceToTheNeutralFibre(C, p_fan);
195  if(dist_c * dist_p < 0. || fabs(dist_c) < m_FHTminusT){
196  B = C;
197  } else {
198  A = C;
199  }
200  niter ++;
201  diff = A - B;
202  } while(diff.mag2() > s_IterationPrecision2 && niter < s_IterationsLimit);
203  assert(niter < s_IterationsLimit);
204  assert(fabs(GetCalculator()->DistanceToTheNeutralFibre(B, p_fan)) < m_FHTplusT);
205  diff = p - B;
206  LWSDBG(7, std::cout << "iip result in " << niter << " = " << B
207  << " " << diff.mag() << std::endl);
208  return diff.mag();
209 }

◆ init_tests()

void LArWheelSliceSolid::init_tests ( void  )
private

Definition at line 608 of file LArWheelSliceSolidTests.cxx.

609 {
610  m_test_index = double(solid.size());
611  solid[m_test_index] = this;
612 
613 #ifdef DEBUG_LARWHEELSLICESOLID
614  if(Verbose > 0)
615  std::cout << "LArWheelSliceSolid::init_tests: put " << this
616  << " with index " << m_test_index << std::endl;
617 #endif
618 
619  m_f_area = new TF1(
620  (GetName() + "_f_area").c_str(), &LArWheelSliceSolid_fcn_area,
621  m_Zmin, m_Zmax, 2
622  );
623  m_f_area->FixParameter(1, m_test_index);
624 
625  m_f_vol = new TF1(
626  (GetName() + "_f_vol").c_str(), &LArWheelSliceSolid_fcn_vol,
627  m_Rmin, m_Rmax, 1
628  );
629  m_f_vol->FixParameter(0, m_test_index);
630 
631  m_f_area_on_pc = new TF1(
632  (GetName() + "_f_area_pc").c_str(), &LArWheelSliceSolid_fcn_area_on_pc,
633  m_Zmin, m_Zmax, 1
634  );
635  m_f_area_on_pc->FixParameter(0, m_test_index);
636 
637  m_f_length = new TF1(
638  (GetName() + "_f_length").c_str(), &fcn_length,
639  m_Zmin, m_Zmax, 2
640  );
641  m_f_length->FixParameter(1, m_test_index);
642 
643  m_f_side_area = new TF1(
644  (GetName() + "_f_side_area").c_str(), &LArWheelSliceSolid_fcn_side_area,
645  m_Rmin, m_Rmax, 1
646  );
647  m_f_side_area->FixParameter(0, m_test_index);
648 }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40 {
41  m_imsg = Athena::getMessageSvc();
42  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

◆ inner_solid_init()

void LArWheelSliceSolid::inner_solid_init ( const G4String &  bs_name,
size_t  slice 
)
private

Definition at line 193 of file LArWheelSliceSolidInit.cxx.

194 {
195  std::array<G4double,2> zPlane{}, rInner{}, rOuter{};
196  zPlane[1] = GetCalculator()->GetWheelThickness();
197  GetCalculator()->GetWheelInnerRadius(rInner);
198  GetCalculator()->GetWheelOuterRadius(rOuter);
199 
200  std::vector<G4double> zsect;
201  fill_zsect(zsect);
202  check_slice(zsect.size(), slice);
203 
204  m_Zmin = zsect[slice]; m_Zmax = zsect[slice + 1];
205  m_Rmin = rInner[0]; m_Rmax = rOuter[1];
206  const G4double ainn = (rInner[1] - rInner[0]) / (zPlane[1] - zPlane[0]);
207  const G4double aout = (rOuter[1] - rOuter[0]) / (zPlane[1] - zPlane[0]);
208  const G4double R1inn = ainn * (m_Zmin - zPlane[0]) + rInner[0];
209  const G4double R1out = aout * (m_Zmin - zPlane[0]) + rOuter[0];
210  const G4double R2inn = ainn * (m_Zmax - zPlane[0]) + rInner[0];
211  const G4double R2out = aout * (m_Zmax - zPlane[0]) + rOuter[0];
212 
213  m_BoundingShape = new G4ShiftedCone(
214  bs_name + "Cone", m_Zmin, m_Zmax, R1inn, R1out, R2inn, R2out
215  );
216 
217  const G4double FanPhiAmplitude = 0.065; // internal technical constant, should not go in DB
218  const G4double phi_min = CLHEP::halfpi
219  - FanPhiAmplitude
220  - GetCalculator()->GetFanStepOnPhi() * 2;
221  m_Xmax = rOuter[1]*cos(phi_min);
222  m_Xmin = -m_Xmax;
223 
224  m_Ymin = m_Rmin * 0.9;
225 }

◆ Inside()

EInside LArWheelSliceSolid::Inside ( const G4ThreeVector &  inputP) const

Definition at line 15 of file LArWheelSliceSolid.cxx.

16 {
17  LWSDBG(10, std::cout << std::setprecision(25));
18  LWSDBG(1, std::cout << TypeStr() << " Inside " << MSG_VECTOR(inputP) << std::endl);
19  const EInside inside_BS = m_BoundingShape->Inside(inputP);
20  if(inside_BS == kOutside){
21  LWSDBG(2, std::cout << "outside BS" << std::endl);
22  return kOutside;
23  }
24  G4ThreeVector p(inputP);
25  int p_fan = 0;
26  const G4double d = fabs(GetCalculator()->DistanceToTheNearestFan(p, p_fan));
27  if(d > m_FHTplusT){
28  LWSDBG(2, std::cout << "outside fan d=" << d << ", m_FHTplusT=" << m_FHTplusT << std::endl);
29  return kOutside;
30  }
31  if(d < m_FHTminusT){
32  LWSDBG(2, std::cout << "inside fan d=" << d << ", m_FHTminusT=" << m_FHTminusT << ", inside_BS=" << inside(inside_BS) << std::endl);
33  return inside_BS;
34  }
35  LWSDBG(2, std::cout << "surface" << std::endl);
36  return kSurface;
37 }

◆ Inside_accordion()

EInside LArWheelSliceSolid::Inside_accordion ( const G4ThreeVector &  p) const
private

Definition at line 29 of file LArWheelSliceSolidTests.cxx.

30 {
31  G4ThreeVector p1 = p;
32  int p1_fan = 0;
33  G4double d = m_FanHalfThickness - fabs(GetCalculator()->DistanceToTheNearestFan(p1, p1_fan));
34  if(d > s_Tolerance) return kInside;
35  if(d > -s_Tolerance) return kSurface;
36  return kOutside;
37 }

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 164 of file AthMessaging.h.

165 {
166  MsgStream* ms = m_msg_tls.get();
167  if (!ms) {
168  if (!m_initialized.test_and_set()) initMessaging();
169  ms = new MsgStream(m_imsg,m_nm);
170  m_msg_tls.reset( ms );
171  }
172 
173  ms->setLevel (m_lvl);
174  return *ms;
175 }

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level  lvl) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 179 of file AthMessaging.h.

180 { return msg() << lvl; }

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Test the output level.

Parameters
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152 {
153  if (!m_initialized.test_and_set()) initMessaging();
154  if (m_lvl <= lvl) {
155  msg() << lvl;
156  return true;
157  } else {
158  return false;
159  }
160 }

◆ out_iteration_process()

G4double LArWheelSliceSolid::out_iteration_process ( const G4ThreeVector &  p,
G4ThreeVector &  B,
const int  p_fan 
) const
private

Definition at line 139 of file LArWheelSliceSolidDisToOut.cxx.

141 {
142  LWSDBG(6, std::cout << "oip: " << p << " " << B);
143  assert(fabs(GetCalculator()->DistanceToTheNeutralFibre(p, p_fan)) < m_FHTplusT);
144  assert(fabs(GetCalculator()->DistanceToTheNeutralFibre(B, p_fan)) > m_FHTminusT);
145  G4ThreeVector A(p), C, diff;
146  unsigned int niter = 0;
147  do {
148  C = A + B;
149  C *= 0.5;
150  if(fabs(GetCalculator()->DistanceToTheNeutralFibre(C, p_fan)) < m_FHTplusT){
151  A = C;
152  } else {
153  B = C;
154  }
155  niter ++;
156  diff = A - B;
157  } while(diff.mag2() > s_IterationPrecision2 && niter < s_IterationsLimit);
158  assert(fabs(GetCalculator()->DistanceToTheNeutralFibre(B, p_fan)) > m_FHTplusT);
159  assert(niter < s_IterationsLimit);
160  diff = p - B;
161  LWSDBG(7, std::cout << " -> " << B << " " << diff.mag());
162  LWSDBG(6, std::cout << std::endl);
163  return diff.mag();
164 }

◆ outer_solid_init()

void LArWheelSliceSolid::outer_solid_init ( const G4String &  bs_name,
size_t  slice 
)
private

Definition at line 227 of file LArWheelSliceSolidInit.cxx.

228 {
229  std::array<G4double,3> zPlane{}, rInner{}, rOuter{};
230  zPlane[1] = GetCalculator()->GetWheelInnerRadius(rInner);
231  zPlane[2] = GetCalculator()->GetWheelThickness();
232  GetCalculator()->GetWheelOuterRadius(rOuter);
233 
234  std::vector<G4double> zsect;
235  fill_zsect(zsect, zPlane[1]);
236  check_slice(zsect.size(), slice);
237 
238  m_Zmin = zsect[slice]; m_Zmax = zsect[slice + 1];
239  m_Rmin = rInner[0]; m_Rmax = rOuter[1];
240  const size_t i = m_Zmax > zPlane[1]? 1: 0;
241  const G4double dz = zPlane[i + 1] - zPlane[i];
242  const G4double ainn = (rInner[i + 1] - rInner[i]) / dz;
243  const G4double aout = (rOuter[i + 1] - rOuter[i]) / dz;
244  const G4double R1inn = ainn * (m_Zmin - zPlane[i]) + rInner[i];
245  const G4double R1out = aout * (m_Zmin - zPlane[i]) + rOuter[i];
246  const G4double R2inn = ainn * (m_Zmax - zPlane[i]) + rInner[i];
247  const G4double R2out = aout * (m_Zmax - zPlane[i]) + rOuter[i];
248 
249  m_BoundingShape = new G4ShiftedCone(
250  bs_name + "Cone", m_Zmin, m_Zmax, R1inn, R1out, R2inn, R2out
251  );
252 
253  const G4double FanPhiAmplitude = 0.02; // internal technical constant, should not go in DB
254  const G4double phi_min = CLHEP::halfpi
255  - FanPhiAmplitude
256  - GetCalculator()->GetFanStepOnPhi() * 2;
257  m_Xmax = rOuter[1]*cos(phi_min);
258  m_Xmin = -m_Xmax;
259 
260  m_Ymin = m_Rmin * 0.9;
261 }

◆ search_for_most_remoted_point()

G4bool LArWheelSliceSolid::search_for_most_remoted_point ( const G4ThreeVector &  a,
const G4ThreeVector &  b,
G4ThreeVector &  C,
const int  p_fan 
) const
private

Definition at line 169 of file LArWheelSliceSolidDisToOut.cxx.

172 {
173  LWSDBG(6, std::cout << "sfmrp " << a << " " << b << std::endl);
174  G4ThreeVector diff(b - a);
175 
176  if(diff.mag2() <= s_IterationPrecision2) return false;
177  G4ThreeVector A(a), B(b), l(diff.unit() * s_IterationPrecision);
178  // find the most remoted point on the line AB
179  // and check if it is outside vertical fan
180  // small vector along the segment AB
181  G4double d1, d2;
182  unsigned int niter = 0;
183  // searching for maximum of (GetCalculator()->DistanceToTheNeutralFibre)^2 along AB
184  do {
185  C = A + B;
186  C *= 0.5;
187  d1 = GetCalculator()->DistanceToTheNeutralFibre(C, p_fan);
188  if(fabs(d1) > m_FHTplusT){
189  // here out_iteration_process gives the answer
190  LWSDBG(7, std::cout << "sfmrp -> " << C << " " << fabs(d1)
191  << " " << (C - a).unit() << " "
192  << (C - a).mag() << std::endl);
193  return true;
194  }
195  // sign of derivative
196  //d1 = GetCalculator()->DistanceToTheNeutralFibre(C + l);
197  d2 = GetCalculator()->DistanceToTheNeutralFibre(C - l, p_fan);
198  if(d1 * d1 - d2 * d2 > 0.) A = C;
199  else B = C;
200  niter ++;
201  diff = A - B;
202  } while(diff.mag2() > s_IterationPrecision2 && niter < s_IterationsLimit);
203  // the line entirely lies inside fan
204  assert(niter < s_IterationsLimit);
205  return false;
206 }

◆ search_for_nearest_point()

G4double LArWheelSliceSolid::search_for_nearest_point ( const G4ThreeVector &  p_in,
const G4double  dist_p_in,
const G4ThreeVector &  p_out,
int  p_fan 
) const
private

Definition at line 213 of file LArWheelSliceSolidDisToIn.cxx.

217 {
218  LWSDBG(6, std::cout << "sfnp " << MSG_VECTOR(p_in) << " "
219  << MSG_VECTOR(p_out) << std::endl);
220 
221  G4ThreeVector A, B, C, l, diff;
222  A = p_in;
223  B = p_out;
224  diff = B - A;
225  l = diff.unit() * s_IterationPrecision;
226  // this is to correctly take the sign of the distance into account
227  G4double sign = dist_p_in < 0.? -1. : 1.;
228  G4double d_prime;
229  G4double dist_c;
230  unsigned long niter = 0;
231  do {
232  C = A + B;
233  C *= 0.5;
234  dist_c = GetCalculator()->DistanceToTheNeutralFibre(C, p_fan);
235  if(dist_c * sign <= 0.){ // we are in coditions for in_iteration_process
236  LWSDBG(7, std::cout << "sfnp0 " << dist_c << std::endl);
237  return in_iteration_process(p_in, dist_p_in, C, p_fan);
238  }
239  // calculate sign of derivative of distance to the neutral fibre
240  // hope this substitution is acceptable
241  diff = C - l;
242  d_prime = (dist_c - GetCalculator()->DistanceToTheNeutralFibre(diff, p_fan)) * sign;
243  if(d_prime < 0.) A = C;
244  else B = C;
245  niter ++;
246  diff = A - B;
247  } while(diff.mag2() > s_IterationPrecision2 && niter < s_IterationsLimit);
248  assert(niter < s_IterationsLimit);
249  if(fabs(dist_c) < m_FHTminusT){
250  LWSDBG(7, std::cout << "sfnp1 " << dist_c << std::endl);
251  return in_iteration_process(p_in, dist_p_in, C, p_fan);
252  }
253  // let's check at p_in and p_out
254  if(dist_p_in * sign < dist_c * sign){
255  C = p_in;
256  dist_c = dist_p_in;
257  }
258  G4double dist_p_out = GetCalculator()->DistanceToTheNeutralFibre(p_out, p_fan);
259  if(dist_p_out *sign < dist_c * sign) C = p_out;
260  if(fabs(dist_p_out) < m_FHTminusT){
261  LWSDBG(7, std::cout << "sfnp2 " << dist_p_out << std::endl);
262  return in_iteration_process(p_in, dist_p_in, C, p_fan);
263  }
264  return kInfinity;
265 }

◆ set_failover_point()

void LArWheelSliceSolid::set_failover_point ( G4ThreeVector &  p,
const char *  m = 0 
) const
private

Definition at line 39 of file LArWheelSliceSolidTests.cxx.

45  {
46  p[0] = 0.; p[1] = m_Rmin;
47  if(m_Zmin < s_Tolerance) p[2] = 0.;
48  else if(m_Calculator->GetWheelThickness() - m_Zmax < s_Tolerance) p[2] = m_Zmax;
49  else p[2] = (m_Zmin + m_Zmax) * 0.5;
50  int p_fan = 0;
51  GetCalculator()->DistanceToTheNearestFan(p, p_fan);
52 
53 #ifdef LOCAL_DEBUG
54  if(m) std::cout << m << std::endl;
55 #endif
56  }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl)
inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

29 {
30  m_lvl = lvl;
31 }

◆ StreamInfo()

virtual std::ostream& LArWheelSliceSolid::StreamInfo ( std::ostream &  os) const
inlinevirtual

Definition at line 82 of file LArWheelSliceSolid.h.

82 { return os; }

◆ SurfaceNormal()

G4ThreeVector LArWheelSliceSolid::SurfaceNormal ( const G4ThreeVector &  inputP) const

Definition at line 39 of file LArWheelSliceSolid.cxx.

40 {
41  LWSDBG(1, std::cout << TypeStr() << " SurfaceNormal" << MSG_VECTOR(inputP) << std::endl);
42  EInside inside_BS = m_BoundingShape->Inside(inputP);
43  if(inside_BS != kInside){
44  LWSDBG(2, std::cout << "not inside BS" << std::endl);
45  return m_BoundingShape->SurfaceNormal(inputP);
46  }
47  G4ThreeVector p( inputP );
48  int p_fan = 0;
49  GetCalculator()->DistanceToTheNearestFan(p, p_fan);
50  G4ThreeVector d = GetCalculator()->NearestPointOnNeutralFibre(p, p_fan);
51  d.rotateZ(inputP.phi() - p.phi()); // rotate back to initial position
52  LWSDBG(4, std::cout << "npnf" << MSG_VECTOR(d) << std::endl);
53  p = inputP - d;
54  LWSDBG(2, std::cout << "sn " << MSG_VECTOR(p.unit()) << std::endl);
55  return(p.unit());
56 }

◆ test()

void LArWheelSliceSolid::test ( void  )
private

Definition at line 397 of file LArWheelSliceSolidTests.cxx.

398 {
399  boost::io::ios_all_saver ias(std::cout);
400  const char *on = getenv("LARWHEELSLICESOLID_TEST");
401  if(on == 0) return;
402  std::string test_mode = on;
403 
404  std::cout << "============| LArWheelSliceSolid test() routine |=============="
405  << std::endl;
406  std::cout << "Solid of type " << TypeStr() << std::endl;
407  std::cout.precision(6);
408  std::cout << std::fixed;
409  const char *prec = getenv("LARWHEELSLICESOLID_TEST_INTPRECISION");
410  if(prec) IntPrecision = atof(prec);
411  std::cout << "Int. precision " << IntPrecision << std::endl;
412  std::cout << "test mode " << test_mode << std::endl;
413 
414  std::cout << "m_Rmin = " << m_Rmin << " m_Rmax = " << m_Rmax << std::endl
415  << "m_Zmin = " << m_Zmin << " m_Zmax = " << m_Zmax << std::endl;
416 
417  // TFile *F = new TFile("LArWheelSliceSolid_test.root", "RECREATE");
418  TFile *F = 0;
419  TNtupleD *T = 0;
420  if(test_mode.find("root") != std::string::npos){
421  F = new TFile("LArWheelSliceSolid_test.root", "UPDATE");
422  T = new TNtupleD(GetName(), GetName(), "x:y:z");
423  }
424  int N = 1000000;
425  const int Nmax(1000000000);
426  char *NN = getenv("LARWHEELSLICESOLID_TEST_NPOINTS");
427 
428  if(NN) {
429  char *endptr;
430  N = strtol(NN, &endptr, 0);
431  if (endptr[0] != '\0') {
432  throw std::invalid_argument("Could not convert string to int: " + std::string(NN));
433  }
434  }
435  if (Nmax<N) {
436  std::cout << "Number of points from LARWHEELSLICESOLID_TEST_NPOINTS environment variable ("<<N<<") is too large. Using " << Nmax << " instead." << std::endl;
437  N=Nmax;
438  }
439  if (N<0) {
440  std::cout << "Number of points from LARWHEELSLICESOLID_TEST_NPOINTS environment variable ("<<N<<") is negative!!. Using 0 instead." << std::endl;
441  N=0;
442  }
443  if(test_mode.find("points") == std::string::npos){
444  N = 0;
445  } else {
446  std::cout << N << " points" << std::endl;
447  }
448  for(int i = 0; i < N; ++ i){
449  G4ThreeVector p = GetPointOnSurface();
450 #ifdef LOCAL_DEBUG
451  EInside ii = Inside(p);
452  if(ii != kSurface){
453  std::cout << i << " "
454  << (ii == kInside? "inside": "outside")
455  << std::endl;
456  }
457 #endif
458  if(T) T->Fill(p[0], p[1], p[2]);
459  }
460  if(F){
461  T->Write();
462  F->Write();
463  F->Close();
464  delete F;
465  }
466 
467  if(test_mode.find("volume") != std::string::npos){
468  double cv = GetCubicVolume();
469  std::cout << "GetCubicVolume: " << cv/CLHEP::mm3 << " mm^3" << std::endl;
470  }
471 
472  if(test_mode.find("area") != std::string::npos){
473  double sa = GetSurfaceArea();
474  std::cout << "GetSurfaceArea: " << sa/CLHEP::mm2 << " mm^2" << std::endl;
475  }
476 
477  std::cout << "======= end of ArWheelSolid test() routine ============="
478  << std::endl;
479 
480  if(test_mode.find("once") != std::string::npos) exit(0);
481  ias.restore();
482 }

◆ TypeStr()

G4String LArWheelSliceSolid::TypeStr ( void  ) const
private

Definition at line 67 of file LArWheelSliceSolid.cxx.

68 {
69  G4String ret("");
70  switch(m_Pos){
71  case Inner:
72  switch(m_Type){
73  case Absorber: ret = "LArInnerAbsorberWheel"; break;
74  case Electrode: ret = "LArInnerElectrodWheel"; break;
75  case Glue: ret = "LArInnerGlueWheel"; break;
76  case Lead: ret = "LArInnerLeadWheel"; break;
77  }
78  break;
79  case Outer:
80  switch(m_Type){
81  case Absorber: ret = "LArOuterAbsorberWheel"; break;
82  case Electrode: ret = "LArOuterElectrodWheel"; break;
83  case Glue: ret = "LArOuterGlueWheel"; break;
84  case Lead: ret = "LArOuterLeadWheel"; break;
85  }
86  break;
87  }
88  return ret;
89 }

Friends And Related Function Documentation

◆ LArWheelSliceSolid_fcn_area

double LArWheelSliceSolid_fcn_area ( double *  x,
double *  p 
)
friend

Definition at line 528 of file LArWheelSliceSolidTests.cxx.

529 {
530  const double &z = x[0];
531  const double &r = p[0];
532  const double &index = p[1];
533 
534  G4ThreeVector a(0., r, z);
535  double b = solid[index]->GetCalculator()->AmplitudeOfSurface(a, -1, 121) // sagging ignored, effect should be negligible, use arbitrary fan number
536  - solid[index]->GetCalculator()->AmplitudeOfSurface(a, 1, 121);
537  return b;
538 }

◆ LArWheelSliceSolid_fcn_area_on_pc

double LArWheelSliceSolid_fcn_area_on_pc ( double *  x,
double *  p 
)
friend

Definition at line 548 of file LArWheelSliceSolidTests.cxx.

549 {
550  const double &z = x[0];
551  const double &index = p[0];
552 
553  G4double rmin, rmax;
554  get_r(solid[index]->m_BoundingShape, z, rmin, rmax);
555 
556  double result = 0.;
557  G4ThreeVector a(0., rmin, z);
558  result += solid[index]->GetCalculator()->AmplitudeOfSurface(a, -1, 232) // sagging ignored, effect should be negligible, use arbitrary fan number
559  - solid[index]->GetCalculator()->AmplitudeOfSurface(a, 1, 232);
560  a[1] = rmax;
561  result += solid[index]->GetCalculator()->AmplitudeOfSurface(a, -1, 343)
562  - solid[index]->GetCalculator()->AmplitudeOfSurface(a, 1, 343);
563 
564  return result;
565 }

◆ LArWheelSliceSolid_fcn_side_area

double LArWheelSliceSolid_fcn_side_area ( double *  x,
double *  p 
)
friend

Definition at line 600 of file LArWheelSliceSolidTests.cxx.

601 {
602  const double &r = x[0];
603  const double &index = p[0];
604 
605  return solid[index]->get_length_at_r(r);
606 }

◆ LArWheelSliceSolid_fcn_vol

double LArWheelSliceSolid_fcn_vol ( double *  x,
double *  p 
)
friend

Definition at line 540 of file LArWheelSliceSolidTests.cxx.

541 {
542  const double &r = x[0];
543  const double &index = p[0];
544 
545  return solid[index]->get_area_at_r(r);
546 }

◆ LArWheelSliceSolid_get_dl

double LArWheelSliceSolid_get_dl ( double *  x,
double *  par,
G4int  side 
)
friend

Definition at line 568 of file LArWheelSliceSolidTests.cxx.

569 {
570  const double &z = x[0];
571  const double &r = par[0];
572  const double &index = par[1];
573 
574  const double h = 0.001;
575 
576  //check what happens if z+h > m_Zmax etc
577  G4ThreeVector p(0., r, z + h);
578  G4double D1 = solid[index]->GetCalculator()->AmplitudeOfSurface(p, side, 5665); // sagging ignored, effect should be negligible, use arbitrary fan number
579  p[2] = z - h;
580  D1 -= solid[index]->GetCalculator()->AmplitudeOfSurface(p, side, 5665);
581  D1 /= 2 * h;
582 
583  p[2] = z + h / 2;
584  G4double D2 = solid[index]->GetCalculator()->AmplitudeOfSurface(p, side, 5665);
585  p[2] = z - h / 2;
586  D2 -= solid[index]->GetCalculator()->AmplitudeOfSurface(p, side, 5665);
587  D2 /= h;
588 
589  G4double D = (D2 * 4 - D1) / 3.;
590  G4double dl = sqrt(1 + D * D);
591 
592  return dl;
593 }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_BoundingShape

G4VSolid* LArWheelSliceSolid::m_BoundingShape {}
private

Definition at line 104 of file LArWheelSliceSolid.h.

◆ m_Calculator

const LArWheelCalculator* LArWheelSliceSolid::m_Calculator {}
private

Definition at line 103 of file LArWheelSliceSolid.h.

◆ m_f_area

TF1* LArWheelSliceSolid::m_f_area
protected

Definition at line 158 of file LArWheelSliceSolid.h.

◆ m_f_area_on_pc

TF1 * LArWheelSliceSolid::m_f_area_on_pc
protected

Definition at line 158 of file LArWheelSliceSolid.h.

◆ m_f_length

TF1 * LArWheelSliceSolid::m_f_length
protected

Definition at line 158 of file LArWheelSliceSolid.h.

◆ m_f_side_area

TF1 * LArWheelSliceSolid::m_f_side_area
protected

Definition at line 158 of file LArWheelSliceSolid.h.

◆ m_f_vol

TF1 * LArWheelSliceSolid::m_f_vol
protected

Definition at line 158 of file LArWheelSliceSolid.h.

◆ m_FanHalfThickness

G4double LArWheelSliceSolid::m_FanHalfThickness {}
private

Definition at line 106 of file LArWheelSliceSolid.h.

◆ m_FHTminusT

G4double LArWheelSliceSolid::m_FHTminusT {}
private

Definition at line 106 of file LArWheelSliceSolid.h.

◆ m_FHTplusT

G4double LArWheelSliceSolid::m_FHTplusT {}
private

Definition at line 106 of file LArWheelSliceSolid.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }
mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }
mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls
mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_Pos

pos_t LArWheelSliceSolid::m_Pos {}
private

Definition at line 101 of file LArWheelSliceSolid.h.

◆ m_Rmax

G4double LArWheelSliceSolid::m_Rmax {}
private

Definition at line 115 of file LArWheelSliceSolid.h.

◆ m_Rmin

G4double LArWheelSliceSolid::m_Rmin {}
private

Definition at line 115 of file LArWheelSliceSolid.h.

◆ m_test_index

double LArWheelSliceSolid::m_test_index
protected

Definition at line 161 of file LArWheelSliceSolid.h.

◆ m_Type

type_t LArWheelSliceSolid::m_Type {}
private

Definition at line 102 of file LArWheelSliceSolid.h.

◆ m_Xmax

G4double LArWheelSliceSolid::m_Xmax {}
private

Definition at line 109 of file LArWheelSliceSolid.h.

◆ m_Xmin

G4double LArWheelSliceSolid::m_Xmin {}
private

Definition at line 109 of file LArWheelSliceSolid.h.

◆ m_Ymin

G4double LArWheelSliceSolid::m_Ymin {}
private

Definition at line 112 of file LArWheelSliceSolid.h.

◆ m_Zmax

G4double LArWheelSliceSolid::m_Zmax {}
private

Definition at line 115 of file LArWheelSliceSolid.h.

◆ m_Zmin

G4double LArWheelSliceSolid::m_Zmin {}
private

Definition at line 115 of file LArWheelSliceSolid.h.

◆ s_AngularTolerance

const G4double LArWheelSliceSolid::s_AngularTolerance = G4GeometryTolerance::GetInstance()->GetAngularTolerance() / 2
staticprivate

Definition at line 96 of file LArWheelSliceSolid.h.

◆ s_IterationPrecision

const G4double LArWheelSliceSolid::s_IterationPrecision = 0.001*CLHEP::mm
staticprivate

Definition at line 97 of file LArWheelSliceSolid.h.

◆ s_IterationPrecision2

const G4double LArWheelSliceSolid::s_IterationPrecision2 = s_IterationPrecision * s_IterationPrecision
staticprivate

Definition at line 98 of file LArWheelSliceSolid.h.

◆ s_IterationsLimit

const unsigned int LArWheelSliceSolid::s_IterationsLimit = 50
staticprivate

Definition at line 99 of file LArWheelSliceSolid.h.

◆ s_Tolerance

const G4double LArWheelSliceSolid::s_Tolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance() / 2
staticprivate

Definition at line 95 of file LArWheelSliceSolid.h.

The documentation for this class was generated from the following files:
LArWheelSliceSolid::get_area_on_face
G4double get_area_on_face(void) const
Definition: LArWheelSliceSolidTests.cxx:334
LArWheelSliceSolid::Inner
@ Inner
Definition: LArWheelSliceSolid.h:48
LArWheelSliceSolid::s_Tolerance
static const G4double s_Tolerance
Definition: LArWheelSliceSolid.h:95
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
beamspotman.r
def r
Definition: beamspotman.py:676
LArWheelSliceSolid::Lead
@ Lead
Definition: LArWheelSliceSolid.h:49
TestSUSYToolsAlg.dl
dl
Definition: TestSUSYToolsAlg.py:81
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
LArWheelCalculator::GetStraightStartSection
double GetStraightStartSection() const
Definition: LArWheelCalculator.h:82
get_generator_info.result
result
Definition: get_generator_info.py:21
LArWheelSliceSolid::init_tests
void init_tests(void)
Definition: LArWheelSliceSolidTests.cxx:608
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
LArWheelSliceSolid::GetCalculator
const LArWheelCalculator * GetCalculator(void) const
Definition: LArWheelSliceSolid.h:92
LArWheelSliceSolid::Electrode
@ Electrode
Definition: LArWheelSliceSolid.h:49
LArG4::OuterElectrodWheel
@ OuterElectrodWheel
Definition: LArWheelCalculatorEnums.h:12
LArWheelSliceSolid::search_for_most_remoted_point
G4bool search_for_most_remoted_point(const G4ThreeVector &, const G4ThreeVector &, G4ThreeVector &, const int) const
Definition: LArWheelSliceSolidDisToOut.cxx:169
LArWheelSliceSolid::pos_t
pos_t
Definition: LArWheelSliceSolid.h:48
LArG4::InnerAbsorberWheel
@ InnerAbsorberWheel
Definition: LArWheelCalculatorEnums.h:11
PixelAthClusterMonAlgCfg.zmin
zmin
Definition: PixelAthClusterMonAlgCfg.py:169
index
Definition: index.py:1
hist_file_dump.d
d
Definition: hist_file_dump.py:137
LArWheelSliceSolid::GetPointOnSurface
G4ThreeVector GetPointOnSurface(void) const
Definition: LArWheelSliceSolidTests.cxx:69
LArG4::InnerGlueWheel
@ InnerGlueWheel
Definition: LArWheelCalculatorEnums.h:19
LArWheelSliceSolid::TypeStr
G4String TypeStr(void) const
Definition: LArWheelSliceSolid.cxx:67
LArWheelCalculator::GetFanHalfThickness
double GetFanHalfThickness(LArG4::LArWheelCalculator_t) const
Definition: LArWheelCalculator.cxx:441
LArWheelSliceSolid::in_iteration_process
G4double in_iteration_process(const G4ThreeVector &, G4double, G4ThreeVector &, int) const
Definition: LArWheelSliceSolidDisToIn.cxx:177
InDetAccessor::phi0
@ phi0
Definition: InDetAccessor.h:33
DMTest::C
C_v1 C
Definition: C.h:26
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
LArWheelSliceSolid::Outer
@ Outer
Definition: LArWheelSliceSolid.h:48
LArWheelSliceSolid::m_Rmin
G4double m_Rmin
Definition: LArWheelSliceSolid.h:115
LArWheelCalculator::type
virtual LArG4::LArWheelCalculator_t type() const
Definition: LArWheelCalculator.h:83
LArWheelCalculator::GetNumberOfHalfWaves
int GetNumberOfHalfWaves() const
Definition: LArWheelCalculator.h:91
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
LArWheelSliceSolid::get_area_on_side
G4double get_area_on_side(void) const
Definition: LArWheelSliceSolidTests.cxx:362
dq_defect_virtual_defect_validation.d1
d1
Definition: dq_defect_virtual_defect_validation.py:79
LArWheelSliceSolid::m_f_length
TF1 * m_f_length
Definition: LArWheelSliceSolid.h:158
LArWheelSliceSolid::distance_to_in
virtual G4double distance_to_in(G4ThreeVector &, const G4ThreeVector &, int) const
Definition: LArWheelSliceSolidDisToIn.cxx:121
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
LArWheelSliceSolid::m_Pos
pos_t m_Pos
Definition: LArWheelSliceSolid.h:101
LArWheelSliceSolid::clean_tests
void clean_tests(void)
Definition: LArWheelSliceSolidTests.cxx:484
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
LArWheelSliceSolid::type_t
type_t
Definition: LArWheelSliceSolid.h:49
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
G4ShiftedCone
Definition: G4ShiftedCone.h:87
LArWheelSliceSolid::m_Zmax
G4double m_Zmax
Definition: LArWheelSliceSolid.h:115
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
x
#define x
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
LArWheelSliceSolid::Glue
@ Glue
Definition: LArWheelSliceSolid.h:49
pi
#define pi
Definition: TileMuonFitter.cxx:65
LArWheelSliceSolid::m_Xmin
G4double m_Xmin
Definition: LArWheelSliceSolid.h:109
Monitored::X
@ X
Definition: HistogramFillerUtils.h:24
LArWheelSliceSolid::search_for_nearest_point
G4double search_for_nearest_point(const G4ThreeVector &, const G4double, const G4ThreeVector &, int) const
Definition: LArWheelSliceSolidDisToIn.cxx:213
python.SystemOfUnits.mm3
int mm3
Definition: SystemOfUnits.py:85
TRT::Hit::side
@ side
Definition: HitInfo.h:83
dqt_zlumi_alleff_HIST.A
A
Definition: dqt_zlumi_alleff_HIST.py:110
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
ZDCMsg::Verbose
@ Verbose
Definition: ZDCMsg.h:18
AthMessaging::AthMessaging
AthMessaging()
Default constructor:
LArWheelSliceSolid::m_f_area
TF1 * m_f_area
Definition: LArWheelSliceSolid.h:158
LArWheelSliceSolid::get_point_on_flat_surface
void get_point_on_flat_surface(G4ThreeVector &) const
Definition: LArWheelSliceSolidTests.cxx:288
LArWheelSliceSolid::check_slice
void check_slice(size_t size, size_t slice) const
Definition: LArWheelSliceSolidInit.cxx:183
A
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
LArWheelSliceSolid::s_IterationsLimit
static const unsigned int s_IterationsLimit
Definition: LArWheelSliceSolid.h:99
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
LArWheelCalculator::GetWheelInnerRadius
double GetWheelInnerRadius(std::array< double, 2 > &rInner) const
Definition: LArWheelCalculator.cxx:493
LWSDBG
#define LWSDBG(a, b)
Definition: LArWheelSliceSolid.h:28
LArWheelSliceSolid::m_Xmax
G4double m_Xmax
Definition: LArWheelSliceSolid.h:109
perfmonmt-refit.slice
slice
Definition: perfmonmt-refit.py:52
LArWheelSliceSolid::outer_solid_init
void outer_solid_init(const G4String &, size_t slice)
Definition: LArWheelSliceSolidInit.cxx:227
LArWheelSliceSolid::get_point_on_polycone_surface
void get_point_on_polycone_surface(G4ThreeVector &) const
Definition: LArWheelSliceSolidTests.cxx:165
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
LArWheelCalculator::GetNumberOfFans
int GetNumberOfFans() const
Definition: LArWheelCalculator.h:92
LArG4::OuterGlueWheel
@ OuterGlueWheel
Definition: LArWheelCalculatorEnums.h:19
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
extractSporadic.h
list h
Definition: extractSporadic.py:97
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
makeTRTBarrelCans.y2
tuple y2
Definition: makeTRTBarrelCans.py:18
LArWheelCalculator::GetWheelThickness
double GetWheelThickness() const
Definition: LArWheelCalculator.h:80
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
PixelAthClusterMonAlgCfg.zmax
zmax
Definition: PixelAthClusterMonAlgCfg.py:169
sign
int sign(int a)
Definition: TRT_StrawNeighbourSvc.h:107
LArWheelSliceSolid::out_iteration_process
G4double out_iteration_process(const G4ThreeVector &, G4ThreeVector &, const int) const
Definition: LArWheelSliceSolidDisToOut.cxx:139
LArWheelSliceSolid::get_point_on_accordion_surface
void get_point_on_accordion_surface(G4ThreeVector &) const
Definition: LArWheelSliceSolidTests.cxx:101
LArWheelCalculator
Definition: LArWheelCalculator.h:60
LArWheelSliceSolid::createSolid
void createSolid(const G4String &name, G4int zside, size_t slice, const EMECData *emecData)
Definition: LArWheelSliceSolidInit.cxx:104
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
LArWheelSliceSolid::m_Ymin
G4double m_Ymin
Definition: LArWheelSliceSolid.h:112
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
calibdata.exit
exit
Definition: calibdata.py:236
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AthMessaging.h:164
LArG4::InnerLeadWheel
@ InnerLeadWheel
Definition: LArWheelCalculatorEnums.h:20
LArWheelCalculator::GetWheelOuterRadius
void GetWheelOuterRadius(std::array< double, 2 > &rOuter) const
Definition: LArWheelCalculator.cxx:525
CxxUtils::atof
double atof(std::string_view str)
Converts a string into a double / float.
Definition: Control/CxxUtils/Root/StringUtils.cxx:91
LArWheelSliceSolid::GetCubicVolume
G4double GetCubicVolume(void)
Definition: LArWheelSliceSolidTests.cxx:316
LArWheelSliceSolid::LArWheelSliceSolid_fcn_area_on_pc
friend double LArWheelSliceSolid_fcn_area_on_pc(double *, double *)
Definition: LArWheelSliceSolidTests.cxx:548
twopi
constexpr double twopi
Definition: VertexPointEstimator.cxx:16
python.SystemOfUnits.mm2
int mm2
Definition: SystemOfUnits.py:84
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:29
LArWheelSliceSolid::s_IterationPrecision2
static const G4double s_IterationPrecision2
Definition: LArWheelSliceSolid.h:98
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
LArWheelSliceSolid::GetSurfaceArea
G4double GetSurfaceArea(void)
Definition: LArWheelSliceSolidTests.cxx:367
LArWheelSliceSolid::m_Zmin
G4double m_Zmin
Definition: LArWheelSliceSolid.h:115
dqt_zlumi_alleff_HIST.B
B
Definition: dqt_zlumi_alleff_HIST.py:110
LArWheelSliceSolid::m_BoundingShape
G4VSolid * m_BoundingShape
Definition: LArWheelSliceSolid.h:104
LArWheelCalculator::GetHalfWaveLength
double GetHalfWaveLength() const
Definition: LArWheelCalculator.h:96
LArWheelSliceSolid::set_failover_point
void set_failover_point(G4ThreeVector &p, const char *m=0) const
Definition: LArWheelSliceSolidTests.cxx:39
LArWheelSliceSolid::inner_solid_init
void inner_solid_init(const G4String &, size_t slice)
Definition: LArWheelSliceSolidInit.cxx:193
library_scraper.dd
list dd
Definition: library_scraper.py:46
LArWheelCalculator::AmplitudeOfSurface
double AmplitudeOfSurface(const CLHEP::Hep3Vector &P, int side, int fan_number) const
Definition: LArWheelCalculatorGeometry.cxx:130
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
LArWheelSliceSolid::LArWheelSliceSolid_fcn_side_area
friend double LArWheelSliceSolid_fcn_side_area(double *, double *)
Definition: LArWheelSliceSolidTests.cxx:600
LArWheelCalculator::DistanceToTheNearestFan
double DistanceToTheNearestFan(CLHEP::Hep3Vector &p, int &out_fan_number) const
Determines the nearest to the input point fan.
Definition: LArWheelCalculatorGeometry.cxx:90
python.PyAthena.v
v
Definition: PyAthena.py:154
Trk::inside
@ inside
Definition: PropDirection.h:29
makeTRTBarrelCans.dy
tuple dy
Definition: makeTRTBarrelCans.py:21
DeMoScan.index
string index
Definition: DeMoScan.py:364
LArWheelSliceSolid::s_IterationPrecision
static const G4double s_IterationPrecision
Definition: LArWheelSliceSolid.h:97
LArWheelSliceSolid::m_FHTplusT
G4double m_FHTplusT
Definition: LArWheelSliceSolid.h:106
LArWheelSliceSolid::test
void test(void)
Definition: LArWheelSliceSolidTests.cxx:397
a
TList * a
Definition: liststreamerinfos.cxx:10
SCT_ConditionsAlgorithms::CoveritySafe::getenv
std::string getenv(const std::string &variableName)
get an environment variable
Definition: SCT_ConditionsUtilities.cxx:17
h
LArWheelCalculator::NearestPointOnNeutralFibre
CLHEP::Hep3Vector NearestPointOnNeutralFibre(const CLHEP::Hep3Vector &p, int fan_number) const
Definition: LArWheelCalculatorGeometry.cxx:113
LArWheelSliceSolid::m_Calculator
const LArWheelCalculator * m_Calculator
Definition: LArWheelSliceSolid.h:103
LArWheelSliceSolid::m_test_index
double m_test_index
Definition: LArWheelSliceSolid.h:161
LArWheelSliceSolid::LArWheelSliceSolid_fcn_area
friend double LArWheelSliceSolid_fcn_area(double *, double *)
Definition: LArWheelSliceSolidTests.cxx:528
LArWheelSliceSolid::m_Type
type_t m_Type
Definition: LArWheelSliceSolid.h:102
LArWheelSliceSolid::m_Rmax
G4double m_Rmax
Definition: LArWheelSliceSolid.h:115
unit
const PlainObject unit() const
This is a plugin that makes Eigen look like CLHEP & defines some convenience methods.
Definition: AmgMatrixBasePlugin.h:21
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
dq_defect_virtual_defect_validation.d2
d2
Definition: dq_defect_virtual_defect_validation.py:81
DeMoScan.first
bool first
Definition: DeMoScan.py:536
F
#define F(x, y, z)
Definition: MD5.cxx:112
LArWheelCalculator::GetFanStepOnPhi
double GetFanStepOnPhi() const
Definition: LArWheelCalculator.h:95
LArCellBinning.step
step
Definition: LArCellBinning.py:158
extractSporadic.q
list q
Definition: extractSporadic.py:98
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
LArWheelCalculator::DistanceToTheNeutralFibre
double DistanceToTheNeutralFibre(const CLHEP::Hep3Vector &p, int fan_number) const
Calculates aproximate, probably underestimate, distance to the neutral fibre of the vertical fan.
Definition: LArWheelCalculatorGeometry.cxx:108
LArG4::OuterLeadWheel
@ OuterLeadWheel
Definition: LArWheelCalculatorEnums.h:20
LArWheelSliceSolid::m_f_vol
TF1 * m_f_vol
Definition: LArWheelSliceSolid.h:158
LArWheelSliceSolid::m_f_area_on_pc
TF1 * m_f_area_on_pc
Definition: LArWheelSliceSolid.h:158
jobOptions.prec
prec
Definition: jobOptions.Superchic_UPC_yyMuMu.py:20
LArWheelSliceSolid::LArWheelSliceSolid_fcn_vol
friend double LArWheelSliceSolid_fcn_vol(double *, double *)
Definition: LArWheelSliceSolidTests.cxx:540
LArWheelSliceSolid::m_FanHalfThickness
G4double m_FanHalfThickness
Definition: LArWheelSliceSolid.h:106
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition: AthMessaging.cxx:39
python.PhysicalConstants.halfpi
float halfpi
Definition: PhysicalConstants.py:51
LArG4::OuterAbsorberWheel
@ OuterAbsorberWheel
Definition: LArWheelCalculatorEnums.h:11
AthMessaging::m_msg_tls
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels)
Definition: AthMessaging.h:132
LArWheelSliceSolid::m_FHTminusT
G4double m_FHTminusT
Definition: LArWheelSliceSolid.h:106
beamspotnt.calc
calc
Definition: bin/beamspotnt.py:1252
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
LArG4::InnerElectrodWheel
@ InnerElectrodWheel
Definition: LArWheelCalculatorEnums.h:12
mag
Scalar mag() const
mag method
Definition: AmgMatrixBasePlugin.h:26
LArWheelSliceSolid::m_f_side_area
TF1 * m_f_side_area
Definition: LArWheelSliceSolid.h:158
LArWheelSliceSolid::get_area_on_polycone
G4double get_area_on_polycone(void) const
Definition: LArWheelSliceSolidTests.cxx:329
LArWheelSliceSolid::Absorber
@ Absorber
Definition: LArWheelSliceSolid.h:49
LArWheelSliceSolid::Inside
EInside Inside(const G4ThreeVector &) const
Definition: LArWheelSliceSolid.cxx:15
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
LArG4::LArWheelCalculator_t
LArWheelCalculator_t
Definition: LArWheelCalculatorEnums.h:10
LArWheelSliceSolid::fill_zsect
void fill_zsect(std::vector< G4double > &, G4double zMid=0.) const
Definition: LArWheelSliceSolidInit.cxx:263
Generated on Thu Nov 7 2024 21:50:37 for ATLAS Offline Software by   doxygen 1.8.18