ATLAS Offline Software
TileGeoSectionBuilder.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "TileGeoSectionBuilder.h"
6 #include "TileDetDescr/TileDetDescrManager.h"
7 #include "TileDetDescr/TileDddbManager.h"
8 #include "TileDetDescr/TileDetDescriptor.h"
9 #include "TileDetDescr/TileCellDim.h"
10 
11 #include "GeoModelKernel/GeoPcon.h"
12 #include "GeoModelKernel/GeoTubs.h"
13 #include "GeoModelKernel/GeoTube.h"
14 #include "GeoModelKernel/GeoTrd.h"
15 #include "GeoModelKernel/GeoTrap.h"
16 #include "GeoModelKernel/GeoBox.h"
17 #include "GeoModelKernel/GeoMaterial.h"
18 #include "GeoModelKernel/GeoLogVol.h"
19 #include "GeoModelKernel/GeoPhysVol.h"
20 #include "GeoModelKernel/GeoNameTag.h"
21 #include "GeoModelKernel/GeoTransform.h"
22 #include "GeoModelKernel/GeoSerialIdentifier.h"
23 #include "GeoModelKernel/GeoIdentifierTag.h"
24 #include "GeoModelKernel/GeoDefinitions.h"
25 #include "GeoModelKernel/Units.h"
26 
27 #include "GeoModelKernel/GeoShapeUnion.h"
28 #include "GeoModelKernel/GeoShapeShift.h"
29 #include "GeoModelKernel/GeoShapeSubtraction.h"
30 #include "GeoModelKernel/GeoCutVolAction.h"
31 
32 #include "GeoGenericFunctions/AbsFunction.h"
33 #include "GeoGenericFunctions/Variable.h"
34 #include "GeoModelKernel/GeoXF.h"
35 #include "GeoModelKernel/GeoSerialTransformer.h"
36 #include "GeoModelInterfaces/StoredMaterialManager.h"
37 
38 #include "GaudiKernel/MsgStream.h"
39 #include "GaudiKernel/SystemOfUnits.h"
40 
41 #include "boost/io/ios_state.hpp"
42 #include <iostream>
43 
44 #include <assert.h>
45 
46 #define MLOG(x) if (m_log->level()<=MSG::x) *m_log << MSG::x
47 
48 using namespace GeoGenfun;
49 using namespace GeoXF;
50 
51 
52 TileGeoSectionBuilder::TileGeoSectionBuilder(StoredMaterialManager* matManager,
53  TileDddbManager * pDbManager,
54  const TileSwitches & switches,
55  MsgStream * log)
56  : m_theMaterialManager(matManager)
57  , m_dbManager(pDbManager)
58  , m_log(log)
59  , m_switches(switches)
60  , m_barrelPeriodThickness(0.)
61  , m_barrelGlue(0.)
62  , m_extendedPeriodThickness(0.)
63  , m_verbose(log->level()<=MSG::VERBOSE)
64  , m_matLArServices(0)
65  , m_matIronHalfDens(0)
66  , m_additionalIronLayer(0.027)
67 {
68 }
69 
70 
71 TileGeoSectionBuilder::~TileGeoSectionBuilder() = default;
72 
73 
74 void TileGeoSectionBuilder::fillSection(PVLink& mother,
75  int sec_number,
76  double tile_rmax,
77  double rminb,
78  double dzglue,
79  double delta_phi,
80  int ModuleNcp,
81  double zlen_itc2,
82  bool neg)
83 {
84  (*m_log) << MSG::DEBUG <<" TileGeoSectionBuilder::fillSection ModuleNcp= "<<ModuleNcp<< endmsg;
85 
86  double tan_delta_phi_2 = std::tan(delta_phi/2*Gaudi::Units::deg);
87 
88  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
89  // Obtain required materials - Air and Iron
90 
91  const GeoMaterial* matAir = m_theMaterialManager->getMaterial("std::Air");
92  const GeoMaterial* matIron = (m_switches.steel) ? m_theMaterialManager->getMaterial("tile::Steel")
93  : m_theMaterialManager->getMaterial("std::Iron");
94  const GeoMaterial* matAluminium{nullptr};
95 
96  // -----------------------------------------------------------------------------------------------------------------
97  // Cut-outs
98  //static bool First =true;
99  double dX1 =0., dX2 =0., dY1 =0., dY2 =0., dZ1 =0., dZ2 =0.;
100  std::string volname ="";
101 
102  // Cuting positioning
103  float PosXcut =0., PosYcut =0., PosY =0., Rmore =0.;
104  float Radius =0., YcorA =0., YcorB =0., lenPla =0., Blia =0.;
105 
106  // General rotation and transformations
107  float phi = (double(ModuleNcp-1) + 0.5)*delta_phi;
108 
109  // Special module flag
110  int SideFl = 1;
111  if (ModuleNcp>=35 && ModuleNcp<=37) SideFl = -1;
112 
113  GeoTrf::Transform3D TransCut2(GeoTrf::Transform3D::Identity());
114  GeoTrf::Transform3D TransCutL(GeoTrf::Transform3D::Identity());
115  GeoTrf::Transform3D TransCutR(GeoTrf::Transform3D::Identity());
116 
117  GeoIntrusivePtr<const GeoShapeUnion> CutA{nullptr};
118  GeoIntrusivePtr<GeoShape> CutB{nullptr};
119 
120  // ext. barrel Cuts description
121  if (sec_number==2 && m_dbManager->BoolCuts() && ((ModuleNcp>=35 && ModuleNcp<=37) || (ModuleNcp>=60 && ModuleNcp<=62))) {
122  volname = "CutB"; m_dbManager->SetCurrentCuts(volname);
123  PosXcut = m_dbManager->CutsXpos();
124  PosYcut = m_dbManager->CutsYpos();
125  Rmore = 0.8*Gaudi::Units::cm;
126 
127  // Inert materials, CutB1
128  dX1 = m_dbManager->CutsDX1()+Rmore;
129  dX2 = m_dbManager->CutsDX2()+Rmore;
130  dY1 = m_dbManager->CutsDY1()+Rmore;
131  dY2 = m_dbManager->CutsDY2()+Rmore;
132  dZ1 = m_dbManager->CutsDZ1();
133 
134  checking("CutB1", false, 1, dX1,dX2,dY1,dY2,dZ1);
135  GeoTrd* CutB1 = new GeoTrd(dX1,dX2,dY1,dY2,dZ1);
136  //const GeoShape& CutB = *CutB1;
137  CutB = CutB1;
138 
139  // Materials are in cuting region, 1up Iron plate
140  volname = "Cut1up"; m_dbManager->SetCurrentCuts(volname); //>>
141  PosY = m_dbManager->CutsYpos();
142 
143  dX1 = m_dbManager->CutsDX1()+Rmore;
144  dX2 = m_dbManager->CutsDX2()+Rmore;
145  dY1 = m_dbManager->CutsDY1();
146  dY2 = m_dbManager->CutsDY2();
147  dZ1 = m_dbManager->CutsDZ1();
148 
149  checking("Cut1up", false, 1, dX1,dX2,dY1,dY2,dZ1);
150  GeoTrd* Cut1up = new GeoTrd(dX1,dX2,dY1,dY2,dZ1);
151 
152  volname = "Cut2down"; m_dbManager->SetCurrentCuts(volname); //>>
153  dX1 = m_dbManager->CutsDX1()+Rmore;
154  dX2 = m_dbManager->CutsDX2()+Rmore;
155  dY1 = m_dbManager->CutsDY1();
156  dY2 = m_dbManager->CutsDY2();
157  dZ2 = m_dbManager->CutsDZ1();
158 
159  checking("Cut2down", false, 1, dX1,dX2,dY1,dY2,dZ2);
160  GeoTrd* Cut1down = new GeoTrd(dX1,dX2,dY1,dY2,dZ2);
161 
162  GeoTrf::Translate3D yPosA(0.,0.,-dZ1-dZ2);
163 
164  const GeoShapeUnion& CutA1 = Cut1up->add(*Cut1down<<yPosA);
165  CutA = &CutA1;
166 
167  Radius = (m_dbManager->TILBrmaximal() + m_dbManager->TILBrminimal())/2 * Gaudi::Units::cm;
168 
169  if (ModuleNcp==35||ModuleNcp==62) { YcorA = 5*Gaudi::Units::cm; YcorB = 5*Gaudi::Units::cm; lenPla =0.8*Gaudi::Units::cm, Blia = 17.4*Gaudi::Units::cm;}
170  if (ModuleNcp==36||ModuleNcp==61) { YcorA = 6.5*Gaudi::Units::cm; YcorB = 6*Gaudi::Units::cm; lenPla =1.7*Gaudi::Units::cm; Blia = 16.9*Gaudi::Units::cm;}
171  if (ModuleNcp==37||ModuleNcp==60) { YcorA = 8*Gaudi::Units::cm; YcorB = 9*Gaudi::Units::cm; lenPla =2.8*Gaudi::Units::cm; Blia = 16.4*Gaudi::Units::cm;}
172 
173  TransCut2 = GeoTrf::TranslateZ3D(-Radius)
174  * GeoTrf::RotateX3D((90-phi)*Gaudi::Units::deg) * GeoTrf::RotateY3D(180*Gaudi::Units::deg)
175  * GeoTrf::Translate3D(0.1*Gaudi::Units::cm,SideFl*17.5*Gaudi::Units::cm,-PosY+YcorA);
176 
177  // For modules on the side C apply extra transformation
178  // which implements ReflectZ(0)
179  if (neg) {
180  GeoTrf::Vector3D ptTmp = TransCut2*GeoTrf::Vector3D(0.,0.,0.);
181  TransCut2 = GeoTrf::TranslateX3D(2*ptTmp.x())*GeoTrf::RotateZ3D(180*Gaudi::Units::deg)*TransCut2;
182  }
183 
184  if (ModuleNcp>=60 && ModuleNcp<=62) {
185  TransCutL = GeoTrf::TranslateZ3D(-Radius)
186  * GeoTrf::RotateY3D(180*Gaudi::Units::deg) * GeoTrf::RotateX3D(phi*Gaudi::Units::deg)
187  * GeoTrf::Translate3D(-1.4*Gaudi::Units::cm,PosYcut+YcorB,-PosXcut-Blia);
188 
189  // ReflectZ for C side
190  if (neg) {
191  GeoTrf::Vector3D ptTmp = TransCutL*GeoTrf::Vector3D(0.,0.,0.);
192  TransCutL = GeoTrf::TranslateX3D(2*ptTmp.x())*GeoTrf::RotateZ3D(180*Gaudi::Units::deg)*TransCutL;
193  }
194 
195  } else if (ModuleNcp>=35 && ModuleNcp<=37) {
196  TransCutR = GeoTrf::TranslateZ3D(-Radius)
197  * GeoTrf::RotateY3D(180*Gaudi::Units::deg) * GeoTrf::RotateX3D(phi*Gaudi::Units::deg)
198  * GeoTrf::Translate3D(-1.4*Gaudi::Units::cm,PosYcut+YcorB,PosXcut+Blia)
199  * GeoTrf::RotateY3D(180*Gaudi::Units::deg);
200  // ReflectZ for C side
201  if (neg) {
202  GeoTrf::Vector3D ptTmp = TransCutR*GeoTrf::Vector3D(0.,0.,0.);
203  TransCutR = GeoTrf::TranslateX3D(2*ptTmp.x())*GeoTrf::RotateZ3D(180*Gaudi::Units::deg)*TransCutR;
204  }
205  }
206 
207  if (m_log->level()<=MSG::DEBUG)
208  (*m_log) << MSG::DEBUG <<" _fillSection: CutA and CutB Ok"<< endmsg;
209  } // end if, BoolCuts
210 
211  //---------------------Girder-----------------------------------------
212 
213  int Id4 = m_dbManager->GetModType()%100;
214  double thicknessGirderMother = 0.0;
215  double specialModuleZShift = 0.0;
216 
217  if (m_dbManager->TILBngirder() > 0) {
218  // Mother volume for girder
219  thicknessGirderMother = (m_dbManager->TILBdzmodul() - m_dbManager->TILBdzend() - m_dbManager->TILBdzend2())*Gaudi::Units::cm;
220  // special module with special girder
221  if ((Id4 == 7) && (sec_number == 3))
222  thicknessGirderMother = (m_dbManager->TILBdzgir() - m_dbManager->TILBdzend() - m_dbManager->TILBdzend2())*Gaudi::Units::cm;
223 
224  double heightGirderMother = (tile_rmax - m_dbManager->TILBrmax())*Gaudi::Units::cm;
225  double dy1GirderMother = m_dbManager->TILBrmax() * tan_delta_phi_2 * Gaudi::Units::cm;
226  double dy2GirderMother = tile_rmax * tan_delta_phi_2 * Gaudi::Units::cm;
227  // ps test the TILB DZGIR
228  // std::cout <<"\t\t PS Girder Module = "<<ModuleNcp<< std::endl;
229  // std::cout <<"\t\t PS thicknessGirderMother = "<<thicknessGirderMother<< std::endl;
230  //ps account for special ITC modules 14,15,18,19
231  if ((Id4 == 7) && (sec_number == 3)) {
232  specialModuleZShift = 0.5*Gaudi::Units::cm*(m_dbManager->TILBdzgir() - m_dbManager->TILBdzmodul());
233  }
234  //
235  checking("GirderMother", false, 3,
236  thicknessGirderMother/2,thicknessGirderMother/2,dy1GirderMother,dy2GirderMother,heightGirderMother/2);
237 
238  GeoTrd* girderMother = new GeoTrd(thicknessGirderMother/2,
239  thicknessGirderMother/2,
240  dy1GirderMother,
241  dy2GirderMother,
242  heightGirderMother/2);
243 
244  GeoLogVol* lvGirderMother = new GeoLogVol("GirderMother",girderMother,matAir);
245  PVLink pvGirderMother = new GeoPhysVol(lvGirderMother);
246 
247  fillGirder(pvGirderMother,
248  tile_rmax,
249  m_dbManager->TILBrmax(),
250  tan_delta_phi_2,
251  thicknessGirderMother*(1./Gaudi::Units::cm));
252 
253  GeoTransform* tfGirderMother{nullptr};
254 
255  if (sec_number==3)
256  tfGirderMother = new GeoTransform(GeoTrf::Translate3D((m_dbManager->TILBdzend()-m_dbManager->TILBdzend2())*Gaudi::Units::cm/2, 0.,
257  (m_dbManager->TILBrmax()-m_dbManager->TILBrmin())*Gaudi::Units::cm/2));
258  else
259  tfGirderMother = new GeoTransform(GeoTrf::Translate3D((m_dbManager->TILBdzend()-m_dbManager->TILBdzend2())*Gaudi::Units::cm/2, 0.,
260  (m_dbManager->TILBrmax()-rminb)*Gaudi::Units::cm/2));
261 
262  mother->add(tfGirderMother);
263  mother->add(pvGirderMother);
264 
265  if (m_log->level()<=MSG::DEBUG)
266  (*m_log) << MSG::DEBUG <<" _fillSection: GirderMother Ok "<< endmsg;
267 
268  } // End Girder
269 
270  //--------------------Front Plate-------------------------------------
271  double thicknessFrontPlate, heightFrontPlate, dy1FrontPlate, dy2FrontPlate;
272  double rless =.150; // 150 [mkm]
273  int NbPeriod =0;
274 
275  if (m_dbManager->TILBdrfront() > 0) {
276  if (sec_number==3) {
277  //ITC coverplate
278  thicknessFrontPlate = (m_dbManager->TILBdzmodul() - zlen_itc2)*Gaudi::Units::cm;
279 
280  if (thicknessFrontPlate > rless) {
281  heightFrontPlate = m_dbManager->TILBdrfront()*Gaudi::Units::cm;
282  dy1FrontPlate = (rminb*tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
283  dy2FrontPlate = (m_dbManager->TILBrmin()*tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
284 
285  if (m_log->level()<=MSG::DEBUG)
286  (*m_log) << MSG::DEBUG <<" FrontPlateSh dX1,dX2= "<<thicknessFrontPlate/2<<", "<<thicknessFrontPlate/2
287  <<" dY1,dY2= "<<dy1FrontPlate<<" "<<dy2FrontPlate<<" dZ= "<<heightFrontPlate/2
288  << endmsg;
289 
290  GeoTrd* frontPlateSh = new GeoTrd(thicknessFrontPlate/2,
291  thicknessFrontPlate/2,
292  dy1FrontPlate,
293  dy2FrontPlate,
294  heightFrontPlate/2);
295 
296  GeoLogVol* lvFrontPlateSh = new GeoLogVol("FrontPlateSh",frontPlateSh,matIron);
297  PVLink pvFrontPlateSh = new GeoPhysVol(lvFrontPlateSh);
298  GeoTransform* tfFrontPlateSh = new GeoTransform(GeoTrf::Translate3D(
299  -m_dbManager->TILBdzmodul()/2*Gaudi::Units::cm+thicknessFrontPlate/2, 0.,
300  (rminb - tile_rmax)/2*Gaudi::Units::cm));
301 
302  mother->add(tfFrontPlateSh);
303  mother->add(pvFrontPlateSh);
304 
305  } else {
306  if (m_log->level()<=MSG::DEBUG)
307  (*m_log) << MSG::DEBUG <<" FrontPlateSh was lost "<< endmsg;
308  }
309 
310  } else if (sec_number==2 && (m_dbManager->BoolCuts() &&
311  ((ModuleNcp>=35 && ModuleNcp<=37)||(ModuleNcp>=60 && ModuleNcp<=62)) )) {
312 
313  std::string volname ="";
314  double dXCutA = 0, dXCutB = 0;
315 
316  volname = "Cut1up"; m_dbManager->SetCurrentCuts(volname);
317  dXCutA = m_dbManager->CutsDX1();
318 
319  volname = "CutB"; m_dbManager->SetCurrentCuts(volname);
320  dXCutB = m_dbManager->CutsDX1();
321 
322  thicknessFrontPlate = (m_dbManager->TILBdzmodul() - m_dbManager->TILBdzend1() - m_dbManager->TILBdzend2())*Gaudi::Units::cm;
323  heightFrontPlate = m_dbManager->TILBdrfront()*Gaudi::Units::cm;
324  dy1FrontPlate = (rminb*tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
325  dy2FrontPlate = (m_dbManager->TILBrmin()*tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
326 
327  GeoTrd* frontPlate = new GeoTrd(thicknessFrontPlate/2 -(dXCutA+dXCutB),
328  thicknessFrontPlate/2 -(dXCutA+dXCutB),
329  dy1FrontPlate,
330  dy2FrontPlate,
331  heightFrontPlate/2);
332 
333  // Cuting of Plate
334  /*
335  GeoTrf::Transform3D TCu2 = GeoTrf::RotateX3D((90-phi)*Gaudi::Units::deg) * GeoTrf::RotateY3D(180*Gaudi::Units::deg)
336  * GeoTrf::Translate3D(thicknessFrontPlate/2-dXCutA,0,0);
337  GeoTransform* TCu = new GeoTransform(TCu2);
338 
339  const GeoShape &tmp_frontPlate = frontPlate->subtract((*CutA)<<TCu2);
340  .subtract((*CutB)<<TransCutL);
341  */
342 
343  GeoLogVol* lvFrontPlate = new GeoLogVol("FrontPlate",frontPlate,matIron);
344  PVLink pvFrontPlate = new GeoPhysVol(lvFrontPlate);
345  GeoTransform* tfFrontPlate = new GeoTransform(GeoTrf::Translate3D(
346  (m_dbManager->TILBdzend1() - m_dbManager->TILBdzend2())/2*Gaudi::Units::cm+ dXCutB, 0.,
347  (m_dbManager->TILBrmin()-m_dbManager->TILBdrfront()/2-(tile_rmax + rminb)/2)*Gaudi::Units::cm));
348 
349  mother->add(tfFrontPlate);
350  mother->add(pvFrontPlate);
351 
352  if (m_log->level()<=MSG::DEBUG)
353  (*m_log) << MSG::DEBUG<<" _fillSection: FrontPlate Cut Ok "<< endmsg;
354 
355  } else {
356  //Ordinary frontplate
357  thicknessFrontPlate = (m_dbManager->TILBdzmodul() - m_dbManager->TILBdzend1() - m_dbManager->TILBdzend2())*Gaudi::Units::cm;
358  heightFrontPlate = m_dbManager->TILBdrfront()*Gaudi::Units::cm;
359  dy1FrontPlate = (rminb*tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
360  dy2FrontPlate = (m_dbManager->TILBrmin()*tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
361 
362  GeoTrd* frontPlate = new GeoTrd(thicknessFrontPlate/2,
363  thicknessFrontPlate/2,
364  dy1FrontPlate,
365  dy2FrontPlate,
366  heightFrontPlate/2);
367 
368  GeoLogVol* lvFrontPlate = new GeoLogVol("FrontPlate",frontPlate,matIron);
369  PVLink pvFrontPlate = new GeoPhysVol(lvFrontPlate);
370  GeoTransform* tfFrontPlate = new GeoTransform(GeoTrf::Translate3D(
371  (m_dbManager->TILBdzend1() - m_dbManager->TILBdzend2())/2*Gaudi::Units::cm, 0.,
372  (m_dbManager->TILBrmin()-m_dbManager->TILBdrfront()/2-(tile_rmax + rminb)/2)*Gaudi::Units::cm));
373 
374  mother->add(tfFrontPlate);
375  mother->add(pvFrontPlate);
376  }
377  } // End Front Plate
378 
379  //--------------------End Plates--------------------------------------
380  double dy1EndPlate, dy2EndPlate, thicknessEndPlate, heightEndPlate;
381 
382  //VARIABLES FOR END PLATE HOLE
383  double heightEPHole = m_dbManager->TILBflangex()*Gaudi::Units::cm;
384  double dyEPHole = m_dbManager->TILBflangex()*Gaudi::Units::cm/2;
385 
386  // ps . shifts for end plates in cutout regions
387  GeoTrf::Transform3D cutOutTransformation(GeoTrf::Transform3D::Identity());
388  //first endplate
389  GeoIntrusivePtr<GeoTransform> tfEndPlateSh{nullptr};
390 
391  if (m_dbManager->TILBdzend1() > 0) {
392  if (m_dbManager->TILBdzend() < m_dbManager->TILBdzend1()) {
393 
394  //Short endplate
395  dy1EndPlate = rminb * tan_delta_phi_2 * Gaudi::Units::cm;
396  dy2EndPlate = m_dbManager->TILBrmax() * tan_delta_phi_2 * Gaudi::Units::cm;
397  thicknessEndPlate = m_dbManager->TILBdzend1() * Gaudi::Units::cm;
398  heightEndPlate = (m_dbManager->TILBrmax() - rminb) * Gaudi::Units::cm;
399  //
400  // creating standart endplate. It is the same for
401  // both standard mosules and modules with cuts
402  //
403  GeoTrd* endPlateSh = new GeoTrd(thicknessEndPlate/2,
404  thicknessEndPlate/2,
405  dy1EndPlate,
406  dy2EndPlate,
407  heightEndPlate/2);
408  GeoLogVol* lvEndPlateSh{nullptr};
409 
410  // if ( sec_number==2 && ( (ModuleNcp==37)||( ModuleNcp==60) ) )
411  if (sec_number==2 && ((ModuleNcp>=35 && ModuleNcp<=37)||(ModuleNcp>=60 && ModuleNcp<=62)) ) { // Short endplate Cut-outs
412 
413  //
414  // shape for the cutted part
415  //
416  GeoTrd* endPlateShCut = new GeoTrd(thicknessEndPlate,
417  thicknessEndPlate,
418  heightEndPlate/2.,
419  heightEndPlate/2.,
420  dy2EndPlate);
421 
422 
423  double rotationAngle ;
424  double shiftCutPlate ;
425  int rotationSign = 1;
426  if (ModuleNcp > 50) rotationSign *= -1;
427  if ( neg ) rotationSign *= -1;
428 
429 
430  if ( ( ModuleNcp == 37 ) || ( ModuleNcp == 60 ) ) {
431  rotationAngle = (180.0 - 25.3125 )* Gaudi::Units::deg ; // ATLLEMS_0003 0004
432  shiftCutPlate = 38.7 * Gaudi::Units::mm;
433 
434  cutOutTransformation =
435  GeoTrf::Translate3D(0,0, -heightEndPlate/2.) *
436  GeoTrf::RotateX3D( 90 * Gaudi::Units::deg ) *
437  GeoTrf::Translate3D(0.,0., -rotationSign * (dy2EndPlate + shiftCutPlate ) ) *
438  GeoTrf::RotateX3D( rotationSign * rotationAngle ) ;
439 
440  const GeoShape & endPlateShCutted3760 = (endPlateSh->subtract( (*endPlateShCut)<< cutOutTransformation ) ) ;
441  lvEndPlateSh = new GeoLogVol("EndPlateSh", &(endPlateShCutted3760) , matIron);
442 
443  } else if ( ( ModuleNcp == 36 ) || ( ModuleNcp == 61 ) ) {
444  rotationAngle = - ( 116.4832 - 90. )* Gaudi::Units::deg ; // ATLLEMS_0005 0006
445  shiftCutPlate = ( ( m_dbManager->TILBrmax() - rminb )*Gaudi::Units::cm - 1448.4 * Gaudi::Units::mm);
446 
447  cutOutTransformation =
448  GeoTrf::Translate3D( 0, 0, -heightEndPlate/2. ) *
449  GeoTrf::Translate3D( 0, 0, - (dy2EndPlate - shiftCutPlate + 0.5*dy2EndPlate*(1.- std::cos(rotationAngle*Gaudi::Units::rad))) ) *
450  GeoTrf::RotateX3D( rotationSign * rotationAngle ) ;
451 
452  const GeoShape & endPlateShCutted3661 = (endPlateSh->subtract( (*endPlateShCut)<< cutOutTransformation ) ) ;
453  lvEndPlateSh = new GeoLogVol("EndPlateSh", &(endPlateShCutted3661) , matIron);
454 
455  } else if ( ( ModuleNcp == 35 ) || ( ModuleNcp == 62 ) ) {
456  rotationAngle = - ( 104.0625 - 90.0 )* Gaudi::Units::deg ; // ATLLEMS_0007 0008
457  shiftCutPlate = ( ( m_dbManager->TILBrmax() - rminb )*Gaudi::Units::cm - 1534.6 * Gaudi::Units::mm);
458 
459  cutOutTransformation =
460  GeoTrf::Translate3D( 0, 0, -heightEndPlate/2. ) *
461  GeoTrf::Translate3D( 0, 0, - (dy2EndPlate - shiftCutPlate) ) *
462  GeoTrf::RotateX3D( rotationSign * rotationAngle ) ;
463 
464  const GeoShape & endPlateShCutted3562 = (endPlateSh->subtract( (*endPlateShCut)<< cutOutTransformation ) ) ;
465  lvEndPlateSh = new GeoLogVol("EndPlateSh", &(endPlateShCutted3562) , matIron);
466 
467  } else {
468  //coverity[DEADCODE]
469  // logically cannot reach here --- but leave in place to guard
470  // against future changes.
471  (*m_log) << MSG::ERROR <<" TileGeoSectionBuilder::fillSection . Wrong Module in cut-out region. ModuleNcp= "<<ModuleNcp<< endmsg;
472  lvEndPlateSh = new GeoLogVol("EndPlateSh", endPlateSh , matIron);
473  }
474 
475  } else {
476  lvEndPlateSh = new GeoLogVol("EndPlateSh", endPlateSh , matIron);
477  }
478 
479 
480 
481 
482  // const GeoShape & endPlateShFinal = (endPlateSh->subtract( (*CutB)<<TransCutL ) );
483  //subtract((*CutB)<<TransCutL);
484 
485  PVLink pvEndPlateSh = new GeoPhysVol(lvEndPlateSh);
486 
487  tfEndPlateSh = new GeoTransform(GeoTrf::Translate3D(
488  specialModuleZShift +
489  (m_dbManager->TILBdzend1() - m_dbManager->TILBdzmodul())*Gaudi::Units::cm/2, 0.,
490  (m_dbManager->TILBrmax() - tile_rmax)*Gaudi::Units::cm/2));
491 
492  mother->add(tfEndPlateSh);
493  mother->add(pvEndPlateSh);
494 
495  if (m_log->level()<=MSG::DEBUG)
496  (*m_log) << MSG::DEBUG <<" _fillSection: ext.barrel EndPlateSh Ok "<< endmsg;
497 
498  } else {
499  //Ordinary endplate
500  dy1EndPlate = rminb * tan_delta_phi_2 * Gaudi::Units::cm;
501  dy2EndPlate = tile_rmax * tan_delta_phi_2 * Gaudi::Units::cm;
502  thicknessEndPlate = m_dbManager->TILBdzend1() * Gaudi::Units::cm;
503  heightEndPlate = (tile_rmax-rminb)*Gaudi::Units::cm;
504 
505  GeoTrd* endPlate1 = new GeoTrd(thicknessEndPlate/2,
506  thicknessEndPlate/2,
507  dy1EndPlate,
508  dy2EndPlate,
509  heightEndPlate/2);
510 
511  GeoLogVol* lvEndPlate1 = new GeoLogVol("EndPlate1",endPlate1,matIron);
512  PVLink pvEndPlate1 = new GeoPhysVol(lvEndPlate1);
513 
514  //Position air hole
515  if (m_dbManager->TILBflangex() > 0.) {
516  GeoTrd* epHole1 = new GeoTrd (thicknessEndPlate/2,
517  thicknessEndPlate/2,
518  dyEPHole,
519  dyEPHole,
520  heightEPHole/2);
521 
522  GeoLogVol* lvEPHole1 = new GeoLogVol("EPHole1",epHole1,matAir);
523  PVLink pvEPHole1 = new GeoPhysVol(lvEPHole1);
524  GeoTransform* tfEPHole1 = new GeoTransform(GeoTrf::Translate3D(0.,0.,
525  (m_dbManager->TILBflangey()-(tile_rmax + rminb)/2)*Gaudi::Units::cm));
526  pvEndPlate1->add(tfEPHole1);
527  pvEndPlate1->add(pvEPHole1);
528  }
529 
530  GeoTransform* tfEndPlate1 = new GeoTransform(GeoTrf::Translate3D(
531  (m_dbManager->TILBdzend1() - m_dbManager->TILBdzmodul())*Gaudi::Units::cm/2, 0., 0.));
532  mother->add(tfEndPlate1);
533  mother->add(pvEndPlate1);
534 
535  if (m_log->level()<=MSG::DEBUG)
536  (*m_log) << MSG::DEBUG <<" _fillSection: Ordinary EndPlateSh Ok "<< endmsg;
537  }
538  }
539 
540  //second endplate
541  GeoIntrusivePtr<GeoTransform> tfEndPlate2{nullptr};
542 
543  if (m_dbManager->TILBdzend2() > 0) {
544  //Short endplate Cut-outs
545  double radShift =lenPla;
546  double rminbT=rminb + radShift;
547 
548  dy1EndPlate = rminb * tan_delta_phi_2 * Gaudi::Units::cm;
549  dy2EndPlate = tile_rmax * tan_delta_phi_2 * Gaudi::Units::cm;
550  thicknessEndPlate = m_dbManager->TILBdzend2() * Gaudi::Units::cm;
551  heightEndPlate = (tile_rmax-rminb) * Gaudi::Units::cm;
552 
553 
554  GeoLogVol* lvEndPlate2{nullptr};
555  GeoTrd* endPlate2 = new GeoTrd(thicknessEndPlate/2,
556  thicknessEndPlate/2,
557  dy1EndPlate,
558  dy2EndPlate,
559  heightEndPlate/2);
560 
561  tfEndPlate2 = new GeoTransform(GeoTrf::Translate3D(
562  (-m_dbManager->TILBdzend2() + m_dbManager->TILBdzmodul())*Gaudi::Units::cm/2, 0., 0.));
563 
564  if (sec_number==2 && ((ModuleNcp>=35 && ModuleNcp<=37)||(ModuleNcp>=60 && ModuleNcp<=62)) ) { // Short endplate Cut-outs
565 
566  GeoTrd* endPlate2Cut = new GeoTrd(thicknessEndPlate,
567  thicknessEndPlate,
568  heightEndPlate/2.,
569  heightEndPlate/2.,
570  dy2EndPlate);
571  double rotationAngle ;
572  double shiftCutPlate ;
573  int rotationSign = 1;
574  if (ModuleNcp > 50) rotationSign *= -1;
575  if ( neg ) rotationSign *= -1;
576 
577  if ( ( ModuleNcp == 37 ) || ( ModuleNcp == 60 ) ) {
578  rotationAngle = - ( 115.3125 - 90.0 )* Gaudi::Units::deg ; // ATLLEMS_0011 0012
579  shiftCutPlate = ( ( m_dbManager->TILBrmax() - rminb )*Gaudi::Units::cm - 1364.0 * Gaudi::Units::mm);
580 
581  cutOutTransformation =
582  GeoTrf::Translate3D( 0, 0, -heightEndPlate/2. ) *
583  GeoTrf::Translate3D( 0, 0, - (dy2EndPlate - shiftCutPlate) ) *
584  GeoTrf::RotateX3D( rotationSign * rotationAngle ) ;
585 
586  const GeoShape & endPlate2Cutted3760 = (endPlate2->subtract( (*endPlate2Cut)<< cutOutTransformation ) ) ;
587  lvEndPlate2 = new GeoLogVol("EndPlate2", &(endPlate2Cutted3760) , matIron);
588 
589  } else if ( ( ModuleNcp == 36 ) || ( ModuleNcp == 61 ) ) {
590  rotationAngle = - ( 109.6875 - 90.0 )* Gaudi::Units::deg ; // ATLLEMS_0009 0010
591  shiftCutPlate = ( ( m_dbManager->TILBrmax() - rminb )*Gaudi::Units::cm - 1464.0 * Gaudi::Units::mm);
592 
593  cutOutTransformation =
594  GeoTrf::Translate3D( 0, 0, -heightEndPlate/2. ) *
595  GeoTrf::Translate3D( 0, 0, - (dy2EndPlate - shiftCutPlate) ) *
596  GeoTrf::RotateX3D( rotationSign * rotationAngle ) ;
597 
598  const GeoShape & endPlate2Cutted3661 = (endPlate2->subtract( (*endPlate2Cut)<< cutOutTransformation ) ) ;
599  lvEndPlate2 = new GeoLogVol("EndPlate2", &(endPlate2Cutted3661) , matIron);
600 
601  } else if ( ( ModuleNcp == 35 ) || ( ModuleNcp == 62 ) ) {
602  rotationAngle = - ( 104.0625 - 90.0 )* Gaudi::Units::deg ; // ATLLEMS_0009 0010
603  shiftCutPlate = ( ( m_dbManager->TILBrmax() - rminb )*Gaudi::Units::cm - ( 1915.0 -385.0 )* Gaudi::Units::mm); // girder is subtracted (no drawing)
604 
605  cutOutTransformation =
606  GeoTrf::Translate3D( 0, 0, -heightEndPlate/2. ) *
607  GeoTrf::Translate3D( 0, 0, - (dy2EndPlate - shiftCutPlate) ) *
608  GeoTrf::RotateX3D( rotationSign * rotationAngle ) ;
609 
610  const GeoShape & endPlate2Cutted3562 = (endPlate2->subtract( (*endPlate2Cut)<< cutOutTransformation ) ) ;
611  lvEndPlate2 = new GeoLogVol("EndPlate2", &(endPlate2Cutted3562) , matIron);
612  }
613 
614  // dy1EndPlate = rminbT * tan_delta_phi_2 * Gaudi::Units::cm;
615  // dy2EndPlate = tile_rmax * tan_delta_phi_2 * Gaudi::Units::cm;
616  // thicknessEndPlate = m_dbManager->TILBdzend2() * Gaudi::Units::cm;
617  // heightEndPlate = (tile_rmax - rminbT) * Gaudi::Units::cm;
618 
619  // tfEndPlate2 = new GeoTransform(GeoTrf::Translate3D(
620  // (-m_dbManager->TILBdzend2() + m_dbManager->TILBdzmodul())*Gaudi::Units::cm/2, 0, radShift/2*Gaudi::Units::cm));
621 
622  } else {
623  lvEndPlate2 = new GeoLogVol("EndPlate2",endPlate2,matIron);
624  }
625 
626  PVLink pvEndPlate2 = new GeoPhysVol(lvEndPlate2);
627 
628  //Position air hole
629  if (m_dbManager->TILBflangex() > 0) {
630  dyEPHole = m_dbManager->TILBflangex()*Gaudi::Units::cm/2;
631 
632  GeoTrd* epHole2 = new GeoTrd (thicknessEndPlate/2,
633  thicknessEndPlate/2,
634  dyEPHole,
635  dyEPHole,
636  heightEPHole/2);
637 
638  GeoLogVol* lvEPHole2 = new GeoLogVol("EPHole2",epHole2,matAir);
639  PVLink pvEPHole2 = new GeoPhysVol(lvEPHole2);
640  GeoTransform* tfEPHole2 = new GeoTransform(GeoTrf::Translate3D(0.,0.,
641  (m_dbManager->TILBflangey()-(tile_rmax + rminbT)/2)*Gaudi::Units::cm));
642  pvEndPlate2->add(tfEPHole2);
643  pvEndPlate2->add(pvEPHole2);
644  }
645 
646  mother->add(tfEndPlate2);
647  mother->add(pvEndPlate2);
648 
649  if (m_log->level()<=MSG::DEBUG)
650  (*m_log) << MSG::DEBUG <<" _fillSection: EndPlate2 Ok "<< endmsg;
651 
652  } // End Plates
653 
654  //---------------------------------------------------Absorber--------------------------------------------------------
655  double heightAbsorber = (m_dbManager->TILBrmax() - m_dbManager->TILBrmin())*Gaudi::Units::cm;
656  double thicknessAbsorber = (m_dbManager->TILBdzmodul() - m_dbManager->TILBdzend1() - m_dbManager->TILBdzend2())*Gaudi::Units::cm;
657  double dy1Absorber = (m_dbManager->TILBrmin()*tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
658  double dy2Absorber = (m_dbManager->TILBrmax()*tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
659 
660  checking("Absorber", true, 3,
661  thicknessAbsorber/2,thicknessAbsorber/2,dy1Absorber,dy2Absorber,heightAbsorber/2);
662 
663  //----------------------------- Absorber -------------------------------------------------------------------
664  double thicknessPeriod =0, thicknessAbsorber1 =0, thicknessAbsorber2 =0, thicknessAbsorber3 =0;
665  double PosAbsor1 =0, PosAbsor2 =0, PosAbsor3 =0;
666  int nA1 =32, nA2 = 0, nA3 =16;
667 
668  GeoTrd *absorber{nullptr}, *absorber1{nullptr}, *absorber3{nullptr};
669  GeoLogVol *lvAbsorber{nullptr}, *lvAbsorber1{nullptr}, *lvAbsorber3{nullptr};
670  PVLink pvAbsorber{nullptr}, pvAbsorber1{nullptr}, pvAbsorber3{nullptr},
671  pvTmp_Absorber1{nullptr}, pvTmp_Absorber3{nullptr};
672 
673  // Perform different actions depending on sections
674  switch (sec_number) {
675  case 2:
676  {
677  //Extended barrel - consists of ordinary periods of type 1 only
678  thicknessPeriod = 2.*(m_dbManager->TILBdzmast() + m_dbManager->TILBdzspac() + 2.*dzglue)*Gaudi::Units::cm;
679 
680  // The period number for middle absorber
681  nA2 = m_dbManager->TILBnperiod() - (nA1+nA3);
682 
683  thicknessAbsorber1 = nA1*thicknessPeriod;
684  PosAbsor1 = thicknessAbsorber/2 - thicknessAbsorber1/2;
685 
686  thicknessAbsorber2 = nA2*thicknessPeriod;
687  PosAbsor2 = thicknessAbsorber/2 - thicknessAbsorber1 - thicknessAbsorber2/2;
688 
689  thicknessAbsorber3 = nA3*thicknessPeriod;
690  PosAbsor3 = thicknessAbsorber/2 - thicknessAbsorber1 - thicknessAbsorber2 - thicknessAbsorber3/2;
691 
692  if (m_log->level()<=MSG::DEBUG)
693  (*m_log) << MSG::DEBUG <<" Number of periods per Module: N= "<<nA1+nA2+nA3
694  << " Middle absorber, numbers of periods = "<<nA2
695  << endmsg;
696 
697  // First Cut-out part
698  absorber1 = new GeoTrd(thicknessAbsorber1/2, thicknessAbsorber1/2,
699  dy1Absorber, dy2Absorber,
700  heightAbsorber/2);
701 
702  lvAbsorber1 = new GeoLogVol("Absorber",absorber1,matIron);
703  pvAbsorber1 = new GeoPhysVol(lvAbsorber1);
704 
705  // absorber without Cut-out, middle part
706  absorber = new GeoTrd(thicknessAbsorber2/2, thicknessAbsorber2/2,
707  dy1Absorber, dy2Absorber,
708  heightAbsorber/2);
709 
710  lvAbsorber = new GeoLogVol("Absorber",absorber,matIron);
711  pvAbsorber = new GeoPhysVol(lvAbsorber);
712 
713  //
714  // Second Cut-out part
715  absorber3 = new GeoTrd(thicknessAbsorber3/2, thicknessAbsorber3/2,
716  dy1Absorber, dy2Absorber,
717  heightAbsorber/2);
718 
719  lvAbsorber3 = new GeoLogVol("Absorber",absorber3,matIron);
720  pvAbsorber3 = new GeoPhysVol(lvAbsorber3);
721  //
722 
723  if (m_log->level()<=MSG::DEBUG)
724  (*m_log) << MSG::DEBUG <<" _fillSection: Ex.Barrel pvAbsorber 1,3 Ok "<< endmsg;
725 
726  break;
727  }
728  default:
729  {
730  absorber = new GeoTrd(thicknessAbsorber/2, thicknessAbsorber/2,
731  dy1Absorber, dy2Absorber,
732  heightAbsorber/2);
733 
734  if (m_dbManager->TILBnperiod() > 1) {
735  lvAbsorber = new GeoLogVol("Absorber",absorber,matIron);
736  } else {
737  // make C10special/Gap/Crack absorber volume from Air, Aluminium will be in period
738  lvAbsorber = new GeoLogVol("Absorber",absorber,matAir);
739  }
740  pvAbsorber = new GeoPhysVol(lvAbsorber);
741 
742  if (m_log->level()<=MSG::DEBUG) {
743  if (m_dbManager->TILBnperiod() > 1) {
744  (*m_log) << MSG::DEBUG <<" _fillSection: default pvAbsorber Ok "<< endmsg;
745  } else {
746  (*m_log) << MSG::DEBUG <<" _fillSection: special pvAbsorber made from Air Ok "<< endmsg;
747  }
748  }
749 
750  break;
751  }
752  }
753  //----- ------ ------- PERIODS ------ ------ ------ PERIODS ----- ------- -------
754  double thicknessAbsorberChild;
755  Variable periodInd;
756 
757  GeoTrd* period{nullptr};
758  GeoLogVol* lvPeriod{nullptr};
759  PVLink pvPeriod{nullptr};
760  GeoTransform* tfPeriod{nullptr};
761  GeoSerialTransformer* stPeriod{nullptr};
762 
763  GeoTrd* absorberChild{nullptr};
764  GeoLogVol* lvAbsorberChild{nullptr};
765  PVLink pvAbsorberChild{nullptr};
766  GeoTransform* tfAbsorberChild{nullptr};
767 
768  // Perform different actions depending on sections
769  switch (sec_number) {
770  case 1:
771  {
772  //Barrel section
773  //Divide absorber volume on two parts: first filled with
774  //nrOfPeriods-1 ordinary period and second with one special period of type 2
775 
776  //First division
777  thicknessPeriod = 2.*(m_dbManager->TILBdzmast() + m_dbManager->TILBdzspac() + 2.*dzglue)*Gaudi::Units::cm;
778  MLOG(DEBUG) << "BARREL Section -- m_dbManager->TILBdzmast(): " << m_dbManager->TILBdzmast() << ", m_dbManager->TILBdzspac(): " << m_dbManager->TILBdzspac()
779  << ", dzglue: " << dzglue << " ==> thicknessPeriod: " << thicknessPeriod << endmsg;
780 
781  m_barrelPeriodThickness = thicknessPeriod;
782  m_barrelGlue = dzglue*Gaudi::Units::cm;
783 
784  checking("Period 0", false, 4,
785  thicknessPeriod/2,thicknessPeriod/2,dy1Absorber,dy2Absorber,heightAbsorber/2);
786 
787  period = new GeoTrd(thicknessPeriod/2,
788  thicknessPeriod/2,
789  dy1Absorber,
790  dy2Absorber,
791  heightAbsorber/2);
792 
793  lvPeriod = new GeoLogVol("Period",period,matIron);
794  pvPeriod = new GeoPhysVol(lvPeriod);
795 
796  fillPeriod(pvPeriod,
797  thicknessPeriod*(1./Gaudi::Units::cm),
798  dzglue,
799  tan_delta_phi_2,
800  1); // 1-period type
801 
802 
803  thicknessAbsorberChild = thicknessPeriod*(m_dbManager->TILBnperiod()-1);
804  absorberChild = new GeoTrd(thicknessAbsorberChild/2,
805  thicknessAbsorberChild/2,
806  dy1Absorber,
807  dy2Absorber,
808  heightAbsorber/2);
809  lvAbsorberChild = new GeoLogVol("AbsorberChild",absorberChild,matAir);
810  pvAbsorberChild = new GeoPhysVol(lvAbsorberChild);
811 
812  // Place periods into Absorber Child like G4 replica
813  GENFUNCTION periodPos1 = (thicknessPeriod*(2*periodInd+1)-thicknessAbsorberChild)/2;
814  TRANSFUNCTION xfReplica1 = Pow(GeoTrf::TranslateX3D(1.),periodPos1);
815  if (m_verbose) checktransfunc(thicknessAbsorberChild,thicknessPeriod,m_dbManager->TILBnperiod()-1,
816  (thicknessAbsorberChild - thicknessAbsorber)/2);
817 
818  stPeriod = new GeoSerialTransformer(pvPeriod,
819  &xfReplica1,
820  m_dbManager->TILBnperiod()-1);
821 
822  pvAbsorberChild->add(new GeoSerialIdentifier(0));
823  pvAbsorberChild->add(stPeriod);
824 
825  // Place absorber child
826  tfAbsorberChild = new GeoTransform(GeoTrf::Translate3D((thicknessAbsorberChild - thicknessAbsorber)/2,0.,0.));
827  pvAbsorber->add(tfAbsorberChild);
828  pvAbsorber->add(pvAbsorberChild);
829 
830  //Second division
831  thicknessPeriod = (m_dbManager->TILBdzmast() + 2.*m_dbManager->TILBdzspac() + 2.*dzglue)*Gaudi::Units::cm;
832 
833  checking("Period 1", false, 4,
834  thicknessPeriod/2,thicknessPeriod/2,dy1Absorber,dy2Absorber,heightAbsorber/2);
835 
836  period = new GeoTrd(thicknessPeriod/2,
837  thicknessPeriod/2,
838  dy1Absorber,
839  dy2Absorber,
840  heightAbsorber/2);
841  lvPeriod = new GeoLogVol("Period",period,matIron);
842  pvPeriod = new GeoPhysVol(lvPeriod);
843 
844  fillPeriod(pvPeriod,
845  thicknessPeriod*(1./Gaudi::Units::cm),
846  dzglue,
847  tan_delta_phi_2,
848  2); // 2-period type
849 
850 
851  thicknessAbsorberChild = thicknessPeriod;
852  absorberChild = new GeoTrd(thicknessAbsorberChild/2,
853  thicknessAbsorberChild/2,
854  dy1Absorber,
855  dy2Absorber,
856  heightAbsorber/2);
857  lvAbsorberChild = new GeoLogVol("AbsorberChild",absorberChild,matAir);
858  pvAbsorberChild = new GeoPhysVol(lvAbsorberChild);
859 
860  if (m_verbose) checktransfunc(thicknessAbsorberChild,thicknessPeriod,1,
861  (-thicknessAbsorberChild + thicknessAbsorber)/2);
862 
863  // Place period in the absorber child
864  tfPeriod = new GeoTransform(GeoTrf::Translate3D(0.,0.,0.));
865 
866  pvAbsorberChild->add(new GeoIdentifierTag(m_dbManager->TILBnperiod()-1));
867  pvAbsorberChild->add(tfPeriod);
868  pvAbsorberChild->add(pvPeriod);
869 
870  // Place absorber child
871  tfAbsorberChild = new GeoTransform(GeoTrf::Translate3D((-thicknessAbsorberChild + thicknessAbsorber)/2,0.,0.));
872  pvAbsorber->add(tfAbsorberChild);
873  pvAbsorber->add(pvAbsorberChild);
874 
875  break;
876  }
877  case 2:
878  {
879  //Extended barrel - consists of ordinary periods of type 1 only
880  thicknessPeriod = 2. * (m_dbManager->TILBdzmast() + m_dbManager->TILBdzspac() + 2.*dzglue) * Gaudi::Units::cm;
881  MLOG(DEBUG) << "EXTENDED BARREL Section -- m_dbManager->TILBdzmast(): " << m_dbManager->TILBdzmast() << ", m_dbManager->TILBdzspac(): " << m_dbManager->TILBdzspac()
882  << ", dzglue: " << dzglue << " ==> thicknessPeriod: " << thicknessPeriod << endmsg;
883 
884  checking("Period 2", false, 4,
885  thicknessPeriod/2,thicknessPeriod/2,dy1Absorber,dy2Absorber,heightAbsorber/2);
886 
887  period = new GeoTrd(thicknessPeriod/2,
888  thicknessPeriod/2,
889  dy1Absorber,
890  dy2Absorber,
891  heightAbsorber/2);
892  lvPeriod = new GeoLogVol("Period",period,matIron);
893  pvPeriod = new GeoPhysVol(lvPeriod);
894 
895  m_extendedPeriodThickness = thicknessPeriod;
896 
897  fillPeriod(pvPeriod,
898  thicknessPeriod*(1./Gaudi::Units::cm),
899  dzglue,
900  tan_delta_phi_2,
901  1); // 1-period type
902 
903  // Place periods into Absorber like G4 replica
904  // - first partr of absorber
905  //
906  GENFUNCTION periodPos1 = (thicknessPeriod*(2*periodInd+1)-thicknessAbsorber1)/2;
907  TRANSFUNCTION xfReplica1 = Pow(GeoTrf::TranslateX3D(1.),periodPos1);
908  if (m_verbose) checktransfunc(thicknessAbsorber1,thicknessPeriod,nA1,
909  (-thicknessAbsorber+thicknessAbsorber1)/2.);
910 
911  stPeriod = new GeoSerialTransformer(pvPeriod,&xfReplica1,nA1); //m_dbManager->TILBnperiod());
912 
913  pvAbsorber1->add(new GeoSerialIdentifier(0));
914  pvAbsorber1->add(stPeriod);
915  //
916 
917  if (m_dbManager->BoolCuts()) {
918  if ((ModuleNcp>=35 && ModuleNcp<=37) || (ModuleNcp>=60 && ModuleNcp<=62)) {
919  // Cuting of (-)
920  GeoCutVolAction action1(*CutA, TransCut2);
921  pvAbsorber1->apply(&action1);
922  pvTmp_Absorber1 = action1.getPV();
923  //
924  if (m_log->level()<=MSG::DEBUG)
925  (*m_log) << MSG::DEBUG <<" _fillSection: CutA Ok "<< endmsg;
926  } // end special modules
927  } // end if, BoolCuts()
928  if (m_log->level()<=MSG::DEBUG)
929  (*m_log) << MSG::DEBUG <<" _fillSection: Absorber1 Ok "<< endmsg;
930 
931  // middle partr of absorber
932  GENFUNCTION periodPos2 = (thicknessPeriod*(2*periodInd+1)-thicknessAbsorber2)/2;
933  TRANSFUNCTION xfReplica2 = Pow(GeoTrf::TranslateX3D(1.),periodPos2);
934  if (m_verbose) checktransfunc(thicknessAbsorber2,thicknessPeriod,nA2,
935  (-thicknessAbsorber+thicknessAbsorber2)/2.+thicknessAbsorber1);
936 
937  stPeriod = new GeoSerialTransformer(pvPeriod,&xfReplica2,nA2); //m_dbManager->TILBnperiod());
938 
939  pvAbsorber->add(new GeoSerialIdentifier(nA1));
940  pvAbsorber->add(stPeriod);
941 
942  if (m_log->level()<=MSG::DEBUG)
943  (*m_log) << MSG::DEBUG <<" _fillSection: pvAbsorber Ok "<< endmsg;
944 
945  // second partr of absorber
946  //
947  GENFUNCTION periodPos3 = (thicknessPeriod*(2*periodInd+1)-thicknessAbsorber3)/2;
948  TRANSFUNCTION xfReplica3 = Pow(GeoTrf::TranslateX3D(1.),periodPos3);
949  if (m_verbose) checktransfunc(thicknessAbsorber3,thicknessPeriod,nA3,
950  (-thicknessAbsorber+thicknessAbsorber3)/2.+thicknessAbsorber2+thicknessAbsorber1);
951 
952  stPeriod = new GeoSerialTransformer(pvPeriod,&xfReplica3,nA3); //m_dbManager->TILBnperiod());
953 
954  pvAbsorber3->add(new GeoSerialIdentifier(nA1+nA2));
955  pvAbsorber3->add(stPeriod);
956 
957  if (m_dbManager->BoolCuts()) {
958  if (ModuleNcp>=60 && ModuleNcp<=62) {
959  // Cuting of pvEBarrelModuleMotherPos (Left)
960  //
961  GeoCutVolAction action2(*CutB, TransCutL);
962  pvAbsorber3->apply(&action2);
963  pvTmp_Absorber3 = action2.getPV();
964  if (m_log->level()<=MSG::DEBUG)
965  (*m_log) << MSG::DEBUG <<" _fillSection: CutB L Ok "<< endmsg;
966 
967  } else if (ModuleNcp>=35 && ModuleNcp<=37) {
968  // Cuting of pvEBarrelModuleMotherPos (Right)
969  //
970  GeoCutVolAction action3(*CutB, TransCutR);
971  pvAbsorber3->apply(&action3);
972  pvTmp_Absorber3 = action3.getPV();
973  if (m_log->level()<=MSG::DEBUG)
974  (*m_log) << MSG::DEBUG <<" _fillSection: CutB R Ok "<< endmsg;
975  }
976  } // end if, BoolCuts()
977  if (m_log->level()<=MSG::DEBUG) {
978  (*m_log) << MSG::DEBUG <<" _fillSection: Absorber3 Ok "<< endmsg;
979  }
980 
981  break;
982  }
983  case 3:
984  {
985  //Plug Section 1 - consists of ordinary periods of type 3
986  // ps plug1 special module
987  if ((m_dbManager->TILBsection() == 7)||(m_dbManager->TILBsection() == 8)) {
988  //Divide absorber volume on two parts: first filled with
989  //nrOfPeriods-1 ordinary period of type 1 and second with one special period of type 4
990 
991  //First division
992  thicknessPeriod = 2.*(m_dbManager->TILBdzmast() + m_dbManager->TILBdzspac() + 2.*dzglue)*Gaudi::Units::cm;
993  MLOG(DEBUG) << "PLUG Section 1 -- m_dbManager->TILBdzmast(): " << m_dbManager->TILBdzmast() << ", m_dbManager->TILBdzspac(): " << m_dbManager->TILBdzspac()
994  << ", dzglue: " << dzglue << " ==> thicknessPeriod: " << thicknessPeriod << endmsg;
995 
996  checking("Period 3 (ITC1 special)", true, 4,
997  thicknessPeriod/2,thicknessPeriod/2,dy1Absorber,dy2Absorber,heightAbsorber/2);
998 
999  period = new GeoTrd(thicknessPeriod/2,
1000  thicknessPeriod/2,
1001  dy1Absorber,
1002  dy2Absorber,
1003  heightAbsorber/2);
1004  lvPeriod = new GeoLogVol("Period",period,matIron);
1005  pvPeriod = new GeoPhysVol(lvPeriod);
1006 
1007  fillPeriod(pvPeriod,
1008  thicknessPeriod*(1./Gaudi::Units::cm),
1009  dzglue,
1010  tan_delta_phi_2,
1011  1); // 1-period type
1012 
1013  thicknessAbsorberChild = thicknessPeriod*(m_dbManager->TILBnperiod()-1);
1014 
1015  absorberChild = new GeoTrd(thicknessAbsorberChild/2,
1016  thicknessAbsorberChild/2,
1017  dy1Absorber,
1018  dy2Absorber,
1019  heightAbsorber/2);
1020  lvAbsorberChild = new GeoLogVol("AbsorberChild",absorberChild,matAir);
1021  pvAbsorberChild = new GeoPhysVol(lvAbsorberChild);
1022 
1023  // Place periods into Absorber Child like G4 replica
1024  GENFUNCTION periodPosITC1sp = (thicknessPeriod*(2*periodInd+1)-thicknessAbsorberChild)/2;
1025  TRANSFUNCTION xfReplicaITC1sp = Pow(GeoTrf::TranslateX3D(1.),periodPosITC1sp);
1026  if (m_verbose) checktransfunc(thicknessAbsorberChild,thicknessPeriod,m_dbManager->TILBnperiod()-1,
1027  (thicknessAbsorberChild - thicknessAbsorber)/2);
1028 
1029  stPeriod = new GeoSerialTransformer(pvPeriod,
1030  &xfReplicaITC1sp,
1031  m_dbManager->TILBnperiod()-1);
1032 
1033  pvAbsorberChild->add(new GeoSerialIdentifier(0));
1034  pvAbsorberChild->add(stPeriod);
1035 
1036  // Place absorber child
1037  tfAbsorberChild = new GeoTransform(GeoTrf::Translate3D((thicknessAbsorberChild - thicknessAbsorber)/2,0.,0.));
1038  pvAbsorber->add(tfAbsorberChild);
1039  pvAbsorber->add(pvAbsorberChild);
1040  //
1041  //Second division
1042  //
1043  thicknessPeriod = m_dbManager->TILBdzspac()*Gaudi::Units::cm;
1044 
1045  checking("Period 5 (ITC1 special)", true, 4,
1046  thicknessPeriod/2,thicknessPeriod/2,dy1Absorber,dy2Absorber,heightAbsorber/2);
1047 
1048  period = new GeoTrd(thicknessPeriod/2,
1049  thicknessPeriod/2,
1050  dy1Absorber,
1051  dy2Absorber,
1052  heightAbsorber/2);
1053  lvPeriod = new GeoLogVol("Period",period,matIron);
1054  pvPeriod = new GeoPhysVol(lvPeriod);
1055 
1056  fillPeriod(pvPeriod,
1057  thicknessPeriod*(1./Gaudi::Units::cm),
1058  dzglue,
1059  tan_delta_phi_2,
1060  4); // 4-period type
1061 
1062  thicknessAbsorberChild = thicknessPeriod;
1063  absorberChild = new GeoTrd(thicknessAbsorberChild/2,
1064  thicknessAbsorberChild/2,
1065  dy1Absorber,
1066  dy2Absorber,
1067  heightAbsorber/2);
1068  lvAbsorberChild = new GeoLogVol("AbsorberChild",absorberChild,matAir);
1069  pvAbsorberChild = new GeoPhysVol(lvAbsorberChild);
1070 
1071  if (m_verbose) checktransfunc(thicknessAbsorberChild,thicknessPeriod,1,
1072  (-thicknessAbsorberChild + thicknessAbsorber)/2);
1073 
1074  // Place period in the absorber child
1075  tfPeriod = new GeoTransform(GeoTrf::Translate3D(0.,0.,0.));
1076  pvAbsorberChild->add(new GeoIdentifierTag(m_dbManager->TILBnperiod()-1));
1077  pvAbsorberChild->add(tfPeriod);
1078  pvAbsorberChild->add(pvPeriod);
1079 
1080  // Place absorber child
1081  tfAbsorberChild = new GeoTransform(GeoTrf::Translate3D((-thicknessAbsorberChild + thicknessAbsorber)/2,0.,0.));
1082  pvAbsorber->add(tfAbsorberChild);
1083  pvAbsorber->add(pvAbsorberChild);
1084 
1085  if (m_log->level()<=MSG::DEBUG)
1086  (*m_log) << MSG::DEBUG <<" _fillSection: Absorber (ITC plug special) Ok "<< endmsg;
1087 
1088  } else {
1089  thicknessPeriod = 2.*(m_dbManager->TILBdzmast() + m_dbManager->TILBdzspac() + 2.*dzglue)*Gaudi::Units::cm;
1090 
1091  checking("Period 3", true, 4,
1092  thicknessPeriod/2,thicknessPeriod/2,dy1Absorber,dy2Absorber,heightAbsorber/2);
1093 
1094  period = new GeoTrd(thicknessPeriod/2,
1095  thicknessPeriod/2,
1096  dy1Absorber,
1097  dy2Absorber,
1098  heightAbsorber/2);
1099  lvPeriod = new GeoLogVol("Period",period,matIron);
1100  pvPeriod = new GeoPhysVol(lvPeriod);
1101 
1102  fillPeriod(pvPeriod,
1103  thicknessPeriod*(1./Gaudi::Units::cm),
1104  dzglue,
1105  tan_delta_phi_2,
1106  3); // 3-period type
1107 
1108  // Place periods into Absorber like G4 replica
1109  GENFUNCTION periodPos3 = (thicknessPeriod*(2*periodInd+1)-thicknessAbsorber)/2;
1110  TRANSFUNCTION xfReplica3 = Pow(GeoTrf::TranslateX3D(1.),periodPos3);
1111  if (m_verbose) checktransfunc(thicknessAbsorber,thicknessPeriod,m_dbManager->TILBnperiod(),0.0);
1112 
1113  //ps if ( (m_dbManager->TILBsection()==7 || m_dbManager->TILBsection()==8) && m_dbManager->SCNTitem()==302)
1114  // if ( m_dbManager->TILBsection()==7 && m_dbManager->SCNTitem() == 302)
1115  // NbPeriod = m_dbManager->TILBnperiod() - 1;
1116  // else
1117  NbPeriod = m_dbManager->TILBnperiod();
1118 
1119  if (m_log->level()<=MSG::DEBUG)
1120  (*m_log) << MSG::DEBUG <<" SCNTitem= "<<m_dbManager->SCNTitem()<<" NbPeriod= "<<NbPeriod<< endmsg;
1121  stPeriod = new GeoSerialTransformer(pvPeriod,
1122  &xfReplica3,
1123  NbPeriod);//sbb
1124 
1125  pvAbsorber->add(new GeoSerialIdentifier(0));
1126  pvAbsorber->add(stPeriod);
1127  if (m_log->level()<=MSG::DEBUG)
1128  (*m_log) << MSG::DEBUG <<" _fillSection: Absorber (case 3) Ok "<< endmsg;
1129  }
1130  break;
1131  }
1132  case 4:
1133  {
1134  //Plug Section 2
1135  //Divide absorber volume on two parts: first filled with
1136  //nrOfPeriods-1 ordinary period of type 1 and second with one special period of type 4
1137 
1138  //First division
1139  thicknessPeriod = 2.*(m_dbManager->TILBdzmast() + m_dbManager->TILBdzspac() + 2.*dzglue)*Gaudi::Units::cm;
1140  MLOG(DEBUG) << "PLUG Section 2 -- m_dbManager->TILBdzmast(): " << m_dbManager->TILBdzmast() << ", m_dbManager->TILBdzspac(): " << m_dbManager->TILBdzspac()
1141  << ", dzglue: " << dzglue << " ==> thicknessPeriod: " << thicknessPeriod << endmsg;
1142 
1143  checking("Period 4", true, 4,
1144  thicknessPeriod/2,thicknessPeriod/2,dy1Absorber,dy2Absorber,heightAbsorber/2);
1145 
1146  period = new GeoTrd(thicknessPeriod/2,
1147  thicknessPeriod/2,
1148  dy1Absorber,
1149  dy2Absorber,
1150  heightAbsorber/2);
1151  lvPeriod = new GeoLogVol("Period",period,matIron);
1152  pvPeriod = new GeoPhysVol(lvPeriod);
1153 
1154  fillPeriod(pvPeriod,
1155  thicknessPeriod*(1./Gaudi::Units::cm),
1156  dzglue,
1157  tan_delta_phi_2,
1158  1); // 1-period type
1159 
1160 
1161  thicknessAbsorberChild = thicknessPeriod*(m_dbManager->TILBnperiod()-1);
1162  absorberChild = new GeoTrd(thicknessAbsorberChild/2,
1163  thicknessAbsorberChild/2,
1164  dy1Absorber,
1165  dy2Absorber,
1166  heightAbsorber/2);
1167  lvAbsorberChild = new GeoLogVol("AbsorberChild",absorberChild,matAir);
1168  pvAbsorberChild = new GeoPhysVol(lvAbsorberChild);
1169 
1170  // Place periods into Absorber Child like G4 replica
1171  GENFUNCTION periodPos1 = (thicknessPeriod*(2*periodInd+1)-thicknessAbsorberChild)/2;
1172  TRANSFUNCTION xfReplica1 = Pow(GeoTrf::TranslateX3D(1.),periodPos1);
1173  if (m_verbose) checktransfunc(thicknessAbsorberChild,thicknessPeriod,m_dbManager->TILBnperiod()-1,
1174  (thicknessAbsorberChild - thicknessAbsorber)/2);
1175 
1176  stPeriod = new GeoSerialTransformer(pvPeriod,
1177  &xfReplica1,
1178  m_dbManager->TILBnperiod()-1);
1179 
1180  pvAbsorberChild->add(new GeoSerialIdentifier(0));
1181  pvAbsorberChild->add(stPeriod);
1182 
1183  // Place absorber child
1184  tfAbsorberChild = new GeoTransform(GeoTrf::Translate3D((thicknessAbsorberChild - thicknessAbsorber)/2,0.,0.));
1185  pvAbsorber->add(tfAbsorberChild);
1186  pvAbsorber->add(pvAbsorberChild);
1187 
1188  //Second division
1189  thicknessPeriod = m_dbManager->TILBdzspac()*Gaudi::Units::cm;
1190 
1191  checking("Period 5", true, 4,
1192  thicknessPeriod/2,thicknessPeriod/2,dy1Absorber,dy2Absorber,heightAbsorber/2);
1193 
1194  period = new GeoTrd(thicknessPeriod/2,
1195  thicknessPeriod/2,
1196  dy1Absorber,
1197  dy2Absorber,
1198  heightAbsorber/2);
1199  lvPeriod = new GeoLogVol("Period",period,matIron);
1200  pvPeriod = new GeoPhysVol(lvPeriod);
1201 
1202  fillPeriod(pvPeriod,
1203  thicknessPeriod*(1./Gaudi::Units::cm),
1204  dzglue,
1205  tan_delta_phi_2,
1206  4); // 4-period type
1207 
1208  thicknessAbsorberChild = thicknessPeriod;
1209  absorberChild = new GeoTrd(thicknessAbsorberChild/2,
1210  thicknessAbsorberChild/2,
1211  dy1Absorber,
1212  dy2Absorber,
1213  heightAbsorber/2);
1214  lvAbsorberChild = new GeoLogVol("AbsorberChild",absorberChild,matAir);
1215  pvAbsorberChild = new GeoPhysVol(lvAbsorberChild);
1216 
1217  if (m_verbose) checktransfunc(thicknessAbsorberChild,thicknessPeriod,1,
1218  (-thicknessAbsorberChild + thicknessAbsorber)/2);
1219 
1220  // Place period in the absorber child
1221  tfPeriod = new GeoTransform(GeoTrf::Translate3D(0.,0.,0.));
1222  pvAbsorberChild->add(new GeoIdentifierTag(m_dbManager->TILBnperiod()-1));
1223  pvAbsorberChild->add(tfPeriod);
1224  pvAbsorberChild->add(pvPeriod);
1225 
1226  // Place absorber child
1227  tfAbsorberChild = new GeoTransform(GeoTrf::Translate3D((-thicknessAbsorberChild + thicknessAbsorber)/2,0.,0.));
1228  pvAbsorber->add(tfAbsorberChild);
1229  pvAbsorber->add(pvAbsorberChild);
1230 
1231  if (m_log->level()<=MSG::DEBUG)
1232  (*m_log) << MSG::DEBUG <<" _fillSection: Absorber (case 4) Ok "<< endmsg;
1233  break;
1234  }
1235  default:
1236  {
1237  // C10_missing/Gap/Crack 5,6,14,15,16
1238 
1239  if ((m_dbManager->TILBsection()==5)||(m_dbManager->TILBsection()==6)) { // Gap/Crack
1240  m_dbManager->SetCurrentScin(100*m_dbManager->TILBsection() + 1);
1241 
1242  } else if ((m_dbManager->TILBsection()==14) || (m_dbManager->TILBsection()==15) || (m_dbManager->TILBsection()==16)) {
1243  m_dbManager->SetCurrentScin(m_dbManager->TILBcurscint());
1244 
1245  } else {
1246  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::fillSection: Unexpected section = "
1247  << m_dbManager->TILBsection() << " for Gap/Crack" << endmsg;
1248  return;
1249  }
1250 
1251  thicknessPeriod = thicknessAbsorber; // the same as absorber, but made from Aluminium
1252  MLOG(DEBUG) << "DEFAULT Section -- thicknessAbsorber: " << thicknessAbsorber << " ==> thicknessPeriod: " << thicknessPeriod << endmsg;
1253 
1254  checking("Period 6", true, 4,
1255  thicknessPeriod/2,thicknessPeriod/2,dy1Absorber,dy2Absorber,heightAbsorber/2);
1256 
1257  double dy1Period = m_dbManager->TILBflangex()/2.*Gaudi::Units::cm; // correct size from the drawings
1258  double dy2Period = m_dbManager->TILBflangey()/2.*Gaudi::Units::cm; // correct size from the drawings
1259  if (dy1Period <= 0.0 || dy2Period <= 0.0 || dy1Period > dy1Absorber || dy2Period > dy2Absorber || dy1Period >= dy2Period ) {
1260  dy1Period = dy1Absorber;
1261  dy2Period = dy2Absorber;
1262  }
1263 
1264  period = new GeoTrd(thicknessPeriod/2,
1265  thicknessPeriod/2,
1266  dy1Period,
1267  dy2Period,
1268  heightAbsorber/2);
1269  if (!matAluminium) matAluminium = m_theMaterialManager->getMaterial("std::Aluminium");
1270  lvPeriod = new GeoLogVol("Period",period,matAluminium); // note - aluminium period inside air absorber here
1271  pvPeriod = new GeoPhysVol(lvPeriod);
1272 
1273  fillPeriod(pvPeriod,
1274  thicknessPeriod*(1./Gaudi::Units::cm),
1275  dzglue,
1276  tan_delta_phi_2,
1277  5, period);
1278 
1279  if (m_verbose) checktransfunc(thicknessAbsorber,thicknessPeriod,1,0.0);
1280 
1281  // Place period in the absorber
1282  tfPeriod = new GeoTransform(GeoTrf::Translate3D(0.,0.,0.));
1283  pvAbsorber->add(new GeoIdentifierTag(0));
1284  pvAbsorber->add(tfPeriod);
1285  pvAbsorber->add(pvPeriod);
1286 
1287  if (m_log->level()<=MSG::DEBUG)
1288  (*m_log) << MSG::DEBUG <<" _fillSection: Absorber (case default) Ok "<< endmsg;
1289  break;
1290  }
1291  }
1292 
1293  // Place absorber in the module mother
1294  GeoTransform *tfAbsorber{nullptr}, *tfAbsorber1{nullptr}, *tfAbsorber3{nullptr};
1295 
1296  double dXAbsorber = (m_dbManager->TILBdzend1() - m_dbManager->TILBdzend2());
1297  double dZAbsorber = (m_dbManager->TILBrmax() - tile_rmax);
1298 
1299  if (sec_number==3) {
1300  // ps specialModuleZShift
1301  tfAbsorber = new GeoTransform(GeoTrf::Translate3D( specialModuleZShift + dXAbsorber*Gaudi::Units::cm/2, 0., dZAbsorber*Gaudi::Units::cm/2));
1302  mother->add(tfAbsorber);
1303  mother->add(pvAbsorber);
1304 
1305  } else if (sec_number==2) {
1306  if (m_log->level()<=MSG::DEBUG)
1307  (*m_log) << MSG::DEBUG << " _fillsection Ex.barrel in "<< endmsg;
1308 
1309  tfAbsorber1 = new GeoTransform(GeoTrf::Translate3D(dXAbsorber*Gaudi::Units::cm/2 - PosAbsor1, 0.,
1310  (dZAbsorber + m_dbManager->TILBrmin() - rminb)*Gaudi::Units::cm/2));
1311  mother->add(tfAbsorber1);
1312  if (m_dbManager->BoolCuts() && ((ModuleNcp>=35 && ModuleNcp<=37) || (ModuleNcp>=60 && ModuleNcp<=62)) ) {
1313  mother->add(pvTmp_Absorber1);
1314  } else {
1315  mother->add(pvAbsorber1);
1316  }
1317 
1318  if (m_log->level()<=MSG::DEBUG)
1319  (*m_log) << MSG::DEBUG << " _fillsection ext.barrel pvAbsorber1 Ok"<< endmsg;
1320 
1321  tfAbsorber = new GeoTransform(GeoTrf::Translate3D(dXAbsorber*Gaudi::Units::cm/2 - PosAbsor2, 0.,
1322  (dZAbsorber + m_dbManager->TILBrmin() - rminb)*Gaudi::Units::cm/2));
1323  mother->add(tfAbsorber);
1324  mother->add(pvAbsorber);
1325 
1326  if (m_log->level()<=MSG::DEBUG)
1327  (*m_log) << MSG::DEBUG << " _fillsection ext.barrel pvAbsorber Ok"<< endmsg;
1328 
1329  tfAbsorber3 = new GeoTransform(GeoTrf::Translate3D(dXAbsorber*Gaudi::Units::cm/2 - PosAbsor3, 0.,
1330  (dZAbsorber + m_dbManager->TILBrmin() - rminb)*Gaudi::Units::cm/2));
1331  mother->add(tfAbsorber3);
1332  if (m_dbManager->BoolCuts() && ((ModuleNcp>=35 && ModuleNcp<=37) || (ModuleNcp>=60 && ModuleNcp<=62)) ) {
1333  mother->add(pvTmp_Absorber3);
1334  } else {
1335  mother->add(pvAbsorber3);
1336  }
1337 
1338  if (m_log->level()<=MSG::DEBUG)
1339  (*m_log) << MSG::DEBUG << " _fillsection ext.barrel pvAbsorber3 Ok"<< endmsg;
1340 
1341  } else {
1342  tfAbsorber = new GeoTransform(GeoTrf::Translate3D(dXAbsorber*Gaudi::Units::cm/2, 0.,
1343  (dZAbsorber + m_dbManager->TILBrmin() - rminb)*Gaudi::Units::cm/2));
1344  mother->add(tfAbsorber);
1345  mother->add(pvAbsorber);
1346  if (m_log->level()<=MSG::DEBUG)
1347  (*m_log) << MSG::DEBUG << " _fillsection other pvAbsorber Ok"<< endmsg;
1348  }
1349 
1350 
1351 }
1352 
1353 
1354 void TileGeoSectionBuilder::fillGirder(PVLink & mother,
1355  double tile_rmax,
1356  double tilb_rmax,
1357  double tan_delta_phi_2,
1358  double thickness)
1359 {
1360  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
1361  // Obtain required materials - Iron, Aluminium and electronic boards
1362 
1363  const GeoMaterial* matIron = (m_switches.steel) ? m_theMaterialManager->getMaterial("tile::Steel")
1364  : m_theMaterialManager->getMaterial("std::Iron");
1365  const GeoMaterial* matAluminium = m_theMaterialManager->getMaterial("std::Aluminium");
1366  const GeoMaterial* matElBoard = m_theMaterialManager->getMaterial("tile::SiO2CondEpox");
1367 
1368  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
1369 
1370  GeoTrd* girderElement{nullptr};
1371  GeoLogVol* lvGirderElement{nullptr};
1372  PVLink pvGirderElement{nullptr};
1373  GeoTransform* tfGirderElement{nullptr};
1374 
1375  int CurrentGird = 1;
1376  int j;
1377 
1378  //if (m_dbManager->TILBsection()==8)
1379  // CurrentGird = 801; //Prototype module
1380  // ps commented out old geometry
1381 
1382  for (j = CurrentGird; j < (CurrentGird + m_dbManager->TILBngirder()); j++) {
1383  m_dbManager->SetCurrentGird(j);
1384  double elementRC = m_dbManager->TIGRrc();
1385  double elementSizeInR = m_dbManager->TIGRdr();
1386  double elementSizeInY = m_dbManager->TIGRdw();
1387  double elementOffsetInY = m_dbManager->TIGRoff();
1388 
1389  double dy1GirderElement, dy2GirderElement;
1390  if (elementSizeInY >0) {
1391  dy1GirderElement = elementSizeInY/2;
1392  dy2GirderElement = elementSizeInY/2;
1393  } else {
1394  dy1GirderElement = (elementRC - elementSizeInR/2) * tan_delta_phi_2;
1395  dy2GirderElement = (elementRC + elementSizeInR/2) * tan_delta_phi_2;
1396  }
1397 
1398  girderElement = new GeoTrd(thickness/2*Gaudi::Units::cm,
1399  thickness/2*Gaudi::Units::cm,
1400  dy1GirderElement*Gaudi::Units::cm,
1401  dy2GirderElement*Gaudi::Units::cm,
1402  elementSizeInR/2*Gaudi::Units::cm);
1403 
1404  switch(m_dbManager->TIGRmaterial()) {
1405  case 1: //Iron
1406  {
1407  lvGirderElement = new GeoLogVol("GirderIron",girderElement,matIron);
1408  break;
1409  }
1410  case 2: //Aluminium
1411  {
1412  lvGirderElement = new GeoLogVol("GirderAluminium",girderElement,matAluminium);
1413  break;
1414  }
1415  case 3: //Electronics
1416  {
1417  lvGirderElement = new GeoLogVol("GirderElectronics",girderElement,matElBoard);
1418  break;
1419  }
1420  default:
1421  {
1422  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::FillGirder: unknown material = "
1423  << m_dbManager->TIGRmaterial() << endmsg;
1424  return;
1425  }
1426  }
1427 
1428  pvGirderElement = new GeoPhysVol(lvGirderElement);
1429  tfGirderElement = new GeoTransform(GeoTrf::Translate3D(0.,
1430  elementOffsetInY*Gaudi::Units::cm,
1431  (elementRC-(tilb_rmax + tile_rmax)/2)*Gaudi::Units::cm));
1432  mother->add(tfGirderElement);
1433  mother->add(pvGirderElement);
1434  }
1435 }
1436 
1437 
1438 void TileGeoSectionBuilder::fillFinger(PVLink & mother,
1439  int sec_number,
1440  double tile_rmax,
1441  double tilb_rmax,
1442  double /* delta_phi */,
1443  bool testbeam,
1444  int ModuleNcp,
1445  double corrected_dz)
1446 {
1447  bool boolNeg = false;
1448 
1449  if (ModuleNcp > 99) {
1450  ModuleNcp = ModuleNcp/100;
1451  boolNeg = true;
1452  }
1453 
1454  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
1455  // Obtain required materials - Iron, Aluminium and electronic boards
1456 
1457  const GeoMaterial* matIron = (m_switches.steel) ? m_theMaterialManager->getMaterial("tile::Steel")
1458  : m_theMaterialManager->getMaterial("std::Iron");
1459  const GeoMaterial* matAluminium = m_theMaterialManager->getMaterial("std::Aluminium");
1460  const GeoMaterial* matElBoard = m_theMaterialManager->getMaterial("tile::SiO2CondEpox");
1461 
1462  // Get required elements
1463  //const GeoElement* oxygen = m_theMaterialManager->getElement("Oxygen");
1464  //const GeoElement* hydrogen = m_theMaterialManager->getElement("Hydrogen");
1465  const GeoElement* copper = m_theMaterialManager->getElement("Copper");
1466 
1467  // Get some standard materials
1468  const GeoMaterial *air = m_theMaterialManager->getMaterial("std::Air");
1469  const GeoMaterial *iron = m_theMaterialManager->getMaterial("std::Iron");
1470  const GeoMaterial *shieldSteel = m_theMaterialManager->getMaterial("shield::ShieldSteel");
1471  const GeoMaterial *matRubber = m_theMaterialManager->getMaterial("std::Rubber")!=nullptr
1472  ? m_theMaterialManager->getMaterial("std::Rubber")
1473  : m_theMaterialManager->getMaterial("sct::Rubber");
1474 
1475  // m_matLArServices
1476  if (!m_matLArServices) {
1477  m_matLArServices = new GeoMaterial("LArServices", 2.5*GeoModelKernelUnits::gram/Gaudi::Units::cm3);
1478  m_matLArServices->add(shieldSteel, 0.20);
1479  m_matLArServices->add(copper, 0.60);
1480  m_matLArServices->add(matRubber, 0.10);
1481  m_matLArServices->add(air, 0.10);
1482  m_matLArServices->lock();
1483  }
1484 
1485  // m_matIronHalfDens
1486  if (!m_matIronHalfDens) {
1487  m_matIronHalfDens = new GeoMaterial("LArIronBox", 4.5*GeoModelKernelUnits::gram/Gaudi::Units::cm3);
1488  m_matIronHalfDens->add(shieldSteel, 0.80);
1489  m_matIronHalfDens->add(matRubber, 0.10);
1490  m_matIronHalfDens->add(copper, 0.10);
1491  m_matIronHalfDens->lock();
1492  }
1493 
1494  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
1495 
1496  GeoTrd* fingerElementTrd{nullptr};
1497  GeoTrap* fingerElementTrap{nullptr};
1498 
1499  GeoBox *fingerCablesL{nullptr}, *fingerCablesR{nullptr};
1500  PVLink pvFingerElement{nullptr}, pvFingerCablesL{nullptr}, pvFingerCablesR{nullptr};
1501  GeoLogVol *lvFingerElement{nullptr}, *lvFingerCablesL{nullptr}, *lvFingerCablesR{nullptr};
1502  GeoTransform* tfFingerElement{nullptr}, *tfFingerCables{nullptr};
1503 
1504  GeoTransform* ZrotateMod{nullptr};
1505  GeoTransform* yrotateMod{nullptr};
1506  GeoTransform* zrotateMod{nullptr};
1507 
1508  const GeoMaterial *currentMaterial{nullptr}, *leftMaterial{nullptr}, *rightMaterial{nullptr};
1509  std::string currentName, leftName, rightName;
1510 
1511  int CurrentTicg = 100*sec_number + 1;
1512  int j;
1513  double AirVolumeShift = 0.0;
1514  double AirVolumeSize = corrected_dz;
1515 
1516  for (j = CurrentTicg; j < (CurrentTicg + m_dbManager->TIFGnelem()); j++) {
1517  m_dbManager->SetCurrentTicg(j);
1518  double elementRC = m_dbManager->TICGrc();
1519  double elementHeight = m_dbManager->TICGdr();
1520  double elementDy1 = m_dbManager->TICGdx1();
1521  double elementDy2 = m_dbManager->TICGdx2();
1522  double elementOffset = m_dbManager->TICGoff();
1523  double elementDz = m_dbManager->TICGdz();
1524  double elementZPozition = m_dbManager->TICGzc();
1525 
1526  if (corrected_dz > 0.) {
1527  if (j-CurrentTicg==0) { // take air volume size from first element
1528  AirVolumeShift = (elementDz-corrected_dz)/2 - elementZPozition;
1529  AirVolumeSize = elementDz;
1530  if (m_log->level()<=MSG::DEBUG) {
1531  (*m_log) << MSG::DEBUG << "TileFinger: OldAirVolumeCenter ="<<elementZPozition << endmsg;
1532  (*m_log) << MSG::DEBUG << "TileFinger: NewAirVolumeCenter ="<<elementZPozition+AirVolumeShift << endmsg;
1533  (*m_log) << MSG::DEBUG << "TileFinger: AirVolumeShift ="<< AirVolumeShift << endmsg;
1534  (*m_log) << MSG::DEBUG << "TileFinger: AirVolumeSize ="<< AirVolumeSize << endmsg;
1535  }
1536  }
1537 
1538  if (elementZPozition*2-AirVolumeSize<-0.01) { // compare with zero with 0.1 Gaudi::Units::mm precision
1539  elementZPozition += AirVolumeShift; // shift all volumes keeping size
1540 
1541  } else { // resize finger cover with shims attached to it
1542  if (m_log->level()<=MSG::DEBUG)
1543  (*m_log) << MSG::DEBUG << "TileFinger: OldCoverThickness ="<<elementDz << endmsg;
1544  elementDz = corrected_dz - AirVolumeSize;
1545  if (m_log->level()<=MSG::DEBUG) {
1546  (*m_log) << MSG::DEBUG << "TileFinger: NewCoverThickness ="<<elementDz << endmsg;
1547  (*m_log) << MSG::DEBUG << "TileFinger: OldCoverCenter ="<<elementZPozition << endmsg;
1548  }
1549  elementZPozition = (corrected_dz-elementDz)/2;
1550  if (m_log->level()<=MSG::DEBUG)
1551  (*m_log) << MSG::DEBUG << "TileFinger: NewCoverCenter ="<<elementZPozition << endmsg;
1552  }
1553  }
1554 
1555  switch(m_dbManager->TICGmaterial()) {
1556  case 1:
1557  {
1558  currentMaterial = matIron;
1559  currentName = "FingerIron";
1560  break;
1561  }
1562  case 2:
1563  {
1564  currentMaterial = matAluminium;
1565  currentName = "FingerAluminum";
1566  break;
1567  }
1568  case 3:
1569  {
1570  currentMaterial = matElBoard;
1571  currentName = "FingerElectronics";
1572  break;
1573  }
1574  default:
1575  {
1576  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::fillFinger: unexpected material = "
1577  << m_dbManager->TICGmaterial() << " for finger element" << endmsg;
1578  return;
1579  }
1580  }
1581 
1582  if (m_dbManager->TICGshape()==1) {
1583  fingerElementTrd = new GeoTrd(elementDz/2*Gaudi::Units::cm,
1584  elementDz/2*Gaudi::Units::cm,
1585  elementDy1/2*Gaudi::Units::cm,
1586  elementDy2/2*Gaudi::Units::cm,
1587  elementHeight/2*Gaudi::Units::cm);
1588  lvFingerElement = new GeoLogVol(currentName,fingerElementTrd,currentMaterial);
1589 
1590  } else if (m_dbManager->TICGshape()==2) {
1591 
1592  fingerElementTrap = new GeoTrap(elementDz/2*Gaudi::Units::cm,
1593  0.,
1594  0.,
1595  elementHeight/2*Gaudi::Units::cm,
1596  elementDy2/2*Gaudi::Units::cm,
1597  elementDy1/2*Gaudi::Units::cm,
1598  std::atan((elementDy1-elementDy2)/(2.*elementHeight)),
1599  elementHeight/2*Gaudi::Units::cm,
1600  elementDy2/2*Gaudi::Units::cm,
1601  elementDy1/2*Gaudi::Units::cm,
1602  std::atan((elementDy1-elementDy2)/(2.*elementHeight)));
1603 
1604  lvFingerElement = new GeoLogVol(currentName,fingerElementTrap,currentMaterial);
1605 
1606  } else {
1607  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::fillFinger: unexpected shape = "
1608  << m_dbManager->TICGshape() << " for finger element" << endmsg;
1609  return;
1610  }
1611 
1612 
1613  pvFingerElement = new GeoPhysVol(lvFingerElement);
1614  tfFingerElement = new GeoTransform(GeoTrf::Translate3D(elementZPozition*Gaudi::Units::cm,
1615  elementOffset*Gaudi::Units::cm,
1616  (elementRC-(tilb_rmax + tile_rmax)/2)*Gaudi::Units::cm));
1617 
1618  mother->add(tfFingerElement);
1619  if (m_dbManager->TICGshape()==2) {
1620  if (elementOffset<0) {
1621  ZrotateMod = new GeoTransform(GeoTrf::RotateZ3D(180*Gaudi::Units::deg));
1622  mother->add(ZrotateMod);
1623  }
1624 
1625  zrotateMod = new GeoTransform(GeoTrf::RotateZ3D(90*Gaudi::Units::deg));
1626  yrotateMod = new GeoTransform(GeoTrf::RotateY3D(-90*Gaudi::Units::deg));
1627  mother->add(yrotateMod);
1628  mother->add(zrotateMod);
1629  }
1630 
1631  mother->add(new GeoIdentifierTag(ModuleNcp));
1632  mother->add(pvFingerElement);
1633  }
1634 
1635  if (testbeam) return; // no cables between fingers at the testbeam
1636 
1637  // Cables space
1638 
1639  int Isector =0, LRflag =0;
1640 
1641  if ((ModuleNcp/4 - (float)ModuleNcp/4) != 0) {
1642  Isector = (int)ModuleNcp/4;
1643  } else {
1644  Isector = (int)ModuleNcp/4-1;
1645  }
1646  LRflag = ModuleNcp-4*Isector;
1647 
1648  m_dbManager->SetCurrentTicg(CurrentTicg);
1649 
1650  double elementRC = m_dbManager->TICGrc();
1651  double elementOffset = m_dbManager->TICGoff();
1652  double elementDz = m_dbManager->TICGdz();
1653  double elementZPozition = m_dbManager->TICGzc();
1654 
1655  double dXleft =35., dXright = 35.;
1656  double dZleft = elementDz/2, dZright = dZleft;
1657  double dZsaddleL = elementDz/4, dZsaddleR = dZsaddleL;
1658  double dY = 7.5;
1659 
1660  rightMaterial = leftMaterial = m_matLArServices;
1661  rightName = leftName = "LArCables";
1662 
1663  if (LRflag == 1) {
1664  dZright = elementDz, dXright = 35;
1665  dZsaddleR = 0;
1666  rightMaterial = m_matIronHalfDens;
1667  rightName = "LArService";
1668 
1669  } else if (LRflag == 4) {
1670  dZleft = elementDz, dXleft = 35;
1671  dZsaddleL = 0;
1672  leftMaterial = m_matIronHalfDens;
1673  leftName = "LArService";
1674  }
1675 
1676  if (sec_number == 1) {
1677  if ( (ModuleNcp >=40 && ModuleNcp <=41) || (ModuleNcp >=56 && ModuleNcp <=57) ) {
1678  dZright = dZleft = 8.5;
1679  dZsaddleL = dZsaddleR = 13.7;
1680  rightMaterial = leftMaterial = iron;
1681  rightName = leftName = "BarrelSaddleSupport";
1682  }
1683 
1684  } else {
1685  if ( (ModuleNcp >=39 && ModuleNcp <=42) || (ModuleNcp >=55 && ModuleNcp <=58) ) {
1686  dZright = dZleft = 8.5;
1687  dZsaddleR = dZsaddleL = 13.7;
1688  rightMaterial = leftMaterial = iron;
1689  rightName = leftName = "ExtBarrelSaddleSupport";
1690  }
1691  }
1692 
1693  if (m_log->level()<=MSG::DEBUG)
1694  (*m_log) << MSG::DEBUG << " Finger : number= "<<sec_number<<" ModuleNcp = " <<ModuleNcp<< " Sector= "<< Isector
1695  << " LRflag= " << LRflag <<" Neg "<< boolNeg
1696  << endmsg;
1697 
1698  GeoTransform *rotateY = new GeoTransform(GeoTrf::RotateY3D(90*Gaudi::Units::deg));
1699  GeoTransform *rotateZ = new GeoTransform(GeoTrf::RotateZ3D(3*Gaudi::Units::deg));
1700  GeoTransform *rotateZm = new GeoTransform(GeoTrf::RotateZ3D(-3*Gaudi::Units::deg));
1701 
1702  // Left (+phi)
1703  fingerCablesL = new GeoBox(dXleft/2*Gaudi::Units::cm, dY/2*Gaudi::Units::cm, dZleft/2*Gaudi::Units::cm);
1704  lvFingerCablesL = new GeoLogVol(leftName,fingerCablesL,leftMaterial);
1705  pvFingerCablesL = new GeoPhysVol(lvFingerCablesL);
1706 
1707  // Right (-phi)
1708  fingerCablesR = new GeoBox(dXright/2*Gaudi::Units::cm, dY/2*Gaudi::Units::cm, dZright/2*Gaudi::Units::cm);
1709  lvFingerCablesR = new GeoLogVol(rightName,fingerCablesR,rightMaterial);
1710  pvFingerCablesR = new GeoPhysVol(lvFingerCablesR);
1711 
1712  double YpoFinger =0;
1713 
1714  if (boolNeg) {
1715  YpoFinger = -elementOffset+5.4;
1716  } else {
1717  YpoFinger = elementOffset-5.4;
1718  }
1719 
1720  tfFingerCables = new GeoTransform(GeoTrf::Translate3D(elementZPozition*Gaudi::Units::cm +0.5*Gaudi::Units::cm -dZsaddleL*Gaudi::Units::cm,
1721  YpoFinger*Gaudi::Units::cm,
1722  (elementRC-(tilb_rmax + tile_rmax)/2)*Gaudi::Units::cm));
1723  mother->add(tfFingerCables);
1724 
1725  // inversion for negativ fingers, Left
1726  if (boolNeg) {
1727  mother->add(rotateY);
1728  mother->add(rotateZm);
1729  } else {
1730  mother->add(rotateY);
1731  mother->add(rotateZ);
1732  }
1733 
1734  mother->add(new GeoIdentifierTag(ModuleNcp));
1735  mother->add(pvFingerCablesL);
1736 
1737  if (boolNeg) {
1738  YpoFinger = elementOffset-5.4;
1739  } else {
1740  YpoFinger = -elementOffset+5.4;
1741  }
1742 
1743  tfFingerCables = new GeoTransform(GeoTrf::Translate3D(elementZPozition*Gaudi::Units::cm +0.5*Gaudi::Units::cm -dZsaddleR*Gaudi::Units::cm,
1744  YpoFinger*Gaudi::Units::cm,
1745  (elementRC-(tilb_rmax + tile_rmax)/2)*Gaudi::Units::cm));
1746  mother->add(tfFingerCables);
1747 
1748  // inversion for negativ fingers, Right
1749  if (boolNeg) {
1750  mother->add(rotateY);
1751  mother->add(rotateZ);
1752  } else {
1753  mother->add(rotateY);
1754  mother->add(rotateZm);
1755  }
1756 
1757  mother->add(new GeoIdentifierTag(ModuleNcp));
1758  mother->add(pvFingerCablesR);
1759 }
1760 
1761 
1762 void TileGeoSectionBuilder::fillPeriod(PVLink & mother,
1763  double thickness,
1764  double dzglue,
1765  double tan_delta_phi_2,
1766  int period_type,
1767  GeoTrd * period)
1768 {
1769  int j;
1770  int CurrentScin = 0;
1771  const GeoShape* glue{nullptr};
1772  GeoLogVol* lvGlue{nullptr};
1773  PVLink pvGlue{nullptr};
1774  GeoTransform* tfGlue{nullptr};
1775 
1776  double scintiWrapInZ, scintiWrapInR, scintiThickness, scintiDeltaInPhi;
1777  double scintiHeight, scintiRC, scintiZPos, dy1Scintillator, dy2Scintillator;
1778  const GeoShape* scintillator{nullptr};
1779  GeoLogVol* lvScintillator{nullptr};
1780  PVLink pvScintillator{nullptr};
1781  GeoTransform* tfScintillator{nullptr};
1782 
1783  double thicknessWrapper, heightWrapper, dy1Wrapper, dy2Wrapper;
1784  const GeoShape* wrapper{nullptr};
1785  GeoLogVol* lvWrapper{nullptr};
1786  PVLink pvWrapper{nullptr};
1787  GeoTransform* tfWrapper{nullptr};
1788 
1789  (*m_log) << MSG::VERBOSE <<" TileGeoSectionBuilder::fillPeriod"<< endmsg;
1790 
1791  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
1792 
1793  // Determine the number of first scintillator depending on the section type
1794  if (m_dbManager->TILBsection() >= 7 && m_dbManager->TILBcurscint() == 0) {
1795  CurrentScin = 101; //special modules for testbeam identical to normal barrel module
1796  } else {
1797  if (m_dbManager->TILBcurscint()>0) {
1798  CurrentScin = m_dbManager->TILBcurscint();
1799  } else {
1800  CurrentScin = 100*m_dbManager->TILBsection()+1;
1801  }
1802  }
1803 
1804  // special EB modules with cut-outs
1805  if (m_dbManager->TILBsection()>=26 && m_dbManager->TILBsection()<=38 && m_dbManager->TILBcurscint() == 0) {
1806  //ps shortcut. Should be read from DB later on.
1807  CurrentScin = 100*2 + 1;
1808  }
1809 
1810  int zpShift = 1;
1811  // special EB modules with small D4 cell
1812  if (m_dbManager->TILBsection()>=7 && m_dbManager->TILBsection()<=8 && m_dbManager->TILBcurscint() == 301) {
1813  //ps fix. Should put curscint = 1301 in DB and zpShift will not be needed
1814  zpShift = -1;
1815  }
1816 
1817  (*m_log) << MSG::VERBOSE <<" TILBsection= "<<m_dbManager->TILBsection()<<endmsg;
1818  (*m_log) << MSG::VERBOSE <<" CurrentScin= "<<CurrentScin<<" TILBcurscint= "<<m_dbManager->TILBcurscint()
1819  << " - " << m_dbManager->TILBcurscint()+m_dbManager->TILBnscin()-1 <<endmsg;
1820  (*m_log) << MSG::VERBOSE <<" period_type= "<<period_type <<endmsg;
1821 
1822  // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
1823  // Obtain required materials - Air, Glue, Scintillator
1824 
1825  const GeoMaterial* matAir = m_theMaterialManager->getMaterial("std::Air");
1826  const GeoMaterial* matScin = nullptr;
1827  if (m_switches.pvt) {
1828  if (m_switches.testBeam || // choose PVT for all scintillators in testbeam setup
1829  ( period_type>4 && // choose PVT for crack scintillators (defined starting from RUN3)
1830  (m_dbManager->TILBsection() == 6 || m_dbManager->TILBsection() == 16) ) ) {
1831  // different material for crack scintillators
1832  matScin = m_theMaterialManager->getMaterial("tile::Polyvinyltoluene");
1833  if (matScin != nullptr) {
1834  (*m_log) << MSG::VERBOSE << "Using Polyvinyltoluene for section = " << m_dbManager->TILBsection() << endmsg;
1835  } else {
1836  (*m_log) << MSG::VERBOSE << "Using Polystyrene for section = " << m_dbManager->TILBsection() << endmsg;
1837  }
1838  }
1839  }
1840  if (matScin == nullptr) matScin = m_theMaterialManager->getMaterial("tile::Scintillator");
1841 
1842  //Cs hole parameters
1843  double csHoleR = 0.45 * Gaudi::Units::cm;
1844  double csTubeOuterR = 0.4 * Gaudi::Units::cm;
1845  double csTubeInnerR = 0.3 * Gaudi::Units::cm;
1846  double csTubeOffCorr = 1.35 * Gaudi::Units::cm;
1847 
1848  double thicknessMother2 = thickness/2.*Gaudi::Units::cm;
1849  double heightMother2 = (m_dbManager->TILBrmax() - m_dbManager->TILBrmin())*Gaudi::Units::cm/2.;
1850 
1851  const bool removeGlue = (m_switches.glue == 0 || m_switches.glue == 2);
1852 
1853  //Glue layer
1854  if (dzglue>0.0 && period_type<4 && !removeGlue) {
1855  const GeoMaterial* matGlue = m_theMaterialManager->getMaterial("tile::Glue");
1856 
1857  double dzglue2 = dzglue/2*Gaudi::Units::cm;
1858  dzglue2 = floor(dzglue2*1.0e+10)*1.0e-10;
1859 
1860  if (m_verbose) {
1861  printdouble(" period thickness/2 = ",thickness/2*Gaudi::Units::cm);
1862  printdouble(" glue thickness/2 = ",dzglue/2*Gaudi::Units::cm);
1863  printdouble("rounded thickness/2 = ",dzglue2);
1864  }
1865 
1866  double dy1Glue = (m_dbManager->TILBrmin() * tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
1867  double dy2Glue = (m_dbManager->TILBrmax() * tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
1868  double heightGlue2 = (m_dbManager->TILBrmax() - m_dbManager->TILBrmin())*Gaudi::Units::cm/2.;
1869 
1870  checking("Glue 0", false, 4,
1871  dzglue2,dzglue2,dy1Glue,dy2Glue,heightGlue2);
1872 
1873  glue = new GeoTrd(dzglue2,dzglue2,dy1Glue,dy2Glue,heightGlue2);
1874 
1875  //Cs tubes in mother volume and holes in glue
1876  if (m_switches.csTube) {
1877  for (j = CurrentScin; j < (CurrentScin + m_dbManager->TILBnscin()); j++) {
1878  m_dbManager->SetCurrentScin(j);
1879 
1880  double off0 = m_dbManager->SCNTrc()*Gaudi::Units::cm - heightMother2;
1881  double off = m_dbManager->SCNTdr()/2.*Gaudi::Units::cm - csTubeOffCorr;
1882 
1883  GeoTrf::Transform3D tfHole1 = GeoTrf::Translate3D(0.,0.,(off0-off)) * GeoTrf::RotateY3D(-90*Gaudi::Units::deg);
1884  GeoTrf::Transform3D tfHole2 = GeoTrf::Translate3D(0.,0.,(off0+off)) * GeoTrf::RotateY3D(-90*Gaudi::Units::deg);
1885 
1886  // air around iron rod, around Cs tube and inside Cs tube
1887  GeoShape *air1 = new GeoTubs(csTubeOuterR, csHoleR, thicknessMother2, 0.,360.0 * Gaudi::Units::deg);
1888  GeoShape *air2 = new GeoTubs(csTubeOuterR, csHoleR, thicknessMother2, 0.,360.0 * Gaudi::Units::deg);
1889  GeoShape *air3 = new GeoTubs(0., csTubeInnerR, thicknessMother2, 0.,360.0 * Gaudi::Units::deg);
1890 
1891  GeoLogVol * lvAir1 = new GeoLogVol("CsTubeAir1",air1,matAir);
1892  GeoLogVol * lvAir2 = new GeoLogVol("CsTubeAir2",air2,matAir);
1893  GeoLogVol * lvAir3 = new GeoLogVol("CsTubeAir3",air3,matAir);
1894  GeoPhysVol * pvAir1 = new GeoPhysVol(lvAir1);
1895  GeoPhysVol * pvAir2 = new GeoPhysVol(lvAir2);
1896  GeoPhysVol * pvAir3 = new GeoPhysVol(lvAir3);
1897 
1898  GeoTransform* tftube1 = new GeoTransform(tfHole1);
1899  GeoTransform* tftube2 = new GeoTransform(tfHole2);
1900  GeoTransform* tftube3 = new GeoTransform(tfHole2);
1901 
1902  mother->add(tftube1);
1903  mother->add(pvAir1);
1904  mother->add(tftube2);
1905  mother->add(pvAir2);
1906  mother->add(tftube3);
1907  mother->add(pvAir3);
1908 
1909  //Holes in Glue
1910  if (glue) {
1911  glue = makeHoles(glue, csHoleR, dzglue2, off, off0);
1912  }
1913  }
1914  }
1915  lvGlue = new GeoLogVol("Glue",glue,matGlue);
1916  pvGlue = new GeoPhysVol(lvGlue);
1917  }
1918 
1919  switch(period_type) {
1920  case 1:
1921  {
1922  //Ordinary period in Barrel and Extended barrel - /spacer/glue/master/glue/spacer/glue/master/glue
1923 
1924  //Glue layer
1925  if (glue) {
1926  if (m_verbose)
1927  printdouble(" glue position = ",(-3.*dzglue/2-m_dbManager->TILBdzmast())*Gaudi::Units::cm);
1928  tfGlue = new GeoTransform(GeoTrf::Translate3D((-3.*dzglue/2-m_dbManager->TILBdzmast())*Gaudi::Units::cm,0.,0.));
1929  mother->add(tfGlue);
1930  mother->add(pvGlue);
1931 
1932  if (m_verbose)
1933  printdouble(" glue position = ",-dzglue/2*Gaudi::Units::cm);
1934  tfGlue = new GeoTransform(GeoTrf::Translate3D(-dzglue/2*Gaudi::Units::cm,0.,0.));
1935  mother->add(tfGlue);
1936  mother->add(pvGlue);
1937 
1938  if (m_verbose)
1939  printdouble(" glue position = ",(dzglue/2+m_dbManager->TILBdzspac())*Gaudi::Units::cm);
1940  tfGlue = new GeoTransform(GeoTrf::Translate3D((dzglue/2+m_dbManager->TILBdzspac())*Gaudi::Units::cm,0.,0.));
1941  mother->add(tfGlue);
1942  mother->add(pvGlue);
1943 
1944  if (m_verbose)
1945  printdouble(" glue position = ",(thickness-dzglue)/2*Gaudi::Units::cm);
1946  tfGlue = new GeoTransform(GeoTrf::Translate3D((thickness-dzglue)/2*Gaudi::Units::cm,0.,0.));
1947  mother->add(tfGlue);
1948  mother->add(pvGlue);
1949  }
1950 
1951  for (j = CurrentScin; j < (CurrentScin + m_dbManager->TILBnscin()); j++) {
1952  GeoIdentifierTag* idTag = new GeoIdentifierTag(j-CurrentScin);
1953  m_dbManager->SetCurrentScin(j);
1954 
1955  scintiHeight = m_dbManager->SCNTdr();
1956  scintiRC = m_dbManager->SCNTrc();
1957  scintiZPos = zpShift * m_dbManager->SCNTzp(); // ps special module inversion
1958  scintiThickness = m_dbManager->SCNTdt();
1959  scintiWrapInZ = m_dbManager->SCNTdtw();
1960  scintiWrapInR = m_dbManager->SCNTdrw();
1961  scintiDeltaInPhi = (m_switches.uShape > 0) ? 0.0 : m_dbManager->SCNTdphi();
1962 
1963  thicknessWrapper = (m_dbManager->TILBdzspac() <= (scintiThickness + 2*scintiWrapInZ)) ?
1964  (scintiThickness + 2*scintiWrapInZ)*Gaudi::Units::cm: m_dbManager->TILBdzspac()*Gaudi::Units::cm;
1965  if (m_switches.glue == 2) thicknessWrapper = std::max(thicknessWrapper - m_additionalIronLayer, scintiThickness);
1966 
1967  // create wrapper
1968  heightWrapper = (scintiHeight + 2*scintiWrapInR)*Gaudi::Units::cm;
1969  dy1Wrapper = ((scintiRC - scintiHeight/2 - scintiWrapInR + m_dbManager->TILBrmin()) *
1970  tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
1971  dy2Wrapper = ((scintiRC + scintiHeight/2 + scintiWrapInR + m_dbManager->TILBrmin()) *
1972  tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
1973 
1974  checking("Wrapper 0", true, 5,
1975  thicknessWrapper/2,thicknessWrapper/2,dy1Wrapper,dy2Wrapper,heightWrapper/2);
1976 
1977  wrapper = new GeoTrd(thicknessWrapper/2,
1978  thicknessWrapper/2,
1979  dy1Wrapper,
1980  dy2Wrapper,
1981  heightWrapper/2);
1982 
1983  if (m_switches.csTube) {
1984  wrapper = makeHoles(wrapper, csHoleR, thicknessWrapper/2, scintiHeight/2.*Gaudi::Units::cm - csTubeOffCorr);
1985  }
1986  lvWrapper = new GeoLogVol("Wrapper",wrapper,matAir);
1987  pvWrapper = new GeoPhysVol(lvWrapper);
1988 
1989  // create scintillator
1990  dy1Scintillator = ((scintiRC - scintiHeight/2 + m_dbManager->TILBrmin()) *
1991  tan_delta_phi_2 - m_dbManager->TILBphigap()/2 - scintiDeltaInPhi)*Gaudi::Units::cm;
1992  dy2Scintillator = ((scintiRC + scintiHeight/2 + m_dbManager->TILBrmin()) *
1993  tan_delta_phi_2 - m_dbManager->TILBphigap()/2 - scintiDeltaInPhi)*Gaudi::Units::cm;
1994 
1995  checking("Scintillator 0", true, 6,
1996  scintiThickness/2*Gaudi::Units::cm,scintiThickness/2*Gaudi::Units::cm,dy1Scintillator,dy2Scintillator,scintiHeight/2*Gaudi::Units::cm);
1997 
1998  scintillator = new GeoTrd(scintiThickness/2*Gaudi::Units::cm,
1999  scintiThickness/2*Gaudi::Units::cm,
2000  dy1Scintillator,
2001  dy2Scintillator,
2002  scintiHeight/2*Gaudi::Units::cm);
2003 
2004  if (m_switches.csTube) {
2005  scintillator = makeHolesScint(scintillator, csHoleR, scintiThickness/2 * Gaudi::Units::cm, scintiHeight/2.*Gaudi::Units::cm - csTubeOffCorr);
2006  }
2007  lvScintillator = new GeoLogVol("Scintillator",scintillator,matScin);
2008  pvScintillator = new GeoPhysVol(lvScintillator);
2009 
2010  // place scintillator in wrapper
2011  tfScintillator = new GeoTransform(GeoTrf::Translate3D(0.,0.,0.));
2012  pvWrapper->add(idTag);
2013  pvWrapper->add(tfScintillator);
2014  pvWrapper->add(pvScintillator);
2015 
2016  //place wrapper in period
2017  if (m_verbose) {
2018  (*m_log) << MSG::VERBOSE <<" X scintiZPos= "<<scintiZPos;
2019  printdouble(" ==> ",(scintiZPos*thickness+m_dbManager->TILBdzspac()/2)*Gaudi::Units::cm);
2020  (*m_log) << MSG::VERBOSE <<" Y scintiRC= "<<scintiRC <<endmsg;
2021  }
2022 
2023  tfWrapper = new GeoTransform(GeoTrf::Translate3D((scintiZPos*thickness+m_dbManager->TILBdzspac()/2)*Gaudi::Units::cm,
2024  0.,
2025  (scintiRC-(m_dbManager->TILBrmax()-m_dbManager->TILBrmin())/2)*Gaudi::Units::cm));
2026  mother->add(idTag);
2027  mother->add(tfWrapper);
2028  mother->add(pvWrapper);
2029  }
2030  break;
2031  }
2032  case 2:
2033  {
2034  //Special period in the barrel - /spacer/glue/master/glue/spacer
2035 
2036  //Glue layer
2037  if (glue) {
2038  if (m_verbose)
2039  printdouble(" glue position = ",(dzglue + m_dbManager->TILBdzmast())*Gaudi::Units::cm/2);
2040  tfGlue = new GeoTransform(GeoTrf::Translate3D((dzglue + m_dbManager->TILBdzmast())*Gaudi::Units::cm/2,0.,0.));
2041  mother->add(tfGlue);
2042  mother->add(pvGlue);
2043 
2044  if (m_verbose)
2045  printdouble(" glue position = ",-(dzglue + m_dbManager->TILBdzmast())*Gaudi::Units::cm/2);
2046  tfGlue = new GeoTransform(GeoTrf::Translate3D(-(dzglue + m_dbManager->TILBdzmast())*Gaudi::Units::cm/2,0.,0.));
2047  mother->add(tfGlue);
2048  mother->add(pvGlue);
2049  }
2050 
2051  for (j = CurrentScin; j < (CurrentScin + m_dbManager->TILBnscin()); j++) {
2052  GeoIdentifierTag* idTag = new GeoIdentifierTag(j-CurrentScin);
2053  m_dbManager->SetCurrentScin(j);
2054 
2055  scintiHeight = m_dbManager->SCNTdr();
2056  scintiRC = m_dbManager->SCNTrc();
2057  scintiZPos = m_dbManager->SCNTzp();
2058  scintiThickness = m_dbManager->SCNTdt();
2059  scintiWrapInZ = m_dbManager->SCNTdtw();
2060  scintiWrapInR = m_dbManager->SCNTdrw();
2061  scintiDeltaInPhi = (m_switches.uShape > 0) ? 0.0 : m_dbManager->SCNTdphi();
2062 
2063  thicknessWrapper = (m_dbManager->TILBdzspac() <= (scintiThickness + 2*scintiWrapInZ)) ?
2064  (scintiThickness + 2*scintiWrapInZ)*Gaudi::Units::cm: m_dbManager->TILBdzspac()*Gaudi::Units::cm;
2065  if (m_switches.glue == 2) thicknessWrapper = std::max(thicknessWrapper - m_additionalIronLayer, scintiThickness);
2066 
2067  // create wrapper
2068  heightWrapper = (scintiHeight + 2*scintiWrapInR)*Gaudi::Units::cm;
2069  dy1Wrapper = ((scintiRC - scintiHeight/2 - scintiWrapInR + m_dbManager->TILBrmin()) *
2070  tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
2071  dy2Wrapper = ((scintiRC + scintiHeight/2 + scintiWrapInR + m_dbManager->TILBrmin()) *
2072  tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
2073 
2074  checking("Wrapper 1", true, 5,
2075  thicknessWrapper/2,thicknessWrapper/2,dy1Wrapper,dy2Wrapper,heightWrapper/2);
2076 
2077  wrapper = new GeoTrd(thicknessWrapper/2,
2078  thicknessWrapper/2,
2079  dy1Wrapper,
2080  dy2Wrapper,
2081  heightWrapper/2);
2082 
2083  if (m_switches.csTube) {
2084  wrapper = makeHoles(wrapper, csHoleR, thicknessWrapper/2, scintiHeight/2.*Gaudi::Units::cm - csTubeOffCorr);
2085  }
2086  lvWrapper = new GeoLogVol("Wrapper",wrapper,matAir);
2087  pvWrapper = new GeoPhysVol(lvWrapper);
2088 
2089  // create scintillator
2090  dy1Scintillator = ((scintiRC - scintiHeight/2 + m_dbManager->TILBrmin()) *
2091  tan_delta_phi_2 - m_dbManager->TILBphigap()/2 - scintiDeltaInPhi)*Gaudi::Units::cm;
2092  dy2Scintillator = ((scintiRC + scintiHeight/2 + m_dbManager->TILBrmin()) *
2093  tan_delta_phi_2 - m_dbManager->TILBphigap()/2 - scintiDeltaInPhi)*Gaudi::Units::cm;
2094 
2095  checking("Scintillator 1", true, 6,
2096  scintiThickness/2*Gaudi::Units::cm,scintiThickness/2*Gaudi::Units::cm,dy1Scintillator,dy2Scintillator,scintiHeight/2*Gaudi::Units::cm);
2097 
2098  scintillator = new GeoTrd(scintiThickness/2*Gaudi::Units::cm,
2099  scintiThickness/2*Gaudi::Units::cm,
2100  dy1Scintillator,
2101  dy2Scintillator,
2102  scintiHeight/2*Gaudi::Units::cm);
2103 
2104  if (m_switches.csTube) {
2105  scintillator = makeHolesScint(scintillator, csHoleR, scintiThickness/2 * Gaudi::Units::cm, scintiHeight/2.*Gaudi::Units::cm - csTubeOffCorr);
2106  }
2107  lvScintillator = new GeoLogVol("Scintillator",scintillator,matScin);
2108  pvScintillator = new GeoPhysVol(lvScintillator);
2109 
2110  // place scintillator in wrapper
2111  tfScintillator = new GeoTransform(GeoTrf::Translate3D(0.,0.,0.));
2112  pvWrapper->add(idTag);
2113  pvWrapper->add(tfScintillator);
2114  pvWrapper->add(pvScintillator);
2115 
2116  //place wrapper in period
2117  if (m_verbose) {
2118  (*m_log) << MSG::VERBOSE <<" X scintiZPos= "<<scintiZPos;
2119  printdouble(" ==> ",(2*scintiZPos+0.5)*(thickness-m_dbManager->TILBdzspac())*Gaudi::Units::cm);
2120  (*m_log) << MSG::VERBOSE <<" Y scintiRC= "<<scintiRC <<endmsg;
2121  }
2122 
2123  tfWrapper = new GeoTransform(GeoTrf::Translate3D((2*scintiZPos+0.5)*(thickness-m_dbManager->TILBdzspac())*Gaudi::Units::cm,
2124  0.,
2125  (scintiRC-(m_dbManager->TILBrmax()-m_dbManager->TILBrmin())/2)*Gaudi::Units::cm));
2126  mother->add(idTag);
2127  mother->add(tfWrapper);
2128  mother->add(pvWrapper);
2129  }
2130  break;
2131  }
2132  case 3:
2133  {
2134  //Ordinary period in Plug Section 1 - /glue/master/glue/spacer/glue/master/glue/spacer
2135 
2136  //Glue layer
2137  if (glue) {
2138  if (m_verbose)
2139  printdouble(" glue position = ",(-thickness + dzglue)*Gaudi::Units::cm/2);
2140  tfGlue = new GeoTransform(GeoTrf::Translate3D((-thickness + dzglue)*Gaudi::Units::cm/2,0.,0.));
2141  mother->add(tfGlue);
2142  mother->add(pvGlue);
2143 
2144  if (m_verbose)
2145  printdouble(" glue position = ",((-thickness + 3*dzglue)+m_dbManager->TILBdzmast())/2*Gaudi::Units::cm);
2146  tfGlue = new GeoTransform(GeoTrf::Translate3D(((-thickness + 3*dzglue)+m_dbManager->TILBdzmast())/2*Gaudi::Units::cm,0.,0.));
2147  mother->add(tfGlue);
2148  mother->add(pvGlue);
2149 
2150  if (m_verbose)
2151  printdouble(" glue position = ",dzglue/2*Gaudi::Units::cm);
2152  tfGlue = new GeoTransform(GeoTrf::Translate3D(dzglue/2*Gaudi::Units::cm,0.,0.));
2153  mother->add(tfGlue);
2154  mother->add(pvGlue);
2155 
2156  if (m_verbose)
2157  printdouble(" glue position = ",(3.*dzglue/2 + m_dbManager->TILBdzmast())*Gaudi::Units::cm);
2158  tfGlue = new GeoTransform(GeoTrf::Translate3D((3.*dzglue/2 + m_dbManager->TILBdzmast())*Gaudi::Units::cm,0.,0.));
2159  mother->add(tfGlue);
2160  mother->add(pvGlue);
2161  }
2162 
2163  for (j = CurrentScin; j < (CurrentScin + m_dbManager->TILBnscin()); j++) {
2164  GeoIdentifierTag* idTag = new GeoIdentifierTag(j-CurrentScin);
2165  m_dbManager->SetCurrentScin(j);
2166 
2167  scintiHeight = m_dbManager->SCNTdr();
2168  scintiRC = m_dbManager->SCNTrc();
2169  scintiZPos = m_dbManager->SCNTzp();
2170  scintiThickness = m_dbManager->SCNTdt();
2171  scintiWrapInZ = m_dbManager->SCNTdtw();
2172  scintiWrapInR = m_dbManager->SCNTdrw();
2173  scintiDeltaInPhi = (m_switches.uShape > 0) ? 0. : m_dbManager->SCNTdphi();
2174 
2175  thicknessWrapper = (m_dbManager->TILBdzspac() <= (scintiThickness + 2*scintiWrapInZ)) ?
2176  (scintiThickness + 2*scintiWrapInZ)*Gaudi::Units::cm: m_dbManager->TILBdzspac()*Gaudi::Units::cm;
2177  if (m_switches.glue == 2) thicknessWrapper = std::max(thicknessWrapper - m_additionalIronLayer, scintiThickness);
2178 
2179  // create wrapper
2180  heightWrapper = (scintiHeight + 2*scintiWrapInR)*Gaudi::Units::cm;
2181 
2182  dy1Wrapper = ((scintiRC - scintiHeight/2 - scintiWrapInR + m_dbManager->TILBrmin()) *
2183  tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
2184  dy2Wrapper = ((scintiRC + scintiHeight/2 + scintiWrapInR + m_dbManager->TILBrmin()) *
2185  tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
2186 
2187  checking("Wrapper 2", true, 5,
2188  thicknessWrapper/2,thicknessWrapper/2,dy1Wrapper,dy2Wrapper,heightWrapper/2);
2189 
2190  wrapper = new GeoTrd(thicknessWrapper/2,
2191  thicknessWrapper/2,
2192  dy1Wrapper,
2193  dy2Wrapper,
2194  heightWrapper/2);
2195 
2196  if (m_switches.csTube) {
2197  wrapper = makeHoles(wrapper, csHoleR, thicknessWrapper/2, scintiHeight/2.*Gaudi::Units::cm - csTubeOffCorr);
2198  }
2199  lvWrapper = new GeoLogVol("Wrapper",wrapper,matAir);
2200  pvWrapper = new GeoPhysVol(lvWrapper);
2201 
2202  // create scintillator
2203  dy1Scintillator = ((scintiRC - scintiHeight/2 + m_dbManager->TILBrmin()) *
2204  tan_delta_phi_2 - m_dbManager->TILBphigap()/2 - scintiDeltaInPhi)*Gaudi::Units::cm;
2205  dy2Scintillator = ((scintiRC + scintiHeight/2 + m_dbManager->TILBrmin()) *
2206  tan_delta_phi_2 - m_dbManager->TILBphigap()/2 - scintiDeltaInPhi)*Gaudi::Units::cm;
2207 
2208  checking("Scintillator 2", true, 6,
2209  scintiThickness/2*Gaudi::Units::cm,scintiThickness/2*Gaudi::Units::cm,dy1Scintillator,dy2Scintillator,scintiHeight/2*Gaudi::Units::cm);
2210 
2211  scintillator = new GeoTrd(scintiThickness/2*Gaudi::Units::cm,
2212  scintiThickness/2*Gaudi::Units::cm,
2213  dy1Scintillator,
2214  dy2Scintillator,
2215  scintiHeight/2*Gaudi::Units::cm);
2216 
2217  if (m_switches.csTube) {
2218  scintillator = makeHolesScint(scintillator, csHoleR, scintiThickness/2 * Gaudi::Units::cm, scintiHeight/2.*Gaudi::Units::cm - csTubeOffCorr);
2219  }
2220  lvScintillator = new GeoLogVol("Scintillator",scintillator,matScin);
2221  pvScintillator = new GeoPhysVol(lvScintillator);
2222 
2223  // place scintillator in wrapper
2224  tfScintillator = new GeoTransform(GeoTrf::Translate3D(0.,0.,0.));
2225  pvWrapper->add(idTag);
2226  pvWrapper->add(tfScintillator);
2227  pvWrapper->add(pvScintillator);
2228 
2229  //place wrapper in period
2230  if (m_verbose) {
2231  (*m_log) << MSG::VERBOSE <<" X scintiZPos= "<<scintiZPos;
2232  printdouble(" ==> ",(scintiZPos*thickness-m_dbManager->TILBdzspac()/2)*Gaudi::Units::cm);
2233  (*m_log) << MSG::VERBOSE <<" Y scintiRC= "<<scintiRC <<endmsg;
2234  }
2235 
2236  tfWrapper = new GeoTransform(GeoTrf::Translate3D((scintiZPos*thickness-m_dbManager->TILBdzspac()/2)*Gaudi::Units::cm,
2237  0.,
2238  (scintiRC-(m_dbManager->TILBrmax()-m_dbManager->TILBrmin())/2)*Gaudi::Units::cm));
2239  mother->add(idTag);
2240  mother->add(tfWrapper);
2241  mother->add(pvWrapper);
2242  }
2243  break;
2244  }
2245  case 4:
2246  {
2247  //Special period in Plug Section - /spacer
2248 
2249  for (j = CurrentScin; j < (CurrentScin + m_dbManager->TILBnscin()); j++) {
2250  m_dbManager->SetCurrentScin(j);
2251 
2252  scintiHeight = m_dbManager->SCNTdr();
2253  scintiRC = m_dbManager->SCNTrc();
2254  scintiZPos = zpShift * m_dbManager->SCNTzp(); // ps special module inversion
2255  scintiThickness = m_dbManager->SCNTdt();
2256  scintiWrapInZ = m_dbManager->SCNTdtw();
2257  scintiWrapInR = m_dbManager->SCNTdrw();
2258  scintiDeltaInPhi = (m_switches.uShape > 0) ? 0.0 : m_dbManager->SCNTdphi();
2259 
2260  thicknessWrapper = (m_dbManager->TILBdzspac() <= (scintiThickness + 2*scintiWrapInZ)) ?
2261  (scintiThickness + 2*scintiWrapInZ)*Gaudi::Units::cm: m_dbManager->TILBdzspac()*Gaudi::Units::cm;
2262  if (m_switches.glue == 2) thicknessWrapper = std::max(thicknessWrapper - m_additionalIronLayer, scintiThickness);
2263 
2264  if (scintiZPos<0) {
2265  GeoIdentifierTag* idTag = new GeoIdentifierTag(j-CurrentScin);
2266  // create wrapper
2267  heightWrapper = (scintiHeight + 2*scintiWrapInR)*Gaudi::Units::cm;
2268  dy1Wrapper = ((scintiRC - scintiHeight/2 - scintiWrapInR + m_dbManager->TILBrmin()) *
2269  tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
2270  dy2Wrapper = ((scintiRC + scintiHeight/2 + scintiWrapInR + m_dbManager->TILBrmin()) *
2271  tan_delta_phi_2 - m_dbManager->TILBphigap()/2)*Gaudi::Units::cm;
2272 
2273  checking("Wrapper 3", true, 5,
2274  thicknessWrapper/2,thicknessWrapper/2,dy1Wrapper,dy2Wrapper,heightWrapper/2);
2275 
2276  wrapper = new GeoTrd(thicknessWrapper/2,
2277  thicknessWrapper/2,
2278  dy1Wrapper,
2279  dy2Wrapper,
2280  heightWrapper/2);
2281 
2282  if (m_switches.csTube) {
2283  wrapper = makeHoles(wrapper, csHoleR, thicknessWrapper/2, scintiHeight/2.*Gaudi::Units::cm - csTubeOffCorr);
2284  }
2285  lvWrapper = new GeoLogVol("Wrapper",wrapper,matAir);
2286  pvWrapper = new GeoPhysVol(lvWrapper);
2287 
2288  // create scintillator
2289  dy1Scintillator = ((scintiRC - scintiHeight/2 + m_dbManager->TILBrmin()) *
2290  tan_delta_phi_2 - m_dbManager->TILBphigap()/2 - scintiDeltaInPhi)*Gaudi::Units::cm;
2291  dy2Scintillator = ((scintiRC + scintiHeight/2 + m_dbManager->TILBrmin()) *
2292  tan_delta_phi_2 - m_dbManager->TILBphigap()/2 - scintiDeltaInPhi)*Gaudi::Units::cm;
2293 
2294  checking("Scintillator 3", true, 6,
2295  scintiThickness/2*Gaudi::Units::cm,scintiThickness/2*Gaudi::Units::cm,dy1Scintillator,dy2Scintillator,scintiHeight/2*Gaudi::Units::cm);
2296 
2297  scintillator = new GeoTrd(scintiThickness/2*Gaudi::Units::cm,
2298  scintiThickness/2*Gaudi::Units::cm,
2299  dy1Scintillator,
2300  dy2Scintillator,
2301  scintiHeight/2*Gaudi::Units::cm);
2302 
2303  if (m_switches.csTube) {
2304  scintillator = makeHolesScint(scintillator, csHoleR, scintiThickness/2 * Gaudi::Units::cm, scintiHeight/2.*Gaudi::Units::cm - csTubeOffCorr);
2305  }
2306  lvScintillator = new GeoLogVol("Scintillator",scintillator,matScin);
2307  pvScintillator = new GeoPhysVol(lvScintillator);
2308 
2309  // place scintillator in wrapper
2310  tfScintillator = new GeoTransform(GeoTrf::Translate3D(0.,0.,0.));
2311  pvWrapper->add(idTag);
2312  pvWrapper->add(tfScintillator);
2313  pvWrapper->add(pvScintillator);
2314 
2315  //place wrapper in period
2316  if (m_verbose) {
2317  (*m_log) << MSG::VERBOSE <<" X scintiZPos= "<<0.0 <<endmsg;
2318  (*m_log) << MSG::VERBOSE <<" Y scintiRC= "<<scintiRC <<endmsg;
2319  }
2320 
2321  tfWrapper = new GeoTransform(GeoTrf::Translate3D(0.,
2322  0.,
2323  (scintiRC-(m_dbManager->TILBrmax()-m_dbManager->TILBrmin())/2)*Gaudi::Units::cm));
2324  mother->add(idTag);
2325  mother->add(tfWrapper);
2326  mother->add(pvWrapper);
2327  }
2328  }
2329  break;
2330  }
2331  default:
2332  {
2333  //Scintillator layers in Plug Sections 3 and 4
2334 
2335  // checking shape of mother volume.
2336  double dy1Period = period->getYHalfLength1();
2337  double tanphi = (period->getYHalfLength2()-dy1Period)/period->getZHalfLength()/2.;
2338  if (m_log->level()<=MSG::DEBUG)
2339  if (std::abs(tanphi-tan_delta_phi_2) > 1.e-5)
2340  (*m_log) << MSG::DEBUG <<"Different tan_delta_phi_2 " << tanphi << " " << tan_delta_phi_2 <<endmsg;
2341 
2342  for (j = CurrentScin; j < (CurrentScin + m_dbManager->TILBnscin()); j++) {
2343  GeoIdentifierTag* idTag = new GeoIdentifierTag(j-CurrentScin);
2344  m_dbManager->SetCurrentScin(j);
2345 
2346  scintiHeight = m_dbManager->SCNTdr();
2347  scintiRC = m_dbManager->SCNTrc();
2348  scintiZPos = m_dbManager->SCNTzp();
2349  scintiThickness = m_dbManager->SCNTdt();
2350  scintiWrapInZ = m_dbManager->SCNTdtw();
2351  scintiWrapInR = m_dbManager->SCNTdrw();
2352  scintiDeltaInPhi = m_dbManager->SCNTdphi(); // don't need to check m_uShape for single scintillator
2353 
2354  // create wrapper
2355  heightWrapper = (scintiHeight + 2*scintiWrapInR)*Gaudi::Units::cm;
2356  thicknessWrapper = (scintiThickness + 2*scintiWrapInZ)*Gaudi::Units::cm;
2357  if (m_switches.glue == 2) thicknessWrapper = std::max(thicknessWrapper - m_additionalIronLayer, scintiThickness);
2358 
2359  double thicknessEnvelope = (m_dbManager->TILBdzmodul()*Gaudi::Units::cm - thicknessWrapper); // along phi thickness is twice bigger than along Z
2360  dy1Wrapper = dy1Period - thicknessEnvelope + ((scintiRC - scintiHeight/2. - scintiWrapInR)*tanphi)*Gaudi::Units::cm;
2361  dy2Wrapper = dy1Period - thicknessEnvelope + ((scintiRC + scintiHeight/2. + scintiWrapInR)*tanphi)*Gaudi::Units::cm;
2362 
2363  if (m_log->level()<=MSG::DEBUG)
2364  (*m_log) << MSG::DEBUG <<"Envelope thickness is " << thicknessEnvelope <<endmsg;
2365  checking("Wrapper 4", true, 5,
2366  thicknessWrapper/2,thicknessWrapper/2,dy1Wrapper,dy2Wrapper,heightWrapper/2);
2367 
2368  wrapper = new GeoTrd(thicknessWrapper/2,
2369  thicknessWrapper/2,
2370  dy1Wrapper,
2371  dy2Wrapper,
2372  heightWrapper/2);
2373  lvWrapper = new GeoLogVol("Wrapper",wrapper,matAir);
2374  pvWrapper = new GeoPhysVol(lvWrapper);
2375 
2376  // create scintillator
2377  dy1Scintillator = dy1Period - thicknessEnvelope + ((scintiRC - scintiHeight/2.)*tanphi - scintiDeltaInPhi)*Gaudi::Units::cm;
2378  dy2Scintillator = dy1Period - thicknessEnvelope + ((scintiRC + scintiHeight/2.)*tanphi - scintiDeltaInPhi)*Gaudi::Units::cm;
2379 
2380  checking("Scintillator 4", true, 6,
2381  scintiThickness/2*Gaudi::Units::cm,scintiThickness/2*Gaudi::Units::cm,dy1Scintillator,dy2Scintillator,scintiHeight/2*Gaudi::Units::cm);
2382 
2383  scintillator = new GeoTrd(scintiThickness/2*Gaudi::Units::cm,
2384  scintiThickness/2*Gaudi::Units::cm,
2385  dy1Scintillator,
2386  dy2Scintillator,
2387  scintiHeight/2*Gaudi::Units::cm);
2388  lvScintillator = new GeoLogVol("Scintillator",scintillator,matScin);
2389  pvScintillator = new GeoPhysVol(lvScintillator);
2390 
2391  // place scintillator in wrapper
2392  tfScintillator = new GeoTransform(GeoTrf::Translate3D(0.,0.,0.));
2393  pvWrapper->add(idTag);
2394  pvWrapper->add(tfScintillator);
2395  pvWrapper->add(pvScintillator);
2396 
2397  //place wrapper in period
2398  if (m_verbose) {
2399  (*m_log) << MSG::VERBOSE <<" X scintiZPos= "<<0.0 <<endmsg;
2400  (*m_log) << MSG::VERBOSE <<" Y scintiRC= "<<scintiRC <<endmsg;
2401  }
2402 
2403  tfWrapper = new GeoTransform(GeoTrf::Translate3D(0.,
2404  0.,
2405  (scintiRC-(m_dbManager->TILBrmax()-m_dbManager->TILBrmin())/2)*Gaudi::Units::cm));
2406  mother->add(idTag);
2407  mother->add(tfWrapper);
2408  mother->add(pvWrapper);
2409  }
2410  break;
2411  }
2412  }
2413 }
2414 
2415 
2416 // Checking geometry dimensions for all directions
2417 
2418 void TileGeoSectionBuilder::checking(const std::string& Name, bool print, int level,
2419  double X1, double X2, double Y1, double Y2, double Z)
2420 {
2421  double rless = .005; //5 [mkm]
2422  std::string Step[8] = {" ",
2423  " ",
2424  " ",
2425  " ",
2426  " ",
2427  " ",
2428  " ",
2429  " "};
2430  if (print) {
2431  if (m_log->level()<=MSG::DEBUG)
2432  (*m_log) << MSG::DEBUG <<Step[level]<<Name<<" -"<<level
2433  << std::setiosflags(std::ios::fixed) << std::setw(9) << std::setprecision(4)
2434  <<" dX1,dX2= "<<X1<<" "<<X2
2435  <<" dY1,dY2= "<<Y1<<" "<<Y2
2436  <<" dZ= "<<Z
2437  << std::resetiosflags(std::ios::fixed)
2438  <<endmsg;
2439  }
2440  if (X1 < rless && X2 < rless) {
2441  (*m_log) << MSG::WARNING <<" volume "<<Name<<" is empty, X1 or X2<0 "<<endmsg;
2442  }
2443  if (Y1 < rless && Y2 < rless) {
2444  (*m_log) << MSG::WARNING <<" volume "<<Name<<" is empty, Y1 or Y2<0 "<<endmsg;
2445  }
2446  if (Z < rless) {
2447  (*m_log) << MSG::WARNING <<" volume "<<Name<<" is empty, Z<0 "<<endmsg;
2448  }
2449 }
2450 
2451 
2452 // -- Readout
2453 
2454 void TileGeoSectionBuilder::fillDescriptor(TileDetDescriptor*& descriptor,
2455  unsigned int detector,
2456  int side,
2457  bool testbeam,
2458  bool addPlates,
2459  unsigned int nphi,
2460  float zshift)
2461 {
2462  // auxillary variables
2463  unsigned int index;
2464  int currentSample, etaIndex, nsamp;
2465  std::vector<int> samples; // samples of a given region
2466  std::vector<int> firstScin; // first scintillator for samples of a given region
2467  std::vector<int> lastScin; // last scintillator for samples of a given region
2468 
2469  // -- default values for all regions
2470  // they are overwritten later in calculateR() by actual values taken from DB
2471  float phi_min, phi_max;
2472  float dphi = 2.0f*M_PI/64;
2473 
2474  if (testbeam) { // put modules symmetricaly
2475  phi_max = nphi*dphi/2;
2476  phi_min = -phi_max;
2477  } else { // put edge of very first module on horizontal plane
2478  phi_min = 0.;
2479  phi_max = nphi * dphi;
2480  }
2481 
2482  // Hardcoded values for R/dR
2483  float rBarrel[] = {2450., 3020., 3630.};
2484  float drBarrel[] = {300., 840., 380.};
2485 
2486  float rExtended[] = {2450., 2870., 3480.};
2487  float drExtended[] = {300., 540., 680.};
2488 
2489  float rGap[] = {3215., 3630., 2802.5, 2475.5, 2066., 1646.};
2490  float drGap[] = {450., 380., 313., 341., 478., 362.};
2491 
2492  if (addPlates) {
2493  rBarrel[0] -= 10*Gaudi::Units::mm/2;
2494  rBarrel[2] += 40*Gaudi::Units::mm/2;
2495  drBarrel[0] += 10*Gaudi::Units::mm;
2496  drBarrel[2] += 40*Gaudi::Units::mm;
2497  rExtended[0] -= 10*Gaudi::Units::mm/2;
2498  rExtended[2] += 40*Gaudi::Units::mm/2;
2499  drExtended[0] += 10*Gaudi::Units::mm;
2500  drExtended[2] += 40*Gaudi::Units::mm;
2501  rGap[1] += 40*Gaudi::Units::mm/2;
2502  drGap[1] += 40*Gaudi::Units::mm;
2503  }
2504 
2505  int indHardcoded = 0;
2506 
2507  // --------------------------------
2508 
2509  // -- initialize all necessary arrays with 0.
2510  std::vector<float> eta_min (MAX_N_SAMP_TILEDD, 0.);
2511  std::vector<float> eta_max (MAX_N_SAMP_TILEDD, 0.);
2512  std::vector<float> deta (MAX_N_SAMP_TILEDD, 0.);
2513  std::vector<unsigned int> neta (size_t(MAX_N_SAMP_TILEDD), 0U);
2514  std::vector<float> rcenter (MAX_N_SAMP_TILEDD, 0.);
2515  std::vector<float> dr (MAX_N_SAMP_TILEDD, 0.);
2516  std::vector<float> zcenter (MAX_N_SAMP_TILEDD, 0.);
2517  std::vector<float> dz (MAX_N_SAMP_TILEDD, 0.);
2518 
2519  // ---------------------------------
2520 
2521  // Set side
2522  int sign_eta = (side>0) ? 1 : -1;
2523 
2524 
2525  // iterate over all samples of the region and fill corresponding eta values.
2526  // this works for Central and Extended Barrel regions only!
2527  if (detector==TILE_REGION_CENTRAL || detector == TILE_REGION_EXTENDED) {
2528  // -- Calculate number of samples for the region
2529  // find first TICL for the given detector
2530  if (m_dbManager->SetFirstTiclInDet(detector)) {
2531  // for the central barrel region take care of the side
2532  if (detector == TILE_REGION_CENTRAL) {
2533  while (sign_eta * m_dbManager->TICLncell() < 0) {
2534  if (!(m_dbManager->SetNextTiclInDet())) {
2535  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::fillDescriptor: No TICL structures for detector: "
2536  << detector << " and side: " << sign_eta << endmsg;
2537  return;
2538  }
2539  }
2540  }
2541 
2542  samples.push_back((int)m_dbManager->TICLsample());
2543  firstScin.push_back((int)m_dbManager->TICLfirstrow());
2544  lastScin.push_back((int)m_dbManager->TICLlastrow());
2545 
2546  // iterate over all other TICLs in the detector
2547  while (m_dbManager->SetNextTiclInDet()) {
2548  if (!((detector == TILE_REGION_CENTRAL)&&(sign_eta * m_dbManager->TICLncell() < 0))) {
2549  // find if the sample of the cell is already in the samples vector
2550  // and if not then add it
2551  currentSample = (int)m_dbManager->TICLsample();
2552  for (index=0; index<samples.size(); index++)
2553  if (currentSample==samples[index]) break;
2554  if (index==samples.size()) {
2555  samples.push_back(currentSample);
2556  firstScin.push_back((int)m_dbManager->TICLfirstrow());
2557  lastScin.push_back((int)m_dbManager->TICLlastrow());
2558  }
2559  }
2560  }
2561 
2562  } else {
2563  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::fillDescriptor: No TICL structures for the detector: "
2564  << detector << endmsg;
2565  return;
2566  }
2567 
2568  nsamp = 0;
2569  for (index=0; index<samples.size(); index++, indHardcoded++) {
2570  etaIndex = samples[index];
2571  if (etaIndex > nsamp) nsamp = etaIndex;
2572  calculateEta(detector,
2573  side,
2574  etaIndex,
2575  eta_min[etaIndex-1], // In TICL structures samples are numbered from 1
2576  eta_max[etaIndex-1],
2577  deta[etaIndex-1],
2578  neta[etaIndex-1]);
2579  calculateZ(detector,
2580  side,
2581  etaIndex,
2582  zshift,
2583  zcenter[etaIndex-1],
2584  dz[etaIndex-1]);
2585 
2586  // Fill in the hardcoded values
2587  if (detector == TILE_REGION_CENTRAL) {
2588  rcenter[etaIndex-1] = rBarrel[indHardcoded];
2589  dr[etaIndex-1] = drBarrel[indHardcoded];
2590  } else {
2591  rcenter[etaIndex-1] = rExtended[indHardcoded];
2592  dr[etaIndex-1] = drExtended[indHardcoded];
2593  }
2594  calculateR(detector,
2595  etaIndex,
2596  addPlates,
2597  firstScin[index],
2598  lastScin[index],
2599  rcenter[etaIndex-1],
2600  dr[etaIndex-1]);
2601  }
2602 
2603  } else if (detector == TILE_REGION_GAP) {
2604  // We are in GAP detectors (detector = 3 & 4)
2605  // Loop over all TICL structures of these detectors
2606  // Determine eta_min, eta_max, deta
2607  // neta = 1 for all
2608  //
2609  // !!! For DETECTOR=4 INDEX is set by TOWER and NOT SAMPLE !!!
2610  //
2611 
2612  nsamp = 0;
2613  for (unsigned int det = detector; det < detector+2; det++)
2614  for (int status=m_dbManager->SetFirstTiclInDet(det); status>0; status=m_dbManager->SetNextTiclInDet()) {
2615  if ((int)m_dbManager->TICLtower()>16) continue;
2616  if (det==detector)
2617  etaIndex = (int)m_dbManager->TICLsample();
2618  else
2619  etaIndex = (int)m_dbManager->TICLtower();
2620  if (etaIndex > nsamp) nsamp = etaIndex;
2621  // simple calculations of eta for one cell
2622  neta[etaIndex-1] = 1;
2623  deta[etaIndex-1] = m_dbManager->TICLdeta();
2624  eta_min[etaIndex-1] = m_dbManager->TICLeta() - m_dbManager->TICLdeta()/2;
2625  eta_max[etaIndex-1] = m_dbManager->TICLeta() + m_dbManager->TICLdeta()/2;
2626  calculateZ(detector,
2627  side,
2628  etaIndex,
2629  zshift,
2630  zcenter[etaIndex-1],
2631  dz[etaIndex-1]);
2632 
2633  // Fill in the hardcoded values
2634  rcenter[etaIndex-1] = rGap[indHardcoded];
2635  dr[etaIndex-1] = drGap[indHardcoded];
2636  indHardcoded++;
2637  calculateR(detector,
2638  etaIndex,
2639  addPlates,
2640  m_dbManager->TICLfirstrow(),
2641  m_dbManager->TICLlastrow(),
2642  rcenter[etaIndex-1],
2643  dr[etaIndex-1]);
2644  }
2645 
2646  } else {
2647  // MBSCIN case
2648  // - should not arrive to this place !!!
2649  // TileDetDescrManager do not expect MBSCIN at all
2650  // it is kept here just in case we'll want to describe
2651  // them as a separate region
2652  //
2653  assert (detector <= TILE_REGION_GAP);
2654 
2655  // diameter: 276 - 740 - 1964
2656  // radius: 138 - 370 - 982
2657  float rMB[] = { 676., 254. };
2658  float drMB[] = { 306., 116. };
2659  float zMB = 3500;
2660  float dzMB = 30;
2661 
2662  for (int ind=0; ind<2; ++ind) {
2663  neta[ind] = 1;
2664  deta[ind] = 1.;
2665  eta_min[ind] = 2. + ind;
2666  eta_max[ind] = 3. + ind;
2667  zcenter[ind] = zMB;
2668  dz[ind] = dzMB;
2669  rcenter[ind] = rMB[ind];
2670  dr[ind] = drMB[ind];
2671  }
2672  nsamp = 2;
2673  nphi = 8;
2674  dphi = M_PI_4;
2675  phi_min = -dphi/2;
2676  phi_max = nphi * dphi + phi_min;
2677  }
2678 
2679  descriptor->set(&*eta_min.begin(),
2680  &*eta_max.begin(),
2681  &*deta.begin(),
2682  phi_min,
2683  phi_max,
2684  dphi,
2685  zshift,
2686  &*rcenter.begin(),
2687  &*dr.begin(),
2688  &*zcenter.begin(),
2689  &*dz.begin(),
2690  nsamp,
2691  &*neta.begin(),
2692  nphi,
2693  sign_eta);
2694 
2695 
2696  // debug print
2697  if (m_verbose)
2698  descriptor->print();
2699 
2700 }
2701 
2702 
2709 void TileGeoSectionBuilder::computeCellDim(TileDetDescrManager*& manager,
2710  int detector,
2711  bool addPlates,
2712  float zShiftPos,
2713  float zShiftNeg)
2714 {
2715  MLOG(DEBUG) << "TileGeoSectionBuilder::computeCellDim for detector="
2716  << detector << endmsg;
2717 
2719  std::vector<double> rmins;
2720  std::vector<double> rmaxs;
2721  std::vector<double> zmins;
2722  std::vector<double> zmaxs;
2723 
2725  int currentSample;
2726  std::vector<int> samples;
2727 
2729  unsigned int index;
2730  unsigned int CurrentScin;
2731 
2732  int nSide, nTower, nSample=0;
2733  unsigned int nFirstRow, nLastRow, nRows;
2734 
2735  double dzCell, dzPeriod;
2736  double rMin, rMax;
2737  double zEnd1 =0,zEnd2 =0,zEnd1Lim =0,zEnd2Lim =0;
2738 
2739  bool isSquare;
2740  float minTilesInRow;
2741  TileCellDim *cellDim =0, *cellDimNeg =0;
2742  // -------- Auxiliary variables ----------
2743 
2744  MLOG(DEBUG) << "Auxiliary variables..." << endmsg;
2745 
2746  // Barrel/Extended barrel regions
2747  if (detector != TILE_REGION_GAP ) {
2748  MLOG(DEBUG) << "Barrel/ExtendedBarrel regions..." << endmsg;
2749 
2750  if (detector == TILE_REGION_CENTRAL) {
2751  m_dbManager->SetCurrentSection(TileDddbManager::TILE_BARREL);
2752  dzPeriod = m_barrelPeriodThickness;
2753  } else {
2754  m_dbManager->SetCurrentSection(TileDddbManager::TILE_EBARREL);
2755  dzPeriod = m_extendedPeriodThickness;
2756  }
2757  MLOG(DEBUG) << "dzPeriod: " << dzPeriod << "\n" << endmsg;
2758 
2759 
2760  rMin = m_dbManager->TILBrmin() *Gaudi::Units::cm;
2761  if (addPlates) rMin -= m_dbManager->TILBdrfront() *Gaudi::Units::cm;
2762  int section = m_dbManager->TILBsection();
2763  if (section < 0) {
2764  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::computeCellDim: Error return from TileDddbManager::TILBsection() " << endmsg;
2765  return;
2766  }
2767  CurrentScin = 100*section + 1;
2768  //dzMaster = m_dbManager->TILBdzmast()*Gaudi::Units::cm;
2769 
2774  for (unsigned int j = CurrentScin; j < (CurrentScin + m_dbManager->TILBnscin()); j++) {
2775  m_dbManager->SetCurrentScin(j);
2776 
2777  if ( (j == CurrentScin + m_dbManager->TILBnscin() - 1) && addPlates ) {
2778  // use end of the master as end of last cell
2779  rMax = m_dbManager->TILBrmax()*Gaudi::Units::cm;
2780 
2781  } else {
2782  double tileSize=m_dbManager->SCNTdr();
2783  if (m_dbManager->SCNTdrw() > 0)
2784  // round to integer for all tiles except gap scin
2785  tileSize=round(tileSize);
2786  rMax = (m_dbManager->TILBrmin() + m_dbManager->SCNTrc() + tileSize/2)*Gaudi::Units::cm;
2787  }
2788 
2789  rmins.push_back(rMin);
2790  rmaxs.push_back(rMax);
2791  rMin = rMax;
2792 
2793  if (detector == TILE_REGION_CENTRAL) {
2794  zmins.push_back((-m_dbManager->TILBdzmast()/2 - m_barrelGlue*(1./Gaudi::Units::cm)
2795  -(m_dbManager->TILBdzmodul()/2-m_dbManager->TILBdzend1()))*Gaudi::Units::cm);
2796  zEnd1Lim = (-m_dbManager->TILBdzmodul()/2+m_dbManager->TILBdzend1())*Gaudi::Units::cm;
2797  zEnd2Lim = ( m_dbManager->TILBdzmodul()/2-m_dbManager->TILBdzend2())*Gaudi::Units::cm;
2798  zEnd1 = (-m_dbManager->TILBdzmodul()/2)*Gaudi::Units::cm;
2799  zEnd2 = ( m_dbManager->TILBdzmodul()/2)*Gaudi::Units::cm;
2800 
2801  } else {
2802  zmins.push_back((m_dbManager->TILBzoffset() - m_dbManager->TILBdzmodul()/2 + m_dbManager->TILBdzend1())*Gaudi::Units::cm);
2803  zEnd1Lim = (m_dbManager->TILBzoffset() - m_dbManager->TILBdzmodul()/2+m_dbManager->TILBdzend1()+0.001)*Gaudi::Units::cm;
2804  zEnd2Lim = (m_dbManager->TILBzoffset() + m_dbManager->TILBdzmodul()/2-m_dbManager->TILBdzend2()-0.001)*Gaudi::Units::cm;
2805  zEnd1 = (m_dbManager->TILBzoffset() - m_dbManager->TILBdzmodul()/2)*Gaudi::Units::cm;
2806  zEnd2 = (m_dbManager->TILBzoffset() + m_dbManager->TILBdzmodul()/2)*Gaudi::Units::cm;
2807  }
2808 
2809  // init all zmaxs to 0.
2810  zmaxs.push_back(0.);
2811  }
2812 
2813  // Iterate through region cells and fill in the Samples vector
2814  if (m_dbManager->SetFirstTiclInDet(detector)) {
2815  samples.push_back((int)m_dbManager->TICLsample());
2816 
2817  // iterate over all other TICLs in the detector
2818  while (m_dbManager->SetNextTiclInDet()) {
2820  currentSample = (int)m_dbManager->TICLsample();
2821  for (index=0; index<samples.size(); index++)
2822  if (currentSample==samples[index]) break;
2823  if (index==samples.size()) samples.push_back(currentSample);
2824  }
2825 
2826  } else {
2827  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::computeCellDim: No TICL structures for the detector: "
2828  << detector << endmsg;
2829  return;
2830  }
2831 
2833  for (index=0; index<samples.size(); index++) {
2834  currentSample = samples[index];
2835 
2836  if (m_dbManager->SetFirstTiclInDetSamp(detector, currentSample)) {
2837  nFirstRow = (int)m_dbManager->TICLfirstrow();
2838  // BC sample
2839  if (m_dbManager->TICLsample()==2 && detector == TILE_REGION_CENTRAL)
2840  nLastRow = nFirstRow + 2;
2841  else
2842  nLastRow = (int)m_dbManager->TICLlastrow();
2843 
2844  nRows = nLastRow - nFirstRow + 1;
2845 
2846  do {
2847  isSquare = true;
2848  minTilesInRow = m_dbManager->TICLntilesrow(0);
2849  for (unsigned int jj=1; jj<nRows; jj++) {
2850  if (m_dbManager->TICLntilesrow(jj)!=minTilesInRow)
2851  isSquare = false;
2852  if (m_dbManager->TICLntilesrow(jj)<minTilesInRow)
2853  minTilesInRow = m_dbManager->TICLntilesrow(jj);
2854  }
2855 
2856  if (isSquare)
2857  dzCell = minTilesInRow * dzPeriod;
2858  else
2859  dzCell = (minTilesInRow + 0.5) * dzPeriod;
2860 
2861  MLOG(DEBUG) << "dzCell: " << dzCell << " minTilesInRow: " << minTilesInRow << " isSquare: " << isSquare << " dzPeriod: " << dzPeriod << endmsg;
2862 
2863  for (unsigned int jj=nFirstRow; jj<=nLastRow; jj++)
2864  zmaxs[jj-1] = zmins[jj-1] + dzCell;
2865 
2866 
2868  bool BCcell = (m_dbManager->TICLsample()==2 && detector == TILE_REGION_CENTRAL);
2869  if (BCcell) {
2870  isSquare = true;
2871  int firstC = nLastRow + 1;
2872  nLastRow +=3;
2873 
2874  minTilesInRow = m_dbManager->TICLntilesrow(firstC-nFirstRow);
2875 
2876  for (unsigned int jj=firstC-nFirstRow+1; jj<=nLastRow-nFirstRow; jj++) {
2877  if (m_dbManager->TICLntilesrow(jj)!=minTilesInRow)
2878  isSquare = false;
2879  if (m_dbManager->TICLntilesrow(jj)<minTilesInRow)
2880  minTilesInRow = m_dbManager->TICLntilesrow(jj);
2881  }
2882 
2883  if (isSquare)
2884  dzCell = minTilesInRow*dzPeriod;
2885  else
2886  dzCell = (minTilesInRow + 0.5)*dzPeriod;
2887 
2888 
2889  MLOG(DEBUG) << "BC - dzCell: " << dzCell << " minTilesInRow: " << minTilesInRow << " isSquare: " << isSquare << endmsg;
2890 
2891  for (unsigned int jj=firstC; jj<=nLastRow; jj++)
2892  zmaxs[jj-1] = zmins[jj-1] + dzCell;
2893  }
2894 
2896  if (m_dbManager->TICLsample()==2 && detector == TILE_REGION_CENTRAL)
2897  cellDim = new TileCellDim(2*nRows);
2898  else
2899  cellDim = new TileCellDim(nRows);
2900 
2901  if (detector != TILE_REGION_CENTRAL)
2902  cellDimNeg = new TileCellDim(nRows);
2903 
2904  for (unsigned int jj=nFirstRow; jj<=nLastRow; jj++) {
2905  double Zmin=zmins[jj-1];
2906  double Zmax=zmaxs[jj-1];
2907  if (addPlates) {
2908  if (Zmin<zEnd1Lim) Zmin=zEnd1;
2909  else if (Zmin>zEnd2Lim) Zmin=zEnd2;
2910  if (Zmax<zEnd1Lim) Zmax=zEnd1;
2911  else if (Zmax>zEnd2Lim) Zmax=zEnd2;
2912  }
2913 
2914  cellDim->addRMin(rmins[jj-1]);
2915  cellDim->addRMax(rmaxs[jj-1]);
2916  cellDim->addZMin(Zmin+zShiftPos);
2917  cellDim->addZMax(Zmax+zShiftPos);
2918 
2919  if (detector != TILE_REGION_CENTRAL) {
2920  cellDimNeg->addRMin(rmins[jj-1]);
2921  cellDimNeg->addRMax(rmaxs[jj-1]);
2922  cellDimNeg->addZMin(-Zmax-zShiftNeg);
2923  cellDimNeg->addZMax(-Zmin-zShiftNeg);
2924  if (jj==nFirstRow)
2925  MLOG(DEBUG) << "Zmin: " << Zmin << " Zmax: " << Zmax << " zShiftPos: " << zShiftPos << " zShiftNeg: " << zShiftNeg << endmsg;
2926 
2927  } else {
2928  if (jj==nFirstRow || (BCcell && jj==nLastRow))
2929  MLOG(DEBUG) << "Zmin: " << Zmin << " Zmax: " << Zmax << " zShift: " << zShiftPos << endmsg;
2930  }
2931  }
2932 
2933  for (unsigned int jj=nFirstRow; jj<=nLastRow; jj++)
2934  zmins[jj-1] = zmaxs[jj-1];
2935 
2936  if (m_dbManager->TICLncell()<0)
2937  nSide = -1;
2938  else
2939  nSide = 1;
2940 
2941  nTower = abs((int)m_dbManager->TICLtower())-1;
2942  nSample = currentSample - 1;
2943 
2944  if (detector == TILE_REGION_CENTRAL) {
2945  cellDim->computeVolume();
2946  manager->add_cellDim(detector, nSide, nTower, nSample, cellDim);
2947 
2948  } else {
2949  cellDim->computeVolume();
2950  cellDimNeg->computeVolume();
2951  manager->add_cellDim(detector, 1, nTower, nSample, cellDim);
2952  manager->add_cellDim(detector, -1, nTower, nSample, cellDimNeg);
2953  }
2954 
2955  if (m_dbManager->TICLsample()==2 && detector == TILE_REGION_CENTRAL) nLastRow -=3;
2956 
2957  /* -------- DEBUG printouts -------------- */
2958 
2959  if (m_verbose) {
2960  std::cout << std::setiosflags(std::ios::fixed)
2961  << std::setw(9) << std::setprecision(2);
2962  std::cout << "\n **** Cell dimensions computed for : ";
2963  std::cout << "(" << detector << ", "
2964  << nSide << ", "
2965  << nTower << ", "
2966  << nSample << ")\n";
2967  std::cout << " >> CellDim contains " << cellDim->getNRows() << " rows\n";
2968  for (unsigned int jj=0; jj<cellDim->getNRows(); jj++)
2969  std::cout << cellDim->getRMin(jj) << " "
2970  << cellDim->getRMax(jj) << " "
2971  << cellDim->getZMin(jj) << " "
2972  << cellDim->getZMax(jj) << "\n";
2973  std::cout << " >> Cell Volume is " << cellDim->getVolume()*(1./Gaudi::Units::cm3) << " cm^3\n";
2974 
2975  if (detector != TILE_REGION_CENTRAL) {
2976  std::cout << " >> CellDimNeg contains " << cellDimNeg->getNRows() << " rows\n";
2977  for (unsigned int jj=0; jj<cellDimNeg->getNRows(); jj++)
2978  std::cout << cellDimNeg->getRMin(jj) << " "
2979  << cellDimNeg->getRMax(jj) << " "
2980  << cellDimNeg->getZMin(jj) << " "
2981  << cellDimNeg->getZMax(jj) << "\n";
2982  std::cout << " >> CellNeg Volume is " << cellDimNeg->getVolume()*(1./Gaudi::Units::cm3) << " cm^3\n";
2983  }
2984  std::cout << "\n" << std::resetiosflags(std::ios::fixed);
2985  }
2986  /* ------------------------------------------------------------------------------------------------ */
2987  }
2988  while (m_dbManager->SetNextTiclInDetSamp());
2989 
2990  } else {
2991  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::computeCellDim: No TICL structures in detector: "
2992  << detector << " for sample: " << nSample << endmsg;
2993  return;
2994  }
2995  }
2996 
2997  } else { // ITC/GAP/CRACK
2998  MLOG(DEBUG) << "ITC/GAP/CRACK regions...\n" << endmsg;
2999  nSide = 1;
3000  // Deal with ITC
3001  for (unsigned int sec=0; sec<2; sec++) { // PLUG1 & PLUG2
3002  rmins.clear();
3003  rmaxs.clear();
3004  zmins.clear();
3005  zmaxs.clear();
3006 
3007  m_dbManager->SetFirstTiclInDet(detector);
3008 
3009  if (sec) {
3010  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG2);
3011  } else {
3012  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG1);
3013  m_dbManager->SetNextTiclInDet();
3014  }
3015 
3016  rMin = m_dbManager->TILBrmin()*Gaudi::Units::cm;
3017  if (addPlates) rMin -= m_dbManager->TILBdrfront() *Gaudi::Units::cm;
3018  CurrentScin = 100*m_dbManager->TILBsection() + 1;
3019 
3020  for (unsigned int j = CurrentScin; j < (CurrentScin + m_dbManager->TILBnscin()); j++) {
3021  m_dbManager->SetCurrentScin(j);
3022 
3023  if ( (j == CurrentScin + m_dbManager->TILBnscin() - 1) && addPlates ) {
3025  rMax = m_dbManager->TILBrmax()*Gaudi::Units::cm;
3027  if (addPlates && sec)
3028  rMax -= m_dbManager->TILBdrfront()*Gaudi::Units::cm;
3029 
3030  } else {
3031  double tileSize=m_dbManager->SCNTdr();
3032  if (m_dbManager->SCNTdrw() > 0)
3034  tileSize=round(tileSize);
3035  rMax = (m_dbManager->TILBrmin() + m_dbManager->SCNTrc() + tileSize/2)*Gaudi::Units::cm;
3036  }
3037 
3038  rmins.push_back(rMin);
3039  rmaxs.push_back(rMax);
3040  rMin = rMax;
3041 
3042  zEnd1Lim = (m_dbManager->TILBzoffset() - m_dbManager->TILBdzmodul()/2+m_dbManager->TILBdzend1()+0.001)*Gaudi::Units::cm;
3043  zEnd2Lim = (m_dbManager->TILBzoffset() + m_dbManager->TILBdzmodul()/2-m_dbManager->TILBdzend2()-0.001)*Gaudi::Units::cm;
3044  zEnd1 = (m_dbManager->TILBzoffset() - m_dbManager->TILBdzmodul()/2)*Gaudi::Units::cm;
3045  zEnd2 = (m_dbManager->TILBzoffset() + m_dbManager->TILBdzmodul()/2)*Gaudi::Units::cm;
3046 
3047  if ( addPlates ) {
3048  zmins.push_back((m_dbManager->TILBzoffset() - m_dbManager->TILBdzmodul()/2)*Gaudi::Units::cm);
3049  zmaxs.push_back((m_dbManager->TILBzoffset() + m_dbManager->TILBdzmodul()/2)*Gaudi::Units::cm);
3050  } else {
3051  zmins.push_back((m_dbManager->TILBzoffset() - m_dbManager->TILBdzmodul()/2 + m_dbManager->TILBdzend1())*Gaudi::Units::cm);
3052  zmaxs.push_back((m_dbManager->TILBzoffset() + m_dbManager->TILBdzmodul()/2 - m_dbManager->TILBdzend2())*Gaudi::Units::cm);
3053  }
3054  }
3055 
3056  // Create TileCellDim objects
3057  if (m_dbManager->TILBnscin() < 0) {
3058  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::computeCellDim: Bad return from TILBnscin" << endmsg;
3059  return;
3060  }
3061  unsigned int nscin = static_cast<unsigned int>(m_dbManager->TILBnscin());
3062  cellDim = new TileCellDim(nscin);
3063  cellDimNeg = new TileCellDim(nscin);
3064 
3065  for (unsigned int jj=0; jj<nscin; jj++) {
3066  cellDim->addRMin(rmins[jj]);
3067  cellDim->addRMax(rmaxs[jj]);
3068  cellDim->addZMin(zmins[jj]+zShiftPos);
3069  cellDim->addZMax(zmaxs[jj]+zShiftPos);
3070 
3071  cellDimNeg->addRMin(rmins[jj]);
3072  cellDimNeg->addRMax(rmaxs[jj]);
3073  cellDimNeg->addZMin(-zmaxs[jj]-zShiftNeg);
3074  cellDimNeg->addZMax(-zmins[jj]-zShiftNeg);
3075  }
3076  MLOG(DEBUG) << "Zmin: " << zmins[0] << " Zmax: " << zmaxs[0] << " zShiftPos: " << zShiftPos << " zShiftNeg: " << zShiftNeg << endmsg;
3077 
3078  nTower = (int)m_dbManager->TICLtower()-1;
3079  nSample = (int)m_dbManager->TICLsample()-1;
3080 
3081  cellDim->computeVolume();
3082  cellDimNeg->computeVolume();
3083  manager->add_cellDim(detector, 1, nTower, nSample, cellDim);
3084  manager->add_cellDim(detector, -1, nTower, nSample, cellDimNeg);
3085 
3086 /* -------- DEBUG printouts -------------- */
3087  if (m_verbose) {
3088  std::cout << std::setiosflags(std::ios::fixed)
3089  << std::setw(9) << std::setprecision(2);
3090  std::cout << "\n **** Cell dimension computed for : ";
3091  std::cout << "(" << detector << ", "
3092  << nSide << ", "
3093  << nTower << ", "
3094  << nSample << ")\n";
3095  std::cout << " >> CellDim contains " << cellDim->getNRows() << " rows\n";
3096  for (unsigned int jj=0; jj<cellDim->getNRows(); jj++)
3097  std::cout << cellDim->getRMin(jj) << " "
3098  << cellDim->getRMax(jj) << " "
3099  << cellDim->getZMin(jj) << " "
3100  << cellDim->getZMax(jj) << "\n";
3101  std::cout<< " >> Cell Volume is " << cellDim->getVolume()*(1./Gaudi::Units::cm3) << " cm^3\n";
3102 
3103  std::cout << " >> CellDimNeg contains " << cellDimNeg->getNRows() << " rows\n";
3104  for (unsigned int jj=0; jj<cellDimNeg->getNRows(); jj++)
3105  std::cout << cellDimNeg->getRMin(jj) << " "
3106  << cellDimNeg->getRMax(jj) << " "
3107  << cellDimNeg->getZMin(jj) << " "
3108  << cellDimNeg->getZMax(jj) << "\n";
3109  std::cout << " >> CellNeg Volume is " << cellDimNeg->getVolume()*(1./Gaudi::Units::cm3) << " cm^3\n";
3110  std::cout << "\n" << std::resetiosflags(std::ios::fixed);
3111  }
3112 /* -------------------------------------------- */
3113  }
3114 
3115  for (unsigned int sec=0; sec<2; sec++) { // GAP & CRACK
3116  rmins.clear();
3117  rmaxs.clear();
3118  zmins.clear();
3119  zmaxs.clear();
3120 
3121  if (sec) {
3122  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG4);
3123  CurrentScin = 100*m_dbManager->TILBsection()+1;
3124  } else {
3125  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG3);
3126  CurrentScin = 100*m_dbManager->TILBsection()+1;
3127  }
3128 
3129  double rMIN = m_dbManager->TILBrmin()*Gaudi::Units::cm;
3130  double rMAX = m_dbManager->TILBrmax()*Gaudi::Units::cm;
3131 
3132  // Initialize rMin, rMax, zMin, zMax vectors
3133  for (unsigned int j = CurrentScin; j < (CurrentScin + m_dbManager->TILBnscin()); j++) {
3134  m_dbManager->SetCurrentScin(j);
3135 
3136  double rCenter = rMIN + m_dbManager->SCNTrc()*Gaudi::Units::cm;
3137  double dR2 = (0.5 * m_dbManager->SCNTdr() + m_dbManager->SCNTdrw()) *Gaudi::Units::cm;
3138  if (addPlates) {
3139  if (j==CurrentScin) { // cells E2, E4 - use rMin of mother volume, calculate rMax
3140  rMin = rMIN;
3141  rMax = rCenter + dR2;
3142  } else { // cells E1, E3 - use rMax of mother volume, calculate rMin
3143  rMin = rCenter - dR2;
3144  rMax = rMAX;
3145  }
3146  } else {
3147  rMin = rCenter - dR2;
3148  rMax = rCenter + dR2;
3149  }
3150 
3151  rmins.push_back(rMin);
3152  rmaxs.push_back(rMax);
3153 
3154  zmins.push_back((m_dbManager->TILBzoffset() - m_dbManager->TILBdzmodul()/2)*Gaudi::Units::cm);
3155  zmaxs.push_back((m_dbManager->TILBzoffset() + m_dbManager->TILBdzmodul()/2)*Gaudi::Units::cm);
3156  }
3157 
3158  // Iterate through scintillators and create corresponding TileCellDim objects (+/-)
3159  for (unsigned int jj = 0; jj < (unsigned int)m_dbManager->TILBnscin(); jj++) {
3160  if (sec==0 && jj==0)
3161  m_dbManager->SetFirstTiclInDet(detector+1);
3162  else
3163  m_dbManager->SetNextTiclInDet();
3164  if ((int)m_dbManager->TICLtower()>16) continue;
3165 
3166  cellDim = new TileCellDim(1);
3167  cellDimNeg = new TileCellDim(1);
3168 
3169  cellDim->addRMin(rmins[m_dbManager->TILBnscin() - jj - 1]);
3170  cellDim->addRMax(rmaxs[m_dbManager->TILBnscin() - jj - 1]);
3171  cellDim->addZMin(zmins[m_dbManager->TILBnscin() - jj - 1]+zShiftPos);
3172  cellDim->addZMax(zmaxs[m_dbManager->TILBnscin() - jj - 1]+zShiftPos);
3173 
3174  cellDimNeg->addRMin(rmins[m_dbManager->TILBnscin() - jj - 1]);
3175  cellDimNeg->addRMax(rmaxs[m_dbManager->TILBnscin() - jj - 1]);
3176  cellDimNeg->addZMin(-zmaxs[m_dbManager->TILBnscin() - jj - 1]-zShiftNeg);
3177  cellDimNeg->addZMax(-zmins[m_dbManager->TILBnscin() - jj - 1]-zShiftNeg);
3178 
3179  MLOG(DEBUG) << "Zmin: " << zmins[m_dbManager->TILBnscin() - jj - 1] << " Zmax: " << zmaxs[m_dbManager->TILBnscin() - jj - 1] << " zShiftPos: " << zShiftPos << " zShiftNeg: " << zShiftNeg << endmsg;
3180 
3181  nTower = (int)m_dbManager->TICLtower()-1;
3182  nSample = (int)m_dbManager->TICLsample()-1;
3183 
3184  cellDim->computeVolume();
3185  cellDimNeg->computeVolume();
3186  manager->add_cellDim(detector, 1, nTower, nSample, cellDim);
3187  manager->add_cellDim(detector, -1, nTower, nSample, cellDimNeg);
3188 
3189 /* -------- DEBUG printouts -------------- */
3190  if (m_verbose) {
3191  boost::io::ios_base_all_saver coutsave (std::cout);
3192  std::cout << std::setiosflags(std::ios::fixed)
3193  << std::setw(9) << std::setprecision(2);
3194  std::cout << "\n **** Cell dimension computed for : ";
3195  std::cout << "(" << detector << ", "
3196  << nSide << ", "
3197  << nTower << ", "
3198  << nSample << ")\n";
3199  std::cout << " >> CellDim contains " << cellDim->getNRows() << " rows\n";
3200  for (unsigned int jj=0; jj<cellDim->getNRows(); jj++)
3201  std::cout << cellDim->getRMin(jj) << " "
3202  << cellDim->getRMax(jj) << " "
3203  << cellDim->getZMin(jj) << " "
3204  << cellDim->getZMax(jj) << "\n";
3205  std::cout << " >> Cell Volume is " << cellDim->getVolume()*(1./Gaudi::Units::cm3) << " cm^3\n";
3206 
3207  std::cout << " >> CellDimNeg contains " << cellDimNeg->getNRows() << " rows\n";
3208  for (unsigned int jj=0; jj<cellDimNeg->getNRows(); jj++)
3209  std::cout << cellDimNeg->getRMin(jj) << " "
3210  << cellDimNeg->getRMax(jj) << " "
3211  << cellDimNeg->getZMin(jj) << " "
3212  << cellDimNeg->getZMax(jj) << "\n";
3213  std::cout << " >> CellNeg Volume is " << cellDimNeg->getVolume()*(1./Gaudi::Units::cm3) << " cm^3\n";
3214  }
3215 /* -------------------------------------------- */
3216  }
3217  }
3218  }
3219 }
3220 
3221 
3222 void TileGeoSectionBuilder::calculateZ(int detector,
3223  int side,
3224  int sample,
3225  float zshift,
3226  float& zcenter,
3227  float& dz)
3228 {
3229  switch(detector) {
3230  case TILE_REGION_CENTRAL:
3231  m_dbManager->SetCurrentSection(TileDddbManager::TILE_BARREL);
3232  break;
3233  case TILE_REGION_EXTENDED:
3234  m_dbManager->SetCurrentSection(TileDddbManager::TILE_EBARREL);
3235  break;
3236  case TILE_REGION_GAP:
3237  if (sample==3) { // D4
3238  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG1);
3239  } else if (sample==2) { // C10
3240  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG2);
3241  } else if (sample<13) { // E1-E2
3242  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG3);
3243  } else { // E3-E4
3244  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG4);
3245  }
3246  break;
3247  default:
3248  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::calculateZ: Unexpected detector: "
3249  << detector << endmsg;
3250  return;
3251  }
3252 
3253  // first - find position in ideal world before Z-shift and misalignment
3254  if (detector == TILE_REGION_CENTRAL) {
3255  // need to split one cylinder in pos/neg halves
3256  float zmin=m_dbManager->TILBzoffset()/2 * Gaudi::Units::cm ;
3257  float zmax=zmin+m_dbManager->TILBdzmodul()/2 * Gaudi::Units::cm ;
3258  if (sample==3) { // fix for D0 cell
3259  float D0size = 560.58/307*40 * Gaudi::Units::cm; // size of D0 along Z in Gaudi::Units::cm
3260  // FIXME:: should be taken from DB
3261  if (side>0) // positive
3262  zmin = - D0size/2;
3263  else
3264  zmin = D0size/2;
3265  }
3266  zcenter = (zmin+zmax)/2;
3267  dz = (zmax-zmin);
3268 
3269  } else if (detector == TILE_REGION_GAP && (sample > 9) ) {
3270  zcenter=m_dbManager->TILBzoffset() * Gaudi::Units::cm ;
3271  int section = m_dbManager->TILBsection();
3272  if (section < 0) {
3273  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::calculateZ: Error return from TileDddbManager::TILBsection() " << endmsg;
3274  return;
3275  }
3276  m_dbManager->SetCurrentScin(100*section + 1 );
3277  dz = m_dbManager->SCNTdt()*Gaudi::Units::cm;
3278 
3279  } else {
3280  zcenter=m_dbManager->TILBzoffset() * Gaudi::Units::cm ;
3281  dz=m_dbManager->TILBdzmodul() * Gaudi::Units::cm ;
3282  }
3283 
3284  // apply zshift from ideal pseudo-projective eta (which includes alignment also!)
3285  zcenter += zshift;
3286  // inversion for negative side
3287  if (side<1) zcenter *= -1;
3288 
3289  return;
3290 }
3291 
3292 
3293 void TileGeoSectionBuilder::calculateR(int detector,
3294  int sample,
3295  bool addPlates,
3296  int firstScin,
3297  int lastScin,
3298  float& rcenter,
3299  float& dr)
3300 {
3301  int cell = 0;
3302  switch(detector) {
3303  case TILE_REGION_CENTRAL:
3304  m_dbManager->SetCurrentSection(TileDddbManager::TILE_BARREL);
3305  break;
3306  case TILE_REGION_EXTENDED:
3307  m_dbManager->SetCurrentSection(TileDddbManager::TILE_EBARREL);
3308  break;
3309  case TILE_REGION_GAP:
3310  if (sample==3) { // D4
3311  cell = -2;
3312  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG1);
3313  } else if (sample==2) { // C10
3314  cell = -1;
3315  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG2);
3316  } else if (sample<13) { // E1-E2
3317  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG3);
3318  cell = firstScin - 2; // E2 has index 1, E1 has index 2
3319  } else { // E3-E4
3320  m_dbManager->SetCurrentSection(TileDddbManager::TILE_PLUG4);
3321  cell = firstScin; // E4 has index 1, E3 has index 2
3322  }
3323  break;
3324  default:
3325  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::calculateR: Unexpected detector: "
3326  << detector << endmsg;
3327  return;
3328  }
3329 
3330  float oldrc = rcenter;
3331  float olddr = dr;
3332 
3333  float rMin = m_dbManager->TILBrmin();
3334  float rMax = m_dbManager->TILBrmax();
3335 
3336  if (cell>0) { // single gap/crack scintillator
3337  int section = m_dbManager->TILBsection();
3338  if (section < 0) {
3339  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::calculateR: Error return from TileDddbManager::TILBsection() " << endmsg;
3340  return;
3341  }
3342  m_dbManager->SetCurrentScin(100*section+cell);
3343  rcenter = (rMin + m_dbManager->SCNTrc());
3344  dr = m_dbManager->SCNTdr() + 2. * m_dbManager->SCNTdrw();
3345  if (addPlates) {
3346  if (cell==1) { // cells E4, E2 - use rMin of mother volume, recalculate rMax
3347  rMax = rcenter + dr * 0.5;
3348  } else { // cells E3, E1 - use rMax of mother volume, recalculate rMin
3349  rMin = rcenter - dr * 0.5;
3350  }
3351  rcenter = (rMax+rMin) * 0.5;
3352  dr = (rMax-rMin);
3353  }
3354 
3355  } else {
3356  int first = 100*m_dbManager->TILBsection()+firstScin;
3357  int last = 100*m_dbManager->TILBsection()+lastScin;
3358  if (m_dbManager->TILBcurscint() != 0) { // for cells C10 and D4 first/last should be different
3359  first = m_dbManager->TILBcurscint();
3360  last = first + m_dbManager->TILBnscin()-1;
3361  }
3362  if (addPlates) {
3363  if (cell == -1) { // adjust size for cell C10
3364  rMin -= m_dbManager->TILBdrfront(); // add front plate at inner radius
3365  rMax -= m_dbManager->TILBdrfront(); // decrease outer radius by thickness of front plate of cell D4
3366  } else if (cell == -2) { // adjust size for cell D4, use rMax of mother volume
3367  rMin -= m_dbManager->TILBdrfront(); // add front plate at inner radius
3368  } else if (firstScin == 1) { // decrease rMin by thickness of front plate, calculate rMax for layer A
3369  m_dbManager->SetCurrentScin(last);
3370  rMax = rMin + m_dbManager->SCNTrc() + round(m_dbManager->SCNTdr())*0.5;
3371  rMin -= m_dbManager->TILBdrfront();
3372  } else if (lastScin == m_dbManager->TILBnscin()) { // use rMax of mother volume, calculate rMin for layer D
3373  m_dbManager->SetCurrentScin(first);
3374  rMin += m_dbManager->SCNTrc() - round(m_dbManager->SCNTdr())*0.5;
3375  } else { // calculate both rMin and rMax for layer BC and B
3376  m_dbManager->SetCurrentScin(last);
3377  rMax = rMin + m_dbManager->SCNTrc() + round(m_dbManager->SCNTdr())*0.5;
3378  m_dbManager->SetCurrentScin(first);
3379  rMin += m_dbManager->SCNTrc() - round(m_dbManager->SCNTdr())*0.5;
3380  }
3381 
3382  } else { // keep only sensitive part of the cell without front/back planes
3383  m_dbManager->SetCurrentScin(last);
3384  rMax = rMin + m_dbManager->SCNTrc() + round(m_dbManager->SCNTdr())*0.5;
3385  m_dbManager->SetCurrentScin(first);
3386  rMin += m_dbManager->SCNTrc() - round(m_dbManager->SCNTdr())*0.5;
3387  }
3388 
3389  rcenter = (rMax+rMin)*0.5;
3390  dr = (rMax-rMin);
3391  }
3392 
3393  rcenter *= Gaudi::Units::cm;
3394  dr *= Gaudi::Units::cm;
3395 
3396 /* -------- DEBUG printouts -------------- */
3397  if (m_verbose) {
3398  boost::io::ios_base_all_saver coutsave (std::cout);
3399  std::cout << std::setiosflags(std::ios::fixed) << std::setw(9) << std::setprecision(2);
3400  std::cout << "Detector " << detector << " sample " << sample << " old r/dr " << oldrc << " " << olddr << std::endl;
3401  std::cout << "Detector " << detector << " sample " << sample << " new r/dr " << rcenter << " " << dr << " delta r/dr " << rcenter-oldrc << " " << dr-olddr << std::endl;
3402  }
3403 
3404  return;
3405 }
3406 
3407 
3408 void TileGeoSectionBuilder::calculateEta(int detector,
3409  int side,
3410  int sample,
3411  float& etamin,
3412  float& etamax,
3413  float& deta,
3414  unsigned int& neta)
3415 {
3425  int sign_eta = 1;
3426  if ((detector == TILE_REGION_CENTRAL) && (side<1)) sign_eta = -1;
3427 
3428  switch(detector) {
3429  case TILE_REGION_CENTRAL: // Central Barrel
3430  case TILE_REGION_EXTENDED: // Extended Barrel
3431  {
3432  if (m_dbManager->SetFirstTiclInDetSamp(detector, sample)) {
3433  // --- A ---
3434  while (sign_eta * m_dbManager->TICLncell() < 0)
3435  if (!(m_dbManager->SetNextTiclInDetSamp())) {
3436  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::calculateEta: No TICL structures of positive side "
3437  << "in Central Barrel for sample: " << sample << endmsg;
3438  return;
3439  }
3440 
3441  // --- B ---
3442  neta = 1;
3443  deta = m_dbManager->TICLdeta();
3444  etamin = m_dbManager->TICLeta()*sign_eta - m_dbManager->TICLdeta()/2;
3445  etamax = m_dbManager->TICLeta()*sign_eta + m_dbManager->TICLdeta()/2;
3446 
3447  // --- C ---
3448  while (m_dbManager->SetNextTiclInDetSamp()) {
3449  if (!((detector == TILE_REGION_CENTRAL)&&(sign_eta * m_dbManager->TICLncell() <= 0))) {
3450  neta++;
3451  if (etamax < m_dbManager->TICLeta()*sign_eta + m_dbManager->TICLdeta()/2)
3452  etamax = m_dbManager->TICLeta()*sign_eta + m_dbManager->TICLdeta()/2;
3453  if (etamin > m_dbManager->TICLeta()*sign_eta - m_dbManager->TICLdeta()/2)
3454  etamin = m_dbManager->TICLeta()*sign_eta - m_dbManager->TICLdeta()/2;
3455  }
3456  }
3457 
3458  } else {
3459  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::calculateEta: No TICL structures in detector: "
3460  << detector << " for sample: " << sample << endmsg;
3461  return;
3462  }
3463  break;
3464  }
3465  default:
3466  {
3467  (*m_log) << MSG::ERROR << "TileGeoSectionBuilder::calculateEta: Unexpected detector: "
3468  << detector << endmsg;
3469  return;
3470  }
3471  }
3472 }
3473 
3474 
3475 void TileGeoSectionBuilder::setBarrelPeriodThickness(double val)
3476 {
3477  m_barrelPeriodThickness = val;
3478 }
3479 
3480 
3481 void TileGeoSectionBuilder::setBarrelGlue(double val)
3482 {
3483  m_barrelGlue = val;
3484 }
3485 
3486 
3487 void TileGeoSectionBuilder::setExtendedPeriodThickness(double val)
3488 {
3489  m_extendedPeriodThickness = val;
3490 }
3491 
3492 
3493 void TileGeoSectionBuilder::checktransfunc(double absorber, double period, int np, double center)
3494 {
3495  if (np<0){
3496  (*m_log) << MSG::WARNING << "TileGeoSectionBuilder::checktransfunc: np is negative!"<<endmsg;
3497  return;
3498  }
3499  (*m_log) << MSG::VERBOSE
3500  << std::setprecision (std::numeric_limits<double>::digits10 + 1)
3501  << " Absorber center = " << center
3502  << " length = " << absorber
3503  << " period = " << period
3504  << " nperiods = " << np
3505  << endmsg;
3506  double zC,dZ,z1,z2=-absorber/2.+center;
3507  for (int i=0; i<np; ++i) {
3508  zC = (period*(2*i+1)-absorber)/2. + center;
3509  z1 = zC - period/2.;
3510  dZ = z1 - z2;
3511  z2 = zC + period/2.;
3512  (*m_log) << MSG::VERBOSE << std::setw(4)
3513  << i << " z1= " << z1 << " z2= " << z2
3514  << " dist from previous= " << dZ << endmsg;
3515  }
3516 }
3517 
3518 
3519 void TileGeoSectionBuilder::printdouble(const char * name, double val)
3520 {
3521  (*m_log) << MSG::VERBOSE << std::setprecision (std::numeric_limits<double>::digits10 + 1)
3522  << name << val << endmsg;
3523 }
3524 
3525 
3526 const GeoShape * TileGeoSectionBuilder::makeHolesScint(const GeoShape * mother, double R, double H2, double off, double off0) {
3527  GeoShape *hole = new GeoTubs(0., R, H2, 0., 360.0 * Gaudi::Units::deg);
3528  const GeoShapeUnion& scintUnion = hole->add( *hole << GeoTrf::Translate3D((off0-off*2.0),0.,0.));
3529  GeoTrf::Transform3D tfHole = GeoTrf::Translate3D(0.,0.,(off0-off)) * GeoTrf::RotateY3D(90*Gaudi::Units::deg);
3530  const GeoShape & motherWithHoles = (mother->subtract(scintUnion<<tfHole));
3531  return &motherWithHoles;
3532 }
3533 
3534 
3535 const GeoShape * TileGeoSectionBuilder::makeHoles(const GeoShape * mother, double R, double H2, double off, double off0) {
3536  GeoShape *hole1 = new GeoTubs(0., R, H2, 0., 360.0 * Gaudi::Units::deg);
3537  GeoShape *hole2 = new GeoTubs(0., R, H2, 0., 360.0 * Gaudi::Units::deg);
3538  GeoTrf::Transform3D tfHole1 = GeoTrf::Translate3D(0.,0.,(off0-off)) * GeoTrf::RotateY3D(-90*Gaudi::Units::deg);
3539  GeoTrf::Transform3D tfHole2 = GeoTrf::Translate3D(0.,0.,(off0+off)) * GeoTrf::RotateY3D(-90*Gaudi::Units::deg);
3540  const GeoShape & motherWithHoles = (mother->subtract((*hole1)<<tfHole1).subtract((*hole2)<<tfHole2));
3541  return &motherWithHoles;
3542 }
TileDddbManager::TICLtower
double TICLtower() const
Definition: TileDddbManager.cxx:1621
TileDddbManager::TILE_PLUG3
@ TILE_PLUG3
Definition: TileDddbManager.h:46
TileGeoSectionBuilder::m_matIronHalfDens
GeoIntrusivePtr< GeoMaterial > m_matIronHalfDens
Definition: TileGeoSectionBuilder.h:212
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
python.AtlRunQueryAMI.period
period
Definition: AtlRunQueryAMI.py:224
TileDddbManager::TICGdx2
double TICGdx2() const
Definition: TileDddbManager.cxx:1398
TileCellDim::addRMax
void addRMax(double rMax)
Definition: TileCellDim.cxx:71
TileDddbManager::TILBsection
int TILBsection() const
Definition: TileDddbManager.cxx:601
TileDddbManager::SetCurrentCuts
int SetCurrentCuts(const std::string &input)
Fields of CUTS structure (see also Oracle comments):
Definition: TileDddbManager.cxx:1014
VertexShift::Zmax
const float Zmax
Definition: VertexShift.h:26
TileDddbManager::TIGRmaterial
int TIGRmaterial() const
Definition: TileDddbManager.cxx:1202
TileDddbManager::SCNTitem
int SCNTitem() const
Fields of SCNT structure (see also Oracle comments):
Definition: TileDddbManager.cxx:923
TileGeoSectionBuilder::m_switches
TileSwitches m_switches
Definition: TileGeoSectionBuilder.h:203
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:98
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
TileDddbManager::TILE_BARREL
@ TILE_BARREL
Definition: TileDddbManager.h:42
TileGeoSectionBuilder::calculateR
void calculateR(int detector, int sample, bool addPlates, int firstScin, int lastScin, float &rcenter, float &dr)
Calculator of R position given sample in region (detector):
Definition: TileGeoSectionBuilder.cxx:3293
TileGeoSectionBuilder.h
Definition of TileGeoSectionBuilder class.
TileDddbManager::SetCurrentSection
int SetCurrentSection(unsigned int section, bool print=true)
Definition: TileDddbManager.cxx:582
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
TileDddbManager::TILE_PLUG1
@ TILE_PLUG1
Definition: TileDddbManager.h:44
TileDddbManager::TILBngirder
int TILBngirder() const
Definition: TileDddbManager.cxx:821
TileDddbManager::TICLntilesrow
double TICLntilesrow(unsigned int ind) const
Definition: TileDddbManager.cxx:1687
TRTCalib_Extractor.det
det
Definition: TRTCalib_Extractor.py:36
TileDddbManager::TILBrmax
double TILBrmax() const
Definition: TileDddbManager.cxx:645
PixelAthClusterMonAlgCfg.zmin
zmin
Definition: PixelAthClusterMonAlgCfg.py:169
index
Definition: index.py:1
TRTCalib_cfilter.detector
detector
Definition: TRTCalib_cfilter.py:241
TileDddbManager::TILE_PLUG4
@ TILE_PLUG4
Definition: TileDddbManager.h:47
Monitored::Z
@ Z
Definition: HistogramFillerUtils.h:24
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
TileDddbManager::TICGzc
double TICGzc() const
Definition: TileDddbManager.cxx:1431
TileDddbManager::TILBflangex
double TILBflangex() const
Definition: TileDddbManager.cxx:711
TileCellDim::computeVolume
void computeVolume()
Definition: TileCellDim.cxx:95
TileGeoSectionBuilder::m_log
MsgStream * m_log
Definition: TileGeoSectionBuilder.h:201
TileDddbManager::TICGoff
double TICGoff() const
Definition: TileDddbManager.cxx:1409
MuonGM::round
float round(const float toRound, const unsigned int decimals)
Definition: Mdt.cxx:27
Zmin
double Zmin
Definition: LArDetectorConstructionTBEC.cxx:58
TileCellDim::getVolume
double getVolume() const
Definition: TileCellDim.h:26
StoredMaterialManager::getElement
virtual const GeoElement * getElement(const std::string &name)=0
cm3
#define cm3
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TileDddbManager::SetCurrentTicg
int SetCurrentTicg(int item)
Definition: TileDddbManager.cxx:1312
deg
#define deg
Definition: SbPolyhedron.cxx:17
TileGeoSectionBuilder::m_matLArServices
GeoIntrusivePtr< GeoMaterial > m_matLArServices
Definition: TileGeoSectionBuilder.h:211
TileDddbManager::TICLsample
double TICLsample() const
Definition: TileDddbManager.cxx:1632
TileDddbManager::GetModType
int GetModType() const
Definition: TileDddbManager.cxx:437
TileDddbManager::TILBnscin
int TILBnscin() const
Definition: TileDddbManager.cxx:832
TileGeoSectionBuilder::makeHolesScint
const GeoShape * makeHolesScint(const GeoShape *mother, double R, double H2, double off, double off0=0.)
Definition: TileGeoSectionBuilder.cxx:3526
TileGeoSectionBuilder::fillFinger
void fillFinger(PVLink &mother, int sec_number, double tile_rmax, double tilb_rmax, double delta_phi_not_used, bool testbeam, int ModuleNcp=0, double corrected_dz=0.)
Finger parameters are the following:
Definition: TileGeoSectionBuilder.cxx:1438
TileSwitches::testBeam
bool testBeam
setting up testbeam geometry or ATLAS geometry
Definition: TileSwitches.h:31
TileDddbManager::TILBdzmodul
double TILBdzmodul() const
Definition: TileDddbManager.cxx:766
TILE_REGION_EXTENDED
#define TILE_REGION_EXTENDED
Definition: TileGeoSectionBuilder.h:22
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:111
TileDddbManager::SetNextTiclInDet
int SetNextTiclInDet()
Definition: TileDddbManager.cxx:1564
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
MLOG
#define MLOG(x)
Definition: TileGeoSectionBuilder.cxx:46
TileGeoSectionBuilder::TileGeoSectionBuilder
TileGeoSectionBuilder(StoredMaterialManager *matManager, TileDddbManager *pDbManager, const TileSwitches &switches, MsgStream *log)
Constructor.
Definition: TileGeoSectionBuilder.cxx:52
TileGeoSectionBuilder::setBarrelGlue
void setBarrelGlue(double val)
Definition: TileGeoSectionBuilder.cxx:3481
PlotPulseshapeFromCool.np
np
Definition: PlotPulseshapeFromCool.py:64
TileDetDescriptor::print
void print() const
Definition: TileDetDescriptor.cxx:125
TileDddbManager::TICLfirstrow
double TICLfirstrow() const
Definition: TileDddbManager.cxx:1665
TileDddbManager::TILBdrfront
double TILBdrfront() const
Definition: TileDddbManager.cxx:689
TileDddbManager::TIGRdr
double TIGRdr() const
Definition: TileDddbManager.cxx:1224
TileDddbManager::TICLncell
double TICLncell() const
Definition: TileDddbManager.cxx:1610
H2
#define H2(x, y, z)
Definition: MD5.cxx:115
TileDddbManager::TICGmaterial
int TICGmaterial() const
Definition: TileDddbManager.cxx:1343
TileDddbManager::TILE_PLUG2
@ TILE_PLUG2
Definition: TileDddbManager.h:45
TileSwitches::steel
int steel
0: Absorber is pure Iron 1: Absorber is tile::Steel defined in DB
Definition: TileSwitches.h:51
TileDddbManager::TILBrmin
double TILBrmin() const
Definition: TileDddbManager.cxx:634
TileDddbManager::TILBphigap
double TILBphigap() const
Definition: TileDddbManager.cxx:744
TileDddbManager::TILBzoffset
double TILBzoffset() const
Definition: TileDddbManager.cxx:733
MAX_N_SAMP_TILEDD
#define MAX_N_SAMP_TILEDD
Definition: TileDetDescriptor.h:17
TileDddbManager::SetCurrentScin
int SetCurrentScin(int item)
Definition: TileDddbManager.cxx:903
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
TileDetDescrManager.h
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
TileDddbManager::TILBcurscint
int TILBcurscint() const
Definition: TileDddbManager.cxx:877
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TileCellDim
Definition: TileCellDim.h:19
TileDddbManager::SCNTdr
double SCNTdr() const
Definition: TileDddbManager.cxx:934
TileDddbManager::TIGRrc
double TIGRrc() const
Definition: TileDddbManager.cxx:1213
TileDddbManager::TIGRdw
double TIGRdw() const
Definition: TileDddbManager.cxx:1235
cm
const double cm
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/tools/FCAL_ChannelMap.cxx:25
TileGeoSectionBuilder::fillDescriptor
void fillDescriptor(TileDetDescriptor *&descriptor, unsigned int detector, int side, bool testbeam, bool addPlates, unsigned int nphi, float zshift)
Readout Descriptor parameters are the following:
Definition: TileGeoSectionBuilder.cxx:2454
TileDetDescriptor::set
void set(const Identifier &id)
Definition: TileDetDescriptor.h:244
TileCellDim::getRMax
double getRMax(unsigned int index) const
Definition: TileCellDim.cxx:39
TileDddbManager::SCNTdphi
double SCNTdphi() const
Definition: TileDddbManager.cxx:1000
TileSwitches::uShape
int uShape
0: simulation without U-shape 1: simulation with U-shape
Definition: TileSwitches.h:38
TileCellDim::addZMin
void addZMin(double zMin)
Definition: TileCellDim.cxx:79
TileDddbManager::CutsXpos
double CutsXpos() const
Definition: TileDddbManager.cxx:1104
TileGeoSectionBuilder::fillSection
void fillSection(PVLink &mother, int sec_number, double tile_rmax, double rminb, double dzglue, double delta_phi, int ModuleNcp=0, double zlen_itc2=0., bool neg=false)
Section parameters are the following:
Definition: TileGeoSectionBuilder.cxx:74
TileSwitches::glue
int glue
0: glue layer is removed and replaced by iron, 1: simulation with glue, 2: glue is replaced by iron +...
Definition: TileSwitches.h:43
TileCellDim::getNRows
unsigned int getNRows() const
Definition: TileCellDim.h:25
TileGeoSectionBuilder::fillPeriod
void fillPeriod(PVLink &mother, double thickness, double dzglue, double tan_delta_phi_2, int period_type, GeoTrd *period=nullptr)
Period parameters are the following:
Definition: TileGeoSectionBuilder.cxx:1762
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:116
TileDddbManager::TICLeta
double TICLeta() const
Definition: TileDddbManager.cxx:1643
TileDddbManager::TIFGnelem
int TIFGnelem() const
Definition: TileDddbManager.cxx:1289
TileGeoSectionBuilder::checktransfunc
void checktransfunc(double absorber, double period, int np, double center)
Definition: TileGeoSectionBuilder.cxx:3493
lumiFormat.i
int i
Definition: lumiFormat.py:85
TileDddbManager::TICLlastrow
double TICLlastrow() const
Definition: TileDddbManager.cxx:1676
TileGeoSectionBuilder::m_barrelPeriodThickness
double m_barrelPeriodThickness
Definition: TileGeoSectionBuilder.h:204
TileGeoSectionBuilder::checking
void checking(const std::string &VolumeName, bool print, int level, double X1, double X2, double Y1, double Y2, double Z)
Function for checking empty volumes:
Definition: TileGeoSectionBuilder.cxx:2418
TileDetDescrManager
Definition: TileDetDescrManager.h:33
MSG
Definition: MsgLevel.h:28
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
TileDddbManager::TILBdzgir
double TILBdzgir() const
Definition: TileDddbManager.cxx:891
TileDetDescriptor
Definition: TileDetDescriptor.h:46
TileDddbManager::TILBdzend1
double TILBdzend1() const
Definition: TileDddbManager.cxx:799
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
TileGeoSectionBuilder::m_dbManager
TileDddbManager * m_dbManager
Definition: TileGeoSectionBuilder.h:200
TileDddbManager::TILBrmaximal
double TILBrmaximal() const
Definition: TileDddbManager.cxx:667
TileCellDim::addRMin
void addRMin(double rMin)
Definition: TileCellDim.cxx:63
TileSwitches
Definition: TileSwitches.h:15
PixelAthClusterMonAlgCfg.zmax
zmax
Definition: PixelAthClusterMonAlgCfg.py:169
TileDddbManager::TICGrc
double TICGrc() const
Definition: TileDddbManager.cxx:1365
TileGeoSectionBuilder::calculateEta
void calculateEta(int detector, int side, int sample, float &etamin, float &etamax, float &deta, unsigned int &neta)
calculateEta function calculates are the following parameters given sample in region (detector)
Definition: TileGeoSectionBuilder.cxx:3408
TileDddbManager::TILBdzend
double TILBdzend() const
Definition: TileDddbManager.cxx:700
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
AnalysisUtils::Delta::R
double R(const INavigable4Momentum *p1, const double v_eta, const double v_phi)
Definition: AnalysisMisc.h:49
TileDddbManager::SetFirstTiclInDetSamp
int SetFirstTiclInDetSamp(int detector, double sample)
Definition: TileDddbManager.cxx:1535
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
python.SystemOfUnits.rad
float rad
Definition: SystemOfUnits.py:126
TileCellDim::getRMin
double getRMin(unsigned int index) const
Definition: TileCellDim.cxx:31
TileSwitches::csTube
int csTube
0: without Cesium tubes 1: with cesium tubes
Definition: TileSwitches.h:55
TileGeoSectionBuilder::calculateZ
void calculateZ(int detector, int side, int sample, float zshift, float &zcenter, float &dz)
Calculator of Z position given sample in region (detector):
Definition: TileGeoSectionBuilder.cxx:3222
TileGeoSectionBuilder::makeHoles
const GeoShape * makeHoles(const GeoShape *mother, double R, double H2, double off, double off0=0.)
Definition: TileGeoSectionBuilder.cxx:3535
print
void print(char *figname, TCanvas *c1)
Definition: TRTCalib_StrawStatusPlots.cxx:26
TILE_REGION_CENTRAL
#define TILE_REGION_CENTRAL
Definition: TileGeoSectionBuilder.h:21
TileDddbManager::BoolCuts
bool BoolCuts()
Definition: TileDddbManager.cxx:1037
TileDddbManager::TIGRoff
double TIGRoff() const
Definition: TileDddbManager.cxx:1246
TILE_REGION_GAP
#define TILE_REGION_GAP
Definition: TileGeoSectionBuilder.h:23
TileGeoSectionBuilder::~TileGeoSectionBuilder
~TileGeoSectionBuilder()
Destructor.
TileDddbManager::SCNTzp
double SCNTzp() const
Definition: TileDddbManager.cxx:956
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
StoredMaterialManager.h
TileDddbManager::SetCurrentGird
int SetCurrentGird(int item)
Definition: TileDddbManager.cxx:1171
TileDddbManager::CutsDY2
double CutsDY2() const
Definition: TileDddbManager.cxx:1084
TileDddbManager::TILBdzspac
double TILBdzspac() const
Definition: TileDddbManager.cxx:788
TileGeoSectionBuilder::m_verbose
bool m_verbose
Flag for activation verbose level for debugging.
Definition: TileGeoSectionBuilder.h:209
TileDddbManager::TILE_EBARREL
@ TILE_EBARREL
Definition: TileDddbManager.h:43
TileGeoSectionBuilder::setBarrelPeriodThickness
void setBarrelPeriodThickness(double val)
Definition: TileGeoSectionBuilder.cxx:3475
TileCellDim::getZMax
double getZMax(unsigned int index) const
Definition: TileCellDim.cxx:55
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
TileDddbManager::CutsDX1
double CutsDX1() const
Definition: TileDddbManager.cxx:1054
Variable
Wrapper around a histogram which allows for some additional filling patterns and data manipulation.
Definition: Trigger/TrigCost/TrigCostAnalysis/src/Variable.h:39
TileCellDim.h
TileDddbManager.h
TileDddbManager::TILBrminimal
double TILBrminimal() const
Definition: TileDddbManager.cxx:656
TileDddbManager::CutsYpos
double CutsYpos() const
Definition: TileDddbManager.cxx:1114
TileDddbManager::SetNextTiclInDetSamp
int SetNextTiclInDetSamp()
Definition: TileDddbManager.cxx:1580
DeMoScan.index
string index
Definition: DeMoScan.py:362
TileDddbManager::SCNTdtw
double SCNTdtw() const
Definition: TileDddbManager.cxx:989
Name
JetDumper::Name Name
Definition: JetDumper.cxx:19
TileDddbManager::TICGshape
int TICGshape() const
Definition: TileDddbManager.cxx:1354
TileGeoSectionBuilder::m_theMaterialManager
StoredMaterialManager * m_theMaterialManager
Definition: TileGeoSectionBuilder.h:199
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
TileDddbManager::SCNTdt
double SCNTdt() const
Definition: TileDddbManager.cxx:978
TileDddbManager::SCNTrc
double SCNTrc() const
Definition: TileDddbManager.cxx:945
GeoGenfun
Definition: ArrayFunction.cxx:7
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
eFEXNTuple.delta_phi
def delta_phi(phi1, phi2)
Definition: eFEXNTuple.py:14
TileDddbManager::CutsDZ1
double CutsDZ1() const
Definition: TileDddbManager.cxx:1094
DeMoScan.first
bool first
Definition: DeMoScan.py:534
TileDddbManager::SetFirstTiclInDet
int SetFirstTiclInDet(int detector)
Definition: TileDddbManager.cxx:1517
TileSwitches::pvt
int pvt
0: all scintillators are polystyrene 1: crack scrintillators are PVT, others - polystyrene
Definition: TileSwitches.h:47
DEBUG
#define DEBUG
Definition: page_access.h:11
TileGeoSectionBuilder::fillGirder
void fillGirder(PVLink &mother, double tile_rmax, double tilb_rmax, double tan_delta_phi_2, double thickness)
Girder parameters are the following:
Definition: TileGeoSectionBuilder.cxx:1354
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
TileDddbManager::TICGdr
double TICGdr() const
Definition: TileDddbManager.cxx:1376
StoredMaterialManager::getMaterial
virtual const GeoMaterial * getMaterial(const std::string &name)=0
TileDetDescriptor.h
TileDddbManager::TILBdzend2
double TILBdzend2() const
Definition: TileDddbManager.cxx:810
StoredMaterialManager
This class holds one or more material managers and makes them storeable, under StoreGate.
Definition: StoredMaterialManager.h:28
TileGeoSectionBuilder::setExtendedPeriodThickness
void setExtendedPeriodThickness(double val)
Definition: TileGeoSectionBuilder.cxx:3487
TileDddbManager::TICGdz
double TICGdz() const
Definition: TileDddbManager.cxx:1420
TileDddbManager::TILBflangey
double TILBflangey() const
Definition: TileDddbManager.cxx:722
TileDddbManager::TILBdzmast
double TILBdzmast() const
Definition: TileDddbManager.cxx:777
Trk::hole
@ hole
Definition: MeasurementType.h:36
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
merge.status
status
Definition: merge.py:16
TileGeoSectionBuilder::m_extendedPeriodThickness
double m_extendedPeriodThickness
Definition: TileGeoSectionBuilder.h:206
TileGeoSectionBuilder::printdouble
void printdouble(const char *name, double val)
Definition: TileGeoSectionBuilder.cxx:3519
RPDUtils::nRows
unsigned constexpr int nRows
Definition: RPDUtils.h:24
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
TileGeoSectionBuilder::computeCellDim
void computeCellDim(TileDetDescrManager *&manager, int detector, bool addPlates, float zShiftPos, float zShiftNeg)
Cell dimension parameters are the following:
Definition: TileGeoSectionBuilder.cxx:2709
TileDddbManager::CutsDY1
double CutsDY1() const
Definition: TileDddbManager.cxx:1074
TileDddbManager::TILBnperiod
int TILBnperiod() const
Definition: TileDddbManager.cxx:612
section
void section(const std::string &sec)
Definition: TestTriggerMenuAccess.cxx:22
TileCellDim::addZMax
void addZMax(double zMax)
Definition: TileCellDim.cxx:87
LArCellBinning.etamin
etamin
Definition: LArCellBinning.py:137
TileDddbManager
This class provides access to constants in the Geometry DB.
Definition: TileDddbManager.h:38
TileDddbManager::CutsDX2
double CutsDX2() const
Definition: TileDddbManager.cxx:1064
TileGeoSectionBuilder::m_barrelGlue
double m_barrelGlue
Definition: TileGeoSectionBuilder.h:205
TileCellDim::getZMin
double getZMin(unsigned int index) const
Definition: TileCellDim.cxx:47
TileGeoSectionBuilder::m_additionalIronLayer
double m_additionalIronLayer
Makes iron layer a little bit wider to obtain the same sampling fraction for simulation without a glu...
Definition: TileGeoSectionBuilder.h:215
TileDddbManager::SCNTdrw
double SCNTdrw() const
Definition: TileDddbManager.cxx:967
TileDddbManager::TICLdeta
double TICLdeta() const
Definition: TileDddbManager.cxx:1654
TileDddbManager::TICGdx1
double TICGdx1() const
Definition: TileDddbManager.cxx:1387
python.SystemOfUnits.gram
float gram
Definition: SystemOfUnits.py:183
Generated on Tue Nov 25 2025 21:20:30 for ATLAS Offline Software by   doxygen 1.8.18