ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes | List of all members
LArMaterialManager Class Reference

#include <LArMaterialManager.h>

Inheritance diagram for LArMaterialManager:
Collaboration diagram for LArMaterialManager:

Public Member Functions

 LArMaterialManager (StoreGateSvc *pDetStore)
 ~LArMaterialManager ()=default
void buildMaterials ()
bool msgLvl (const MSG::Level lvl) const
 Test the output level.
MsgStream & msg () const
 The standard message stream.
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream.
void setLevel (MSG::Level lvl)
 Change the current logging level.

Private Member Functions

void initMessaging () const
 Initialize our message level and MessageSvc.

Private Attributes

StoredMaterialManager * m_storedManager {nullptr}
std::string m_nm
 Message source name.
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer.
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level.
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging)

Detailed Description

Definition at line 37 of file LArMaterialManager.h.

Constructor & Destructor Documentation

◆ LArMaterialManager()

LArMaterialManager::LArMaterialManager ( StoreGateSvc * pDetStore)

Definition at line 21 of file LArMaterialManager.cxx.

22 : AthMessaging("LArMaterialManager")
23{
24 if(detStore->retrieve(m_storedManager, "MATERIALS").isFailure())
25 throw std::runtime_error("Error in LArMaterialManager, list of precalculated materials is absent..");
26}
AthMessaging::AthMessaging
AthMessaging()
Default constructor:
LArMaterialManager::m_storedManager
StoredMaterialManager * m_storedManager
Definition LArMaterialManager.h:50

◆ ~LArMaterialManager()

LArMaterialManager::~LArMaterialManager ( )
default

Member Function Documentation

◆ buildMaterials()

void LArMaterialManager::buildMaterials ( )

! Check whether G10 or G10_bar is to be used!!!!

Definition at line 28 of file LArMaterialManager.cxx.

