ATLAS Offline Software
Classes | Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | List of all members
LArGeo::ModulesConstructionH62004 Class Reference

#include <ModulesConstructionH62004.h>

Collaboration diagram for LArGeo::ModulesConstructionH62004:

Classes

struct  LeakGeom
 

Public Member Functions

 ModulesConstructionH62004 ()
 
virtual ~ModulesConstructionH62004 ()
 
GeoIntrusivePtr< GeoVFullPhysVol > GetEnvelope ()
 

Private Member Functions

 ModulesConstructionH62004 (const ModulesConstructionH62004 &)
 
ModulesConstructionH62004 & operator= (const ModulesConstructionH62004 &)
 

Static Private Member Functions

static int GetID (int side, int dir, int calo)
 
static GeoLogVol * construct (StoredMaterialManager *materialManager, int side, int dir, int calo)
 
static GeoTrf::Transform3D position (int side, int dir, int calo)
 

Private Attributes

GeoIntrusivePtr< GeoFullPhysVol > m_ModulesPhys
 
StoreGateSvc * m_detectorStore = nullptr
 
const LArGeoTB2004Options * m_Options
 
int m_fcalVisLimit
 

Static Private Attributes

static const LeakGeom s_leakGeom
 

Detailed Description

Definition at line 21 of file ModulesConstructionH62004.h.

Constructor & Destructor Documentation

◆ ModulesConstructionH62004() [1/2]

LArGeo::ModulesConstructionH62004::ModulesConstructionH62004 ( )

Definition at line 133 of file ModulesConstructionH62004.cxx.

133  :m_ModulesPhys(nullptr),m_Options(nullptr),m_fcalVisLimit(-1)
134 {
135  StatusCode status;
136  ISvcLocator* svcLocator = Gaudi::svcLocator();
137  if (svcLocator->service("DetectorStore", m_detectorStore, false )==StatusCode::FAILURE) {
138  throw std::runtime_error("Error in ModulesConstruction, cannot access DetectorStore");
139  }
140 
141  status = m_detectorStore->retrieve(m_Options, "LArGeoTB2004Options");
142 
143  if(!status.isSuccess() ) {
144  std::cout << "ModulesConstructionH62004:\tCan't access LArGeoTB2004Options, using default values\n";
145  }
146 }

◆ ~ModulesConstructionH62004()

LArGeo::ModulesConstructionH62004::~ModulesConstructionH62004 ( )
virtualdefault

◆ ModulesConstructionH62004() [2/2]

LArGeo::ModulesConstructionH62004::ModulesConstructionH62004 ( const ModulesConstructionH62004 &  )
private

Member Function Documentation

◆ construct()

GeoLogVol * LArGeo::ModulesConstructionH62004::construct ( StoredMaterialManager *  materialManager,
int  side,
int  dir,
int  calo 
)
staticprivate

Definition at line 563 of file ModulesConstructionH62004.cxx.

565 {
566 //--------- Material definition for leakage detectors ---------
567  //double density, pressure, temperature;
568  std::string name;
569 
570  //density = universe_mean_density; //from PhysicalConstants.h
571  //pressure = 3.e-18*pascal;
572  //temperature = 2.73*kelvin;
573  const GeoMaterial* Vacuum = materialManager->getMaterial("std::Vacuum");
574  if (!Vacuum) throw std::runtime_error("Error in ModulesConstruction, std::Vacuum is not found.");
575 
576 //----------------- construct ID and name
577  int myID = GetID(side,dir,calo);
578  if(myID == 0 || myID > NUM_LEAK) return nullptr;
579  if(s_leakGeom.m_dX[myID-1] == 0 && s_leakGeom.m_dY[myID-1] == 0 && s_leakGeom.m_dZ[myID-1] == 0) return nullptr;
580  name = "LArGeoTB::LeakageDet::";
581  switch(calo){
582  case 0:
583  name += "emec";
584  break;
585  case 1:
586  name += "hec1";
587  break;
588  case 2:
589  name += "hec2";
590  break;
591  case 3:
592  name += "fcal1";
593  break;
594  case 4:
595  name += "fcal2";
596  break;
597  case 5:
598  name += "coldtc";
599  break;
600  default:
601  std::cerr << "Wrong calo for leakage !!" << std::endl;
602  return nullptr;
603  }
604  switch(dir){
605  case 0:
606  name += "_side";
607  break;
608  case 1:
609  name += "_up";
610  break;
611  case 2:
612  name += "_back";
613  break;
614  default:
615  std::cerr << "Wrong direction for leakage !!" << std::endl;
616  return nullptr;
617  }
618  if(dir != 1){
619  switch(side){
620  case 0:
621  name += "_left";
622  break;
623  case 1:
624  name += "_right";
625  break;
626  default:
627  std::cerr << "Wrong side for leakage !!" << std::endl;
628  return nullptr;
629  }
630  }
631 
632 // std::cout<<"ModulesConstructionH62004::construct: "<<myID<<": "<<name<<std::endl;
633 
634 //------------------ now construct shape and logical volume ---------------
635  GeoLogVol *volume_log;
636  if(myID == 6 || myID == 9 || myID == 17) {
637  GeoTubs *tub = new GeoTubs(s_leakGeom.m_dX[myID-1],s_leakGeom.m_dY[myID-1],s_leakGeom.m_dZ[myID-1],-43.*Gaudi::Units::degree,86.*Gaudi::Units::degree);
638  volume_log = new GeoLogVol(name,tub,Vacuum);
639  } else if(myID == 3) {
640  GeoTubs *tub = new GeoTubs(s_leakGeom.m_dX[myID-1],s_leakGeom.m_dY[myID-1],s_leakGeom.m_dZ[myID-1],-32.*Gaudi::Units::degree,64.*Gaudi::Units::degree);
641  volume_log = new GeoLogVol(name,tub,Vacuum);
642 #if 0 // impossible case...
643  } else if(myID == 19) {
644  GeoTrd *trd = new GeoTrd(s_leakGeom.m_dX[myID-1]-16.*Gaudi::Units::cm,s_leakGeom.m_dX[myID-1],s_leakGeom.m_dY[myID-1],s_leakGeom.m_dY[myID-1],s_leakGeom.m_dZ[myID-1]);
645  volume_log = new GeoLogVol(name,trd,Vacuum);
646 #endif
647  } else {
648  GeoBox *mbox = new GeoBox(s_leakGeom.m_dX[myID-1], s_leakGeom.m_dY[myID-1], s_leakGeom.m_dZ[myID-1]);
649  volume_log = new GeoLogVol(name,mbox,Vacuum);
650  }
651  return volume_log;
652 }

