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

This class implements the CaloDetDescr/ICaloRecoMaterialTool and provides the average materials needed for the LAr part of the Calorimeter/CaloTrackingGeometry volumes. More...

#include <LArRecoMaterialTool.h>

Inheritance diagram for LArRecoMaterialTool:
Collaboration diagram for LArRecoMaterialTool:

Public Member Functions

 LArRecoMaterialTool (const std::string &type, const std::string &name, const IInterface *parent)
 ~LArRecoMaterialTool ()=default
virtual StatusCode initialize () override
virtual bool get_material (CaloSubdetNames::ALIGNVOL alvol, double &mass, double &volume, double &x0, double &dEdx, double &aveA, double &aveZ) const override
virtual void get_default_material (double &density, double &x0, double &dEdx, double &aveA, double &aveZ) const override
 default material used to fill the envelope
void print () const override

Private Member Functions

void ScanTree ()
 Private method called at initialisation : fills all arrays by calling the "optimised" methods.
bool ScanCRYO (CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
 Private optimised methods for each subsystem.
bool ScanPS (CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
bool ScanEMB (CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
bool ScanEMEC (CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
bool ScanHEC (CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
bool ScanFCAL (CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
void blendGeoVolume (GeoPVConstLink &geoVolLink, std::vector< double > &volume, std::vector< double > &mass, std::vector< double > &x0, std::vector< double > &dEdX, std::vector< double > &aveA, std::vector< double > &aveZ) const
 Private method to blend GeoLogVolume.
void addMaterialFraction (const GeoLogVol &geoVol, std::vector< double > &volume, std::vector< double > &mass, std::vector< double > &x0, std::vector< double > &dEdX, std::vector< double > &aveA, std::vector< double > &aveZ) const
 Private method to add material.
void averageFraction (std::vector< double > &volumeFractions, std::vector< double > &massFractions, std::vector< double > &x0Fractions, std::vector< double > &dEdXFractions, std::vector< double > &aveAFractions, std::vector< double > &aveZFractions, double &mass, double &volume, double &x0, double &dEdx, double &aveA, double &aveZ, double &rho)
 Private method to average results stored in private arrays.
std::string map_av (CaloSubdetNames::ALIGNVOL alvol)

Private Attributes

bool m_parseGeoModelForMaterial = false
 Private bool set at initialisation : decides if the GeoModel is parsed or bypassed.
const CaloCell_ID * m_calo_id {nullptr}
const CaloDM_ID * m_dm_id {nullptr}
std::vector< CaloSubdetNames::ALIGNVOL > m_alignvol_number
std::vector< double > m_alignvol_mass
std::vector< double > m_alignvol_x0
std::vector< double > m_alignvol_dEdX
std::vector< double > m_alignvol_aveA
std::vector< double > m_alignvol_aveZ
std::vector< double > m_massFractions
std::vector< double > m_volumeFractions
std::vector< double > m_x0Fractions
std::vector< double > m_dEdXFractions
std::vector< double > m_averageAFractions
std::vector< double > m_averageZFractions
std::vector< double > m_child_massFractions
std::vector< double > m_child_volumeFractions
std::vector< double > m_child_x0Fractions
std::vector< double > m_child_dEdXFractions
std::vector< double > m_child_averageAFractions
std::vector< double > m_child_averageZFractions
std::vector< double > m_child_Rho
std::vector< double > m_child_Volume
std::vector< double > m_child_Mass

Detailed Description

This class implements the CaloDetDescr/ICaloRecoMaterialTool and provides the average materials needed for the LAr part of the Calorimeter/CaloTrackingGeometry volumes.

For this, it uses the PVLinks provided by the LArSubdetPosHelper.

Note that it means that eta/phi dependencies of the material within a given GeoModel volume is not supported : although an interface using the CaloDM identifiers is foreseen, numbers will be averaged.

Interface and implementation are preliminary !!!!

Definition at line 38 of file LArRecoMaterialTool.h.

Constructor & Destructor Documentation

◆ LArRecoMaterialTool()

LArRecoMaterialTool::LArRecoMaterialTool ( const std::string & type,
const std::string & name,
const IInterface * parent )

Definition at line 29 of file LArRecoMaterialTool.cxx.

32 : base_class(type, name, parent)
33{
34}

◆ ~LArRecoMaterialTool()

LArRecoMaterialTool::~LArRecoMaterialTool ( )
default

Member Function Documentation

◆ addMaterialFraction()

void LArRecoMaterialTool::addMaterialFraction ( const GeoLogVol & geoVol,
std::vector< double > & volume,
std::vector< double > & mass,
std::vector< double > & x0,
std::vector< double > & dEdX,
std::vector< double > & aveA,
std::vector< double > & aveZ ) const
private

Private method to add material.

Definition at line 1051 of file LArRecoMaterialTool.cxx.

1058{
1059 const GeoShape* childShape = geoVol.getShape();
1060 const GeoMaterial* childMaterial = geoVol.getMaterial();
1061
1062 double childVolume = childShape->volume();
1063
1064 double childNumberOfElements = childMaterial->getNumElements();
1065 double childX0 = childMaterial->getRadLength ();
1066 double childDeDx = childMaterial->getDeDxMin();
1067 double childRho = childMaterial->getDensity();
1068
1069 ATH_MSG_DEBUG ("addMaterialFraction : " << geoVol.getName()
1070 << " has volume=" << childVolume << " mm**3 and "
1071 << childNumberOfElements << " elements ");
1072
1073 for (unsigned int iEl=0; iEl<childNumberOfElements; iEl++){
1074 const GeoElement* geoEl = childMaterial->getElement(iEl);
1075 double fraction = childMaterial->getFraction(iEl);
1076
1077 ATH_MSG_DEBUG (" direct child : " << geoEl->getName() << " fraction = " << fraction
1078 << " A= " << geoEl->getA()*(1./GeoModelKernelUnits::gram) << " Z= " << geoEl->getZ());
1079
1080 volume.push_back(fraction*childVolume);
1081 mass.push_back(fraction*childVolume*childRho);
1082 x0.push_back(fraction*childX0);
1083 dEdX.push_back(fraction*childDeDx);
1084 aveA.push_back(fraction*(geoEl->getA()*(1./GeoModelKernelUnits::gram)));
1085 aveZ.push_back(fraction*(geoEl->getZ()));
1086 }
1087
1088}
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
Base_Fragment.mass
mass
Definition Sherpa_i/share/common/Base_Fragment.py:59

◆ averageFraction()

void LArRecoMaterialTool::averageFraction ( std::vector< double > & volumeFractions,
std::vector< double > & massFractions,
std::vector< double > & x0Fractions,
std::vector< double > & dEdXFractions,
std::vector< double > & aveAFractions,
std::vector< double > & aveZFractions,
double & mass,
double & volume,
double & x0,
double & dEdx,
double & aveA,
double & aveZ,
double & rho )
private

Private method to average results stored in private arrays.

Definition at line 1091 of file LArRecoMaterialTool.cxx.

1100{
1101 unsigned int parsedVolumes = massFractions.size();
1102 ATH_MSG_DEBUG (" averageFraction : will average over... "
1103 << parsedVolumes << " elements ");
1104
1105 childMass = 0.;
1106 childVolume = 0.;
1107 childX0 = 0.;
1108 childDeDx = 0.;
1109 childAverageA = 0.;
1110 childAverageZ = 0.;
1111 childRho = 0.;
1112
1113 for (unsigned int ivols = 0; ivols < parsedVolumes; ++ivols) {
1114 childMass += massFractions[ivols];
1115 childVolume += volumeFractions[ivols];
1116 }
1117
1118 for (unsigned int ivolfrac = 0; ivolfrac < parsedVolumes; ++ivolfrac){
1119 double volfrac = volumeFractions[ivolfrac]/childVolume;
1120 childX0 += volfrac * x0Fractions[ivolfrac];
1121 childDeDx += volfrac * dEdXFractions[ivolfrac];
1122 double massfrac = massFractions[ivolfrac]/childMass;
1123 childAverageA += massfrac * averageAFractions[ivolfrac];
1124 childAverageZ += massfrac * averageZFractions[ivolfrac];
1125 }
1126
1127 if (childVolume != 0) {
1128 childRho = childMass/(GeoModelKernelUnits::gram*childVolume);
1129 }
1130
1131 ATH_MSG_DEBUG ("");
1132 ATH_MSG_DEBUG (" + averaged over " << parsedVolumes << " volumes ");
1133 ATH_MSG_DEBUG (" - volume [mm^3] : " << childVolume);
1134 ATH_MSG_DEBUG (" - mass [gram] : " << childMass*(1./GeoModelKernelUnits::gram));
1135 ATH_MSG_DEBUG (" - rho [gram/mm^3] : " << childRho);
1136 ATH_MSG_DEBUG (" - X0 : " << childX0);
1137 ATH_MSG_DEBUG (" - DeDx : " << childDeDx);
1138 ATH_MSG_DEBUG (" - AverageA : " << childAverageA);
1139 ATH_MSG_DEBUG (" - AverageZ : " << childAverageZ);
1140 ATH_MSG_DEBUG ("");
1141
1142}

◆ blendGeoVolume()

void LArRecoMaterialTool::blendGeoVolume ( GeoPVConstLink & geoVolLink,
std::vector< double > & volume,
std::vector< double > & mass,
std::vector< double > & x0,
std::vector< double > & dEdX,
std::vector< double > & aveA,
std::vector< double > & aveZ ) const
private

Private method to blend GeoLogVolume.

Definition at line 1030 of file LArRecoMaterialTool.cxx.

1037{
1038
1039 const GeoLogVol* currentVol = geoVolLink->getLogVol();
1040 if (currentVol){
1041 this->addMaterialFraction(*currentVol, volume, mass, x0, dEdX, aveA, aveZ);
1042 unsigned int currentVolChilds = geoVolLink->getNChildVols();
1043 for (unsigned int ichild = 0; ichild < currentVolChilds; ichild++){
1044 GeoPVConstLink childVolumeLink = geoVolLink->getChildVol(ichild);
1045 this->blendGeoVolume(childVolumeLink, volume, mass, x0, dEdX, aveA, aveZ);
1046 }
1047 }
1048}
LArRecoMaterialTool::addMaterialFraction
void addMaterialFraction(const GeoLogVol &geoVol, std::vector< double > &volume, std::vector< double > &mass, std::vector< double > &x0, std::vector< double > &dEdX, std::vector< double > &aveA, std::vector< double > &aveZ) const
Private method to add material.
Definition LArRecoMaterialTool.cxx:1051
LArRecoMaterialTool::blendGeoVolume
void blendGeoVolume(GeoPVConstLink &geoVolLink, std::vector< double > &volume, std::vector< double > &mass, std::vector< double > &x0, std::vector< double > &dEdX, std::vector< double > &aveA, std::vector< double > &aveZ) const
Private method to blend GeoLogVolume.
Definition LArRecoMaterialTool.cxx:1030

◆ get_default_material()

void LArRecoMaterialTool::get_default_material ( double & density,
double & x0,
double & dEdx,
double & aveA,
double & aveZ ) const
overridevirtual

default material used to fill the envelope

Definition at line 95 of file LArRecoMaterialTool.cxx.

99{
100 // FIXME ! should take real LAr numbers
101 density = 1.;
102 x0 = 5.;
103 dEdx = 1.1e-24;
104 aveA = 39.948;
105 aveZ = 18.;
106
107}

◆ get_material()

bool LArRecoMaterialTool::get_material ( CaloSubdetNames::ALIGNVOL alvol,
double & mass,
double & volume,
double & x0,
double & dEdx,
double & aveA,
double & aveZ ) const
overridevirtual

Definition at line 69 of file LArRecoMaterialTool.cxx.

74{
75 bool result = false;
76
77 for ( unsigned int i = 0; i < m_alignvol_number.size(); i++ )
78 {
79 if ( m_alignvol_number[i] == alvol ) {
80 mass = m_alignvol_mass[i];
81 x0 = m_alignvol_x0[i];
82 dEdx = m_alignvol_dEdX[i];
83 aveA = m_alignvol_aveA[i];
84 aveZ = m_alignvol_aveZ[i];
85 // FIXME
86 volume = 1000.;
87 result = true;
88 }
89 }
90
91 return result;
92}
LArRecoMaterialTool::m_alignvol_x0
std::vector< double > m_alignvol_x0
Definition LArRecoMaterialTool.h:141
LArRecoMaterialTool::m_alignvol_aveA
std::vector< double > m_alignvol_aveA
Definition LArRecoMaterialTool.h:143
LArRecoMaterialTool::m_alignvol_dEdX
std::vector< double > m_alignvol_dEdX
Definition LArRecoMaterialTool.h:142
LArRecoMaterialTool::m_alignvol_number
std::vector< CaloSubdetNames::ALIGNVOL > m_alignvol_number
Definition LArRecoMaterialTool.h:139
LArRecoMaterialTool::m_alignvol_aveZ
std::vector< double > m_alignvol_aveZ
Definition LArRecoMaterialTool.h:144
LArRecoMaterialTool::m_alignvol_mass
std::vector< double > m_alignvol_mass
Definition LArRecoMaterialTool.h:140
get_generator_info.result
result
Definition get_generator_info.py:21

◆ initialize()

StatusCode LArRecoMaterialTool::initialize ( )
overridevirtual

Definition at line 37 of file LArRecoMaterialTool.cxx.

38{
39 ATH_CHECK( detStore()->retrieve (m_calo_id, "CaloCell_ID") );
40 ATH_CHECK( detStore()->retrieve (m_dm_id, "CaloDM_ID") );
41
42 // These vectors will contain the results :
43 m_alignvol_number.resize(0);
44 m_alignvol_mass.resize(0);
45 m_alignvol_x0.resize(0);
46 m_alignvol_dEdX.resize(0);
47 m_alignvol_aveA.resize(0);
48 m_alignvol_aveZ.resize(0);
49
50 // ---------- Fill arrays :
51
52 // going though the full tree is too slow to be used as default,
53 // if you want to do it set this flag to true :
54 // ( will become a property at some point ! )
55 m_parseGeoModelForMaterial = false;
56
57 this->ScanTree();
58 //this->print();
59
60
61 // ---------- That's it
62
63
64 ATH_MSG_INFO (" LArRecoMaterialTool successfully initialized ");
65 return StatusCode::SUCCESS;
66}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
LArRecoMaterialTool::m_calo_id
const CaloCell_ID * m_calo_id
Definition LArRecoMaterialTool.h:135
LArRecoMaterialTool::m_dm_id
const CaloDM_ID * m_dm_id
Definition LArRecoMaterialTool.h:136
LArRecoMaterialTool::ScanTree
void ScanTree()
Private method called at initialisation : fills all arrays by calling the "optimised" methods.
Definition LArRecoMaterialTool.cxx:125
LArRecoMaterialTool::m_parseGeoModelForMaterial
bool m_parseGeoModelForMaterial
Private bool set at initialisation : decides if the GeoModel is parsed or bypassed.
Definition LArRecoMaterialTool.h:70

◆ map_av()

std::string LArRecoMaterialTool::map_av ( CaloSubdetNames::ALIGNVOL alvol)
private

Definition at line 1145 of file LArRecoMaterialTool.cxx.

1146{
1147 switch(alvol)
1148 {
1149 case CaloSubdetNames::LARCRYO_B:
1150 return std::string("LARCRYO_B");
1151 case CaloSubdetNames::LARCRYO_EC_POS:
1152 return std::string("LARCRYO_EC_POS");
1153 case CaloSubdetNames::LARCRYO_EC_NEG:
1154 return std::string("LARCRYO_EC_NEG");
1155 case CaloSubdetNames::SOLENOID:
1156 return std::string("SOLENOID");
1157 case CaloSubdetNames::PRESAMPLER_B_POS:
1158 return std::string("PRESAMPLER_B_POS");
1159 case CaloSubdetNames::PRESAMPLER_B_NEG:
1160 return std::string("PRESAMPLER_B_NEG");
1161 case CaloSubdetNames::EMB_POS:
1162 return std::string("EMB_POS");
1163 case CaloSubdetNames::EMB_NEG:
1164 return std::string("EMB_NEG");
1165 case CaloSubdetNames::PRESAMPLER_EC_POS:
1166 return std::string("PRESAMPLER_EC_POS");
1167 case CaloSubdetNames::PRESAMPLER_EC_NEG:
1168 return std::string("PRESAMPLER_EC_NEG");
1169 case CaloSubdetNames::EMEC_POS:
1170 return std::string("EMEC_POS");
1171 case CaloSubdetNames::EMEC_NEG:
1172 return std::string("EMEC_NEG");
1173 case CaloSubdetNames::HEC1_POS:
1174 return std::string("HEC1_POS");
1175 case CaloSubdetNames::HEC1_NEG:
1176 return std::string("HEC1_NEG");
1177 case CaloSubdetNames::HEC2_POS:
1178 return std::string("HEC2_POS");
1179 case CaloSubdetNames::HEC2_NEG:
1180 return std::string("HEC2_NEG");
1181 case CaloSubdetNames::FCAL1_POS:
1182 return std::string("FCAL1_POS");
1183 case CaloSubdetNames::FCAL1_NEG:
1184 return std::string("FCAL1_NEG");
1185 case CaloSubdetNames::FCAL2_POS:
1186 return std::string("FCAL2_POS");
1187 case CaloSubdetNames::FCAL2_NEG:
1188 return std::string("FCAL2_NEG");
1189 case CaloSubdetNames::FCAL3_POS:
1190 return std::string("FCAL3_POS");
1191 case CaloSubdetNames::FCAL3_NEG:
1192 return std::string("FCAL3_NEG");
1193 default:
1194 return std::string("");
1195 }
1196}

◆ print()

void LArRecoMaterialTool::print ( ) const
override

Definition at line 110 of file LArRecoMaterialTool.cxx.

111{
112
113 for ( unsigned int i = 0; i < m_alignvol_number.size(); i++ )
114 {
115 ATH_MSG_INFO (" + Result for ALIGNVOL " << m_alignvol_number[i]);
116 ATH_MSG_INFO (" - mass [gram] " << m_alignvol_mass[i]);
117 ATH_MSG_INFO (" - X0 " << m_alignvol_x0[i]);
118 ATH_MSG_INFO (" - DeDx " << m_alignvol_dEdX[i]);
119 ATH_MSG_INFO (" - AverageA " << m_alignvol_aveA[i]);
120 ATH_MSG_INFO (" - AverageZ " << m_alignvol_aveZ[i]);
121 }
122}

◆ ScanCRYO()

bool LArRecoMaterialTool::ScanCRYO ( CaloSubdetNames::ALIGNVOL alvol,
double & mass,
double & x0,
double & dEdx,
double & aveA,
double & aveZ )
private

Private optimised methods for each subsystem.

Definition at line 173 of file LArRecoMaterialTool.cxx.

176{
177 mass = 0.;
178 x0 = 0.;
179 dEdx = 0.;
180 aveA = 0.;
181 aveZ = 0.;
182
183 if ( alvol != CaloSubdetNames::LARCRYO_B
184 && alvol != CaloSubdetNames::LARCRYO_EC_POS
185 && alvol != CaloSubdetNames::LARCRYO_EC_NEG
186 && alvol != CaloSubdetNames::SOLENOID ) {
187 ATH_MSG_INFO ("method ScanCryo does not support CaloSubdetNames::ALIGNVOL " << (int) alvol);
188 return false;
189 }
190
191 // For EC, link to GeoModel does not exist (yet) : take barrel numbers
192
193 // Shortcut :
194 if ( !m_parseGeoModelForMaterial )
195 {
196 //if ( alvol == CaloSubdetNames::LARCRYO_B || alvol == CaloSubdetNames::SOLENOID) {
197 mass = 3.61158e+07 ;
198 x0 = 89.411;
199 dEdx = 7.47033e-24 ;
200 aveA = 27.9728;
201 aveZ = 13.4253 ;
202#if 0
203 } else {
204 mass = 3.61158e+07 ;
205 x0 = 89.411;
206 dEdx = 7.47033e-24 ;
207 aveA = 27.9728;
208 aveZ = 13.4253 ;
209 }
210#endif
211 }
212#if 0
213 // Dead code as long as m_parseGeoModelForMaterial is false.
214 // Comment out to avoid coverity warnings.
215 else {
216
217 // Go for it :
218 m_child_massFractions.clear();
219 m_child_volumeFractions.clear();
220 m_child_x0Fractions.clear();
221 m_child_dEdXFractions.clear();
222 m_child_averageAFractions.clear();
223 m_child_averageZFractions.clear();
224 m_child_Rho.clear();
225 m_child_Volume.clear();
226 m_child_Mass.clear();
227
228 double childVolume = 0.;
229 double childMass = 0.;
230 double childX0 = 0.;
231 double childDeDx = 0.;
232 double childAverageA = 0.;
233 double childAverageZ = 0.;
234 double childRho = 0.;
235
236 const StoredPhysVol* storedPV = 0;
237 std::string key = map_av(alvol);
238 if(detStore()->contains<StoredPhysVol>(key))
239 {
240 if(detStore()->retrieve(storedPV,key)==StatusCode::FAILURE)
241 {
242 ATH_MSG_INFO ("Unable to retrieve Stored PV " << key);
243 }
244 }
245
246 if (!storedPV) {
247 ATH_MSG_INFO ("no Volume for " << key);
248 return false;
249 }
250
251 const GeoFullPhysVol* larTopVolLink = storedPV->getPhysVol();
252
253 // get the number of direct childs
254 unsigned int larChilds = larTopVolLink->getNChildVols();
255
256 for (unsigned int ichild = 0; ichild<larChilds; ++ichild){
257
258 bool stop = false;
259
260 // Skip some some of the children : list will get longer in future
261 if ( alvol == CaloSubdetNames::LARCRYO_B &&
262 larTopVolLink->getNameOfChildVol(ichild) == "Total LAR Volume") stop = true;
263 if ( alvol == CaloSubdetNames::SOLENOID &&
264 larTopVolLink->getNameOfChildVol(ichild) == "Total LAR Volume") stop = true;
265
266 if (!stop) {
267
268 ATH_MSG_DEBUG ("CaloSubdetNames::ALIGNVOL " << (int) alvol
269 <<" Direct Child " << ichild << " - with name : "
270 << larTopVolLink->getNameOfChildVol(ichild));
271
272 PVConstLink childVolLink = larTopVolLink->getChildVol(ichild);
273
274 m_massFractions.clear();
275 m_volumeFractions.clear();
276 m_x0Fractions.clear();
277 m_dEdXFractions.clear();
278 m_averageAFractions.clear();
279 m_averageZFractions.clear();
280
281 this->blendGeoVolume(childVolLink,
282 m_volumeFractions,
283 m_massFractions,
284 m_x0Fractions,
285 m_dEdXFractions,
286 m_averageAFractions,
287 m_averageZFractions);
288
289 this->averageFraction(m_volumeFractions,
290 m_massFractions,
291 m_x0Fractions,
292 m_dEdXFractions,
293 m_averageAFractions,
294 m_averageZFractions,
295 childMass, childVolume,
296 childX0, childDeDx,
297 childAverageA, childAverageZ, childRho );
298
299 m_child_x0Fractions.push_back( childX0 );
300 m_child_dEdXFractions.push_back( childDeDx );
301 m_child_averageAFractions.push_back( childAverageA );
302 m_child_averageZFractions.push_back( childAverageZ );
303 m_child_Rho.push_back( childRho );
304 m_child_Volume.push_back( childVolume );
305 m_child_Mass.push_back( childMass );
306
307 }
308 }
309
310 // Now do the final average and store it :
311
312 ATH_MSG_DEBUG ("Final average for CaloSubdetNames::ALIGNVOL " << (int) alvol
313 << " !!!!! ");
314
315 this->averageFraction(m_child_Volume, m_child_Mass,
316 m_child_x0Fractions,
317 m_child_dEdXFractions,
318 m_child_averageAFractions,
319 m_child_averageZFractions,
320 childMass, childVolume,
321 childX0, childDeDx,
322 childAverageA, childAverageZ, childRho );
323
324 mass = childMass/GeoModelKernelUnits::gram;
325 x0 = childX0;
326 dEdx = childDeDx;
327 aveA = childAverageA;
328 aveZ = childAverageZ;
329 }
330#endif
331
332 m_alignvol_number.push_back( alvol );
333 m_alignvol_mass.push_back( mass );
334 m_alignvol_x0.push_back( x0 );
335 m_alignvol_dEdX.push_back( dEdx );
336 m_alignvol_aveA.push_back( aveA );
337 m_alignvol_aveZ.push_back( aveZ );
338
339 return true;
340}
LArRecoMaterialTool::m_child_massFractions
std::vector< double > m_child_massFractions
Definition LArRecoMaterialTool.h:154
LArRecoMaterialTool::m_child_Volume
std::vector< double > m_child_Volume
Definition LArRecoMaterialTool.h:161
LArRecoMaterialTool::map_av
std::string map_av(CaloSubdetNames::ALIGNVOL alvol)
Definition LArRecoMaterialTool.cxx:1145
LArRecoMaterialTool::m_child_Rho
std::vector< double > m_child_Rho
Definition LArRecoMaterialTool.h:160
LArRecoMaterialTool::m_child_averageAFractions
std::vector< double > m_child_averageAFractions
Definition LArRecoMaterialTool.h:158
LArRecoMaterialTool::m_child_volumeFractions
std::vector< double > m_child_volumeFractions
Definition LArRecoMaterialTool.h:155
LArRecoMaterialTool::m_child_Mass
std::vector< double > m_child_Mass
Definition LArRecoMaterialTool.h:162
LArRecoMaterialTool::m_dEdXFractions
std::vector< double > m_dEdXFractions
Definition LArRecoMaterialTool.h:150
LArRecoMaterialTool::m_child_x0Fractions
std::vector< double > m_child_x0Fractions
Definition LArRecoMaterialTool.h:156
LArRecoMaterialTool::m_x0Fractions
std::vector< double > m_x0Fractions
Definition LArRecoMaterialTool.h:149
LArRecoMaterialTool::m_child_averageZFractions
std::vector< double > m_child_averageZFractions
Definition LArRecoMaterialTool.h:159
LArRecoMaterialTool::m_child_dEdXFractions
std::vector< double > m_child_dEdXFractions
Definition LArRecoMaterialTool.h:157
LArRecoMaterialTool::m_averageAFractions
std::vector< double > m_averageAFractions
Definition LArRecoMaterialTool.h:151
LArRecoMaterialTool::averageFraction
void averageFraction(std::vector< double > &volumeFractions, std::vector< double > &massFractions, std::vector< double > &x0Fractions, std::vector< double > &dEdXFractions, std::vector< double > &aveAFractions, std::vector< double > &aveZFractions, double &mass, double &volume, double &x0, double &dEdx, double &aveA, double &aveZ, double &rho)
Private method to average results stored in private arrays.
Definition LArRecoMaterialTool.cxx:1091
LArRecoMaterialTool::m_volumeFractions
std::vector< double > m_volumeFractions
Definition LArRecoMaterialTool.h:148
LArRecoMaterialTool::m_massFractions
std::vector< double > m_massFractions
Definition LArRecoMaterialTool.h:147
LArRecoMaterialTool::m_averageZFractions
std::vector< double > m_averageZFractions
Definition LArRecoMaterialTool.h:152
StoredPhysVol::getPhysVol
GeoFullPhysVol * getPhysVol()
Destructor.
Definition StoredPhysVol.cxx:20
contains
bool contains(const std::string &s, const std::string &regx)
does a string contain the substring
Definition hcg.cxx:114
python.PyKernel.retrieve
retrieve(aClass, aKey=None)
Definition PyKernel.py:110

◆ ScanEMB()

bool LArRecoMaterialTool::ScanEMB ( CaloSubdetNames::ALIGNVOL alvol,
double & mass,
double & x0,
double & dEdx,
double & aveA,
double & aveZ )
private

Definition at line 501 of file LArRecoMaterialTool.cxx.

504{
505 mass = 0.;
506 x0 = 0.;
507 dEdx = 0.;
508 aveA = 0.;
509 aveZ = 0.;
510
511 if ( alvol != CaloSubdetNames::EMB_POS &&
512 alvol != CaloSubdetNames::EMB_NEG ) {
513 ATH_MSG_INFO ("method ScanEMB does not support CaloSubdetNames::ALIGNVOL " << (int) alvol);
514 return false;
515 }
516
517 // Shortcut :
518 if (!m_parseGeoModelForMaterial)
519 {
520 mass = 9.40439e+07 ;
521 x0 = 93.9601;
522 dEdx = 6.0789e-24;
523 aveA = 98.5676;
524 aveZ = 39.7406;
525 }
526 else {
527
528 // Here we go :
529 m_child_massFractions.clear();
530 m_child_volumeFractions.clear();
531 m_child_x0Fractions.clear();
532 m_child_dEdXFractions.clear();
533 m_child_averageAFractions.clear();
534 m_child_averageZFractions.clear();
535 m_child_Rho.clear();
536 m_child_Volume.clear();
537 m_child_Mass.clear();
538
539 double childVolume = 0.;
540 double childMass = 0.;
541 double childX0 = 0.;
542 double childDeDx = 0.;
543 double childAverageA = 0.;
544 double childAverageZ = 0.;
545 double childRho = 0.;
546
547 StoredPhysVol* storedPV = nullptr;
548 std::string key = map_av(alvol);
549 if(detStore()->contains<StoredPhysVol>(key))
550 {
551 if(detStore()->retrieve(storedPV,key)==StatusCode::FAILURE)
552 {
553 ATH_MSG_INFO ("Unable to retrieve Stored PV " << key);
554 }
555 }
556
557 if (!storedPV) {
558 ATH_MSG_INFO ("no Volume for " << key);
559 mass = 0.;
560 x0 = 0.;
561 dEdx = 0.;
562 aveA = 0.;
563 aveZ = 0.;
564 return false;
565 }
566
567 const GeoFullPhysVol* larTopVolLink = storedPV->getPhysVol();
568
569 // get the number of direct childs
570 unsigned int larChilds = larTopVolLink->getNChildVols();
571
572 for (unsigned int ichild = 0; ichild<larChilds; ++ichild){
573
574 bool stop = false;
575
576 // Skip some some of the children : list will get longer in future
577 //if ( alvol == CaloSubdetNames::LARCRYO_B &&
578 // larTopVolLink->getNameOfChildVol(ichild) == "Total LAR Volume") stop = true;
579
580 if (!stop) {
581
582 ATH_MSG_DEBUG ("CaloSubdetNames::ALIGNVOL " << (int) alvol
583 <<" Direct Child " << ichild << " - with name : "
584 << larTopVolLink->getNameOfChildVol(ichild));
585
586 PVConstLink childVolLink = larTopVolLink->getChildVol(ichild);
587
588 m_massFractions.clear();
589 m_volumeFractions.clear();
590 m_x0Fractions.clear();
591 m_dEdXFractions.clear();
592 m_averageAFractions.clear();
593 m_averageZFractions.clear();
594
595 this->blendGeoVolume(childVolLink,
596 m_volumeFractions,
597 m_massFractions,
598 m_x0Fractions,
599 m_dEdXFractions,
600 m_averageAFractions,
601 m_averageZFractions);
602
603 this->averageFraction(m_volumeFractions,
604 m_massFractions,
605 m_x0Fractions,
606 m_dEdXFractions,
607 m_averageAFractions,
608 m_averageZFractions,
609 childMass, childVolume,
610 childX0, childDeDx,
611 childAverageA, childAverageZ, childRho );
612
613 m_child_x0Fractions.push_back( childX0 );
614 m_child_dEdXFractions.push_back( childDeDx );
615 m_child_averageAFractions.push_back( childAverageA );
616 m_child_averageZFractions.push_back( childAverageZ );
617 m_child_Rho.push_back( childRho );
618 m_child_Volume.push_back( childVolume );
619 m_child_Mass.push_back( childMass );
620
621 }
622 }
623
624 // Now do the final average and store it :
625
626 ATH_MSG_DEBUG ("Final average for CaloSubdetNames::ALIGNVOL " << (int) alvol
627 << " !!!!! ");
628
629 this->averageFraction(m_child_Volume, m_child_Mass,
630 m_child_x0Fractions,
631 m_child_dEdXFractions,
632 m_child_averageAFractions,
633 m_child_averageZFractions,
634 childMass, childVolume,
635 childX0, childDeDx,
636 childAverageA, childAverageZ, childRho );
637
638 mass = childMass*(1./GeoModelKernelUnits::gram);
639 x0 = childX0;
640 dEdx = childDeDx;
641 aveA = childAverageA;
642 aveZ = childAverageZ;
643 }
644
645 m_alignvol_number.push_back( alvol );
646 m_alignvol_mass.push_back( mass );
647 m_alignvol_x0.push_back( x0 );
648 m_alignvol_dEdX.push_back( dEdx );
649 m_alignvol_aveA.push_back( aveA );
650 m_alignvol_aveZ.push_back( aveZ );
651
652 return true;
653}

◆ ScanEMEC()

bool LArRecoMaterialTool::ScanEMEC ( CaloSubdetNames::ALIGNVOL alvol,
double & mass,
double & x0,
double & dEdx,
double & aveA,
double & aveZ )
private

Definition at line 656 of file LArRecoMaterialTool.cxx.

659{
660 mass = 0.;
661 x0 = 0.;
662 dEdx = 0.;
663 aveA = 0.;
664 aveZ = 0.;
665
666 if ( alvol != CaloSubdetNames::EMEC_POS && alvol != CaloSubdetNames::EMEC_NEG ) {
667 ATH_MSG_INFO ("method ScanEMEM does not support CaloSubdetNames::ALIGNVOL " << (int) alvol);
668 return false;
669 }
670
671 // EMEC use a couple of custom volumes :
672 // LAr::EMEC::OuterWheel::Absorber has volume=0 mm**3 and 5 elements
673 // LAr::EMEC::OuterWheel::Electrode has volume=0 mm**3 and 5 elements
674 // ==> with volume = 0 avarages cannot work !!!
675 // Take EMB's density for now ....
676 mass = 9.40439e+07 ;
677 x0 = 93.9601;
678 dEdx = 6.0789e-24;
679 aveA = 98.5676;
680 aveZ = 39.7406;
681
682
683 m_alignvol_number.push_back( alvol );
684 m_alignvol_mass.push_back( mass );
685 m_alignvol_x0.push_back( x0 );
686 m_alignvol_dEdX.push_back( dEdx );
687 m_alignvol_aveA.push_back( aveA );
688 m_alignvol_aveZ.push_back( aveZ );
689
690 return true;
691}

◆ ScanFCAL()

bool LArRecoMaterialTool::ScanFCAL ( CaloSubdetNames::ALIGNVOL alvol,
double & mass,
double & x0,
double & dEdx,
double & aveA,
double & aveZ )
private

Definition at line 852 of file LArRecoMaterialTool.cxx.

855{
856 mass = 0.;
857 x0 = 0.;
858 dEdx = 0.;
859 aveA = 0.;
860 aveZ = 0.;
861
862 if ( alvol != CaloSubdetNames::FCAL1_POS &&
863 alvol != CaloSubdetNames::FCAL1_NEG &&
864 alvol != CaloSubdetNames::FCAL2_POS &&
865 alvol != CaloSubdetNames::FCAL2_NEG &&
866 alvol != CaloSubdetNames::FCAL3_POS &&
867 alvol != CaloSubdetNames::FCAL3_NEG ) {
868 ATH_MSG_INFO ("method ScanEMB does not support CaloSubdetNames::ALIGNVOL "
869 << (int) alvol);
870 return false;
871 }
872
873 // Shortcut :
874 if (!m_parseGeoModelForMaterial)
875 {
876 if (alvol == CaloSubdetNames::FCAL1_POS || alvol == CaloSubdetNames::FCAL1_NEG) {
877 mass = 47825.7;
878 x0 = 127.627;
879 dEdx = 4.36158e-24;
880 aveA = 42.5374;
881 aveZ = 19.2601;
882 }
883 else if (alvol == CaloSubdetNames::FCAL2_POS || alvol == CaloSubdetNames::FCAL2_NEG) {
884 mass = 1.77759e+06;
885 x0 = 81.6747;
886 dEdx = 1.9157e-23;
887 aveA = 159.937;
888 aveZ = 64.5724;
889 }
890 else if (alvol == CaloSubdetNames::FCAL3_POS || alvol == CaloSubdetNames::FCAL3_NEG) {
891 mass = 1.80016e+06;
892 x0 = 82.9447;
893 dEdx = 1.86512e-23;
894 aveA = 158.884;
895 aveZ = 64.1669;
896 }
897
898 }
899
900 else {
901
902 // Here we go :
903 m_child_massFractions.clear();
904 m_child_volumeFractions.clear();
905 m_child_x0Fractions.clear();
906 m_child_dEdXFractions.clear();
907 m_child_averageAFractions.clear();
908 m_child_averageZFractions.clear();
909 m_child_Rho.clear();
910 m_child_Volume.clear();
911 m_child_Mass.clear();
912
913 double childVolume = 0.;
914 double childMass = 0.;
915 double childX0 = 0.;
916 double childDeDx = 0.;
917 double childAverageA = 0.;
918 double childAverageZ = 0.;
919 double childRho = 0.;
920
921 StoredPhysVol* storedPV = nullptr;
922 std::string key = map_av(alvol);
923 if(detStore()->contains<StoredPhysVol>(key))
924 {
925 if(detStore()->retrieve(storedPV,key)==StatusCode::FAILURE)
926 {
927 ATH_MSG_INFO ("Unable to retrieve Stored PV " << key);
928 }
929 }
930
931 if (!storedPV) {
932 ATH_MSG_INFO ("no Volume for " << key);
933 mass = 0.;
934 x0 = 0.;
935 dEdx = 0.;
936 aveA = 0.;
937 aveZ = 0.;
938 return false;
939 }
940
941 const GeoFullPhysVol* larTopVolLink = storedPV->getPhysVol();
942
943 // get the number of direct childs
944 unsigned int larChilds = larTopVolLink->getNChildVols();
945
946 for (unsigned int ichild = 0; ichild<larChilds; ++ichild){
947
948 bool stop = false;
949
950 // Skip some some of the children : list will get longer in future
951 //if ( alvol == CaloSubdetNames::LARCRYO_B &&
952 // larTopVolLink->getNameOfChildVol(ichild) == "Total LAR Volume") stop = true;
953
954 if (!stop) {
955
956 ATH_MSG_DEBUG ("CaloSubdetNames::ALIGNVOL " << (int) alvol
957 <<" Direct Child " << ichild << " - with name : "
958 << larTopVolLink->getNameOfChildVol(ichild));
959
960 PVConstLink childVolLink = larTopVolLink->getChildVol(ichild);
961
962 m_massFractions.clear();
963 m_volumeFractions.clear();
964 m_x0Fractions.clear();
965 m_dEdXFractions.clear();
966 m_averageAFractions.clear();
967 m_averageZFractions.clear();
968
969 this->blendGeoVolume(childVolLink,
970 m_volumeFractions,
971 m_massFractions,
972 m_x0Fractions,
973 m_dEdXFractions,
974 m_averageAFractions,
975 m_averageZFractions);
976
977 this->averageFraction(m_volumeFractions,
978 m_massFractions,
979 m_x0Fractions,
980 m_dEdXFractions,
981 m_averageAFractions,
982 m_averageZFractions,
983 childMass, childVolume,
984 childX0, childDeDx,
985 childAverageA, childAverageZ, childRho );
986
987 m_child_x0Fractions.push_back( childX0 );
988 m_child_dEdXFractions.push_back( childDeDx );
989 m_child_averageAFractions.push_back( childAverageA );
990 m_child_averageZFractions.push_back( childAverageZ );
991 m_child_Rho.push_back( childRho );
992 m_child_Volume.push_back( childVolume );
993 m_child_Mass.push_back( childMass );
994
995 }
996 }
997
998 // Now do the final average and store it :
999
1000 ATH_MSG_DEBUG ("Final average for CaloSubdetNames::ALIGNVOL " << (int) alvol
1001 << " !!!!! ");
1002
1003 this->averageFraction(m_child_Volume, m_child_Mass,
1004 m_child_x0Fractions,
1005 m_child_dEdXFractions,
1006 m_child_averageAFractions,
1007 m_child_averageZFractions,
1008 childMass, childVolume,
1009 childX0, childDeDx,
1010 childAverageA, childAverageZ, childRho );
1011
1012 mass = childMass*(1./GeoModelKernelUnits::gram);
1013 x0 = childX0;
1014 dEdx = childDeDx;
1015 aveA = childAverageA;
1016 aveZ = childAverageZ;
1017 }
1018
1019 m_alignvol_number.push_back( alvol );
1020 m_alignvol_mass.push_back( mass );
1021 m_alignvol_x0.push_back( x0 );
1022 m_alignvol_dEdX.push_back( dEdx );
1023 m_alignvol_aveA.push_back( aveA );
1024 m_alignvol_aveZ.push_back( aveZ );
1025
1026 return true;
1027}

◆ ScanHEC()

bool LArRecoMaterialTool::ScanHEC ( CaloSubdetNames::ALIGNVOL alvol,
double & mass,
double & x0,
double & dEdx,
double & aveA,
double & aveZ )
private

Definition at line 694 of file LArRecoMaterialTool.cxx.

697{
698 mass = 0.;
699 x0 = 0.;
700 dEdx = 0.;
701 aveA = 0.;
702 aveZ = 0.;
703
704 if ( alvol != CaloSubdetNames::HEC1_POS &&
705 alvol != CaloSubdetNames::HEC1_NEG &&
706 alvol != CaloSubdetNames::HEC2_POS &&
707 alvol != CaloSubdetNames::HEC2_NEG ) {
708 ATH_MSG_INFO ("method ScanEMB does not support CaloSubdetNames::ALIGNVOL "
709 << (int) alvol);
710 return false;
711 }
712
713 // Shortcut :
714 if (!m_parseGeoModelForMaterial)
715 {
716 mass = 6.06935e+06;
717 x0 = 91.1845;
718 dEdx = 1.14141e-23;
719 aveA = 58.9808;
720 aveZ = 26.8777;
721 }
722 else {
723
724 // Here we go :
725 m_child_massFractions.clear();
726 m_child_volumeFractions.clear();
727 m_child_x0Fractions.clear();
728 m_child_dEdXFractions.clear();
729 m_child_averageAFractions.clear();
730 m_child_averageZFractions.clear();
731 m_child_Rho.clear();
732 m_child_Volume.clear();
733 m_child_Mass.clear();
734
735 double childVolume = 0.;
736 double childMass = 0.;
737 double childX0 = 0.;
738 double childDeDx = 0.;
739 double childAverageA = 0.;
740 double childAverageZ = 0.;
741 double childRho = 0.;
742
743 StoredPhysVol* storedPV = nullptr;
744 std::string key = map_av(alvol);
745 if(detStore()->contains<StoredPhysVol>(key))
746 {
747 if(detStore()->retrieve(storedPV,key)==StatusCode::FAILURE)
748 {
749 ATH_MSG_INFO ("Unable to retrieve Stored PV " << key);
750 }
751 }
752
753 if (!storedPV) {
754 ATH_MSG_INFO ("no Volume for " << key);
755 mass = 0.;
756 x0 = 0.;
757 dEdx = 0.;
758 aveA = 0.;
759 aveZ = 0.;
760 return false;
761 }
762
763 const GeoFullPhysVol* larTopVolLink = storedPV->getPhysVol();
764
765 // get the number of direct childs
766 unsigned int larChilds = larTopVolLink->getNChildVols();
767
768 for (unsigned int ichild = 0; ichild<larChilds; ++ichild){
769
770 bool stop = false;
771
772 // Skip some some of the children : list will get longer in future
773 //if ( alvol == CaloSubdetNames::LARCRYO_B &&
774 // larTopVolLink->getNameOfChildVol(ichild) == "Total LAR Volume") stop = true;
775
776 if (!stop) {
777
778 ATH_MSG_DEBUG ("CaloSubdetNames::ALIGNVOL " << (int) alvol
779 <<" Direct Child " << ichild << " - with name : "
780 << larTopVolLink->getNameOfChildVol(ichild));
781
782 PVConstLink childVolLink = larTopVolLink->getChildVol(ichild);
783
784 m_massFractions.clear();
785 m_volumeFractions.clear();
786 m_x0Fractions.clear();
787 m_dEdXFractions.clear();
788 m_averageAFractions.clear();
789 m_averageZFractions.clear();
790
791 this->blendGeoVolume(childVolLink,
792 m_volumeFractions,
793 m_massFractions,
794 m_x0Fractions,
795 m_dEdXFractions,
796 m_averageAFractions,
797 m_averageZFractions);
798
799 this->averageFraction(m_volumeFractions,
800 m_massFractions,
801 m_x0Fractions,
802 m_dEdXFractions,
803 m_averageAFractions,
804 m_averageZFractions,
805 childMass, childVolume,
806 childX0, childDeDx,
807 childAverageA, childAverageZ, childRho );
808
809 m_child_x0Fractions.push_back( childX0 );
810 m_child_dEdXFractions.push_back( childDeDx );
811 m_child_averageAFractions.push_back( childAverageA );
812 m_child_averageZFractions.push_back( childAverageZ );
813 m_child_Rho.push_back( childRho );
814 m_child_Volume.push_back( childVolume );
815 m_child_Mass.push_back( childMass );
816
817 }
818 }
819
820 // Now do the final average and store it :
821
822 ATH_MSG_DEBUG ("Final average for CaloSubdetNames::ALIGNVOL " << (int) alvol
823 << " !!!!! ");
824
825 this->averageFraction(m_child_Volume, m_child_Mass,
826 m_child_x0Fractions,
827 m_child_dEdXFractions,
828 m_child_averageAFractions,
829 m_child_averageZFractions,
830 childMass, childVolume,
831 childX0, childDeDx,
832 childAverageA, childAverageZ, childRho );
833
834 mass = childMass*(1./GeoModelKernelUnits::gram);
835 x0 = childX0;
836 dEdx = childDeDx;
837 aveA = childAverageA;
838 aveZ = childAverageZ;
839 }
840
841 m_alignvol_number.push_back( alvol );
842 m_alignvol_mass.push_back( mass );
843 m_alignvol_x0.push_back( x0 );
844 m_alignvol_dEdX.push_back( dEdx );
845 m_alignvol_aveA.push_back( aveA );
846 m_alignvol_aveZ.push_back( aveZ );
847
848 return true;
849}

◆ ScanPS()

bool LArRecoMaterialTool::ScanPS ( CaloSubdetNames::ALIGNVOL alvol,
double & mass,
double & x0,
double & dEdx,
double & aveA,
double & aveZ )
private

Definition at line 343 of file LArRecoMaterialTool.cxx.

346{
347 mass = 0.;
348 x0 = 0.;
349 dEdx = 0.;
350 aveA = 0.;
351 aveZ = 0.;
352
353 if ( alvol != CaloSubdetNames::PRESAMPLER_B_POS
354 && alvol != CaloSubdetNames::PRESAMPLER_B_NEG
355 && alvol != CaloSubdetNames::PRESAMPLER_EC_POS
356 && alvol != CaloSubdetNames::PRESAMPLER_EC_NEG
357 ) {
358 ATH_MSG_INFO ("method ScanCryo does not support CaloSubdetNames::ALIGNVOL " << (int) alvol);
359 return false;
360 }
361
362 // for EMEC take Barrel numbers
363
364 // Shortcut :
365 if (!m_parseGeoModelForMaterial ||
366 alvol == CaloSubdetNames::PRESAMPLER_EC_POS ||
367 alvol == CaloSubdetNames::PRESAMPLER_EC_NEG)
368 {
369 mass = 1.80785e+06 ;
370 x0 = 141.837;
371 dEdx = 3.55847e-24;
372 aveA = 39.5576;
373 aveZ = 17.8274;
374 }
375
376 else {
377
378 // Go for it :
379 m_child_massFractions.clear();
380 m_child_volumeFractions.clear();
381 m_child_x0Fractions.clear();
382 m_child_dEdXFractions.clear();
383 m_child_averageAFractions.clear();
384 m_child_averageZFractions.clear();
385 m_child_Rho.clear();
386 m_child_Volume.clear();
387 m_child_Mass.clear();
388
389 double childVolume = 0.;
390 double childMass = 0.;
391 double childX0 = 0.;
392 double childDeDx = 0.;
393 double childAverageA = 0.;
394 double childAverageZ = 0.;
395 double childRho = 0.;
396
397 StoredPhysVol* storedPV = nullptr;
398 std::string key = map_av(alvol);
399 if(detStore()->contains<StoredPhysVol>(key))
400 {
401 if(detStore()->retrieve(storedPV,key)==StatusCode::FAILURE)
402 {
403 ATH_MSG_INFO ("Unable to retrieve Stored PV " << key);
404 }
405 }
406
407 if (!storedPV) {
408 ATH_MSG_INFO ("no Volume for " << key);
409 return false;
410 }
411
412 const GeoFullPhysVol* larTopVolLink = storedPV->getPhysVol();
413
414 // get the number of direct childs
415 unsigned int larChilds = larTopVolLink->getNChildVols();
416
417 for (unsigned int ichild = 0; ichild<larChilds; ++ichild){
418
419 bool stop = false;
420
421 // Skip some some of the children : list will get longer in future
422 //if ( alvol == CaloSubdetNames::LARCRYO_B &&
423 // larTopVolLink->getNameOfChildVol(ichild) == "Total LAR Volume") stop = true;
424
425 if (!stop) {
426
427 ATH_MSG_DEBUG ("CaloSubdetNames::ALIGNVOL " << (int) alvol
428 <<" Direct Child " << ichild << " - with name : "
429 << larTopVolLink->getNameOfChildVol(ichild));
430
431 PVConstLink childVolLink = larTopVolLink->getChildVol(ichild);
432
433 m_massFractions.clear();
434 m_volumeFractions.clear();
435 m_x0Fractions.clear();
436 m_dEdXFractions.clear();
437 m_averageAFractions.clear();
438 m_averageZFractions.clear();
439
440 this->blendGeoVolume(childVolLink,
441 m_volumeFractions,
442 m_massFractions,
443 m_x0Fractions,
444 m_dEdXFractions,
445 m_averageAFractions,
446 m_averageZFractions);
447
448 this->averageFraction(m_volumeFractions,
449 m_massFractions,
450 m_x0Fractions,
451 m_dEdXFractions,
452 m_averageAFractions,
453 m_averageZFractions,
454 childMass, childVolume,
455 childX0, childDeDx,
456 childAverageA, childAverageZ, childRho );
457
458 m_child_x0Fractions.push_back( childX0 );
459 m_child_dEdXFractions.push_back( childDeDx );
460 m_child_averageAFractions.push_back( childAverageA );
461 m_child_averageZFractions.push_back( childAverageZ );
462 m_child_Rho.push_back( childRho );
463 m_child_Volume.push_back( childVolume );
464 m_child_Mass.push_back( childMass );
465
466 }
467 }
468
469 // Now do the final average and store it :
470
471 ATH_MSG_DEBUG ("Final average for CaloSubdetNames::ALIGNVOL " << (int) alvol
472 << " !!!!! ");
473
474 this->averageFraction(m_child_Volume, m_child_Mass,
475 m_child_x0Fractions,
476 m_child_dEdXFractions,
477 m_child_averageAFractions,
478 m_child_averageZFractions,
479 childMass, childVolume,
480 childX0, childDeDx,
481 childAverageA, childAverageZ, childRho );
482
483 mass = childMass*(1./GeoModelKernelUnits::gram);
484 x0 = childX0;
485 dEdx = childDeDx;
486 aveA = childAverageA;
487 aveZ = childAverageZ;
488 }
489
490 m_alignvol_number.push_back( alvol );
491 m_alignvol_mass.push_back( mass );
492 m_alignvol_x0.push_back( x0 );
493 m_alignvol_dEdX.push_back( dEdx );
494 m_alignvol_aveA.push_back( aveA );
495 m_alignvol_aveZ.push_back( aveZ );
496
497 return true;
498}

◆ ScanTree()

void LArRecoMaterialTool::ScanTree ( )
private

Private method called at initialisation : fills all arrays by calling the "optimised" methods.

Definition at line 125 of file LArRecoMaterialTool.cxx.

126{
127 double mass = 0.;
128 double x0 = 0.;
129 double dEdx = 0.;
130 double aveA = 0.;
131 double aveZ = 0.;
132
133 bool result = false;
134
135 ATH_MSG_INFO (" Entering method ScanTree() ");
136
137 result = this->ScanCRYO(CaloSubdetNames::LARCRYO_B,mass,x0,dEdx,aveA,aveZ);
138 result = this->ScanCRYO(CaloSubdetNames::LARCRYO_EC_POS,mass,x0,dEdx,aveA,aveZ);
139 result = this->ScanCRYO(CaloSubdetNames::LARCRYO_EC_NEG,mass,x0,dEdx,aveA,aveZ);
140 result = this->ScanCRYO(CaloSubdetNames::SOLENOID,mass,x0,dEdx,aveA,aveZ);
141
142 result = this->ScanPS(CaloSubdetNames::PRESAMPLER_B_POS,mass,x0,dEdx,aveA,aveZ);
143 result = this->ScanPS(CaloSubdetNames::PRESAMPLER_B_NEG,mass,x0,dEdx,aveA,aveZ);
144
145 result = this->ScanEMB(CaloSubdetNames::EMB_POS,mass,x0,dEdx,aveA,aveZ);
146 result = this->ScanEMB(CaloSubdetNames::EMB_NEG,mass,x0,dEdx,aveA,aveZ);
147
148 result = this->ScanPS(CaloSubdetNames::PRESAMPLER_EC_POS,mass,x0,dEdx,aveA,aveZ);
149 result = this->ScanPS(CaloSubdetNames::PRESAMPLER_EC_NEG,mass,x0,dEdx,aveA,aveZ);
150
151 result = this->ScanEMEC(CaloSubdetNames::EMEC_POS,mass,x0,dEdx,aveA,aveZ);
152 result = this->ScanEMEC(CaloSubdetNames::EMEC_NEG,mass,x0,dEdx,aveA,aveZ);
153
154 result = this->ScanHEC(CaloSubdetNames::HEC1_POS,mass,x0,dEdx,aveA,aveZ);
155 result = this->ScanHEC(CaloSubdetNames::HEC1_NEG,mass,x0,dEdx,aveA,aveZ);
156 result = this->ScanHEC(CaloSubdetNames::HEC2_POS,mass,x0,dEdx,aveA,aveZ);
157 result = this->ScanHEC(CaloSubdetNames::HEC2_NEG,mass,x0,dEdx,aveA,aveZ);
158
159 result = this->ScanFCAL(CaloSubdetNames::FCAL1_POS,mass,x0,dEdx,aveA,aveZ);
160 result = this->ScanFCAL(CaloSubdetNames::FCAL1_NEG,mass,x0,dEdx,aveA,aveZ);
161 result = this->ScanFCAL(CaloSubdetNames::FCAL2_POS,mass,x0,dEdx,aveA,aveZ);
162 result = this->ScanFCAL(CaloSubdetNames::FCAL2_NEG,mass,x0,dEdx,aveA,aveZ);
163 result = this->ScanFCAL(CaloSubdetNames::FCAL3_POS,mass,x0,dEdx,aveA,aveZ);
164 result = this->ScanFCAL(CaloSubdetNames::FCAL3_NEG,mass,x0,dEdx,aveA,aveZ);
165
166 if (!result)
167 ATH_MSG_INFO (" If seems to have failed ?");
168
169 return;
170}
LArRecoMaterialTool::ScanHEC
bool ScanHEC(CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
Definition LArRecoMaterialTool.cxx:694
LArRecoMaterialTool::ScanFCAL
bool ScanFCAL(CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
Definition LArRecoMaterialTool.cxx:852
LArRecoMaterialTool::ScanPS
bool ScanPS(CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
Definition LArRecoMaterialTool.cxx:343
LArRecoMaterialTool::ScanEMB
bool ScanEMB(CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
Definition LArRecoMaterialTool.cxx:501
LArRecoMaterialTool::ScanEMEC
bool ScanEMEC(CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
Definition LArRecoMaterialTool.cxx:656
LArRecoMaterialTool::ScanCRYO
bool ScanCRYO(CaloSubdetNames::ALIGNVOL alvol, double &mass, double &x0, double &dEdx, double &aveA, double &aveZ)
Private optimised methods for each subsystem.
Definition LArRecoMaterialTool.cxx:173

Member Data Documentation

◆ m_alignvol_aveA

std::vector<double> LArRecoMaterialTool::m_alignvol_aveA
private

Definition at line 143 of file LArRecoMaterialTool.h.

◆ m_alignvol_aveZ

std::vector<double> LArRecoMaterialTool::m_alignvol_aveZ
private

Definition at line 144 of file LArRecoMaterialTool.h.

◆ m_alignvol_dEdX

std::vector<double> LArRecoMaterialTool::m_alignvol_dEdX
private

Definition at line 142 of file LArRecoMaterialTool.h.

◆ m_alignvol_mass

std::vector<double> LArRecoMaterialTool::m_alignvol_mass
private

Definition at line 140 of file LArRecoMaterialTool.h.

◆ m_alignvol_number

std::vector<CaloSubdetNames::ALIGNVOL> LArRecoMaterialTool::m_alignvol_number
private

Definition at line 139 of file LArRecoMaterialTool.h.

◆ m_alignvol_x0

std::vector<double> LArRecoMaterialTool::m_alignvol_x0
private

Definition at line 141 of file LArRecoMaterialTool.h.

◆ m_averageAFractions

std::vector<double> LArRecoMaterialTool::m_averageAFractions
private

Definition at line 151 of file LArRecoMaterialTool.h.

◆ m_averageZFractions

std::vector<double> LArRecoMaterialTool::m_averageZFractions
private

Definition at line 152 of file LArRecoMaterialTool.h.

◆ m_calo_id

const CaloCell_ID* LArRecoMaterialTool::m_calo_id {nullptr}
private

Definition at line 135 of file LArRecoMaterialTool.h.

135{nullptr};

◆ m_child_averageAFractions

std::vector<double> LArRecoMaterialTool::m_child_averageAFractions
private

Definition at line 158 of file LArRecoMaterialTool.h.

◆ m_child_averageZFractions

std::vector<double> LArRecoMaterialTool::m_child_averageZFractions
private

Definition at line 159 of file LArRecoMaterialTool.h.

◆ m_child_dEdXFractions

std::vector<double> LArRecoMaterialTool::m_child_dEdXFractions
private

Definition at line 157 of file LArRecoMaterialTool.h.

◆ m_child_Mass

std::vector<double> LArRecoMaterialTool::m_child_Mass
private

Definition at line 162 of file LArRecoMaterialTool.h.

◆ m_child_massFractions

std::vector<double> LArRecoMaterialTool::m_child_massFractions
private

Definition at line 154 of file LArRecoMaterialTool.h.

◆ m_child_Rho

std::vector<double> LArRecoMaterialTool::m_child_Rho
private

Definition at line 160 of file LArRecoMaterialTool.h.

◆ m_child_Volume

std::vector<double> LArRecoMaterialTool::m_child_Volume
private

Definition at line 161 of file LArRecoMaterialTool.h.

◆ m_child_volumeFractions

std::vector<double> LArRecoMaterialTool::m_child_volumeFractions
private

Definition at line 155 of file LArRecoMaterialTool.h.

◆ m_child_x0Fractions

std::vector<double> LArRecoMaterialTool::m_child_x0Fractions
private

Definition at line 156 of file LArRecoMaterialTool.h.

◆ m_dEdXFractions

std::vector<double> LArRecoMaterialTool::m_dEdXFractions
private

Definition at line 150 of file LArRecoMaterialTool.h.

◆ m_dm_id

const CaloDM_ID* LArRecoMaterialTool::m_dm_id {nullptr}
private

Definition at line 136 of file LArRecoMaterialTool.h.

136{nullptr};

◆ m_massFractions

std::vector<double> LArRecoMaterialTool::m_massFractions
private

Definition at line 147 of file LArRecoMaterialTool.h.

◆ m_parseGeoModelForMaterial

bool LArRecoMaterialTool::m_parseGeoModelForMaterial = false
private

Private bool set at initialisation : decides if the GeoModel is parsed or bypassed.

Definition at line 70 of file LArRecoMaterialTool.h.

◆ m_volumeFractions

std::vector<double> LArRecoMaterialTool::m_volumeFractions
private

Definition at line 148 of file LArRecoMaterialTool.h.

◆ m_x0Fractions

std::vector<double> LArRecoMaterialTool::m_x0Fractions
private

Definition at line 149 of file LArRecoMaterialTool.h.

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