29{
30 ATH_MSG_DEBUG("**** in Material Manager ");
31
32 GeoIntrusivePtr<const GeoMaterial> Copper = m_storedManager->getMaterial("std::Copper");
33 if (!Copper) throw std::runtime_error("Error in LArMaterialManager, std::Copper is not found.");
34 ATH_MSG_DEBUG("Copper radiation length " << Copper->getRadLength() << " "
35 << Copper->getDensity()/(GeoModelKernelUnits::g/Gaudi::Units::cm3));
36
37 GeoIntrusivePtr<const GeoMaterial> Iron = m_storedManager->getMaterial("std::Iron");
38 if (!Iron) throw std::runtime_error("Error in LArMaterialManager, std::Iron is not found.");
39
40 GeoIntrusivePtr<const GeoMaterial> Lead = m_storedManager->getMaterial("std::Lead");
41 if (!Lead) throw std::runtime_error("Error in LArMaterialManager, std::Lead is not found.");
42#ifdef DEBUGGEO
43 ATH_MSG_INFO("Lead radiation length " << Lead->getRadLength() << " "
44 << Lead->getDensity()/(GeoModelKernelUnits::g/Gaudi::Units::cm3));
45#endif
46
47
48 GeoIntrusivePtr<const GeoMaterial> LAr = m_storedManager->getMaterial("std::LiquidArgon");
49 if (!LAr) throw std::runtime_error("Error in LArMaterialManager, std::LiquidArgon is not found.");
50
51#ifdef DEBUGGEO
52 ATH_MSG_INFO("LAr radiation length " << LAr->getRadLength() << " "
53 << LAr->getDensity()/(GeoModelKernelUnits::g/Gaudi::Units::cm3));
54#endif
55
56 GeoIntrusivePtr<const GeoMaterial> Air = m_storedManager->getMaterial("std::Air");
57 if (!Air) throw std::runtime_error("Error in LArMaterialManager, std::Air is not found.");
58
59 GeoIntrusivePtr<const GeoMaterial> Kapton = m_storedManager->getMaterial("std::Kapton");
60 if (!Kapton) throw std::runtime_error("Error in LArMaterialManager, std::Kapton is not found.");
61#ifdef DEBUGGEO
62 ATH_MSG_INFO("Kapton radiation length " << Kapton->getRadLength() << " "
63 << Kapton->getDensity()/(GeoModelKernelUnits::g/Gaudi::Units::cm3));
64 for (size_t i = 0; i< Kapton->getNumElements();i++) {
65 ATH_MSG_INFO(int (Kapton->getFraction(i)*100) << "% \t" << Kapton->getElement(i)->getName());
66 }
67#endif
68
69 GeoIntrusivePtr<const GeoMaterial> Glue = m_storedManager->getMaterial("LAr::Glue");
70 if (!Glue) throw std::runtime_error("Error in LArMaterialManager, LAr::Glue is not found.");
71#ifdef DEBUGGEO
72 ATH_MSG_INFO("Glue radiation length " << Glue->getRadLength() << " "
73 << Glue->getDensity()/(GeoModelKernelUnits::g/Gaudi::Units::cm3));
74 for (size_t i = 0; i< Glue->getNumElements();i++) {
75 ATH_MSG_INFO(int (Glue->getFraction(i)*100) << "% \t" << Glue->getElement(i)->getName());
76 }
77#endif
78
79 GeoIntrusivePtr<const GeoMaterial> G10 = m_storedManager->getMaterial("LAr::G10");
80 if (!G10) throw std::runtime_error("Error in LArMaterialManager, LAr::G10 is not found.");
81#ifdef DEBUGGEO
82 ATH_MSG_INFO("G10 radiation length " << G10->getRadLength() << " "
83 << G10->getDensity()/(GeoModelKernelUnits::g/Gaudi::Units::cm3));
84 for (size_t i = 0; i< G10->getNumElements();i++) {
85 ATH_MSG_INFO(int (G10->getFraction(i)*100) << "% \t" << G10->getElement(i)->getName());
86 }
87#endif
88
89 DatabaseAccessTool dB;
90 //----------------------------------------------------------------------------------------//
91 // LAR... //
92 //----------------------------------------------------------------------------------------//
93 {
94
95 //**** GU: be careful
96 // In GeoMaterial::add, the fractions are per MASS
97 //
98 double Tggl, Tgfe, Tgpb, Thgl, Thfe, Thpb, Thcu, Thfg, ThMBcu, ThMBG10;
99
100 // thin and thick lead absorbers
101 double Totalthick,Totalmass,Fracpb,Fracfe,Fracgl;
102 double Totalthicke,Totalmasse,FracCu,FracKap;
103 // contraction from warm to cold
104
105 double contract=dB.getDouble("ColdContraction","ColdContraction-00", "ABSORBERCONTRACTION"); // LArEMBAbsorberContraction
106
107 // first thin absorbers
108 Tggl=dB.getDouble("BarrelGeometry","BarrelGeometry-00","TGGL")*Gaudi::Units::cm*contract; // LArEMBThinAbsGlue
109 Tgfe=dB.getDouble("BarrelGeometry","BarrelGeometry-00","TGFE")*Gaudi::Units::cm*contract; // LArEMBThinAbsIron
110 Tgpb=dB.getDouble("BarrelGeometry","BarrelGeometry-00","TGPB")*Gaudi::Units::cm*contract; // LArEMBThinAbsLead
111 Totalthick = Tggl+Tgfe+Tgpb;
112 Totalmass = (Tgpb*Lead->getDensity()+Tgfe*Iron->getDensity()+Tggl*Glue->getDensity());
113 //***GU below are the fraction per mass
114 Fracpb = (Tgpb*Lead->getDensity())/Totalmass;
115 Fracfe = (Tgfe*Iron->getDensity())/Totalmass;
116 Fracgl = (Tggl*Glue->getDensity())/Totalmass;
117 double density = Totalmass/Totalthick/(contract*contract*contract);
118
119 ATH_MSG_DEBUG("---- THIN absorber characteristics: ----");
120 ATH_MSG_DEBUG(" Fraction pb,fe,gl: "<<Fracpb<<","<<Fracfe<<"," <<Fracgl);
121 ATH_MSG_DEBUG(" Total mass, Thickness: "<<Totalmass<<" ," <<Totalthick);
122 ATH_MSG_DEBUG(" Contraction " << contract);
123 ATH_MSG_DEBUG(" Thinabs Density = "<< density*(Gaudi::Units::cm3/GeoModelKernelUnits::g));
124
125 GeoIntrusivePtr<GeoMaterial> Thin_abs = new GeoMaterial("LAr::Thinabs",density);
126 Thin_abs->add(Lead,Fracpb);
127 Thin_abs->add(Iron,Fracfe);
128 Thin_abs->add(Glue,Fracgl);
129 m_storedManager->addMaterial("LAr", Thin_abs);
130
131#ifdef DEBUGGEO
132 ATH_MSG_INFO("ThinAbs radiation length " << Thin_abs->getRadLength());
133#endif
134
135 // then thick absorbers
136 Thgl=dB.getDouble("BarrelGeometry","BarrelGeometry-00","THGL")*Gaudi::Units::cm*contract; // LArEMBThickAbsGlue
137 Thfe=dB.getDouble("BarrelGeometry","BarrelGeometry-00","THFE")*Gaudi::Units::cm*contract; // LArEMBThickAbsIron
138 Thpb=dB.getDouble("BarrelGeometry","BarrelGeometry-00","THPB")*Gaudi::Units::cm*contract; // LArEMBThickAbsLead
139
140 Totalthick = Thgl+Thfe+Thpb;
141 Totalmass = (Thpb*Lead->getDensity()+Thfe*Iron->getDensity()+Thgl*Glue->getDensity());
142 //**GU below are the fractions per mass
143 Fracpb = (Thpb*Lead->getDensity())/Totalmass;
144 Fracfe = (Thfe*Iron->getDensity())/Totalmass;
145 Fracgl = (Thgl*Glue->getDensity())/Totalmass;
146 density = Totalmass/Totalthick/(contract*contract*contract);
147
148 ATH_MSG_DEBUG("---- THICK absorber characteristics: ----");
149 ATH_MSG_DEBUG(" Fraction pb,fe,gl: "<<Fracpb<<","<<Fracfe<<","<<Fracgl);
150 ATH_MSG_DEBUG(" Total mass, Thickness: "<<Totalmass<<" ,"<<Totalthick);
151 ATH_MSG_DEBUG(" Thickabs Density = " << density*(Gaudi::Units::cm3/GeoModelKernelUnits::g));
152
153 GeoIntrusivePtr<GeoMaterial> Thick_abs = new GeoMaterial("LAr::Thickabs",density);
154 Thick_abs->add(Lead,Fracpb);
155 Thick_abs->add(Iron,Fracfe);
156 Thick_abs->add(Glue,Fracgl);
157 m_storedManager->addMaterial("LAr",Thick_abs);
158#ifdef DEBUGGEO
159 ATH_MSG_INFO("ThickAbs radiation length " << Thick_abs->getRadLength());
160#endif
161
162 // electrode =mixture Kapton+Cu
163 Thcu=dB.getDouble("BarrelGeometry","BarrelGeometry-00","THCU")*Gaudi::Units::cm; // LArEMBThickElecCopper
164 Thfg=dB.getDouble("BarrelGeometry","BarrelGeometry-00","THFG")*Gaudi::Units::cm; // LArEMBThickElecKapton
165 Totalthicke = Thcu+Thfg;
166 Totalmasse = (Thcu*Copper->getDensity()+Thfg*Kapton->getDensity());
167 //**GU below are the fractions per mass
168 FracCu = (Thcu*Copper->getDensity())/Totalmasse;
169 FracKap = (Thfg*Kapton->getDensity())/Totalmasse;
170 // density = Totalmasse/Totalthicke;
171
172 double contract_e=1./1.003625; // From Fares (J.T.)
173 density = (Totalmasse/Totalthicke)/(contract_e*contract_e*contract_e);
174
175 ATH_MSG_DEBUG("---- Electrode characteristics: ----");
176 ATH_MSG_DEBUG(" Fraction Cu, Kapton: " << FracCu << ","<< FracKap);
177 ATH_MSG_DEBUG(" Total mass, Thickness:"<<Totalmasse<<" ,"<<Totalthicke);
178 ATH_MSG_DEBUG(" Electrode Density = " << density*(Gaudi::Units::cm3/GeoModelKernelUnits::g));
179
180 GeoIntrusivePtr<GeoMaterial> Kapton_Cu = new GeoMaterial("LAr::KaptonC",density);
181 Kapton_Cu->add(Copper,FracCu);
182 Kapton_Cu->add(Kapton,FracKap);
183 m_storedManager->addMaterial("LAr",Kapton_Cu);
184#ifdef DEBUGGEO
185 ATH_MSG_INFO("Electrode radiation length " << Kapton_Cu->getRadLength());
186#endif
187
188 // material for Cables/electronics (mixture of Kapton and copper)
189 // density = 2.440*Gaudi::Units::g/Gaudi::Units::cm3;
190 //**GU get fractions per mass
191 double frmassCu = dB.getDouble("BarrelAccordionCables","BarrelAccordionCables-00","PERCU"); // LArEMBmasspercentCu
192 double frmassKap= dB.getDouble("BarrelAccordionCables","BarrelAccordionCables-00","PERKAP"); // LArEMBmasspercentKap
193//GU 28 July 2005 recompute correctly density
194 const double frmassKapOverCu = frmassKap / frmassCu;
195 density = Copper->getDensity()*(1.+frmassKapOverCu)
196 /(1.+frmassKapOverCu*Copper->getDensity()/Kapton->getDensity());
197 GeoIntrusivePtr<GeoMaterial> Cable_elect = new GeoMaterial("LAr::Cables",density);
198 double fractionmass;
199 Cable_elect->add(Copper, fractionmass=frmassCu*Gaudi::Units::perCent);
200 Cable_elect->add(Kapton, fractionmass=frmassKap*Gaudi::Units::perCent);
201 m_storedManager->addMaterial("LAr", Cable_elect);
202#ifdef DEBUGGEO
203 ATH_MSG_INFO("Cable radiation length " << Cable_elect->getRadLength());
204#endif
205
206 // material for motherboard
207 // Mother_board is defined as a mixture of epox_G10 (C8 H14 O4) and Copper
208 ThMBcu = dB.getDouble("BarrelMotherboards","BarrelMotherboards-00","THICU")*Gaudi::Units::cm; // LArEMBCuThickness
209 ThMBG10 = dB.getDouble("BarrelMotherboards","BarrelMotherboards-00","THIG10")*Gaudi::Units::cm; // LArEMBG10Thickness
210 double TotalthickMBe = ThMBcu+ThMBG10;
211 double TotalmassMBe = (ThMBcu*Copper->getDensity()+ThMBG10*G10->getDensity());
212 double FracMBCu = (ThMBcu*Copper->getDensity())/TotalmassMBe;
213 double FracMBG10 = (ThMBG10*G10->getDensity())/TotalmassMBe;
214 density = TotalmassMBe/TotalthickMBe;
215 ATH_MSG_DEBUG("---- Mother Board characteristics: ----");
216 ATH_MSG_DEBUG(" Fraction Cu, G10: " << FracMBCu << ","
217 << FracMBG10);
218 ATH_MSG_DEBUG(" Total mass, Thickness:"
219 << TotalmassMBe <<" ," <<TotalthickMBe);
220 ATH_MSG_DEBUG(" M_board Density = "<<density*(Gaudi::Units::cm3/GeoModelKernelUnits::g));
221 GeoIntrusivePtr<GeoMaterial> Moth_elect = new GeoMaterial("LAr::MBoards",density);
222 // ****GU: use fraction per masses of G10 and Cu
223 Moth_elect->add(G10,FracMBG10);
224 Moth_elect->add(Copper,FracMBCu);
225 m_storedManager->addMaterial("LAr", Moth_elect);
226#ifdef DEBUGGEO
227 ATH_MSG_INFO("MotherBoard radiation length " << Moth_elect->getRadLength());
228#endif
229
230//==GU 28 July 2005
231// implement latest definitions from hard coded geometry
232 const GeoElement* Si = m_storedManager->getElement("Silicon");
233 const GeoElement *O = m_storedManager->getElement("Oxygen");
234
235 density = dB.getDouble("BarrelMotherboards", "BarrelMotherboards-00", "DG10")*(GeoModelKernelUnits::g/Gaudi::Units::cm3); //LArEMBEpoxyVolumicMass
236 GeoIntrusivePtr<GeoMaterial> SiO2{new GeoMaterial("LAr::SiO2",density)};
237 double fractionSi=28.09/(28.09+2*16.0);
238 SiO2->add(Si,fractionSi);
239 double fractionO=2.*16.0/(28.09+2.*16.0);
240 SiO2->add(O,fractionO);
241 SiO2->lock();
242// Gten for the bars of the calorimeter= mixture of regular G10 and SiO2
243 density=1.72*GeoModelKernelUnits::g/Gaudi::Units::cm3; // should be replaced by number from database
244 GeoIntrusivePtr<GeoMaterial> Gten_bar = new GeoMaterial("LAr::G10_bar",density);
245 Gten_bar->add(G10,0.38); // should be replaced by number from database
246 Gten_bar->add(SiO2,0.62); // should be replaced by number from database
247 m_storedManager->addMaterial("LAr",Gten_bar);
248#ifdef DEBUGGEO
249 ATH_MSG_INFO("fracionSi,fracionO2 " << fractionSi << " " << fractionO);
250 ATH_MSG_INFO("SiO2 density " << SiO2->getDensity()/(GeoModelKernelUnits::g/Gaudi::Units::cm3));
251 ATH_MSG_INFO("SiO2 radiation length " << SiO2->getRadLength());
252 ATH_MSG_INFO("G10bar radiation length " << Gten_bar->getRadLength());
253#endif
254
255// material for the effective M_PIn+summing board effect
256 double ThSBCu = 0.28*Gaudi::Units::mm; // should be replaced by number from database
257 double ThSBAr = 9.72*Gaudi::Units::mm; // should be replaced by number from database
258 double TotalThickSB = ThSBCu+ThSBAr;
259 double dcu = Copper->getDensity();
260 double dar = LAr->getDensity();
261 const double TotalMassSB = ThSBCu*dcu + ThSBAr*dar;
262 const double inv_TotalMassSB = 1. /TotalMassSB;
263 double fracSBCu = ThSBCu*dcu*inv_TotalMassSB;
264 double fracSBAr = ThSBAr*dar*inv_TotalMassSB;
265 density = TotalMassSB/TotalThickSB;
266 GeoIntrusivePtr<GeoMaterial> Summing_board = new GeoMaterial("LAr::SBoard",density);
267 Summing_board->add(LAr,fracSBAr);
268 Summing_board->add(Copper,fracSBCu);
269 m_storedManager->addMaterial("LAr",Summing_board);
270#ifdef DEBUGGEO
271 ATH_MSG_INFO("SBoard radiation length " << Summing_board->getRadLength());
272#endif
273
274//==end GU
275
276 }
277
278 //----------------------------------------------------------------------------------------//
279 // LAR Endcap only //
280 //----------------------------------------------------------------------------------------//
281 {
282
283 // ----------------------
284 // Vacuum for TB cryostat
285 // ----------------------
286
287 const GeoElement *H = m_storedManager->getElement( "Hydrogen" );
288
289 GeoIntrusivePtr<GeoMaterial> Vacuum = new GeoMaterial( "LAr::Vacuum", Gaudi::Units::universe_mean_density );
290 Vacuum->add( H, 1. );
291 m_storedManager->addMaterial("LAr", Vacuum );
292#ifdef DEBUGGEO
293 ATH_MSG_INFO("Vacuum radiation length " << Vacuum->getRadLength() << " "
294 << Vacuum->getDensity()/(GeoModelKernelUnits::g/Gaudi::Units::cm3));
295#endif
296
297
298 // ----------------------------
299 // Materials for EMEC absorbers
300 // ----------------------------
301
302 double Tggl, Tgfe, Tgpb, Thgl, Thfe, Thpb;
303 double Totalthick,Totalmass,Fracpb,Fracfe,Fracgl;
304
305 // contraction from warm to cold
306 double contract=dB.getDouble("ColdContraction","ColdContraction-00", "ABSORBERCONTRACTION"); // LArEMBAbsorberContraction
307
308 //
309 // EMEC thin absorbers
310 //
311
312/* Tggl = 0.30 * Gaudi::Units::mm;
313 Tgfe = 0.40 * Gaudi::Units::mm;
314 Tgpb = 1.70 * Gaudi::Units::mm; */
315
316 Tggl = 0.20 * Gaudi::Units::mm;
317 Tgfe = 0.40 * Gaudi::Units::mm;
318 Tgpb = 1.69 * Gaudi::Units::mm;
319
320 Totalthick = Tggl+Tgfe+Tgpb;
321 Totalmass = (Tgpb*Lead->getDensity()+Tgfe*Iron->getDensity()+Tggl*Glue->getDensity());
322 // Fractions per mass
323 Fracpb = (Tgpb*Lead->getDensity())/Totalmass;
324 Fracfe = (Tgfe*Iron->getDensity())/Totalmass;
325 Fracgl = (Tggl*Glue->getDensity())/Totalmass;
326 double density = Totalmass/Totalthick/(contract*contract*contract);
327 ATH_MSG_DEBUG("---- EMEC THIN absorber characteristics: ----");
328 ATH_MSG_DEBUG(" Thickness pb,fe,gl,[mm]="<<Tgpb<<" "<<Tgfe<<" "<<Tggl);
329 ATH_MSG_DEBUG(" Fraction pb,fe,gl ="<<Fracpb<<","<<Fracfe<<"," <<Fracgl);
330 ATH_MSG_DEBUG(" Total mass, Thickness ="<<Totalmass<<" ," <<Totalthick);
331 ATH_MSG_DEBUG(" Thinabs Density ="<< density*(Gaudi::Units::cm3/GeoModelKernelUnits::g));
332
333 ATH_MSG_DEBUG("---- EMEC THIN absorber characteristics: ----");
334 ATH_MSG_DEBUG(" Thickness pb,fe,gl,[mm]="<<Tgpb<<" "<<Tgfe<<" "<<Tggl );
335 ATH_MSG_DEBUG(" Fraction pb,fe,gl ="<<Fracpb<<","<<Fracfe<<"," <<Fracgl );
336 ATH_MSG_DEBUG(" Total mass, Thickness ="<<Totalmass<<" ," <<Totalthick );
337 ATH_MSG_DEBUG(" Thinabs Density ="<< density*(Gaudi::Units::cm3/GeoModelKernelUnits::g));
338
339
340 GeoIntrusivePtr<GeoMaterial> Thin_abs = new GeoMaterial("LAr::EMEC_Thinabs",density);
341 Thin_abs->add(Lead,Fracpb);
342 Thin_abs->add(Iron,Fracfe);
343 Thin_abs->add(Glue,Fracgl);
344 m_storedManager->addMaterial("LAr", Thin_abs);
345
346#ifdef DEBUGGEO
347 ATH_MSG_INFO("EMEC thinAbs radiation length " << Thin_abs->getRadLength());
348#endif
349
350 //
351 // EMEC thick absorbers
352 //
353
354 Thgl = 0.20 * Gaudi::Units::mm;
355 Thfe = 0.40 * Gaudi::Units::mm;
356 Thpb = 2.20 * Gaudi::Units::mm;
357
358 Totalthick = Thgl+Thfe+Thpb;
359 Totalmass = (Thpb*Lead->getDensity()+Thfe*Iron->getDensity()+Thgl*Glue->getDensity());
360 // Fractions per mass
361 Fracpb = (Thpb*Lead->getDensity())/Totalmass;
362 Fracfe = (Thfe*Iron->getDensity())/Totalmass;
363 Fracgl = (Thgl*Glue->getDensity())/Totalmass;
364 density = Totalmass/Totalthick/(contract*contract*contract);
365
366 ATH_MSG_DEBUG("---- EMEC THICK absorber characteristics: ----");
367 ATH_MSG_DEBUG(" Thickness pb,fe,gl[mm]="<<Thpb<<" "<<Thfe<<" "<<Thgl);
368 ATH_MSG_DEBUG(" Fraction pb,fe,gl: "<<Fracpb<<","<<Fracfe<<","<<Fracgl);
369 ATH_MSG_DEBUG(" Total mass, Thickness: "<<Totalmass<<" ,"<<Totalthick);
370 ATH_MSG_DEBUG(" Thickabs Density = "<<density*(Gaudi::Units::cm3/GeoModelKernelUnits::g));
371
372 GeoIntrusivePtr<GeoMaterial> Thick_abs = new GeoMaterial("LAr::EMEC_Thickabs",density);
373 Thick_abs->add(Lead,Fracpb);
374 Thick_abs->add(Iron,Fracfe);
375 Thick_abs->add(Glue,Fracgl);
376 m_storedManager->addMaterial("LAr",Thick_abs);
377#ifdef DEBUGGEO
378 ATH_MSG_INFO("EMEC thickAbs radiation length " << Thick_abs->getRadLength());
379#endif
380
381 //
382 // EMEC shell = iron + glue, identical for inner and outer absorbers
383 //
384 Thgl = 0.20 * Gaudi::Units::mm;
385 Thfe = 0.40 * Gaudi::Units::mm;
386
387 Totalthick = Thgl+Thfe;
388 Totalmass = (Thfe*Iron->getDensity()+Thgl*Glue->getDensity());
389 // Fractions per mass
390 Fracfe = (Thfe*Iron->getDensity())/Totalmass;
391 Fracgl = (Thgl*Glue->getDensity())/Totalmass;
392 density = Totalmass/Totalthick/(contract*contract*contract);
393
394 ATH_MSG_DEBUG("---- EMEC absorber shell characteristics: ----");
395 ATH_MSG_DEBUG(" Thickness fe,gl[mm]="<<Thfe<<" "<<Thgl);
396 ATH_MSG_DEBUG(" Fraction fe,gl: "<<Fracfe<<","<<Fracgl);
397 ATH_MSG_DEBUG(" Total mass, Thickness: "<<Totalmass<<" ,"<<Totalthick);
398 ATH_MSG_DEBUG(" Thickabs Density = "<<density*(Gaudi::Units::cm3/GeoModelKernelUnits::g));
399
400 GeoIntrusivePtr<GeoMaterial> EMEC_shell = new GeoMaterial("LAr::EMEC_shell",density);
401 EMEC_shell->add(Iron,Fracfe);
402 EMEC_shell->add(Glue,Fracgl);
403 m_storedManager->addMaterial("LAr",EMEC_shell);
404
405
406 // ----------------------------
407 // Materials for EMEC barrettes
408 // ----------------------------
409
410 double TgG10, ThG10;
411 double FracG10;
412
413 //
414 // EMEC Outer Wheel barrette
415 //
416
418 Tggl = 0.20 * Gaudi::Units::mm;
419 Tgfe = 0.40 * Gaudi::Units::mm;
420 TgG10 =1.69 * Gaudi::Units::mm;
421
422 Totalthick = Tggl+Tgfe+TgG10;
423 Totalmass = (TgG10*G10->getDensity()+Tgfe*Iron->getDensity()+Tggl*Glue->getDensity());
424 // Fractions per mass
425 FracG10 = (TgG10*G10->getDensity())/Totalmass;
426 Fracfe = (Tgfe*Iron->getDensity())/Totalmass;
427 Fracgl = (Tggl*Glue->getDensity())/Totalmass;
428 density = (Totalmass/Totalthick)/(contract*contract*contract);
429
430 GeoIntrusivePtr<GeoMaterial> G10FeOuter = new GeoMaterial("LAr::G10FeOuter",density);
431 G10FeOuter->add(G10,FracG10);
432 G10FeOuter->add(Iron,Fracfe);
433 G10FeOuter->add(Glue,Fracgl);
434 m_storedManager->addMaterial("LAr", G10FeOuter);
435
436#ifdef DEBUGGEO
437 ATH_MSG_INFO("EMEC G10FeOuter radiation length " << G10FeOuter->getRadLength());
438#endif
439
440 //
441 // EMEC Inner Wheel barrette
442 //
443
444 Thgl = 0.20 * Gaudi::Units::mm;
445 Thfe = 0.40 * Gaudi::Units::mm;
446 ThG10 =2.20 * Gaudi::Units::mm;
447
448 Totalthick = Thgl+Thfe+ThG10;
449 Totalmass = (ThG10*G10->getDensity()+Thfe*Iron->getDensity()+Thgl*Glue->getDensity());
450 // Fractions per mass
451 FracG10 = (ThG10*G10->getDensity())/Totalmass;
452 Fracfe = (Thfe*Iron->getDensity())/Totalmass;
453 Fracgl = (Thgl*Glue->getDensity())/Totalmass;
454 density = (Totalmass/Totalthick)/(contract*contract*contract);
455
456 GeoIntrusivePtr<GeoMaterial> G10FeInner = new GeoMaterial("LAr::G10FeInner",density);
457 G10FeInner->add(G10,FracG10);
458 G10FeInner->add(Iron,Fracfe);
459 G10FeInner->add(Glue,Fracgl);
460 m_storedManager->addMaterial("LAr",G10FeInner);
461#ifdef DEBUGGEO
462 ATH_MSG_INFO("EMEC G10FeInner radiation length " << G10FeInner->getRadLength());
463#endif
464
465 }
466
467 // Materials for Barrel and Endcap Signal Feedthroughs
468 {
469 GeoIntrusivePtr<const GeoMaterial> myIron = m_storedManager->getMaterial("std::Iron");
470 GeoIntrusivePtr<const GeoMaterial> myCopper = m_storedManager->getMaterial("std::Copper");
471 GeoIntrusivePtr<const GeoMaterial> myKapton = m_storedManager->getMaterial("std::Kapton");
472 GeoIntrusivePtr<const GeoMaterial> myAlu = m_storedManager->getMaterial("std::Aluminium");
473 GeoIntrusivePtr<const GeoMaterial> myLAr = m_storedManager->getMaterial("std::LiquidArgon");
474 const GeoElement* O = m_storedManager->getElement("Oxygen");
475 const GeoElement* Na = m_storedManager->getElement("Potassium");
476 const GeoElement* Si = m_storedManager->getElement("Silicon");
477 const GeoElement* Ca = m_storedManager->getElement("Calcium");
478
479 GeoIntrusivePtr<GeoMaterial> myGlass = new GeoMaterial("LAr::PinCarrierGlas",2.40*Gaudi::Units::g/Gaudi::Units::cm3);
480 myGlass->add(O ,0.459800);
481 myGlass->add(Na,0.096441);
482 myGlass->add(Si,0.336553);
483 myGlass->add(Ca,0.107205);
484 myGlass->lock();
485 m_storedManager->addMaterial("LAr",myGlass);
486
487 // Average material for Warm Flange
488 /* contains
489 * bolt ring 1.88 kg Al
490 * seal ring 5.84 kg Fe
491 * heater 1.00 kg Al
492 * plate 8.67 kg - 2*(0.478+0.540) kg = 6.634 kg Fe
493 * pin carr. 2.036 kg mixture Fe+ glass (36g) + Cu (170g)
494 *
495 * hardcoded volume = 37*170^2*pi = 3766141 mm^3
496 */
497 const double wflange_total = 1.88 + 5.84 + 1.0 + 6.634 + 2.036;
498 GeoIntrusivePtr<GeoMaterial> warm_flange = new GeoMaterial("LAr::FT::WarmFlange",
499 wflange_total*Gaudi::Units::kg / (3766141.*Gaudi::Units::mm3)
500 );
501 warm_flange->add(myAlu, 2.88 / wflange_total);
502 warm_flange->add(myIron, (5.84 + 6.634 + 1.83) / wflange_total);
503 warm_flange->add(myCopper, 0.17 / wflange_total);
504 warm_flange->add(myGlass, 0.036 / wflange_total);
505 warm_flange->lock();
506 m_storedManager->addMaterial("LAr", warm_flange);
507
508 // Average material for Cold Flange
509 /* contains
510 * plate 11.21 kg - 2*(0.478+0.540) kg = 9.174 kg Fe
511 * pin carr. 2.036 kg mixture Fe+ glass (36g) + Cu (170g)
512 *
513 * hardcoded volume = 35*141.5^2*pi = 2201561 mm^3
514 */
515 {
516 const double m = 11.21;
517 const double mGlass = 0.036;
518 const double mCopper = 0.170;
519 const double mFe = m - mGlass - mCopper;
520 GeoIntrusivePtr<GeoMaterial> cold_flange = new GeoMaterial("LAr::FT::ColdFlange",
521 m*Gaudi::Units::kg / (2201561.*Gaudi::Units::mm3)
522 );
523 cold_flange->add(myIron, mFe / m);
524 cold_flange->add(myCopper, mCopper / m);
525 cold_flange->add(myGlass, mGlass / m);
526 cold_flange->lock();
527 m_storedManager->addMaterial("LAr", cold_flange);
528 }
529
530 /* bellow is iron + vacuum
531 as geometry described in DMConstruction,
532 bellow also includes cuff ring and some part of seal ring
533 0.511 kg bellow
534 0.840 kg cuff ring
535 0 seal ring (sum whole ring to warm flange)
536 hardcoded volume is 225*pi*(229^2 - (229 - 15)^2)/4 = 1253790 mm^3
537 */
538 GeoIntrusivePtr<GeoMaterial> bellow_mat = new GeoMaterial("LAr::FT::Bellow",
539 1.351*Gaudi::Units::kg / (1253790.*Gaudi::Units::mm3)
540 );
541 bellow_mat->add(myIron, 1.);
542 bellow_mat->lock();
543 m_storedManager->addMaterial("LAr", bellow_mat);
544
545 /* vacuum cables are kapton+copper placed in vacuum,
546 insulation is ignored yet (btw different for barrel and EC)
547 3.928 kg Cu (0.5657)
548 3.015 kg Polymide (0.4343)
549 ------------------
550 6.943 kg total
551 hardcoded volume is 225*pi*(229 - 15)^2/4 = 8092821 mm^3
552
553 */
554 GeoIntrusivePtr<GeoMaterial> vacuum_cables_mat = new GeoMaterial("LAr::FT::VacuumCables",
555 6.943*Gaudi::Units::kg / (8092821.*Gaudi::Units::mm3)
556 );
557 vacuum_cables_mat->add(myCopper, 0.5657);
558 vacuum_cables_mat->add(myKapton, 0.4343);
559 vacuum_cables_mat->lock();
560 m_storedManager->addMaterial("LAr", vacuum_cables_mat);
561
562 /* cables
563 * 0.215 cm^3 per 1m copper
564 * 0.735 cm^3 per 1m kapton
565 * 2.90 g per 1m = 100*pi*(0.11/2)^2 = 0.95 cm^3
566 */
567 const double vCopper = 0.215;
568 const double vKapton = 0.735;
569 const double mCopper = vCopper*8.96;
570 const double mKapton = vKapton*1.3;
571 const double m = mCopper + mKapton;
572 GeoIntrusivePtr<GeoMaterial> cable_mat = new GeoMaterial("LAr::FT::Cable",
573 m*Gaudi::Units::g / ((vCopper + vKapton)*Gaudi::Units::cm3)
574 );
575 cable_mat->add(myCopper, mCopper / m);
576 cable_mat->add(myKapton, mKapton / m);
577 cable_mat->lock();
578 m_storedManager->addMaterial("LAr", cable_mat);
579
580 /* pigtail cables are cables + LAr
581 *
582 */
583 const double v = M_PI*(13.3/2)*(13.3/2);
584 const double vc = M_PI*(.11/2)*(.11/2)*1920;
585 const double va = v - vc;
586 const double mc = vc * 2.9/0.95;
587 const double ma = va * 1.392;
588 GeoIntrusivePtr<GeoMaterial> pigtail_mat = new GeoMaterial("LAr::FT::Pigtail",
589 (mc + ma)*Gaudi::Units::g / (v*Gaudi::Units::cm3)
590 );
591 ATH_MSG_DEBUG(pigtail_mat->getName() << " "
592 << pigtail_mat->getDensity() / (Gaudi::Units::g/Gaudi::Units::cm3));
593 pigtail_mat->add(cable_mat, mc / (mc + ma));
594 pigtail_mat->add(myLAr, ma / (mc + ma));
595 pigtail_mat->lock();
596 m_storedManager->addMaterial("LAr", pigtail_mat);
597 }
598}
M_PI
#define M_PI
Definition ActiveFraction.h:11
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
H
#define H(x, y, z)
Definition MD5.cxx:114
DatabaseAccessTool::getDouble
double getDouble(const std::string &TableName, const std::string &FallbackVersion, const std::string &ColumnName) const
Definition DatabaseAccessTool.cxx:55
PowhegPythia8EvtGen_H2a4X_ctauY.ma
int ma
Definition PowhegPythia8EvtGen_H2a4X_ctauY.py:26

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40{
41 m_imsg = Athena::getMessageSvc();
42 // If user did not set an explicit level, set a default
43 if (m_lvl == MSG::NIL) {
44 m_lvl = m_imsg ?
45 static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
46 MSG::INFO;
47 }
48}
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition AthMessaging.h:129
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition AthMessaging.h:135
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition AthMessaging.h:138
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition getMessageSvc.cxx:20

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const
inlineinherited