◆ GetEnvelope()

GeoIntrusivePtr< GeoVFullPhysVol > LArGeo::ModulesConstructionH62004::GetEnvelope ( )

Definition at line 150 of file ModulesConstructionH62004.cxx.

151 {
152  StoredMaterialManager* materialManager = nullptr;
153  if (StatusCode::SUCCESS != m_detectorStore->retrieve(materialManager, std::string("MATERIALS"))) {
154  throw std::runtime_error("Error in ModulesConstruction, cannot access Material manager");
155  }
156 
157  if (m_ModulesPhys) return (m_ModulesPhys);
158  ISvcLocator *svcLocator = Gaudi::svcLocator();
159  IMessageSvc * msgSvc;
160  if (svcLocator->service("MessageSvc", msgSvc, true )==StatusCode::FAILURE) {
161  throw std::runtime_error("Error in ModulesConstructionH62004, cannot access MessageSvc");
162  }
163  MsgStream log(msgSvc, "ModulesConstructionH62004");
164  log << MSG::INFO;
165  log << "++++++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
166  log << "+ +" << std::endl;
167  log << "+ Start of H62004 GeoModel definition +" << std::endl;
168  log << "+ +" << std::endl;
169  log << "++++++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
170 
171  const GeoMaterial *LAr = materialManager->getMaterial("std::LiquidArgon");
172  if (!LAr) throw std::runtime_error("Error in ModulesConstruction, std::LiquidArgon is not found.");
173 
174  // How to get Rohacell ????
175  // Taking Margret's one
176  // Define Rohacell Foam.
177  // Rohacell foam has density: 0.11g/cm3
178  std::string name;
179  double density;
180 
181  const GeoElement* C=materialManager->getElement("Carbon");
182  const GeoElement* H=materialManager->getElement("Hydrogen");
183  const GeoElement* O=materialManager->getElement("Oxygen");
184  const GeoElement* N=materialManager->getElement("Nitrogen");
185  GeoMaterial* Rohacell = new GeoMaterial(name="Rohacell", density=0.112*GeoModelKernelUnits::g/Gaudi::Units::cm3);
186  Rohacell->add(C,0.6465);
187  Rohacell->add(H,0.07836);
188  Rohacell->add(O,0.19137);
189  Rohacell->add(N,0.08377);
190  Rohacell->lock();
191 
192  /*
193  a = 12.957*GeoModelKernelUnits::g/Gaudi::Units::mole;
194  density = 0.112*g/cm3;
195  z = 6.18;
196  G4Material* Rohacell = new G4Material(name="Rohacell",z, a, density);
197  */
198 
199  const GeoMaterial *Alu = materialManager->getMaterial("std::Aluminium");
200  if (!Alu) throw std::runtime_error("Error in ModulesConstruction, std::Aluminium is not found.");
201 
202  // DB numbers:
203  double bryr_y = 200.0*Gaudi::Units::cm;
204  double bcry_rlar = 125.5*Gaudi::Units::cm;
205  double bcry_phistart = 0.*Gaudi::Units::degree;
206  double bcry_phiend = 360.*Gaudi::Units::degree;
207  //double EMECdzende = 63.2*Gaudi::Units::cm; // Can not get from parameters
208  //double Zall = 62.6*cm; // Excluder dimension
209 
210  double bepo_tx = 180.0*Gaudi::Units::degree;
211  double bepo_tz = 90.0*Gaudi::Units::degree;
212  double bepo_tz_e = ( M_PI / 4 )*Gaudi::Units::rad;
213  double bepo_ty = 90.0*Gaudi::Units::degree;
214  double bepo_Beta = 4.668*Gaudi::Units::degree;
215  double bepo_z_e = -42.86*Gaudi::Units::cm; // 43 Gaudi::Units::cm * cos(4.668)
216  double bepo_emec_shift = 2.5*Gaudi::Units::cm;
217  double bepo_excluder_shift = 34.4*Gaudi::Units::cm;
218  //double bepo_hec_shift = 63.6*Gaudi::Units::cm; // relative position of HEC versus EMEC
219  //double bepo_y_a = bcry_rlar-bepo_emec_shift-bepo_hec_shift;
220  double bepo_y_ex = bcry_rlar-bepo_excluder_shift;
221  double bepo_y_hecshift = 6.*Gaudi::Units::mm;
222  double bepo_y_emecshift = 11.*Gaudi::Units::mm;
223  double bepo_x = -2.75*Gaudi::Units::mm;
224  double bepo_x_e = -17.*Gaudi::Units::mm;
225 // double bepo_x = 13.25*Gaudi::Units::mm;
226 // double bepo_x_e = -3.*Gaudi::Units::mm;
227 // double bepo_x = 17.25*Gaudi::Units::mm;
228 // double bepo_x_e = -3.*Gaudi::Units::mm;
229  //double bepo_z = -48.24*Gaudi::Units::cm; // 48.4 Gaudi::Units::cm * cos(4.668)
230  double bepo_y_e = bcry_rlar-bepo_emec_shift;
231  double bepo_pz = 45.0*Gaudi::Units::degree;
232 
233  std::string baseName = "LArGeoTB::LeakageDet::";
234 
235  double ylen;
236  if(m_Options && m_Options->isRun1()) {
237  ylen = bryr_y;
238  } else {
239  ylen = bryr_y - 200.*Gaudi::Units::mm;
240  }
241  GeoTubs *shapeMother = new GeoTubs( 0.0*Gaudi::Units::cm, bcry_rlar, ylen, bcry_phistart,bcry_phiend);
242  GeoLogVol *logMother = new GeoLogVol(baseName + "LAr", shapeMother, LAr);
243 
244  m_ModulesPhys = new GeoFullPhysVol(logMother);
245 
246  std::string tag = std::string("MODULES_POS");
247  StatusCode status;
248  StoredPhysVol *sPhysVol = new StoredPhysVol(m_ModulesPhys);
249  status=m_detectorStore->record(sPhysVol,tag);
250  if(!status.isSuccess()) throw std::runtime_error ((std::string("Cannot store")+tag).c_str());
251 
252 // position leakage detectors
253 /*
254  for(int cal = 0; cal <= 5; ++cal){
255  for(int dir = 0; dir <= 2; ++dir){
256  for(int sid = 0; sid <= 1; ++sid){
257  GeoLogVol *leak_log = construct(materialManager, sid, dir, cal);
258  if(leak_log == 0) continue;
259  leak_log->SetSensitiveDetector(LeakSDdetector);
260  leak_log->SetVisAttributes(G4VisAttributes::Invisible);
261 // leak_log->SetVisAttributes(new G4VisAttributes(G4Color(0.7,0.1,0.7)));
262  GeoTrf::Transform3D leak_pos = position(sid, dir, cal);
263  G4VPhysicalVolume *leak_phys =
264  new G4PVPlacement(leak_pos,
265  leak_log,
266  leak_log->GetName(),
267  logMother,
268  false,
269  10000+GetID(sid,dir,cal));
270  }
271  }
272  }
273 */
274 
275 // position EMEC excluder
276 
277  ExcluderConstructionH62004 excluder(0);
278  /*if(excluder != 0)*/{
279 // std::cout<<"ModulesConstructionH62004::GetEnvelope positioning Excluder"<<std::endl;
280  GeoIntrusivePtr<GeoVFullPhysVol> excluderEnvelope = excluder.GetEnvelope();
281  /*if(excluderEnvelope != 0)*/{
282  GeoTrf::Transform3D rot2 = GeoTrf::RotateX3D(bepo_Beta) * GeoTrf::RotateX3D(bepo_ty) * GeoTrf::RotateZ3D(bepo_tz);
283  m_ModulesPhys->add(new GeoSerialIdentifier(0));
284  m_ModulesPhys->add(new GeoTransform(GeoTrf::Translation3D(0.,bepo_y_ex,bepo_z_e+42.*Gaudi::Units::mm) * rot2));
285  m_ModulesPhys->add(excluderEnvelope);
286  }
287  }
288 
289 
290 // position FCAL excluder
291 
292 
293  ExcluderConstructionH62004 fcexcluder(1);
294  /*if(fcexcluder != 0)*/{
295 // std::cout<<"ModulesConstructionH62004::GetEnvelope positioning Excluder"<<std::endl;
296  GeoIntrusivePtr<GeoVFullPhysVol> fcexcluderEnvelope = fcexcluder.GetEnvelope();
297  if(fcexcluderEnvelope ){
298  GeoTrf::Transform3D rot2 = GeoTrf::RotateX3D(0.8*bepo_Beta) * GeoTrf::RotateX3D(-bepo_ty) * GeoTrf::RotateZ3D(bepo_tx);
299  m_ModulesPhys->add(new GeoSerialIdentifier(0));
300 // m_ModulesPhys->add(new GeoTransform(GeoTrf::Transform3D(rot2,GeoTrf::Vector3D(0.,bepo_y_ex-138.*Gaudi::Units::mm,-477.3*Gaudi::Units::mm))));
301  m_ModulesPhys->add(new GeoTransform(GeoTrf::Translation3D(0.,bepo_y_ex-146.*Gaudi::Units::mm,-412.0*Gaudi::Units::mm) * rot2));
302  m_ModulesPhys->add(fcexcluderEnvelope);
303  }
304  }
305 
306 
307 // position Front excluder
308 
309  ExcluderConstructionH62004 frontexcluder(2);
310 
311  /*if(frontexcluder != 0)*/{
312  GeoIntrusivePtr<GeoVFullPhysVol> frontexcluderEnvelope = frontexcluder.GetEnvelope();
313  if(frontexcluderEnvelope ){
314  GeoTrf::RotateZ3D rot2((90.)*Gaudi::Units::degree);
315  m_ModulesPhys->add(new GeoSerialIdentifier(0));
316  m_ModulesPhys->add(new GeoTransform(GeoTrf::Translation3D(0.,0.,20.*Gaudi::Units::mm) * rot2));
317  m_ModulesPhys->add(frontexcluderEnvelope);
318  /*
319  G4VPhysicalVolume* frontexcluderPhysical =
320 // new G4PVPlacement(GeoTrf::Transform3D(rot2,GeoTrf::Vector3D(0.,0.,220.*Gaudi::Units::mm)), // Translation
321  new G4PVPlacement(GeoTrf::Transform3D(rot2,GeoTrf::Vector3D(0.,0.,20.*Gaudi::Units::mm)), // Translation
322  frontexcluderEnvelope, // Logical volume
323  frontexcluderEnvelope->GetName(), // Name
324  logMother, // Mother volume
325  false, // Boolean volume?
326  0); // Copy number
327  */
328  }
329  }
330 
331 
332 // position Back excluder
333 
334  ExcluderConstructionH62004 backexcluder(3);
335 
336  /*if(backexcluder != 0)*/{
337  GeoIntrusivePtr<GeoVFullPhysVol> backexcluderEnvelope = backexcluder.GetEnvelope();
338  if(backexcluderEnvelope ){
339  GeoTrf::RotateZ3D rot2((-90.-29.)*Gaudi::Units::degree);
340  m_ModulesPhys->add(new GeoSerialIdentifier(0));
341  m_ModulesPhys->add(new GeoTransform(GeoTrf::Translation3D(0.,0.,0.*Gaudi::Units::mm) * rot2));
342  m_ModulesPhys->add(backexcluderEnvelope);
343  /*
344  G4VPhysicalVolume* backexcluderPhysical =
345  new G4PVPlacement(GeoTrf::Transform3D(rot2,GeoTrf::Vector3D(0.,0.,0.*Gaudi::Units::mm)), // Translation
346  backexcluderEnvelope, // Logical volume
347  backexcluderEnvelope->GetName(), // Name
348  logMother, // Mother volume
349  false, // Boolean volume?
350  0); // Copy number
351  */
352  }
353  }
354 
355 
356 
357  // Let's try assembly volume
358 
359  // G4AssemblyVolume* assemblyMother = new G4AssemblyVolume();
360 
361  // Transformation for assembly - should be putted to each piece now.
362  GeoTrf::Transform3D rota = GeoTrf::RotateX3D(bepo_Beta) * GeoTrf::RotateX3D(bepo_ty) * GeoTrf::RotateZ3D(-bepo_pz);
363  GeoTrf::Transform3D trans = GeoTrf::Translation3D(0.,bepo_y_e,bepo_z_e+65.*Gaudi::Units::mm) * rota;
364 
365 //positions emec
366 
367  // Z-positions DB values !!!!
368 
369  double HECzStart = 427.7*Gaudi::Units::cm;
370  double EMECzStart = 364.1*Gaudi::Units::cm;
371  double FCALzStart = 466.85*Gaudi::Units::cm;
372  double FCALzEnd = 588.28*Gaudi::Units::cm;
373 
374  if((!m_Options) || m_Options->isEmec()){
375  GeoTrf::RotateZ3D MrotEmec(bepo_tz_e);
376  // original value:
377 // GeoTrf::Vector3D pos3Emec( 0*Gaudi::Units::mm, 9.0*Gaudi::Units::mm , 55.9*Gaudi::Units::mm);
378 // GeoTrf::Vector3D pos3Emec( 3.636*Gaudi::Units::mm, 9.0*Gaudi::Units::mm , 55.9*Gaudi::Units::mm);
379 // GeoTrf::Vector3D pos3Emec( bepo_x_e, 9.*Gaudi::Units::mm , 61.*Gaudi::Units::mm);
380  GeoTrf::Translation3D pos3Emec((bepo_x_e - bepo_y_emecshift )/2./sin(bepo_tz_e)
381  , (bepo_x_e + bepo_y_emecshift )/2./sin(bepo_tz_e)
382  , 61.*Gaudi::Units::mm);
383 // GeoTrf::Vector3D pos3Emec( 0.*Gaudi::Units::mm, bepo_x_e, 61.*Gaudi::Units::mm);
384 
385 // std::cout<<"ModulesConstructionH62004 calling EMECModuleConstruction....."<<std::endl;
386  //use this line for physical construction of the EMEC inner wheel only:
387 // EMECModuleConstruction* emecConstruction = new EMECModuleConstruction(true, true, false);
388  EMECModuleConstruction emecConstruction(true, true, false);
389 
390  GeoIntrusivePtr<GeoVFullPhysVol> emecEnvelope = emecConstruction.GetEnvelope();
391  m_ModulesPhys->add(new GeoNameTag("LAr"));
392  m_ModulesPhys->add( new GeoTransform(trans) );
393  m_ModulesPhys->add( new GeoTransform( pos3Emec * MrotEmec ));
394  m_ModulesPhys->add(emecEnvelope);
395 // std::cout<<"ModulesConstructionH62004 EMECModuleConstruction done...."<<std::endl;
396  }
397 
398 
399  if((!m_Options) || m_Options->isHec()){
400  //positions hec
401 
402  HECConstructionH62004 hec;
403  /*if(hec != 0)*/{
404  PVLink hecEnvelope = hec.GetEnvelope();
405  if(hecEnvelope ){
406 // rot.rotateZ(-bepo_pz);
407 // rot.rotateX(bepo_ty);
408 // rot.rotateX(bepo_Beta);
409 
410 // GeoTrf::Transform3D hpos = GeoTrf::Transform3D(rot,GeoTrf::Vector3D(bepo_x,bepo_y_a,bepo_z));
411 // GeoTrf::Vector3D hecshift(0.,6.*Gaudi::Units::mm,HECzStart-EMECzStart);
412 // GeoTrf::Vector3D hecshift((bepo_x - bepo_y_hecshift)/2./sin(bepo_tz_e), (bepo_x + bepo_y_hecshift)/2./sin(bepo_tz_e), HECzStart-EMECzStart);
413 // GeoTrf::Vector3D hecshift(-21.*Gaudi::Units::mm, bepo_x, HECzStart-EMECzStart);
414 // GeoTrf::Vector3D hecshift(-5.*Gaudi::Units::mm, bepo_x, HECzStart-EMECzStart);
415 // GeoTrf::Vector3D hecshift(0.*Gaudi::Units::mm, bepo_x, HECzStart-EMECzStart);
416 // Gaudi::Units::HepRotation norot;
417  m_ModulesPhys->add(new GeoTransform(trans));
418  m_ModulesPhys->add( new GeoTransform(GeoTrf::Translate3D((bepo_x - bepo_y_hecshift)/2./sin(bepo_tz_e)
419  , (bepo_x + bepo_y_hecshift)/2./sin(bepo_tz_e)
420  , HECzStart-EMECzStart)) );
421  m_ModulesPhys->add(hecEnvelope);
422 
423 // assemblyMother->AddPlacedVolume( hecEnvelope, hectrans );
424  }
425  }
426  }
427 
428  if((!m_Options) || m_Options->isFcal()){
429  FCALConstructionH62004 fcal;
430  /*if(fcal != 0)*/{
431  fcal.setFCALVisLimit(m_fcalVisLimit);
432  PVLink fcalEnvelope = fcal.GetEnvelope();
433  if(fcalEnvelope ){
434 // Gaudi::Units::HepRotation rotFCal;
435  // rotFCal.rotateY(0.*Gaudi::Units::deg);
436  // rotFCal.rotateZ(-bepo_pz);
437  // rotFCal.rotateX(bepo_ty);
438  // rotFCal.rotateX(bepo_Beta);
439 // GeoTrf::Vector3D fcalshift(0.,-7.*Gaudi::Units::mm,FCALzStart-EMECzStart+(FCALzEnd-FCALzStart)/2.);
440  m_ModulesPhys->add(new GeoTransform(trans));
441  m_ModulesPhys->add( new GeoTransform(GeoTrf::Translate3D(9.*Gaudi::Units::mm
442  ,0.*Gaudi::Units::mm
443  ,FCALzStart-EMECzStart+(FCALzEnd-FCALzStart)/2.)) );
444  m_ModulesPhys->add(fcalEnvelope);
445  }
446  }
447  }
448 
449  if((!m_Options) || m_Options->isColdnose()){
450  // Position a cold nose
451  //
452 
453  double box_x = (650./2.)*Gaudi::Units::mm;
454  double box_y = (356./2.)*Gaudi::Units::mm;
455  double box_z = (50.8/2.)*Gaudi::Units::mm;
456  double btot = 494.*Gaudi::Units::mm;
457  double tub_r = 452.*Gaudi::Units::mm;
458  double tub1_dr = 8.*Gaudi::Units::mm;
459  double tub1_z = (1320./2.)*Gaudi::Units::mm;
460  double cyl_dr = 10.*Gaudi::Units::mm;
461  double cyl_r1 = 262.*Gaudi::Units::mm;
462  double cyl_r2 = 336.5*Gaudi::Units::mm;
463  double cyl_z = (912./2.)*Gaudi::Units::mm;
464  double cyl_shift = (10. + 25.)*Gaudi::Units::mm;
465 // double NoseZshift = -360.*Gaudi::Units::mm;
466  double NoseZshift = -63.1*Gaudi::Units::mm;
467 // double NoseYshift = 94.4*Gaudi::Units::mm;
468 // double NoseYshift = 96.4*Gaudi::Units::mm;
469  double NoseYshift = 98.4*Gaudi::Units::mm;
470 // double NoseXshift = -195.*Gaudi::Units::mm;
471  double NoseXshift = -94.4*Gaudi::Units::mm;
472 
473  GeoBox* Box1 = new GeoBox(box_x, box_y, box_z);
474  double alpha = acos(box_x/tub_r);
475  double ax = M_PI - 2*alpha;
476  GeoTubs* Tub= new GeoTubs(0., tub_r, box_z, alpha, ax);
477 
478 // tRot.rotateX(90*Gaudi::Units::degree);
479  GeoTrf::Translate3D TubTrans(0.,btot-box_y-tub_r,0.);
480  const GeoShapeUnion &uSolid = (*Box1).add((*Tub)<<TubTrans);
481 
482  GeoTubs* Tub1 = new GeoTubs(tub_r, tub_r+tub1_dr, tub1_z, alpha, ax);
483 // GeoTrf::Vector3D TubShift2(0.,btot-box_y-tub_r,-tub1_z+box_z);
484 // GeoTrf::Vector3D TubShift2(0.,0.,0.);
485 // tRot.rotateX(90*Gaudi::Units::degree);
486  GeoTrf::Translate3D UnTrans(0.,-135.5*Gaudi::Units::mm,-tub1_z+box_z);
487  const GeoShapeUnion &uSolid2 = uSolid.add((*Tub1)<<UnTrans);
488 
489  GeoCons* Cone = new GeoCons(cyl_r2, cyl_r1, cyl_r2+cyl_dr, cyl_r1+cyl_dr, cyl_z, M_PI/4.,M_PI/2.);
490 // GeoTrf::Vector3D CylShift(0.,-box_y+cyl_shift,cyl_z+box_z-3.*Gaudi::Units::mm);
491  GeoTrf::Translation3D CylShift(0.,-box_y+cyl_shift,cyl_z+box_z-5.*Gaudi::Units::mm);
492 // GeoTrf::Vector3D CylShift(0.,0.,cyl_z+box_z);
493  GeoTrf::RotateX3D tRot(1.*Gaudi::Units::degree);
494 // tRot.rotateZ(-90*Gaudi::Units::degree);
495  GeoTrf::Transform3D CylTrans = CylShift * tRot;
496  const GeoShapeUnion &uSolid3 = uSolid2.add((*Cone)<<CylTrans);
497 
498  GeoLogVol* Cnose = new GeoLogVol("LArGeoTB::LeakageDet::ColdNose", &uSolid3 , Alu);
499  GeoIntrusivePtr<GeoPhysVol>PhysCnose = new GeoPhysVol(Cnose);
500 // cnose->SetVisAttributes(G4VisAttributes::Invisible);
501  GeoTrf::Transform3D CRotation = GeoTrf::RotateZ3D(-3*M_PI/4.) * GeoTrf::RotateX3D(M_PI);
502 // GeoTrf::Vector3D tShift(NoseXshift,0.,FCALzStart-EMECzStart+NoseZshift);
503  GeoTrf::Translation3D tShift(NoseXshift,NoseYshift,FCALzStart-EMECzStart+NoseZshift);
504 // GeoTrf::Vector3D tShift(0.,NoseYshift,NoseZshift);
505  GeoTrf::Transform3D CTrans = tShift * CRotation;
506  m_ModulesPhys->add( new GeoTransform(trans) ) ;
507  m_ModulesPhys->add(new GeoTransform(CTrans));
508  m_ModulesPhys->add(PhysCnose);
509 // assemblyMother->AddPlacedVolume( cnose, CTrans );
510  /*
511  G4VPhysicalVolume* nosePhysical = new
512  G4PVPlacement(GeoTrf::Transform3D(CRotation,tShift),
513  cnose, cnose->GetName(),logMother, false, 0);
514  */
515 
516  // Do an imprint of assembly:
517 
518  /*
519  Gaudi::Units::HepRotation rota;
520  rota.rotateZ(-bepo_pz);
521  rota.rotateX(bepo_ty);
522  rota.rotateX(bepo_Beta);
523 
524  GeoTrf::Transform3D trans(rota, GeoTrf::Vector3D(0.,bepo_y_e,bepo_z_e));
525 
526  assemblyMother->MakeImprint( logMother, trans );
527  */
528  }
529  return m_ModulesPhys;
530 }