The standard message stream.

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

Definition at line 163 of file AthMessaging.h.

164{
165 MsgStream* ms = m_msg_tls.get();
166 if (!ms) {
167 if (!m_initialized.test_and_set()) initMessaging();
168 ms = new MsgStream(m_imsg,m_nm);
169 m_msg_tls.reset( ms );
170 }
171
172 ms->setLevel (m_lvl);
173 return *ms;
174}
AthMessaging::m_msg_tls
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels)
Definition AthMessaging.h:132
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition AthMessaging.cxx:39

◆ msg() [2/2]

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

The standard message stream.

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

Definition at line 178 of file AthMessaging.h.

179{ return msg() << lvl; }
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition AthMessaging.h:163

◆ msgLvl()

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

Test the output level.

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

Definition at line 151 of file AthMessaging.h.

152{
153 if (m_lvl <= lvl) {
154 msg() << lvl;
155 return true;
156 } else {
157 return false;
158 }
159}

◆ setLevel()

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

Change the current logging level.

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

Definition at line 28 of file AthMessaging.cxx.

29{
30 m_lvl = lvl;
31}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

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

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_imsg

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

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_lvl

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

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

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

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

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_storedManager

StoredMaterialManager* LArMaterialManager::m_storedManager {nullptr}
private

Definition at line 50 of file LArMaterialManager.h.

50{nullptr};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0