◆ GetID()

int LArGeo::ModulesConstructionH62004::GetID ( int  side,
int  dir,
int  calo 
)
staticprivate

Definition at line 532 of file ModulesConstructionH62004.cxx.

533 {
534  int i;
535  if(calo<0 || calo >5) return 0;
536  if(side<0 || side >1) return 0;
537 
538  switch(dir) {
539  case 0: {
540  if(calo<=2) i=1; else i=5-calo;
541  return 3*calo+i+side;
542  }
543  case 2: {
544  if(side==1) return 0;
545  if(calo==2) return 10;
546  else if(calo==5) return 18;
547  else return 0;
548  }
549  case 1: {
550  if(side==1) return 0;
551  if(calo==3 || calo==4) return 0;
552  if(calo==5) i=2; else i=3;
553  return 3*calo+i;
554  }
555 
556  default : {return 0;}
557  }
558 
559 }

◆ operator=()

ModulesConstructionH62004& LArGeo::ModulesConstructionH62004::operator= ( const ModulesConstructionH62004 &  )
private

◆ position()

GeoTrf::Transform3D LArGeo::ModulesConstructionH62004::position ( int  side,
int  dir,
int  calo 
)
staticprivate

Definition at line 654 of file ModulesConstructionH62004.cxx.

655 {
656  GeoTrf::Transform3D leak_position(GeoTrf::Transform3D::Identity());
657 
658  int myID = GetID(side,dir,calo);
659  if(myID == 0) {
660  std::cerr << "Error! First construct the leakage detector !!" << std::endl;
661  }
662  assert(myID>0 && myID <= NUM_LEAK);
663  if(myID > NUM_LEAK) return leak_position;
664 
665  GeoTrf::Transform3D rotM = GeoTrf::RotateX3D(s_leakGeom.m_angleX[myID-1]) * GeoTrf::RotateY3D(s_leakGeom.m_angleY[myID-1]) * GeoTrf::RotateZ3D(s_leakGeom.m_angleZ[myID-1]);
666 
667  leak_position = GeoTrf::Transform3D(GeoTrf::Translation3D(s_leakGeom.m_shiftX[myID-1],s_leakGeom.m_shiftY[myID-1],s_leakGeom.m_shiftZ[myID-1]) * rotM);
668 
669  return leak_position;
670 }

Member Data Documentation

◆ m_detectorStore

StoreGateSvc* LArGeo::ModulesConstructionH62004::m_detectorStore = nullptr
private

Definition at line 40 of file ModulesConstructionH62004.h.

◆ m_fcalVisLimit

int LArGeo::ModulesConstructionH62004::m_fcalVisLimit
private

Definition at line 52 of file ModulesConstructionH62004.h.

◆ m_ModulesPhys

GeoIntrusivePtr<GeoFullPhysVol> LArGeo::ModulesConstructionH62004::m_ModulesPhys
private

Definition at line 39 of file ModulesConstructionH62004.h.

◆ m_Options

const LArGeoTB2004Options* LArGeo::ModulesConstructionH62004::m_Options
private

Definition at line 42 of file ModulesConstructionH62004.h.

◆ s_leakGeom

const LArGeo::ModulesConstructionH62004::LeakGeom LArGeo::ModulesConstructionH62004::s_leakGeom
staticprivate

Definition at line 50 of file ModulesConstructionH62004.h.

The documentation for this class was generated from the following files:
StoreGateSvc::record
StatusCode record(T *p2BRegistered, const TKEY &key)
Record an object with a key.
fitman.ax
ax
Definition: fitman.py:522
LArGeo::ModulesConstructionH62004::GetID
static int GetID(int side, int dir, int calo)
Definition: ModulesConstructionH62004.cxx:532
LAr
Definition: LArVolumeBuilder.h:36
LArGeo::ModulesConstructionH62004::m_Options
const LArGeoTB2004Options * m_Options
Definition: ModulesConstructionH62004.h:42
LArGeo::ModulesConstructionH62004::LeakGeom::m_angleY
float m_angleY[NUM_LEAK]
Definition: ModulesConstructionH62004.h:48
DMTest::C
C_v1 C
Definition: C.h:26
LArGeo::ModulesConstructionH62004::m_detectorStore
StoreGateSvc * m_detectorStore
Definition: ModulesConstructionH62004.h:40
StoredMaterialManager::getElement
virtual const GeoElement * getElement(const std::string &name)=0
cm3
#define cm3
M_PI
#define M_PI
Definition: ActiveFraction.h:11
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
StoreGateSvc::retrieve
StatusCode retrieve(const T *&ptr) const
Retrieve the default object into a const T*.
StoredPhysVol
Definition: StoredPhysVol.h:27
TRT::Hit::side
@ side
Definition: HitInfo.h:83
cm
const double cm
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/tools/FCAL_ChannelMap.cxx:25
xAOD::Cone
@ Cone
Definition: TrackingPrimitives.h:552
NUM_LEAK
#define NUM_LEAK
Definition: ModulesConstructionH62004.h:19
lwtDev::Component::O
@ O
H
#define H(x, y, z)
Definition: MD5.cxx:114
LArGeo::ModulesConstructionH62004::LeakGeom::m_angleZ
float m_angleZ[NUM_LEAK]
Definition: ModulesConstructionH62004.h:48
LArGeo::ModulesConstructionH62004::LeakGeom::m_angleX
float m_angleX[NUM_LEAK]
Definition: ModulesConstructionH62004.h:48
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
lumiFormat.i
int i
Definition: lumiFormat.py:92
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
LArGeo::ModulesConstructionH62004::m_fcalVisLimit
int m_fcalVisLimit
Definition: ModulesConstructionH62004.h:52
LArGeo::ModulesConstructionH62004::m_ModulesPhys
GeoIntrusivePtr< GeoFullPhysVol > m_ModulesPhys
Definition: ModulesConstructionH62004.h:39
LArGeoTB2004Options::isEmec
bool isEmec(void) const
Definition: LArGeoTB2004Options.h:46
beamspotman.dir
string dir
Definition: beamspotman.py:623
LArGeo::ModulesConstructionH62004::LeakGeom::m_shiftY
float m_shiftY[NUM_LEAK]
Definition: ModulesConstructionH62004.h:47
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
LArGeo::ModulesConstructionH62004::LeakGeom::m_shiftZ
float m_shiftZ[NUM_LEAK]
Definition: ModulesConstructionH62004.h:47
LArGeo::ModulesConstructionH62004::LeakGeom::m_shiftX
float m_shiftX[NUM_LEAK]
Definition: ModulesConstructionH62004.h:47
LArGeoTB2004Options::isFcal
bool isFcal(void) const
Definition: LArGeoTB2004Options.h:48
LArGeoTB2004Options::isColdnose
bool isColdnose(void) const
Definition: LArGeoTB2004Options.h:49
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
LArGeo::ModulesConstructionH62004::LeakGeom::m_dY
float m_dY[NUM_LEAK]
Definition: ModulesConstructionH62004.h:46
LArGeoTB2004Options::isHec
bool isHec(void) const
Definition: LArGeoTB2004Options.h:47
LArGeo::ModulesConstructionH62004::s_leakGeom
static const LeakGeom s_leakGeom
Definition: ModulesConstructionH62004.h:50
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
LArGeo::ModulesConstructionH62004::LeakGeom::m_dX
float m_dX[NUM_LEAK]
Definition: ModulesConstructionH62004.h:46
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
StoredMaterialManager::getMaterial
virtual const GeoMaterial * getMaterial(const std::string &name)=0
StoredMaterialManager
This class holds one or more material managers and makes them storeable, under StoreGate.
Definition: StoredMaterialManager.h:28
merge.status
status
Definition: merge.py:17
LArGeo::ModulesConstructionH62004::LeakGeom::m_dZ
float m_dZ[NUM_LEAK]
Definition: ModulesConstructionH62004.h:46
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:24
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
python.CaloScaleNoiseConfig.default
default
Definition: CaloScaleNoiseConfig.py:79
python.SystemOfUnits.degree
tuple degree
Definition: SystemOfUnits.py:106
python.SystemOfUnits.rad
int rad
Definition: SystemOfUnits.py:111
LArGeoTB2004Options::isRun1
bool isRun1(void) const
Definition: LArGeoTB2004Options.h:45
Generated on Tue Jul 2 2024 22:19:03 for ATLAS Offline Software by   doxygen 1.8.18