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

Class for construction of EMEC internal structure. More...

#include <EMECAccordionConstruction.h>

Collaboration diagram for LArGeo::EMECAccordionConstruction:

Classes

struct  CutPlane
 

Public Member Functions

 EMECAccordionConstruction ()=default
 
 ~EMECAccordionConstruction ()=default
 
void setWheelParameters ()
 
void setInnerWheel (GeoFullPhysVol *innerWheel)
 
void setOuterWheel (GeoFullPhysVol *outerWheel)
 
void setMaterial (const std::string &name, const GeoMaterial *material)
 
void constructInnerWheelStructure (bool makeSlices=true)
 
void constructOuterWheelStructure (bool makeSlices=true)
 

Private Member Functions

void setInnerWheelSlices ()
 
void setOuterWheelSlices ()
 
void getInnerAbsorberData (double &wmin, double &wmax, double &llip1, double &ylip1, double &llip2, double &ylip2) const
 
void getOuterAbsorberData (double &wmin, double &wmax, double &llip1, double &ylip1, double &llip2, double &ylip2) const
 
void getBladeCorners (double wmin, double wmax, double thickness, double rmin, double rmax, double zdel, GeoThreeVector corners[8]) const
 
CutPlane getBottomCutPlane (double zmin, double rmin, double zmax, double rmax) const
 
CutPlane getTopCutPlane (double zmin, double rmin, double zmax, double rmax, const GeoThreeVector corners[8]) const
 
GeoThreeVector IntersectionPoint (const GeoThreeVector &p1, const GeoThreeVector &p2, const CutPlane &plane) const
 
GeoShape * constructBlade (int icase, const GeoThreeVector corners[8], double xscale, double pz1, double pr1min, double pr1max, double pz2, double pr2min, double pr2max) const
 
void constructInnerSlices ()
 
void constructOuterSlices ()
 
void constructInnerLips (double innerLipLength1, double innerLipPosition1, double innerLipLength2, double innerLipPosition2)
 
void constructOuterLips (double outerLipLength1, double outerLipPosition1, double outerLipLength2, double outerLipPosition2)
 
void constructInnerBlades (const GeoThreeVector innerCorners[8], const GeoThreeVector innerElectrodeCorners[8])
 
void constructOuterBlades (const GeoThreeVector outerCorners[8], const GeoThreeVector outerElectrodeCorners[8])
 
void placeInnerGlueAndLead ()
 
void placeOuterGlueAndLead ()
 
void placeInnerSlices (bool makeSlices)
 
void placeOuterSlices (bool makeSlices)
 
void placeInnerAccordion (int innerNoSectors, bool makeSlices, bool makeSectors)
 
void placeOuterAccordion (int outerNoSectors, bool makeSlices, bool makeSectors)
 

Private Attributes

GeoFullPhysVol * m_innerWheel = nullptr
 
GeoFullPhysVol * m_outerWheel = nullptr
 
const GeoMaterial * m_materialLiquidArgon = nullptr
 
const GeoMaterial * m_materialKapton = nullptr
 
const GeoMaterial * m_materialLead = nullptr
 
const GeoMaterial * m_materialSteel = nullptr
 
const GeoMaterial * m_materialGlue = nullptr
 
int m_innerNoElectrodes = 256
 
int m_innerNoAbsorbes = 256
 
int m_innerNoWaves = 6
 
int m_outerNoElectrodes = 768
 
int m_outerNoAbsorbes = 768
 
int m_outerNoWaves = 9
 
std::string m_nameInnerWheel = ""
 
std::string m_nameOuterWheel = ""
 
std::string m_nameSlice = "::Slice"
 
std::string m_nameAbsorber = "::Absorber"
 
std::string m_nameLead = "::Lead"
 
std::string m_nameGlue = "::Glue"
 
std::string m_nameElectrode = "::Electrode"
 
std::string m_nameSuffix [s_outerNoBlades]
 
double m_innerWheelWidth = 0
 
double m_innerLipWidth = 0
 
double m_innerWaveZoneWidth = 0
 
double m_innerWaveWidth = 0
 
double m_innerHalfWaveWidth = 0
 
double m_innerQuaterWaveWidth = 0
 
double m_outerWheelWidth = 0
 
double m_outerLipWidth = 0
 
double m_outerWaveZoneWidth = 0
 
double m_outerWaveWidth = 0
 
double m_outerHalfWaveWidth = 0
 
double m_outerQuaterWaveWidth = 0
 
double m_innerLeadThickness = 0
 
double m_innerSteelThickness = 0
 
double m_innerGlueThickness = 0
 
double m_innerAbsorberThickness = 0
 
double m_innerElectrodeThickness = 0
 
double m_innerGlueRatio = 0
 
double m_innerLeadRatio = 0
 
double m_outerLeadThickness = 0
 
double m_outerSteelThickness = 0
 
double m_outerGlueThickness = 0
 
double m_outerAbsorberThickness = 0
 
double m_outerElectrodeThickness = 0
 
double m_outerGlueRatio = 0
 
double m_outerLeadRatio = 0
 
double m_kContraction = 0
 
std::array< double, 2 > m_zWheelInner = {}
 
std::array< double, 2 > m_rMinInner = {}
 
std::array< double, 2 > m_rMaxInner = {}
 
std::array< double, 3 > m_zWheelOuter = {}
 
std::array< double, 3 > m_rMinOuter = {}
 
std::array< double, 3 > m_rMaxOuter = {}
 
std::array< double, s_innerNoBlades+1 > m_innerWheelZ = {}
 
std::array< double, s_innerNoBlades+1 > m_innerWheelRmin = {}
 
std::array< double, s_innerNoBlades+1 > m_innerWheelRmax = {}
 
double m_innerWheelRminIncrement = 0
 
double m_innerWheelRmaxIncrement = 0
 
double m_innerWheelZmin = 0
 
double m_innerWheelZmax = 0
 
std::array< double, s_outerNoBlades+1 > m_outerWheelZ = {}
 
std::array< double, s_outerNoBlades+1 > m_outerWheelRmin = {}
 
std::array< double, s_outerNoBlades+1 > m_outerWheelRmax = {}
 
std::array< double, 2 > m_outerWheelRminIncrement = {}
 
std::array< double, 2 > m_outerWheelRmaxIncrement = {}
 
double m_outerWheelZmin = 0
 
double m_outerWheelZmax = 0
 
std::array< GeoPhysVol *, s_innerNoBlades > m_innerAbsorber {{nullptr}}
 
std::array< GeoPhysVol *, s_innerNoBlades > m_innerGlue {{nullptr}}
 
std::array< GeoPhysVol *, s_innerNoBlades > m_innerLead {{nullptr}}
 
std::array< GeoPhysVol *, s_innerNoBlades > m_innerElectrode {{nullptr}}
 
std::array< GeoThreeVector, s_innerNoBlades > m_innerAbsorberOffset = {}
 
std::array< GeoThreeVector, s_innerNoBlades > m_innerElectrodeOffset = {}
 
std::array< GeoPhysVol *, s_outerNoBlades > m_outerAbsorber {{nullptr}}
 
std::array< GeoPhysVol *, s_outerNoBlades > m_outerGlue {{nullptr}}
 
std::array< GeoPhysVol *, s_outerNoBlades > m_outerLead {{nullptr}}
 
std::array< GeoPhysVol *, s_outerNoBlades > m_outerElectrode {{nullptr}}
 
std::array< GeoThreeVector, s_outerNoBlades > m_outerAbsorberOffset = {}
 
std::array< GeoThreeVector, s_outerNoBlades > m_outerElectrodeOffset = {}
 
std::array< GeoPhysVol *, s_innerNoBlades > m_innerSlice {{nullptr}}
 
std::array< GeoThreeVector, s_innerNoBlades > m_innerSliceOffset = {}
 
std::array< GeoPhysVol *, s_outerNoBlades > m_outerSlice {{nullptr}}
 
std::array< GeoThreeVector, s_outerNoBlades > m_outerSliceOffset = {}
 
std::array< GeoPhysVol *, s_innerNoBlades > m_innerSector {{nullptr}}
 
std::array< GeoPhysVol *, s_outerNoBlades > m_outerSector {{nullptr}}
 

Static Private Attributes

static constexpr int s_innerNoBlades = 15
 
static constexpr int s_outerNoBlades = 21
 

Detailed Description

Class for construction of EMEC internal structure.

Definition at line 35 of file EMECAccordionConstruction.h.

Constructor & Destructor Documentation

◆ EMECAccordionConstruction()

LArGeo::EMECAccordionConstruction::EMECAccordionConstruction ( )
default

◆ ~EMECAccordionConstruction()

LArGeo::EMECAccordionConstruction::~EMECAccordionConstruction ( )
default

Member Function Documentation

◆ constructBlade()

GeoShape * LArGeo::EMECAccordionConstruction::constructBlade ( int  icase,
const GeoThreeVector  corners[8],
double  xscale,
double  pz1,
double  pr1min,
double  pr1max,
double  pz2,
double  pr2min,
double  pr2max 
) const
private

Definition at line 590 of file EMECAccordionConstruction.cxx.

594 {
595  double z1 = pz1, r1min = pr1min, r1max = pr1max;
596  double z2 = pz2, r2min = pr2min, r2max = pr2max;
597  if (icase == 1) // First quater-wave blade
598  {
599  z1 -= (z2 - z1);
600  r1min -= (r2min - r1min);
601  r1max -= (r2max - r1max);
602  }
603  if (icase == 4) // Last quater-wave blade
604  {
605  z2 += (z2 - z1);
606  r2min += (r2min - r1min);
607  r2max += (r2max - r1max);
608  }
609 
610  // Prepare Blade for cutting
611  std::vector<GeoThreeVector> v3(8);
612  double kx = (icase == 2) ? 1 : -1; // set inclination
613 
614  // Move Blade to required position
615  for (int i = 0; i < 8; ++i)
616  {
617  v3[i] = GeoThreeVector(kx*corners[i].x(), corners[i].y(), corners[i].z() + (z1 + z2)/2.);
618  }
619 
620  // Change order vertices in case of negative inclination
621  if (kx < 0)
622  {
623  std::swap(v3[0],v3[1]);
624  std::swap(v3[2],v3[3]);
625  std::swap(v3[4],v3[5]);
626  std::swap(v3[6],v3[7]);
627  }
628 
629  // Cut Blade by bottom plane
630  LArGeo::EMECAccordionConstruction::CutPlane botPlane = getBottomCutPlane(z1, r1min, z2, r2min);
631  v3[0] = IntersectionPoint(v3[0], v3[3], botPlane);
632  v3[1] = IntersectionPoint(v3[1], v3[2], botPlane);
633  v3[4] = IntersectionPoint(v3[4], v3[7], botPlane);
634  v3[5] = IntersectionPoint(v3[5], v3[6], botPlane);
635 
636  // Cut Blade by top plane
637  LArGeo::EMECAccordionConstruction::CutPlane topPlane = getTopCutPlane(z1, r1max, z2, r2max, corners);
638  v3[3] = IntersectionPoint(v3[0], v3[3], topPlane);
639  v3[2] = IntersectionPoint(v3[1], v3[2], topPlane);
640  v3[7] = IntersectionPoint(v3[4], v3[7], topPlane);
641  v3[6] = IntersectionPoint(v3[5], v3[6], topPlane);
642 
643  if (icase == 1) // First quater-wave blade
644  {
645  v3[0] = (v3[0] + v3[4])/2.;
646  v3[1] = (v3[1] + v3[5])/2.;
647  v3[2] = (v3[2] + v3[6])/2.;
648  v3[3] = (v3[3] + v3[7])/2.;
649  }
650 
651  if (icase == 4) // Last quater-wave blade
652  {
653  v3[4] = (v3[0] + v3[4])/2.;
654  v3[5] = (v3[1] + v3[5])/2.;
655  v3[6] = (v3[2] + v3[6])/2.;
656  v3[7] = (v3[3] + v3[7])/2.;
657  }
658 
659  // Construct GenericTrap solid
660  //
661  // +--------Z
662  // |
663  // | 3 +----------+ 7
664  // | 0 +------|---+ 4 |
665  // X | 2 +----------+ 6
666  // 1 +----------+ 5
667  //
668  std::vector<GeoTwoVector> v2(8);
669  for (int i = 0; i < 8; i += 2)
670  {
671  double xmid = (v3[i + 1].x() + v3[i].x())/2.;
672  double xdel = (v3[i + 1].x() - v3[i].x())*xscale/2.;
673  v2[i + 0] = GeoTwoVector(xmid - xdel, v3[i + 0].y());
674  v2[i + 1] = GeoTwoVector(xmid + xdel, v3[i + 1].y());
675  }
676  return new GeoGenericTrap((pz2 - pz1)/2., v2);
677 }

◆ constructInnerBlades()

void LArGeo::EMECAccordionConstruction::constructInnerBlades ( const GeoThreeVector  innerCorners[8],
const GeoThreeVector  innerElectrodeCorners[8] 
)
private

Definition at line 872 of file EMECAccordionConstruction.cxx.

874 {
875  std::string name;
876  GeoShape* solid;
877 
878  for (int iblade = 1; iblade < s_innerNoBlades - 1; ++iblade)
879  {
880  int icase = (iblade%2 == 0) ? 2 : 3; // positive/negative inclination
881  if (iblade == 1) icase = 1; // first quater-wave
882  if (iblade == s_innerNoBlades - 2) icase = 4; // last quater-wave
883 
884  double z1 = m_innerWheelZ[iblade];
885  double r1min = m_innerWheelRmin[iblade];
886  double r1max = m_innerWheelRmax[iblade];
887  double z2 = m_innerWheelZ[iblade + 1];
888  double r2min = m_innerWheelRmin[iblade + 1];
889  double r2max = m_innerWheelRmax[iblade + 1];
890 
891  // Construct volumes for Absorber, Glue, Lead and Electrode
892  name = m_nameInnerWheel + m_nameAbsorber + m_nameSuffix[iblade];
893  solid = constructBlade(icase, innerCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
894  m_innerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
895 
896  name = m_nameInnerWheel + m_nameGlue + m_nameSuffix[iblade];
897  solid = constructBlade(icase, innerCorners, m_innerGlueRatio, z1, r1min, r1max, z2, r2min, r2max);
898  m_innerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
899 
900  name = m_nameInnerWheel + m_nameLead + m_nameSuffix[iblade];
901  solid = constructBlade(icase, innerCorners, m_innerLeadRatio, z1, r1min, r1max, z2, r2min, r2max);
902  m_innerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
903 
904  name = m_nameInnerWheel + m_nameElectrode + m_nameSuffix[iblade];
905  solid = constructBlade(icase, innerElectrodeCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
906  m_innerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
907 
908  // Set offsets
909  m_innerAbsorberOffset[iblade] = GeoThreeVector(0., 0., (z1 + z2)/2.);
910  m_innerElectrodeOffset[iblade] = GeoThreeVector(0., 0., (z1 + z2)/2.);
911  }
912 }

◆ constructInnerLips()

void LArGeo::EMECAccordionConstruction::constructInnerLips ( double  innerLipLength1,
double  innerLipPosition1,
double  innerLipLength2,
double  innerLipPosition2 
)
private

Definition at line 725 of file EMECAccordionConstruction.cxx.

729 {
730  double dx, dy, dz, xoffset, yoffset, zoffset;
731  std::string name;
732  GeoShape* solid;
733 
734  // Contruct logical volumes for 1st lip
735  int iblade = 0;
736  dx = 0.5*m_innerAbsorberThickness;
737  dy = 0.5*innerLipLength1;
738  dz = 0.5*m_innerLipWidth;
739  name = m_nameInnerWheel + m_nameAbsorber + m_nameSuffix[iblade];
740  solid = new GeoBox(dx, dy, dz);
741  m_innerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
742 
743  name = m_nameInnerWheel + m_nameGlue + m_nameSuffix[iblade];
744  solid = new GeoBox(dx*m_innerGlueRatio, dy, dz);
745  m_innerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
746 
747  name = m_nameInnerWheel + m_nameLead + m_nameSuffix[iblade];
748  solid = new GeoBox(dx*m_innerLeadRatio, dy, dz);
749  m_innerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
750 
751  name = m_nameInnerWheel + m_nameElectrode + m_nameSuffix[iblade];
752  dx = 0.5*m_innerElectrodeThickness;
753  solid = new GeoBox(dx, dy, dz);
754  m_innerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
755 
756  // Set offsets
757  xoffset = 0.;
758  yoffset = m_innerWheelRmin[1] + innerLipPosition1;
759  zoffset = m_innerWheelZmin + dz;
760  m_innerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
761  m_innerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
762 
763  // Contruct logical volumes for 2nd lip
764  iblade = s_innerNoBlades - 1;
765  dx = 0.5*m_innerAbsorberThickness;
766  dy = 0.5*innerLipLength2;
767  dz = 0.5*m_innerLipWidth;
768  name = m_nameInnerWheel + m_nameAbsorber + m_nameSuffix[iblade];
769  solid = new GeoBox(dx, dy, dz);
770  m_innerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
771 
772  name = m_nameInnerWheel + m_nameGlue + m_nameSuffix[iblade];
773  solid = new GeoBox(dx*m_innerGlueRatio, dy, dz);
774  m_innerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
775 
776  name = m_nameInnerWheel + m_nameLead + m_nameSuffix[iblade];
777  solid = new GeoBox(dx*m_innerLeadRatio, dy, dz);
778  m_innerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
779 
780  name = m_nameInnerWheel + m_nameElectrode + m_nameSuffix[iblade];
781  dx = 0.5*m_innerElectrodeThickness;
782  solid = new GeoBox(dx, dy, dz);
783  m_innerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
784 
785  // Set offsets
786  xoffset = 0.;
787  yoffset = m_innerWheelRmin[s_innerNoBlades - 1] + innerLipPosition2;
788  zoffset = m_innerWheelZmax - dz;
789  m_innerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
790  m_innerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
791 }

◆ constructInnerSlices()

void LArGeo::EMECAccordionConstruction::constructInnerSlices ( )
private

Definition at line 683 of file EMECAccordionConstruction.cxx.

684 {
685  std::string name;
686  GeoShape* solid;
687  for (int islice = 0; islice < s_innerNoBlades; ++islice)
688  {
689  name = m_nameInnerWheel + m_nameSlice + m_nameSuffix[islice];
690  double dz = 0.5*(m_innerWheelZ[islice+1] - m_innerWheelZ[islice]);
691  solid = new GeoCons(m_innerWheelRmin[islice], m_innerWheelRmin[islice+1],
692  m_innerWheelRmax[islice], m_innerWheelRmax[islice+1],
693  dz, 0.*SI::deg, 360.*SI::deg);
694  m_innerSlice[islice] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLiquidArgon));
695  m_innerSliceOffset[islice] = GeoThreeVector(0., 0., m_innerWheelZ[islice] + dz);
696  }
697 }

◆ constructInnerWheelStructure()

void LArGeo::EMECAccordionConstruction::constructInnerWheelStructure ( bool  makeSlices = true)

Definition at line 1184 of file EMECAccordionConstruction.cxx.

1185 {
1186  bool makeSectors = false;
1187  int innerNoSectors = 0;
1188 
1189  // P R E L I M I N A R Y C A L C U L A T I O N S
1190  //
1191  setInnerWheelSlices(); // define thickness of slices in Inner Wheel
1192 
1193  // Get enginneering data of absorbers
1194  double innerUncutBladeWidthMin, innerUncutBladeWidthMax;
1195  double innerLipLength1, innerLipPosition1;
1196  double innerLipLength2, innerLipPosition2;
1197  getInnerAbsorberData(innerUncutBladeWidthMin, innerUncutBladeWidthMax,
1198  innerLipLength1, innerLipPosition1,
1199  innerLipLength2, innerLipPosition2);
1200  innerUncutBladeWidthMin *= m_kContraction;
1201  innerUncutBladeWidthMax *= m_kContraction;
1202  innerLipLength1 *= m_kContraction;
1203  innerLipPosition1 *= m_kContraction;
1204  innerLipLength2 *= m_kContraction;
1205  innerLipPosition2 *= m_kContraction;
1206 
1207  // C O M P U T E U N C U T B L A D E C O R N E R S
1208  //
1209  double wmin, wmax, thickness, rmin, rmax, zdel;
1210 
1211  // Compute Inner Absorber Blade corners
1212  GeoThreeVector innerCorners[8];
1213  wmin = innerUncutBladeWidthMin;
1214  wmax = innerUncutBladeWidthMax;
1215  thickness = m_innerAbsorberThickness;
1216  rmin = m_innerWheelRmin[1];
1217  rmax = m_innerWheelRmax[s_innerNoBlades - 1];
1218  zdel = m_innerHalfWaveWidth; // slice width
1219  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, innerCorners);
1220 
1221  // Compute Inner Electrode Blade corners
1222  GeoThreeVector innerElectrodeCorners[8];
1223  thickness = m_innerElectrodeThickness;
1224  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, innerElectrodeCorners);
1225 
1226  // C O N S T R U C T L O G I C A L V O L U M E S
1227  //
1228  // Compute X-scale factors for glue and lead in absorbers
1229  // Needed for construction of corresponding volumes
1230  m_innerGlueRatio = (m_innerLeadThickness + 2*m_innerGlueThickness)/m_innerAbsorberThickness;
1231  m_innerLeadRatio = m_innerLeadThickness/m_innerAbsorberThickness;
1232 
1233  // Construct Lips, set offsets for the case "no Slices, no Sectors"
1234  constructInnerLips(innerLipLength1, innerLipPosition1, innerLipLength2, innerLipPosition2);
1235 
1236  // Construct Blades, set offsets for the case "no Slices, no Sectors"
1237  constructInnerBlades(innerCorners, innerElectrodeCorners);
1238 
1239  // Construct Slices, set offsets
1240  constructInnerSlices();
1241 
1242  // Construct Sectors (disabled)
1243  // constructInnerSectors(innerNoSectors);
1244 
1245  // C O N S T R U C T P H Y S I C A L V O L U M E S
1246  //
1247  placeInnerGlueAndLead(); // place Glue and Lead in Inner Wheel Absorbers
1248  placeInnerSlices(makeSlices); // place Slices, if needed
1249  // PlaceInnerSectors(innerNoSectors, makeSlices, makeSectors); // disabled
1250  placeInnerAccordion(innerNoSectors, makeSlices, makeSectors); // place Absorbers and Electrodes
1251 }

◆ constructOuterBlades()

void LArGeo::EMECAccordionConstruction::constructOuterBlades ( const GeoThreeVector  outerCorners[8],
const GeoThreeVector  outerElectrodeCorners[8] 
)
private

Definition at line 920 of file EMECAccordionConstruction.cxx.

922 {
923  std::string name;
924  GeoShape* solid;
925 
926  for (int iblade = 1; iblade < s_outerNoBlades - 1; ++iblade)
927  {
928  int icase = (iblade%2 == 0) ? 2 : 3; // positive/negative inclination
929  if (iblade == 1) icase = 1; // first quater-wave
930  if (iblade == s_outerNoBlades - 2) icase = 4; // last quater-wave
931 
932  double z1 = m_outerWheelZ[iblade];
933  double r1min = m_outerWheelRmin[iblade];
934  double r1max = m_outerWheelRmax[iblade];
935  double z2 = m_outerWheelZ[iblade + 1];
936  double r2min = m_outerWheelRmin[iblade + 1];
937  double r2max = m_outerWheelRmax[iblade + 1];
938 
939  // Construct volumes for Absorber, Glue, Lead and Electrode
940  name = m_nameOuterWheel + m_nameAbsorber + m_nameSuffix[iblade];
941  solid = constructBlade(icase, outerCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
942  m_outerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
943 
944  name = m_nameOuterWheel + m_nameGlue + m_nameSuffix[iblade];
945  solid = constructBlade(icase, outerCorners, m_outerGlueRatio, z1, r1min, r1max, z2, r2min, r2max);
946  m_outerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
947 
948  name = m_nameOuterWheel + m_nameLead + m_nameSuffix[iblade];
949  solid = constructBlade(icase, outerCorners, m_outerLeadRatio, z1, r1min, r1max, z2, r2min, r2max);
950  m_outerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
951 
952  // Construct solid for Electrode
953  name = m_nameOuterWheel + m_nameElectrode + m_nameSuffix[iblade];
954  solid = constructBlade(icase, outerElectrodeCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
955  m_outerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
956 
957  // Set offsets
958  m_outerAbsorberOffset[iblade] = GeoThreeVector(0., 0., (z1 + z2)/2.);
959  m_outerElectrodeOffset[iblade] = GeoThreeVector(0., 0., (z1 + z2)/2.);
960  }
961 }

◆ constructOuterLips()

void LArGeo::EMECAccordionConstruction::constructOuterLips ( double  outerLipLength1,
double  outerLipPosition1,
double  outerLipLength2,
double  outerLipPosition2 
)
private

Definition at line 798 of file EMECAccordionConstruction.cxx.

802 {
803  double dx, dy, dz, xoffset, yoffset, zoffset;
804  std::string name;
805  GeoShape* solid;
806 
807  // Contruct logical volumes for 1st lip
808  int iblade = 0;
809  dx = 0.5*m_outerAbsorberThickness;
810  dy = 0.5*outerLipLength1;
811  dz = 0.5*m_outerLipWidth;
812  name = m_nameOuterWheel + m_nameAbsorber + m_nameSuffix[iblade];
813  solid = new GeoBox(dx, dy, dz);
814  m_outerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
815 
816  name = m_nameOuterWheel + m_nameGlue + m_nameSuffix[iblade];
817  solid = new GeoBox(dx*m_outerGlueRatio, dy, dz);
818  m_outerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
819 
820  name = m_nameOuterWheel + m_nameLead + m_nameSuffix[iblade];
821  solid = new GeoBox(dx*m_outerLeadRatio, dy, dz);
822  m_outerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
823 
824  name = m_nameOuterWheel + m_nameElectrode + m_nameSuffix[iblade];
825  dx = 0.5*m_outerElectrodeThickness;
826  solid = new GeoBox(dx, dy, dz);
827  m_outerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
828 
829  // Set offsets
830  xoffset = 0.;
831  yoffset = m_outerWheelRmin[1] + outerLipPosition1;
832  zoffset = m_outerWheelZmin + dz;
833  m_outerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
834  m_outerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
835 
836  // Contruct logical volumes for 2nd lip
837  iblade = s_outerNoBlades - 1;
838  dx = 0.5*m_outerAbsorberThickness;
839  dy = 0.5*outerLipLength2;
840  dz = 0.5*m_outerLipWidth;
841  name = m_nameOuterWheel + m_nameAbsorber + m_nameSuffix[iblade];
842  solid = new GeoBox(dx, dy, dz);
843  m_outerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
844 
845  name = m_nameOuterWheel + m_nameGlue + m_nameSuffix[iblade];
846  solid = new GeoBox(dx*m_outerGlueRatio, dy, dz);
847  m_outerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
848 
849  name = m_nameOuterWheel + m_nameLead + m_nameSuffix[iblade];
850  solid = new GeoBox(dx*m_outerLeadRatio, dy, dz);
851  m_outerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
852 
853  name = m_nameOuterWheel + m_nameElectrode + m_nameSuffix[iblade];
854  dx = 0.5*m_outerElectrodeThickness;
855  solid = new GeoBox(dx, dy, dz);
856  m_outerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
857 
858  // Set offsets
859  xoffset = 0.;
860  yoffset = m_outerWheelRmin[s_outerNoBlades -1] + outerLipPosition2;
861  zoffset = m_outerWheelZmax - dz;
862  m_outerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
863  m_outerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
864 }

◆ constructOuterSlices()

void LArGeo::EMECAccordionConstruction::constructOuterSlices ( )
private

Definition at line 703 of file EMECAccordionConstruction.cxx.

704 {
705  std::string name;
706  GeoShape* solid;
707  for (int islice = 0; islice < s_outerNoBlades; ++islice)
708  {
709  name = m_nameOuterWheel + m_nameSlice + m_nameSuffix[islice];
710  double dz = 0.5*(m_outerWheelZ[islice+1] - m_outerWheelZ[islice]);
711  solid = new GeoCons(m_outerWheelRmin[islice], m_outerWheelRmin[islice+1],
712  m_outerWheelRmax[islice], m_outerWheelRmax[islice+1],
713  dz, 0.*SI::deg, 360.*SI::deg);
714  m_outerSlice[islice] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLiquidArgon));
715  m_outerSliceOffset[islice] = GeoThreeVector(0., 0., m_outerWheelZ[islice] + dz);
716  }
717 }

◆ constructOuterWheelStructure()

void LArGeo::EMECAccordionConstruction::constructOuterWheelStructure ( bool  makeSlices = true)

Definition at line 1258 of file EMECAccordionConstruction.cxx.

1259 {
1260  bool makeSectors = false;
1261  int outerNoSectors = 0;
1262 
1263  // P R E L I M I N A R Y C A L C U L A T I O N S
1264  //
1265  setOuterWheelSlices(); // define thickness of slices in Outer Wheel
1266 
1267  // Get enginneering data of absorbers
1268  double outerUncutBladeWidthMin, outerUncutBladeWidthMax;
1269  double outerLipLength1, outerLipPosition1;
1270  double outerLipLength2, outerLipPosition2;
1271  getOuterAbsorberData(outerUncutBladeWidthMin, outerUncutBladeWidthMax,
1272  outerLipLength1, outerLipPosition1,
1273  outerLipLength2, outerLipPosition2);
1274  outerUncutBladeWidthMin *= m_kContraction;
1275  outerUncutBladeWidthMax *= m_kContraction;
1276  outerLipLength1 *= m_kContraction;
1277  outerLipPosition1 *= m_kContraction;
1278  outerLipLength2 *= m_kContraction;
1279  outerLipPosition2 *= m_kContraction;
1280 
1281  // C O M P U T E U N C U T B L A D E C O R N E R S
1282  //
1283  double wmin, wmax, thickness, rmin, rmax, zdel;
1284 
1285  // Compute Outer Absorber Blade corners
1286  GeoThreeVector outerCorners[8];
1287  wmin = outerUncutBladeWidthMin;
1288  wmax = outerUncutBladeWidthMax;
1289  thickness = m_outerAbsorberThickness;
1290  rmin = m_outerWheelRmin[1];
1291  rmax = m_outerWheelRmax[s_outerNoBlades - 1];
1292  zdel = m_outerHalfWaveWidth; // slice width
1293  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, outerCorners);
1294 
1295  // Compute Outer Electrode Blade corners
1296  GeoThreeVector outerElectrodeCorners[8];
1297  thickness = m_outerElectrodeThickness;
1298  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, outerElectrodeCorners);
1299 
1300  // C O N S T R U C T L O G I C A L V O L U M E S
1301  //
1302  // Compute X-scale factors for glue and lead in absorbers
1303  // Needed for construction of corresponding volumes
1304  m_outerGlueRatio = (m_outerLeadThickness + 2*m_outerGlueThickness)/m_outerAbsorberThickness;
1305  m_outerLeadRatio = m_outerLeadThickness/m_outerAbsorberThickness;
1306 
1307  // Construct Lips, set offsets for the case "no Slices, no Sectors"
1308  constructOuterLips(outerLipLength1, outerLipPosition1, outerLipLength2, outerLipPosition2);
1309 
1310  // Construct Blades, set offsets for the case "no Slices, no Sectors"
1311  constructOuterBlades(outerCorners, outerElectrodeCorners);
1312 
1313  // Construct Slices, set offsets
1314  constructOuterSlices();
1315 
1316  // Construct Sectors (disabled)
1317  // constructOuterSectors(outerNoSectors);
1318 
1319  // C O N S T R U C T P H Y S I C A L V O L U M E S
1320  //
1321  placeOuterGlueAndLead(); // place Glue and Lead in Outer Wheel Absorbers
1322  placeOuterSlices(makeSlices); // place Slices, if needed
1323  // PlaceOuterSectors(outerNoSectors, makeSlices, makeSectors); // disabled
1324  placeOuterAccordion(outerNoSectors, makeSlices, makeSectors); // place Absorbers and Electrodes
1325 }

◆ getBladeCorners()

void LArGeo::EMECAccordionConstruction::getBladeCorners ( double  wmin,
double  wmax,
double  thickness,
double  rmin,
double  rmax,
double  zdel,
GeoThreeVector  corners[8] 
) const
private

Definition at line 492 of file EMECAccordionConstruction.cxx.

495 {
496  double z = zdel/2.;
497 
498  double xmin = std::sqrt(wmin*wmin - zdel*zdel)/2.;
499  double dxmin = (thickness/2.)*(wmin/zdel);
500  double ymin = rmin;
501 
502  double xmax = std::sqrt(wmax*wmax - zdel*zdel)/2.;
503  double dxmax = (thickness/2.)*(wmax/zdel);
504  double xtmp = (xmax + dxmax);
505  double ymax = std::sqrt(rmax*rmax - xtmp*xtmp);
506 
507  corners[0] = GeoThreeVector(-xmin + dxmin, ymin, -z);
508  corners[1] = GeoThreeVector(-xmin - dxmin, ymin, -z);
509  corners[2] = GeoThreeVector(-xmax - dxmax, ymax, -z);
510  corners[3] = GeoThreeVector(-xmax + dxmax, ymax, -z);
511 
512  corners[4] = GeoThreeVector(+xmin + dxmin, ymin, +z);
513  corners[5] = GeoThreeVector(+xmin - dxmin, ymin, +z);
514  corners[6] = GeoThreeVector(+xmax - dxmax, ymax, +z);
515  corners[7] = GeoThreeVector(+xmax + dxmax, ymax, +z);
516 }

◆ getBottomCutPlane()

LArGeo::EMECAccordionConstruction::CutPlane LArGeo::EMECAccordionConstruction::getBottomCutPlane ( double  zmin,
double  rmin,
double  zmax,
double  rmax 
) const
private

Definition at line 523 of file EMECAccordionConstruction.cxx.

525 {
526  GeoThreeVector pmin(0, rmin, zmin);
527  GeoThreeVector pmax(0, rmax, zmax);
528  GeoThreeVector v = (pmax - pmin).normalized();
529 
530  LArGeo::EMECAccordionConstruction::CutPlane plane;
531  plane.m_n = GeoThreeVector(0., -v.z(), v.y());
532  plane.m_d = -plane.m_n.dot(pmin);
533  return plane;
534 }

◆ getInnerAbsorberData()

void LArGeo::EMECAccordionConstruction::getInnerAbsorberData ( double &  wmin,
double &  wmax,
double &  llip1,
double &  ylip1,
double &  llip2,
double &  ylip2 
) const
private

Definition at line 332 of file EMECAccordionConstruction.cxx.

335 {
336  // Points taken from technical drawing
337  GeoTwoVector A[14+1] = {}; // A[0] is not used
338  A[1] = GeoTwoVector( 1.700, 1019.908) * SI::mm;
339  A[2] = GeoTwoVector( 36.595, 1022.643) * SI::mm;
340  A[3] = GeoTwoVector(110.351, 1024.416) * SI::mm;
341  A[4] = GeoTwoVector(184.545, 1020.841) * SI::mm;
342  A[5] = GeoTwoVector(258.785, 1011.865) * SI::mm;
343  A[6] = GeoTwoVector(332.678, 997.463) * SI::mm;
344  A[7] = GeoTwoVector(405.824, 977.640) * SI::mm;
345  A[8] = GeoTwoVector(477.824, 952.430) * SI::mm;
346  A[9] = GeoTwoVector(548.280, 921.895) * SI::mm;
347  A[10] = GeoTwoVector(616.797, 886.130) * SI::mm;
348  A[11] = GeoTwoVector(682.985, 845.257) * SI::mm;
349  A[12] = GeoTwoVector(746.463, 799.426) * SI::mm;
350  A[13] = GeoTwoVector(806.859, 748.819) * SI::mm;
351  A[14] = GeoTwoVector(835.788, 723.065) * SI::mm;
352 
353  GeoTwoVector B[14+1] = {}; // B[0] is not used
354  B[1] = GeoTwoVector( 1.132, 710.702) * SI::mm;
355  B[2] = GeoTwoVector( 25.476, 711.930) * SI::mm;
356  B[3] = GeoTwoVector( 76.670, 711.749) * SI::mm;
357  B[4] = GeoTwoVector(127.967, 707.873) * SI::mm;
358  B[5] = GeoTwoVector(179.099, 700.288) * SI::mm;
359  B[6] = GeoTwoVector(229.797, 688.988) * SI::mm;
360  B[7] = GeoTwoVector(279.791, 674.025) * SI::mm;
361  B[8] = GeoTwoVector(328.814, 655.414) * SI::mm;
362  B[9] = GeoTwoVector(376.600, 633.227) * SI::mm;
363  B[10] = GeoTwoVector(422.886, 607.546) * SI::mm;
364  B[11] = GeoTwoVector(467.418, 578.473) * SI::mm;
365  B[12] = GeoTwoVector(509.946, 546.127) * SI::mm;
366  B[13] = GeoTwoVector(550.228, 510.649) * SI::mm;
367  B[14] = GeoTwoVector(568.629, 492.593) * SI::mm;
368 
369  GeoTwoVector C[4+1] = {}; // C[0] is not used
370  C[1] = GeoTwoVector( -1.754, 978.281) * SI::mm;
371  C[2] = GeoTwoVector( 1.668, 978.279) * SI::mm;
372  C[3] = GeoTwoVector(803.643, 696.378) * SI::mm;
373  C[4] = GeoTwoVector(805.917, 693.745) * SI::mm;
374 
375  GeoTwoVector D[4+1] = {}; // D[0] is not used
376  D[1] = GeoTwoVector( -1.894, 786.281) * SI::mm;
377  D[2] = GeoTwoVector( 1.186, 786.279) * SI::mm;
378  D[3] = GeoTwoVector(610.986, 529.319) * SI::mm;
379  D[4] = GeoTwoVector(613.041, 526.940) * SI::mm;
380 
381  // Compute angle between rays
382  int k1 = 2, k2 = 13; // take rays 2 and 13
383  double cosa = A[k1].dot(A[k2])/(A[k1].norm()*A[k2].norm());
384  double ang = std::acos(cosa)/(k2 - k1);
385 
386  // Compute bottom and top width of the accordion blade
387  double rmin = B[1].norm();
388  double rmax = A[14].norm();
389  wmin = 2.*rmin*std::sin(ang/2.);
390  wmax = 2.*rmax*std::sin(ang/2.);
391 
392  // Compute length and position of the first lip
393  llip1 = (C[2] - D[2]).norm();
394  ylip1 = (D[2] - B[1]).norm() + llip1/2.;
395 
396  // Compute length and position of the last lip
397  llip2 = (C[3] - D[3]).norm();
398  ylip2 = (D[3] - B[14]).norm() + llip2/2.;
399 }

◆ getOuterAbsorberData()

void LArGeo::EMECAccordionConstruction::getOuterAbsorberData ( double &  wmin,
double &  wmax,
double &  llip1,
double &  ylip1,
double &  llip2,
double &  ylip2 
) const
private

Definition at line 406 of file EMECAccordionConstruction.cxx.

409 {
410  // Points taken from technical drawing
411  GeoTwoVector A[20+1] = {}; // A[0] is not used
412  A[1] = GeoTwoVector( 1.773, 3438.343) * SI::mm;
413  A[2] = GeoTwoVector( 26.515, 3445.688) * SI::mm;
414  A[3] = GeoTwoVector( 79.893, 3460.218) * SI::mm;
415  A[4] = GeoTwoVector(133.523, 3468.701) * SI::mm;
416  A[5] = GeoTwoVector(186.888, 3466.236) * SI::mm;
417  A[6] = GeoTwoVector(240.209, 3462.949) * SI::mm;
418  A[7] = GeoTwoVector(293.473, 3458.842) * SI::mm;
419  A[8] = GeoTwoVector(346.668, 3453.916) * SI::mm;
420  A[9] = GeoTwoVector(399.780, 3448.172) * SI::mm;
421  A[10] = GeoTwoVector(452.798, 3441.612) * SI::mm;
422  A[11] = GeoTwoVector(505.708, 3434.236) * SI::mm;
423  A[12] = GeoTwoVector(558.499, 3426.047) * SI::mm;
424  A[13] = GeoTwoVector(611.157, 3417.046) * SI::mm;
425  A[14] = GeoTwoVector(663.670, 3407.236) * SI::mm;
426  A[15] = GeoTwoVector(716.027, 3396.619) * SI::mm;
427  A[16] = GeoTwoVector(768.214, 3385.198) * SI::mm;
428  A[17] = GeoTwoVector(820.219, 3372.975) * SI::mm;
429  A[18] = GeoTwoVector(872.029, 3359.953) * SI::mm;
430  A[19] = GeoTwoVector(923.633, 3346.135) * SI::mm;
431  A[20] = GeoTwoVector(947.625, 3339.413) * SI::mm;
432 
433  GeoTwoVector B[20+1] = {}; // B[0] is not used
434  B[1] = GeoTwoVector( 0.810, 2046.995) * SI::mm;
435  B[2] = GeoTwoVector( 15.769, 2049.165) * SI::mm;
436  B[3] = GeoTwoVector( 47.410, 2053.375) * SI::mm;
437  B[4] = GeoTwoVector( 79.185, 2057.095) * SI::mm;
438  B[5] = GeoTwoVector(111.086, 2060.323) * SI::mm;
439  B[6] = GeoTwoVector(143.105, 2063.055) * SI::mm;
440  B[7] = GeoTwoVector(175.234, 2065.288) * SI::mm;
441  B[8] = GeoTwoVector(207.466, 2067.020) * SI::mm;
442  B[9] = GeoTwoVector(239.792, 2068.248) * SI::mm;
443  B[10] = GeoTwoVector(272.205, 2068.969) * SI::mm;
444  B[11] = GeoTwoVector(304.697, 2069.181) * SI::mm;
445  B[12] = GeoTwoVector(337.260, 2068.883) * SI::mm;
446  B[13] = GeoTwoVector(369.885, 2068.071) * SI::mm;
447  B[14] = GeoTwoVector(402.566, 2066.744) * SI::mm;
448  B[15] = GeoTwoVector(435.293, 2064.899) * SI::mm;
449  B[16] = GeoTwoVector(468.058, 2062.536) * SI::mm;
450  B[17] = GeoTwoVector(500.853, 2059.653) * SI::mm;
451  B[18] = GeoTwoVector(533.670, 2056.247) * SI::mm;
452  B[19] = GeoTwoVector(566.501, 2052.318) * SI::mm;
453  B[20] = GeoTwoVector(582.048, 2050.271) * SI::mm;
454 
455  GeoTwoVector C[4+1] = {}; // C[0] is not used
456  C[1] = GeoTwoVector( -1.682, 3416.858) * SI::mm;
457  C[2] = GeoTwoVector( 1.756, 3416.858) * SI::mm;
458  C[3] = GeoTwoVector(932.782, 3287.070) * SI::mm;
459  C[3] = GeoTwoVector(936.090, 3286.130) * SI::mm;
460 
461  GeoTwoVector D[4+1] = {}; // D[0] is not used
462  D[1] = GeoTwoVector( -1.975, 2088.411) * SI::mm;
463  D[2] = GeoTwoVector( 0.839, 2088.410) * SI::mm;
464  D[3] = GeoTwoVector(593.526, 2090.743) * SI::mm;
465  D[4] = GeoTwoVector(596.271, 2089.963) * SI::mm;
466 
467  // Compute angle between rays
468  int k1 = 4, k2 = 19; // take rays 4 and 19
469  double cosa = A[k1].dot(A[k2])/(A[k1].norm()*A[k2].norm());
470  double ang = std::acos(cosa)/(k2 - k1);
471 
472  // Compute bottom and top width of the accordion blade
473  double rmin = B[1].norm();
474  double rmax = A[19].norm(); // A[19] has slightly bigger radius than A[20]
475  wmin = 2.*rmin*std::sin(ang/2.);
476  wmax = 2.*rmax*std::sin(ang/2.);
477 
478  // Compute length and position of the first lip
479  llip1 = (C[2] - D[2]).norm();
480  ylip1 = (D[2] - B[1]).norm() + llip1/2.;
481 
482  // Compute length and position of the last lip
483  llip2 = (C[3] - D[3]).norm();
484  ylip2 = (D[3] - B[20]).norm() + llip2/2.;
485 }

◆ getTopCutPlane()

LArGeo::EMECAccordionConstruction::CutPlane LArGeo::EMECAccordionConstruction::getTopCutPlane ( double  zmin,
double  rmin,
double  zmax,
double  rmax,
const GeoThreeVector  corners[8] 
) const
private

Definition at line 541 of file EMECAccordionConstruction.cxx.

544 {
545  GeoThreeVector pbot(std::min(corners[0].x(), corners[1].x()), corners[0].y(), 0);
546  GeoThreeVector ptop(std::min(corners[2].x(), corners[3].x()), corners[3].y(), 0);
547 
548  GeoThreeVector v = (ptop - pbot).normalized();
549  double d = v.x()*pbot.y() - v.y()*pbot.x();
550  double r = ptop.norm();
551  double l = std::sqrt(r*r - d*d);
552  double wmin = std::sqrt(rmin*rmin - d*d);
553  double wmax = std::sqrt(rmax*rmax - d*d);
554  double ymin = ptop.y() - v.y()*(l - wmin);
555  double ymax = ptop.y() - v.y()*(l - wmax);
556 
557  GeoThreeVector pmin(0, ymin, zmin);
558  GeoThreeVector pmax(0, ymax, zmax);
559  v = (pmax - pmin).normalized();
560 
561  LArGeo::EMECAccordionConstruction::CutPlane plane;
562  plane.m_n = GeoThreeVector(0., -v.z(), v.y());
563  plane.m_d = -plane.m_n.dot(pmin);
564  return plane;
565 }

◆ IntersectionPoint()

GeoThreeVector LArGeo::EMECAccordionConstruction::IntersectionPoint ( const GeoThreeVector &  p1,
const GeoThreeVector &  p2,
const CutPlane &  plane 
) const
private

Definition at line 572 of file EMECAccordionConstruction.cxx.

575 {
576  double d1 = plane.m_n.dot(p1) + plane.m_d;
577  double d2 = plane.m_n.dot(p2) + plane.m_d;
578  return (d2*p1 - d1*p2)/(d2 - d1);
579 }

◆ placeInnerAccordion()

void LArGeo::EMECAccordionConstruction::placeInnerAccordion ( int  innerNoSectors,
bool  makeSlices,
bool  makeSectors 
)
private

Definition at line 1028 of file EMECAccordionConstruction.cxx.

1031 {
1032  int nphi = (makeSectors) ? m_innerNoElectrodes/innerNoSectors : m_innerNoElectrodes;
1033  double dphi = SI::twopi/m_innerNoElectrodes;
1034  GeoPhysVol* mother = nullptr;
1035 
1036  // Place Electordes
1037  for (int iphi = 0; iphi < nphi; ++iphi)
1038  {
1039  GeoTrf::RotateZ3D rotation(dphi*iphi - SI::halfpi);
1040  int copyNo = iphi + 1;
1041  for (int iblade = 0; iblade < s_innerNoBlades; ++iblade)
1042  {
1043  if (makeSlices) mother = m_innerSlice[iblade];
1044  if (makeSectors) mother = m_innerSector[iblade];
1045  if (makeSlices || makeSectors)
1046  {
1047  double x = m_innerElectrodeOffset[iblade].x();
1048  double y = m_innerElectrodeOffset[iblade].y();
1049  double z = 0;
1050  GeoTrf::Translate3D translation(x, y, z);
1051  mother->add(new GeoIdentifierTag(copyNo));
1052  mother->add(new GeoTransform(rotation*translation));
1053  mother->add(m_innerElectrode[iblade]);
1054  }
1055  else
1056  {
1057  double x = m_innerElectrodeOffset[iblade].x();
1058  double y = m_innerElectrodeOffset[iblade].y();
1059  double z = m_innerElectrodeOffset[iblade].z();
1060  GeoTrf::Translate3D translation(x, y, z);
1061  m_innerWheel->add(new GeoIdentifierTag(copyNo));
1062  m_innerWheel->add(new GeoTransform(rotation*translation));
1063  m_innerWheel->add(m_innerElectrode[iblade]);
1064  }
1065  }
1066  }
1067 
1068  // Place Absorbers
1069  for (int iphi = 0; iphi < nphi; ++iphi)
1070  {
1071  GeoTrf::RotateZ3D rotation(dphi*(iphi+0.5) - SI::halfpi);
1072  int copyNo = iphi + 1;
1073  for (int iblade = 0; iblade < s_innerNoBlades; ++iblade)
1074  {
1075  if (makeSlices) mother = m_innerSlice[iblade];
1076  if (makeSectors) mother = m_innerSector[iblade];
1077  if (makeSlices || makeSectors)
1078  {
1079  double x = m_innerAbsorberOffset[iblade].x();
1080  double y = m_innerAbsorberOffset[iblade].y();
1081  double z = 0;
1082  GeoTrf::Translate3D translation(x, y, z);
1083  mother->add(new GeoIdentifierTag(copyNo));
1084  mother->add(new GeoTransform(rotation*translation));
1085  mother->add(m_innerAbsorber[iblade]);
1086  }
1087  else
1088  {
1089  double x = m_innerAbsorberOffset[iblade].x();
1090  double y = m_innerAbsorberOffset[iblade].y();
1091  double z = m_innerAbsorberOffset[iblade].z();
1092  GeoTrf::Translate3D translation(x, y, z);
1093  m_innerWheel->add(new GeoIdentifierTag(copyNo));
1094  m_innerWheel->add(new GeoTransform(rotation*translation));
1095  m_innerWheel->add(m_innerAbsorber[iblade]);
1096  }
1097  }
1098  }
1099 }

◆ placeInnerGlueAndLead()

void LArGeo::EMECAccordionConstruction::placeInnerGlueAndLead ( )
private

Definition at line 967 of file EMECAccordionConstruction.cxx.

968 {
969  for (int iblade = 0; iblade < s_innerNoBlades; ++iblade)
970  {
971  m_innerGlue[iblade]->add(m_innerLead[iblade]);
972  m_innerAbsorber[iblade]->add(m_innerGlue[iblade]);
973  }
974 }

◆ placeInnerSlices()

void LArGeo::EMECAccordionConstruction::placeInnerSlices ( bool  makeSlices)
private

Definition at line 993 of file EMECAccordionConstruction.cxx.

994 {
995  if (!makeSlices) return;
996  for (int islice = 0; islice < s_innerNoBlades; ++islice)
997  {
998  double x = m_innerSliceOffset[islice].x();
999  double y = m_innerSliceOffset[islice].y();
1000  double z = m_innerSliceOffset[islice].z();
1001  m_innerWheel->add(new GeoTransform(GeoTrf::Translate3D(x, y, z)));
1002  m_innerWheel->add(m_innerSlice[islice]);
1003  }
1004 }

◆ placeOuterAccordion()

void LArGeo::EMECAccordionConstruction::placeOuterAccordion ( int  outerNoSectors,
bool  makeSlices,
bool  makeSectors 
)
private

Definition at line 1106 of file EMECAccordionConstruction.cxx.

1109 {
1110  int nphi = (makeSectors) ? m_outerNoElectrodes/outerNoSectors : m_outerNoElectrodes;
1111  double dphi = SI::twopi/m_outerNoElectrodes;
1112  GeoPhysVol* mother = nullptr;
1113 
1114  // Place Electordes
1115  for (int iphi = 0; iphi < nphi; ++iphi)
1116  {
1117  GeoTrf::RotateZ3D rotation(dphi*iphi - SI::halfpi);
1118  int copyNo = iphi + 1;
1119  for (int iblade = 0; iblade < s_outerNoBlades; ++iblade)
1120  {
1121  if (makeSlices) mother = m_outerSlice[iblade];
1122  if (makeSectors) mother = m_outerSector[iblade];
1123  if (makeSlices || makeSectors)
1124  {
1125  double x = m_outerElectrodeOffset[iblade].x();
1126  double y = m_outerElectrodeOffset[iblade].y();
1127  double z = 0;
1128  GeoTrf::Translate3D translation(x, y, z);
1129  mother->add(new GeoIdentifierTag(copyNo));
1130  mother->add(new GeoTransform(rotation*translation));
1131  mother->add(m_outerElectrode[iblade]);
1132  }
1133  else
1134  {
1135  double x = m_outerElectrodeOffset[iblade].x();
1136  double y = m_outerElectrodeOffset[iblade].y();
1137  double z = m_outerElectrodeOffset[iblade].z();
1138  GeoTrf::Translate3D translation(x, y, z);
1139  m_outerWheel->add(new GeoIdentifierTag(copyNo));
1140  m_outerWheel->add(new GeoTransform(rotation*translation));
1141  m_outerWheel->add(m_outerElectrode[iblade]);
1142  }
1143  }
1144  }
1145 
1146  // Place Absorbers
1147  for (int iphi = 0; iphi < nphi; ++iphi)
1148  {
1149  GeoTrf::RotateZ3D rotation(dphi*(iphi+0.5) - SI::halfpi);
1150  int copyNo = iphi + 1;
1151  for (int iblade = 0; iblade < s_outerNoBlades; ++iblade)
1152  {
1153  if (makeSlices) mother = m_outerSlice[iblade];
1154  if (makeSectors) mother = m_outerSector[iblade];
1155  if (makeSlices || makeSectors)
1156  {
1157  double x = m_outerAbsorberOffset[iblade].x();
1158  double y = m_outerAbsorberOffset[iblade].y();
1159  double z = 0;
1160  GeoTrf::Translate3D translation(x, y, z);
1161  mother->add(new GeoIdentifierTag(copyNo));
1162  mother->add(new GeoTransform(rotation*translation));
1163  mother->add(m_outerAbsorber[iblade]);
1164  }
1165  else
1166  {
1167  double x = m_outerAbsorberOffset[iblade].x();
1168  double y = m_outerAbsorberOffset[iblade].y();
1169  double z = m_outerAbsorberOffset[iblade].z();
1170  GeoTrf::Translate3D translation(x, y, z);
1171  m_outerWheel->add(new GeoIdentifierTag(copyNo));
1172  m_outerWheel->add(new GeoTransform(rotation*translation));
1173  m_outerWheel->add(m_outerAbsorber[iblade]);
1174  }
1175  }
1176  }
1177 }

◆ placeOuterGlueAndLead()

void LArGeo::EMECAccordionConstruction::placeOuterGlueAndLead ( )
private

Definition at line 980 of file EMECAccordionConstruction.cxx.

981 {
982  for (int iblade = 0; iblade < s_outerNoBlades; ++iblade)
983  {
984  m_outerGlue[iblade]->add(m_outerLead[iblade]);
985  m_outerAbsorber[iblade]->add(m_outerGlue[iblade]);
986  }
987 }

◆ placeOuterSlices()

void LArGeo::EMECAccordionConstruction::placeOuterSlices ( bool  makeSlices)
private

Definition at line 1010 of file EMECAccordionConstruction.cxx.

1011 {
1012  if (!makeSlices) return;
1013  for (int islice = 0; islice < s_outerNoBlades; ++islice)
1014  {
1015  double x = m_outerSliceOffset[islice].x();
1016  double y = m_outerSliceOffset[islice].y();
1017  double z = m_outerSliceOffset[islice].z();
1018  m_outerWheel->add(new GeoTransform(GeoTrf::Translate3D(x, y, z)));
1019  m_outerWheel->add(m_outerSlice[islice]);
1020  }
1021 }

◆ setInnerWheel()

void LArGeo::EMECAccordionConstruction::setInnerWheel ( GeoFullPhysVol *  innerWheel)

Definition at line 192 of file EMECAccordionConstruction.cxx.

193 {
194  m_innerWheel = innerWheel;
195  const GeoShape* shape = innerWheel->getLogVol()->getShape();
196  if (shape->type() != "Pcon") {
197  throw std::runtime_error( "LArGeo::EMECAccordionConstruction::setInnerWheel: unexpected shape type '"+ shape->type() + "', expected 'Pcon'!");
198  }
199  const GeoPcon* pcon = (GeoPcon *)shape;
200  auto nplanes = pcon->getNPlanes();
201  if (nplanes != 2) {
202  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setInnerWheel: wrong number of Z planes '" + std::to_string(nplanes) + "', expected '2'!");
203  }
204  for (unsigned int i = 0; i < nplanes; ++i)
205  {
206  m_zWheelInner[i] = pcon->getZPlane(i);
207  m_rMinInner[i] = pcon->getRMinPlane(i);
208  m_rMaxInner[i] = pcon->getRMaxPlane(i);
209  }
210  // Set Inner Wheel base name
211  m_nameInnerWheel = innerWheel->getLogVol()->getName();
212 }

◆ setInnerWheelSlices()

void LArGeo::EMECAccordionConstruction::setInnerWheelSlices ( )
private

Definition at line 245 of file EMECAccordionConstruction.cxx.

246 {
247  if (!m_innerWheel)
248  {
249  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setInnerWheelSlices: Inner Wheel volume is not set!" );
250  }
251  // Compute slices
252  m_innerWheelRminIncrement = (m_rMinInner[1] - m_rMinInner[0])/(m_zWheelInner[1] - m_zWheelInner[0]);
253  m_innerWheelRmaxIncrement = (m_rMaxInner[1] - m_rMaxInner[0])/(m_zWheelInner[1] - m_zWheelInner[0]);
254  m_innerWheelZmin = m_zWheelInner[0];
255  m_innerWheelZmax = m_zWheelInner[1];
256 
257  m_innerWheelZ[0] = m_innerWheelZmin;
258  m_innerWheelZ[1] = m_innerWheelZ[0] + m_innerLipWidth;
259  m_innerWheelZ[2] = m_innerWheelZ[1] + m_innerQuaterWaveWidth;
260  for (int i = 3; i < s_innerNoBlades - 1; ++i)
261  {
262  m_innerWheelZ[i] = m_innerWheelZ[i - 1] + m_innerHalfWaveWidth;
263  }
264  m_innerWheelZ[s_innerNoBlades] = m_innerWheelZmax;
265  m_innerWheelZ[s_innerNoBlades - 1] = m_innerWheelZ[s_innerNoBlades] - m_innerLipWidth;
266  for (int i = 0; i < s_innerNoBlades + 1; ++i)
267  {
268  m_innerWheelRmin[i] = m_rMinInner[0] + (m_innerWheelZ[i] - m_innerWheelZ[0])*m_innerWheelRminIncrement;
269  m_innerWheelRmax[i] = m_rMaxInner[0] + (m_innerWheelZ[i] - m_innerWheelZ[0])*m_innerWheelRmaxIncrement;
270  }
271 }

◆ setMaterial()

void LArGeo::EMECAccordionConstruction::setMaterial ( const std::string &  name,
const GeoMaterial *  material 
)

Definition at line 313 of file EMECAccordionConstruction.cxx.

315 {
316  if (name == "LiquidArgon") m_materialLiquidArgon = material;
317  else if (name == "Kapton") m_materialKapton = material;
318  else if (name == "Lead" ) m_materialLead = material;
319  else if (name == "Steel" ) m_materialSteel = material;
320  else if (name == "Glue" ) m_materialGlue = material;
321  else
322  {
323  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setMaterial: unexpected material name '" + name + "'!");
324  }
325 }

◆ setOuterWheel()

void LArGeo::EMECAccordionConstruction::setOuterWheel ( GeoFullPhysVol *  outerWheel)

Definition at line 218 of file EMECAccordionConstruction.cxx.

219 {
220  m_outerWheel = outerWheel;
221  const GeoShape* shape = outerWheel->getLogVol()->getShape();
222  if (shape->type() != "Pcon") {
223  throw std::runtime_error( "LArGeo::EMECAccordionConstruction::setOuterWheel: unexpected shape type '"+ shape->type() + "', expected 'Pcon'!");
224 
225  }
226  const GeoPcon* pcon = (GeoPcon *)shape;
227  auto nplanes = pcon->getNPlanes();
228  if (nplanes != 3) {
229  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setOuterWheel: wrong number of Z planes" + std::to_string(nplanes) + "', expected '3'!" );
230  }
231  for (unsigned int i = 0; i < nplanes; ++i)
232  {
233  m_zWheelOuter[i] = pcon->getZPlane(i);
234  m_rMinOuter[i] = pcon->getRMinPlane(i);
235  m_rMaxOuter[i] = pcon->getRMaxPlane(i);
236  }
237  // Set Outer Wheel base name
238  m_nameOuterWheel = outerWheel->getLogVol()->getName();
239 }

◆ setOuterWheelSlices()

void LArGeo::EMECAccordionConstruction::setOuterWheelSlices ( )
private

Definition at line 277 of file EMECAccordionConstruction.cxx.

278 {
279  if (!m_outerWheel)
280  {
281  throw std::runtime_error( "LArGeo::EMECAccordionConstruction::setOuterWheelSlices: Outer Wheel volume is not set!");
282  }
283  // Compute slices
284  m_outerWheelRminIncrement[0] = (m_rMinOuter[1] - m_rMinOuter[0])/(m_zWheelOuter[1] - m_zWheelOuter[0]);
285  m_outerWheelRminIncrement[1] = (m_rMinOuter[2] - m_rMinOuter[1])/(m_zWheelOuter[2] - m_zWheelOuter[1]);
286  m_outerWheelRmaxIncrement[0] = (m_rMaxOuter[1] - m_rMaxOuter[0])/(m_zWheelOuter[1] - m_zWheelOuter[0]);
287  m_outerWheelRmaxIncrement[1] = (m_rMaxOuter[2] - m_rMaxOuter[1])/(m_zWheelOuter[2] - m_zWheelOuter[1]);
288  m_outerWheelZmin = m_zWheelOuter[0];
289  m_outerWheelZmax = m_zWheelOuter[2];
290 
291  m_outerWheelZ[0] = m_outerWheelZmin;
292  m_outerWheelZ[1] = m_outerWheelZ[0] + m_outerLipWidth;
293  m_outerWheelZ[2] = m_outerWheelZ[1] + m_outerQuaterWaveWidth;
294  for (int i = 3; i < s_outerNoBlades - 1; ++i)
295  {
296  m_outerWheelZ[i] = m_outerWheelZ[i - 1] + m_outerHalfWaveWidth;
297  }
298  m_outerWheelZ[s_outerNoBlades] = m_outerWheelZmax;
299  m_outerWheelZ[s_outerNoBlades - 1] = m_outerWheelZ[s_outerNoBlades] - m_outerLipWidth;
300  for (int i = 0; i < s_outerNoBlades + 1; ++i)
301  {
302  m_outerWheelRmin[i] = m_rMinOuter[0] + (m_outerWheelZ[i] - m_outerWheelZ[0])*m_outerWheelRminIncrement[0];
303  m_outerWheelRmax[i] = m_rMaxOuter[0] + (m_outerWheelZ[i] - m_outerWheelZ[0])*m_outerWheelRmaxIncrement[0];
304  if (m_outerWheelRmax[i] > m_rMaxOuter[2]) m_outerWheelRmax[i] = m_rMaxOuter[2]; // 2034 mm starting from i = 3
305  }
306 }

◆ setWheelParameters()

void LArGeo::EMECAccordionConstruction::setWheelParameters ( )

Definition at line 51 of file EMECAccordionConstruction.cxx.

52 {
53  ISvcLocator *svcLocator = Gaudi::svcLocator();
54  SmartIF<StoreGateSvc> detStore{svcLocator->service("DetectorStore")};
55  if(!detStore.isValid()) {
56  throw std::runtime_error("Error in EndcapCryostatConstruction, cannot access DetectorStore");
57  }
58 
59  // Get GeoModelSvc and RDBAccessSvc
60 
61  SmartIF<IRDBAccessSvc> rdbAccess{svcLocator->service("RDBAccessSvc")};
62  if(!rdbAccess.isValid()){
63  throw std::runtime_error("EMECConstruction: cannot locate RDBAccessSvc!");
64  }
65 
66  SmartIF<IGeoModelSvc> geoModelSvc{svcLocator->service("GeoModelSvc")};
67  if(!geoModelSvc.isValid()) {
68  throw std::runtime_error("EMECAccordionConstruction: cannot locate GeoModelSvc!");
69  }
70 
71  DecodeVersionKey larVersionKey(geoModelSvc, "LAr");
72  IRDBRecordset_ptr DB_EmecGeometry = rdbAccess->getRecordsetPtr("EmecGeometry", larVersionKey.tag(), larVersionKey.node());
73  if(DB_EmecGeometry->size() == 0){
74  DB_EmecGeometry = rdbAccess->getRecordsetPtr("EmecGeometry", "EmecGeometry-00");
75  }
76 
77  IRDBRecordset_ptr emecWheelParameters = rdbAccess->getRecordsetPtr("EmecWheelParameters", larVersionKey.tag(), larVersionKey.node());
78  if(emecWheelParameters->size() == 0){
79  emecWheelParameters = rdbAccess->getRecordsetPtr("EmecWheelParameters", "EmecWheelParameters-00");
80  }
81 
82 
83  IRDBRecordset_ptr emecMagicNumbers = rdbAccess->getRecordsetPtr("EmecMagicNumbers", larVersionKey.tag(), larVersionKey.node());
84  if(emecMagicNumbers->size() == 0){
85  emecMagicNumbers = rdbAccess->getRecordsetPtr("EmecMagicNumbers", "EmecMagicNumbers-00");
86  }
87 
88  IRDBRecordset_ptr coldContraction = rdbAccess->getRecordsetPtr("ColdContraction", larVersionKey.tag(), larVersionKey.node());
89  if(coldContraction->size() == 0){
90  coldContraction = rdbAccess->getRecordsetPtr("ColdContraction", "ColdContraction-00");
91  }
92 
93  IRDBRecordset_ptr emecFan = rdbAccess->getRecordsetPtr("EmecFan", larVersionKey.tag(), larVersionKey.node());
94  if(emecFan->size() == 0){
95  emecFan = rdbAccess->getRecordsetPtr("EmecFan", "EmecFan-00");
96  }
97 
98 
99  // Inner wheel accordion wave parameters
100  m_innerNoAbsorbes = (*emecWheelParameters)[0]->getInt("NABS"); // 256
101  m_innerNoElectrodes = (*emecWheelParameters)[0]->getInt("NABS"); // 256
102  m_innerNoWaves = (*emecWheelParameters)[0]->getInt("NACC"); // 6
103 
104  m_innerLipWidth = (*emecMagicNumbers)[0]->getDouble("STRAIGHTSTARTSECTION") * SI::mm; // 2 mm
105  m_innerWaveZoneWidth = (*emecMagicNumbers)[0]->getDouble("ACTIVELENGTH") * SI::mm; // 510 mm
106  m_innerWheelWidth = m_innerWaveZoneWidth + 2*m_innerLipWidth; // 514 mm
107  m_innerWaveWidth = m_innerWaveZoneWidth/m_innerNoWaves; // 510/6 = 85 mm
108  m_innerHalfWaveWidth = m_innerWaveWidth/2;
109  m_innerQuaterWaveWidth = m_innerWaveWidth/4;
110 
111  // Check values
112  if (m_innerNoAbsorbes != 256) {
113  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of absorbers. (NABS = " + std::to_string( m_innerNoAbsorbes) + ") for Inner Wheel, expected 256!");
114  }
115  if (m_innerNoWaves != 6) {
116  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of waves. (NACC = " + std::to_string( m_innerNoAbsorbes ) + ") for Inner Wheel, expected 6!");
117  }
118  if (m_innerLipWidth != 2 * SI::mm) {
119  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong width of absorber lips. (STRAIGHTSTARTSECTION = " + std::to_string( m_innerNoAbsorbes/SI::mm) + "), expected 2 mm!" );
120  }
121  if (m_innerWaveZoneWidth != 510 * SI::mm) {
122  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong width of absorber active zone. (ACTIVELENGTH = " + std::to_string(m_innerWaveZoneWidth/SI::mm) + "), expected 510 mm!");
123  }
124 
125  // Outer wheel accordion wave parameters
126  m_outerNoAbsorbes = (*emecWheelParameters)[1]->getInt("NABS"); // 768
127  m_outerNoElectrodes = (*emecWheelParameters)[1]->getInt("NABS"); // 768
128  m_outerNoWaves = (*emecWheelParameters)[1]->getInt("NACC"); // 9
129 
130  m_outerLipWidth = m_innerLipWidth; // 2 mm
131  m_outerWaveZoneWidth = m_innerWaveZoneWidth; // 510 mm
132  m_outerWheelWidth = m_outerWaveZoneWidth + 2*m_outerLipWidth; // 514 mm
133  m_outerWaveWidth = m_outerWaveZoneWidth/m_outerNoWaves; // 510/9 = 56.67 mm
134  m_outerHalfWaveWidth = m_outerWaveWidth/2;
135  m_outerQuaterWaveWidth = m_outerWaveWidth/4;
136 
137  // Check values
138  if (m_outerNoAbsorbes != 768) {
139  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of absorbers. (NABS = " + std::to_string (m_outerNoAbsorbes) + ") for Outer Wheel, expected 768!");
140  }
141  if (m_outerNoWaves != 9) {
142  throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of waves. (NACC = " + std::to_string(m_outerNoAbsorbes) + ") for Outer Wheel, expected 9!" );
143  }
144 
145  // Inner wheel thiknesses
146  m_innerLeadThickness = (*emecFan)[0]->getDouble("LEADTHICKNESSINNER") * SI::mm; // 2.2 mm
147  m_innerSteelThickness = (*emecFan)[0]->getDouble("STEELTHICKNESS") * SI::mm; // 0.2 mm
148  m_innerGlueThickness = (*emecFan)[0]->getDouble("GLUETHICKNESS") * SI::mm; // 0.1 mm (TRD: 0.15 mm)
149  m_innerElectrodeThickness = (*emecFan)[0]->getDouble("ELECTRODETOTALTHICKNESS") * SI::mm; // 0.275 mm
150 
151  // Outer wheel thiknesses
152  m_outerLeadThickness = (*emecFan)[0]->getDouble("LEADTHICKNESSOUTER") * SI::mm; // 1.69 mm (TRD: 1.7 mm)
153  m_outerSteelThickness = m_innerSteelThickness;
154  m_outerGlueThickness = m_innerGlueThickness;
155  m_outerElectrodeThickness = m_innerElectrodeThickness;
156 
157  // E.T. notes:
158  // 1. In LArCustomShapeExtensionSolid.cxx the contraction factor was equal to 0.991, here 0.997
159  // 2. There is a discrepancy between specified thickness of glue (0.1 mm) and its value in TDR (0.15 mm)
160  // 3. There is a discrepancy between specified thickness of lead in the outer wheel (1.69 mm) and its value in TDR (1.7 mm)
161  // 4. Application of the contraction factor to the thicknesses (?) is under question
162  // 5. Materials are specified at room temperature (?) instead of LAr temperature
163  // 6. Iron (?) is used instead of Steel in absorbers
164  //
165  // for more information see:
166  // https://indico.cern.ch/event/1236615/contributions/5313135/attachments/2610372/4509836/2023.03.13-EMEC_discrepancies.pdf
167 
168  // Contraction factor
169  m_kContraction = (*coldContraction)[0]->getDouble("ABSORBERCONTRACTION"); // 0.997, in LArCustomShapeExtensionSolid.cxx was 0.991
170 
171  // Applying contraction factor to thicknesses (?)
172  m_innerLeadThickness *= m_kContraction;
173  m_innerSteelThickness *= m_kContraction;
174  m_innerGlueThickness *= m_kContraction;
175  m_innerAbsorberThickness = m_innerLeadThickness + 2*m_innerSteelThickness + 2*m_innerGlueThickness;
176 
177  m_outerLeadThickness *= m_kContraction;
178  m_outerSteelThickness *= m_kContraction;
179  m_outerGlueThickness *= m_kContraction;
180  m_outerAbsorberThickness = m_outerLeadThickness + 2*m_outerSteelThickness + 2*m_outerGlueThickness;
181 
182  // 1./eleInvContraction = 0.99639
183  double eleInvContraction = (*coldContraction)[0]->getDouble("ELECTRODEINVCONTRACTION"); // 1.0036256
184  m_innerElectrodeThickness /= eleInvContraction;
185  m_outerElectrodeThickness /= eleInvContraction;
186 }

Member Data Documentation

◆ m_innerAbsorber

std::array<GeoPhysVol*, s_innerNoBlades> LArGeo::EMECAccordionConstruction::m_innerAbsorber {{nullptr}}
private

Definition at line 199 of file EMECAccordionConstruction.h.

◆ m_innerAbsorberOffset

std::array<GeoThreeVector, s_innerNoBlades> LArGeo::EMECAccordionConstruction::m_innerAbsorberOffset = {}
private

Definition at line 203 of file EMECAccordionConstruction.h.

◆ m_innerAbsorberThickness

double LArGeo::EMECAccordionConstruction::m_innerAbsorberThickness = 0
private

Definition at line 153 of file EMECAccordionConstruction.h.

◆ m_innerElectrode

std::array<GeoPhysVol*, s_innerNoBlades> LArGeo::EMECAccordionConstruction::m_innerElectrode {{nullptr}}
private

Definition at line 202 of file EMECAccordionConstruction.h.

◆ m_innerElectrodeOffset

std::array<GeoThreeVector, s_innerNoBlades> LArGeo::EMECAccordionConstruction::m_innerElectrodeOffset = {}
private

Definition at line 204 of file EMECAccordionConstruction.h.

◆ m_innerElectrodeThickness

double LArGeo::EMECAccordionConstruction::m_innerElectrodeThickness = 0
private

Definition at line 154 of file EMECAccordionConstruction.h.

◆ m_innerGlue

std::array<GeoPhysVol*, s_innerNoBlades> LArGeo::EMECAccordionConstruction::m_innerGlue {{nullptr}}
private

Definition at line 200 of file EMECAccordionConstruction.h.

◆ m_innerGlueRatio

double LArGeo::EMECAccordionConstruction::m_innerGlueRatio = 0
private

Definition at line 155 of file EMECAccordionConstruction.h.

◆ m_innerGlueThickness

double LArGeo::EMECAccordionConstruction::m_innerGlueThickness = 0
private

Definition at line 152 of file EMECAccordionConstruction.h.

◆ m_innerHalfWaveWidth

double LArGeo::EMECAccordionConstruction::m_innerHalfWaveWidth = 0
private

Definition at line 138 of file EMECAccordionConstruction.h.

◆ m_innerLead

std::array<GeoPhysVol*, s_innerNoBlades> LArGeo::EMECAccordionConstruction::m_innerLead {{nullptr}}
private

Definition at line 201 of file EMECAccordionConstruction.h.

◆ m_innerLeadRatio

double LArGeo::EMECAccordionConstruction::m_innerLeadRatio = 0
private

Definition at line 156 of file EMECAccordionConstruction.h.

◆ m_innerLeadThickness

double LArGeo::EMECAccordionConstruction::m_innerLeadThickness = 0
private

Definition at line 150 of file EMECAccordionConstruction.h.

◆ m_innerLipWidth

double LArGeo::EMECAccordionConstruction::m_innerLipWidth = 0
private

Definition at line 135 of file EMECAccordionConstruction.h.

◆ m_innerNoAbsorbes

int LArGeo::EMECAccordionConstruction::m_innerNoAbsorbes = 256
private

Definition at line 110 of file EMECAccordionConstruction.h.

◆ m_innerNoElectrodes

int LArGeo::EMECAccordionConstruction::m_innerNoElectrodes = 256
private

Definition at line 109 of file EMECAccordionConstruction.h.

◆ m_innerNoWaves

int LArGeo::EMECAccordionConstruction::m_innerNoWaves = 6
private

Definition at line 111 of file EMECAccordionConstruction.h.

◆ m_innerQuaterWaveWidth

double LArGeo::EMECAccordionConstruction::m_innerQuaterWaveWidth = 0
private

Definition at line 139 of file EMECAccordionConstruction.h.

◆ m_innerSector

std::array<GeoPhysVol*, s_innerNoBlades> LArGeo::EMECAccordionConstruction::m_innerSector {{nullptr}}
private

Definition at line 224 of file EMECAccordionConstruction.h.

◆ m_innerSlice

std::array<GeoPhysVol*, s_innerNoBlades> LArGeo::EMECAccordionConstruction::m_innerSlice {{nullptr}}
private

Definition at line 215 of file EMECAccordionConstruction.h.

◆ m_innerSliceOffset

std::array<GeoThreeVector, s_innerNoBlades> LArGeo::EMECAccordionConstruction::m_innerSliceOffset = {}
private

Definition at line 216 of file EMECAccordionConstruction.h.

◆ m_innerSteelThickness

double LArGeo::EMECAccordionConstruction::m_innerSteelThickness = 0
private

Definition at line 151 of file EMECAccordionConstruction.h.

◆ m_innerWaveWidth

double LArGeo::EMECAccordionConstruction::m_innerWaveWidth = 0
private

Definition at line 137 of file EMECAccordionConstruction.h.

◆ m_innerWaveZoneWidth

double LArGeo::EMECAccordionConstruction::m_innerWaveZoneWidth = 0
private

Definition at line 136 of file EMECAccordionConstruction.h.

◆ m_innerWheel

GeoFullPhysVol* LArGeo::EMECAccordionConstruction::m_innerWheel = nullptr
private

Definition at line 100 of file EMECAccordionConstruction.h.

◆ m_innerWheelRmax

std::array<double, s_innerNoBlades + 1> LArGeo::EMECAccordionConstruction::m_innerWheelRmax = {}
private

Definition at line 183 of file EMECAccordionConstruction.h.

◆ m_innerWheelRmaxIncrement

double LArGeo::EMECAccordionConstruction::m_innerWheelRmaxIncrement = 0
private

Definition at line 185 of file EMECAccordionConstruction.h.

◆ m_innerWheelRmin

std::array<double, s_innerNoBlades + 1> LArGeo::EMECAccordionConstruction::m_innerWheelRmin = {}
private

Definition at line 182 of file EMECAccordionConstruction.h.

◆ m_innerWheelRminIncrement

double LArGeo::EMECAccordionConstruction::m_innerWheelRminIncrement = 0
private

Definition at line 184 of file EMECAccordionConstruction.h.

◆ m_innerWheelWidth

double LArGeo::EMECAccordionConstruction::m_innerWheelWidth = 0
private

Definition at line 134 of file EMECAccordionConstruction.h.

◆ m_innerWheelZ

std::array<double, s_innerNoBlades + 1> LArGeo::EMECAccordionConstruction::m_innerWheelZ = {}
private

Definition at line 181 of file EMECAccordionConstruction.h.

◆ m_innerWheelZmax

double LArGeo::EMECAccordionConstruction::m_innerWheelZmax = 0
private

Definition at line 187 of file EMECAccordionConstruction.h.

◆ m_innerWheelZmin

double LArGeo::EMECAccordionConstruction::m_innerWheelZmin = 0
private

Definition at line 186 of file EMECAccordionConstruction.h.

◆ m_kContraction

double LArGeo::EMECAccordionConstruction::m_kContraction = 0
private

Definition at line 168 of file EMECAccordionConstruction.h.

◆ m_materialGlue

const GeoMaterial* LArGeo::EMECAccordionConstruction::m_materialGlue = nullptr
private

Definition at line 107 of file EMECAccordionConstruction.h.

◆ m_materialKapton

const GeoMaterial* LArGeo::EMECAccordionConstruction::m_materialKapton = nullptr
private

Definition at line 104 of file EMECAccordionConstruction.h.

◆ m_materialLead

const GeoMaterial* LArGeo::EMECAccordionConstruction::m_materialLead = nullptr
private

Definition at line 105 of file EMECAccordionConstruction.h.

◆ m_materialLiquidArgon

const GeoMaterial* LArGeo::EMECAccordionConstruction::m_materialLiquidArgon = nullptr
private

Definition at line 103 of file EMECAccordionConstruction.h.

◆ m_materialSteel

const GeoMaterial* LArGeo::EMECAccordionConstruction::m_materialSteel = nullptr
private

Definition at line 106 of file EMECAccordionConstruction.h.

◆ m_nameAbsorber

std::string LArGeo::EMECAccordionConstruction::m_nameAbsorber = "::Absorber"
private

Definition at line 123 of file EMECAccordionConstruction.h.

◆ m_nameElectrode

std::string LArGeo::EMECAccordionConstruction::m_nameElectrode = "::Electrode"
private

Definition at line 126 of file EMECAccordionConstruction.h.

◆ m_nameGlue

std::string LArGeo::EMECAccordionConstruction::m_nameGlue = "::Glue"
private

Definition at line 125 of file EMECAccordionConstruction.h.

◆ m_nameInnerWheel

std::string LArGeo::EMECAccordionConstruction::m_nameInnerWheel = ""
private

Definition at line 120 of file EMECAccordionConstruction.h.

◆ m_nameLead

std::string LArGeo::EMECAccordionConstruction::m_nameLead = "::Lead"
private

Definition at line 124 of file EMECAccordionConstruction.h.

◆ m_nameOuterWheel

std::string LArGeo::EMECAccordionConstruction::m_nameOuterWheel = ""
private

Definition at line 121 of file EMECAccordionConstruction.h.

◆ m_nameSlice

std::string LArGeo::EMECAccordionConstruction::m_nameSlice = "::Slice"
private

Definition at line 122 of file EMECAccordionConstruction.h.

◆ m_nameSuffix

std::string LArGeo::EMECAccordionConstruction::m_nameSuffix[s_outerNoBlades]
private
Initial value:
= {
"01","02","03","04","05","06","07","08","09","10",
"11","12","13","14","15","16","17","18","19","20","21"
}

Definition at line 128 of file EMECAccordionConstruction.h.

◆ m_outerAbsorber

std::array<GeoPhysVol*, s_outerNoBlades> LArGeo::EMECAccordionConstruction::m_outerAbsorber {{nullptr}}
private

Definition at line 207 of file EMECAccordionConstruction.h.

◆ m_outerAbsorberOffset

std::array<GeoThreeVector, s_outerNoBlades> LArGeo::EMECAccordionConstruction::m_outerAbsorberOffset = {}
private

Definition at line 211 of file EMECAccordionConstruction.h.

◆ m_outerAbsorberThickness

double LArGeo::EMECAccordionConstruction::m_outerAbsorberThickness = 0
private

Definition at line 162 of file EMECAccordionConstruction.h.

◆ m_outerElectrode

std::array<GeoPhysVol*, s_outerNoBlades> LArGeo::EMECAccordionConstruction::m_outerElectrode {{nullptr}}
private

Definition at line 210 of file EMECAccordionConstruction.h.

◆ m_outerElectrodeOffset

std::array<GeoThreeVector, s_outerNoBlades> LArGeo::EMECAccordionConstruction::m_outerElectrodeOffset = {}
private

Definition at line 212 of file EMECAccordionConstruction.h.

◆ m_outerElectrodeThickness

double LArGeo::EMECAccordionConstruction::m_outerElectrodeThickness = 0
private

Definition at line 163 of file EMECAccordionConstruction.h.

◆ m_outerGlue

std::array<GeoPhysVol*, s_outerNoBlades> LArGeo::EMECAccordionConstruction::m_outerGlue {{nullptr}}
private

Definition at line 208 of file EMECAccordionConstruction.h.

◆ m_outerGlueRatio

double LArGeo::EMECAccordionConstruction::m_outerGlueRatio = 0
private

Definition at line 164 of file EMECAccordionConstruction.h.

◆ m_outerGlueThickness

double LArGeo::EMECAccordionConstruction::m_outerGlueThickness = 0
private

Definition at line 161 of file EMECAccordionConstruction.h.

◆ m_outerHalfWaveWidth

double LArGeo::EMECAccordionConstruction::m_outerHalfWaveWidth = 0
private

Definition at line 146 of file EMECAccordionConstruction.h.

◆ m_outerLead

std::array<GeoPhysVol*, s_outerNoBlades> LArGeo::EMECAccordionConstruction::m_outerLead {{nullptr}}
private

Definition at line 209 of file EMECAccordionConstruction.h.

◆ m_outerLeadRatio

double LArGeo::EMECAccordionConstruction::m_outerLeadRatio = 0
private

Definition at line 165 of file EMECAccordionConstruction.h.

◆ m_outerLeadThickness

double LArGeo::EMECAccordionConstruction::m_outerLeadThickness = 0
private

Definition at line 159 of file EMECAccordionConstruction.h.

◆ m_outerLipWidth

double LArGeo::EMECAccordionConstruction::m_outerLipWidth = 0
private

Definition at line 143 of file EMECAccordionConstruction.h.

◆ m_outerNoAbsorbes

int LArGeo::EMECAccordionConstruction::m_outerNoAbsorbes = 768
private

Definition at line 115 of file EMECAccordionConstruction.h.

◆ m_outerNoElectrodes

int LArGeo::EMECAccordionConstruction::m_outerNoElectrodes = 768
private

Definition at line 114 of file EMECAccordionConstruction.h.

◆ m_outerNoWaves

int LArGeo::EMECAccordionConstruction::m_outerNoWaves = 9
private

Definition at line 116 of file EMECAccordionConstruction.h.

◆ m_outerQuaterWaveWidth

double LArGeo::EMECAccordionConstruction::m_outerQuaterWaveWidth = 0
private

Definition at line 147 of file EMECAccordionConstruction.h.

◆ m_outerSector

std::array<GeoPhysVol*, s_outerNoBlades> LArGeo::EMECAccordionConstruction::m_outerSector {{nullptr}}
private

Definition at line 227 of file EMECAccordionConstruction.h.

◆ m_outerSlice

std::array<GeoPhysVol*, s_outerNoBlades> LArGeo::EMECAccordionConstruction::m_outerSlice {{nullptr}}
private

Definition at line 220 of file EMECAccordionConstruction.h.

◆ m_outerSliceOffset

std::array<GeoThreeVector, s_outerNoBlades> LArGeo::EMECAccordionConstruction::m_outerSliceOffset = {}
private

Definition at line 221 of file EMECAccordionConstruction.h.

◆ m_outerSteelThickness

double LArGeo::EMECAccordionConstruction::m_outerSteelThickness = 0
private

Definition at line 160 of file EMECAccordionConstruction.h.

◆ m_outerWaveWidth

double LArGeo::EMECAccordionConstruction::m_outerWaveWidth = 0
private

Definition at line 145 of file EMECAccordionConstruction.h.

◆ m_outerWaveZoneWidth

double LArGeo::EMECAccordionConstruction::m_outerWaveZoneWidth = 0
private

Definition at line 144 of file EMECAccordionConstruction.h.

◆ m_outerWheel

GeoFullPhysVol* LArGeo::EMECAccordionConstruction::m_outerWheel = nullptr
private

Definition at line 101 of file EMECAccordionConstruction.h.

◆ m_outerWheelRmax

std::array<double, s_outerNoBlades + 1> LArGeo::EMECAccordionConstruction::m_outerWheelRmax = {}
private

Definition at line 192 of file EMECAccordionConstruction.h.

◆ m_outerWheelRmaxIncrement

std::array<double, 2> LArGeo::EMECAccordionConstruction::m_outerWheelRmaxIncrement = {}
private

Definition at line 194 of file EMECAccordionConstruction.h.

◆ m_outerWheelRmin

std::array<double, s_outerNoBlades + 1> LArGeo::EMECAccordionConstruction::m_outerWheelRmin = {}
private

Definition at line 191 of file EMECAccordionConstruction.h.

◆ m_outerWheelRminIncrement

std::array<double, 2> LArGeo::EMECAccordionConstruction::m_outerWheelRminIncrement = {}
private

Definition at line 193 of file EMECAccordionConstruction.h.

◆ m_outerWheelWidth

double LArGeo::EMECAccordionConstruction::m_outerWheelWidth = 0
private

Definition at line 142 of file EMECAccordionConstruction.h.

◆ m_outerWheelZ

std::array<double, s_outerNoBlades + 1> LArGeo::EMECAccordionConstruction::m_outerWheelZ = {}
private

Definition at line 190 of file EMECAccordionConstruction.h.

◆ m_outerWheelZmax

double LArGeo::EMECAccordionConstruction::m_outerWheelZmax = 0
private

Definition at line 196 of file EMECAccordionConstruction.h.

◆ m_outerWheelZmin

double LArGeo::EMECAccordionConstruction::m_outerWheelZmin = 0
private

Definition at line 195 of file EMECAccordionConstruction.h.

◆ m_rMaxInner

std::array<double, 2> LArGeo::EMECAccordionConstruction::m_rMaxInner = {}
private

Definition at line 173 of file EMECAccordionConstruction.h.

◆ m_rMaxOuter

std::array<double, 3> LArGeo::EMECAccordionConstruction::m_rMaxOuter = {}
private

Definition at line 178 of file EMECAccordionConstruction.h.

◆ m_rMinInner

std::array<double, 2> LArGeo::EMECAccordionConstruction::m_rMinInner = {}
private

Definition at line 172 of file EMECAccordionConstruction.h.

◆ m_rMinOuter

std::array<double, 3> LArGeo::EMECAccordionConstruction::m_rMinOuter = {}
private

Definition at line 177 of file EMECAccordionConstruction.h.

◆ m_zWheelInner

std::array<double, 2> LArGeo::EMECAccordionConstruction::m_zWheelInner = {}
private

Definition at line 171 of file EMECAccordionConstruction.h.

◆ m_zWheelOuter

std::array<double, 3> LArGeo::EMECAccordionConstruction::m_zWheelOuter = {}
private

Definition at line 176 of file EMECAccordionConstruction.h.

◆ s_innerNoBlades

constexpr int LArGeo::EMECAccordionConstruction::s_innerNoBlades = 15
staticconstexprprivate

Definition at line 112 of file EMECAccordionConstruction.h.

◆ s_outerNoBlades

constexpr int LArGeo::EMECAccordionConstruction::s_outerNoBlades = 21
staticconstexprprivate

Definition at line 117 of file EMECAccordionConstruction.h.

The documentation for this class was generated from the following files:
LArGeo::EMECAccordionConstruction::m_innerLead
std::array< GeoPhysVol *, s_innerNoBlades > m_innerLead
Definition: EMECAccordionConstruction.h:201
beamspotman.r
def r
Definition: beamspotman.py:676
LArGeo::EMECAccordionConstruction::m_innerNoElectrodes
int m_innerNoElectrodes
Definition: EMECAccordionConstruction.h:109
LArGeo::EMECAccordionConstruction::m_nameSuffix
std::string m_nameSuffix[s_outerNoBlades]
Definition: EMECAccordionConstruction.h:128
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
ymin
double ymin
Definition: listroot.cxx:63
LArGeo::EMECAccordionConstruction::getOuterAbsorberData
void getOuterAbsorberData(double &wmin, double &wmax, double &llip1, double &ylip1, double &llip2, double &ylip2) const
Definition: EMECAccordionConstruction.cxx:406
LArGeo::EMECAccordionConstruction::constructBlade
GeoShape * constructBlade(int icase, const GeoThreeVector corners[8], double xscale, double pz1, double pr1min, double pr1max, double pz2, double pr2min, double pr2max) const
Definition: EMECAccordionConstruction.cxx:590
LArGeo::EMECAccordionConstruction::m_outerWheelRmax
std::array< double, s_outerNoBlades+1 > m_outerWheelRmax
Definition: EMECAccordionConstruction.h:192
LArGeo::EMECAccordionConstruction::m_outerWheelRminIncrement
std::array< double, 2 > m_outerWheelRminIncrement
Definition: EMECAccordionConstruction.h:193
LArGeo::EMECAccordionConstruction::m_outerLeadThickness
double m_outerLeadThickness
Definition: EMECAccordionConstruction.h:159
LArGeo::EMECAccordionConstruction::CutPlane::m_d
double m_d
Definition: EMECAccordionConstruction.h:52
LArGeo::EMECAccordionConstruction::m_outerLead
std::array< GeoPhysVol *, s_outerNoBlades > m_outerLead
Definition: EMECAccordionConstruction.h:209
LArGeo::EMECAccordionConstruction::CutPlane::m_n
GeoThreeVector m_n
Definition: EMECAccordionConstruction.h:51
LArGeo::EMECAccordionConstruction::getInnerAbsorberData
void getInnerAbsorberData(double &wmin, double &wmax, double &llip1, double &ylip1, double &llip2, double &ylip2) const
Definition: EMECAccordionConstruction.cxx:332
LArGeo::EMECAccordionConstruction::m_outerAbsorberOffset
std::array< GeoThreeVector, s_outerNoBlades > m_outerAbsorberOffset
Definition: EMECAccordionConstruction.h:211
LArGeo::EMECAccordionConstruction::m_materialGlue
const GeoMaterial * m_materialGlue
Definition: EMECAccordionConstruction.h:107
LArGeo::EMECAccordionConstruction::m_innerNoAbsorbes
int m_innerNoAbsorbes
Definition: EMECAccordionConstruction.h:110
LArGeo::EMECAccordionConstruction::m_innerGlueThickness
double m_innerGlueThickness
Definition: EMECAccordionConstruction.h:152
LArGeo::EMECAccordionConstruction::placeOuterAccordion
void placeOuterAccordion(int outerNoSectors, bool makeSlices, bool makeSectors)
Definition: EMECAccordionConstruction.cxx:1106
PixelAthClusterMonAlgCfg.zmin
zmin
Definition: PixelAthClusterMonAlgCfg.py:169
hist_file_dump.d
d
Definition: hist_file_dump.py:137
LArGeo::EMECAccordionConstruction::constructInnerBlades
void constructInnerBlades(const GeoThreeVector innerCorners[8], const GeoThreeVector innerElectrodeCorners[8])
Definition: EMECAccordionConstruction.cxx:872
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
LArGeo::EMECAccordionConstruction::m_outerGlueRatio
double m_outerGlueRatio
Definition: EMECAccordionConstruction.h:164
DMTest::C
C_v1 C
Definition: C.h:26
LArGeo::EMECAccordionConstruction::IntersectionPoint
GeoThreeVector IntersectionPoint(const GeoThreeVector &p1, const GeoThreeVector &p2, const CutPlane &plane) const
Definition: EMECAccordionConstruction.cxx:572
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
LArGeo::EMECAccordionConstruction::m_innerElectrode
std::array< GeoPhysVol *, s_innerNoBlades > m_innerElectrode
Definition: EMECAccordionConstruction.h:202
LArGeo::EMECAccordionConstruction::m_outerAbsorber
std::array< GeoPhysVol *, s_outerNoBlades > m_outerAbsorber
Definition: EMECAccordionConstruction.h:207
LArGeo::EMECAccordionConstruction::m_materialLead
const GeoMaterial * m_materialLead
Definition: EMECAccordionConstruction.h:105
deg
#define deg
Definition: SbPolyhedron.cxx:17
LArGeo::EMECAccordionConstruction::m_innerWheelZmin
double m_innerWheelZmin
Definition: EMECAccordionConstruction.h:186
LArGeo::EMECAccordionConstruction::m_outerLeadRatio
double m_outerLeadRatio
Definition: EMECAccordionConstruction.h:165
LArGeo::EMECAccordionConstruction::m_materialLiquidArgon
const GeoMaterial * m_materialLiquidArgon
Definition: EMECAccordionConstruction.h:103
dq_defect_virtual_defect_validation.d1
d1
Definition: dq_defect_virtual_defect_validation.py:79
LArGeo::EMECAccordionConstruction::m_nameLead
std::string m_nameLead
Definition: EMECAccordionConstruction.h:124
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
LArGeo::EMECAccordionConstruction::m_innerWheel
GeoFullPhysVol * m_innerWheel
Definition: EMECAccordionConstruction.h:100
LArGeo::EMECAccordionConstruction::m_outerHalfWaveWidth
double m_outerHalfWaveWidth
Definition: EMECAccordionConstruction.h:146
LArGeo::EMECAccordionConstruction::constructInnerLips
void constructInnerLips(double innerLipLength1, double innerLipPosition1, double innerLipLength2, double innerLipPosition2)
Definition: EMECAccordionConstruction.cxx:725
LArGeo::EMECAccordionConstruction::m_innerWaveWidth
double m_innerWaveWidth
Definition: EMECAccordionConstruction.h:137
LArGeo::EMECAccordionConstruction::getBottomCutPlane
CutPlane getBottomCutPlane(double zmin, double rmin, double zmax, double rmax) const
Definition: EMECAccordionConstruction.cxx:523
x
#define x
LArGeo::EMECAccordionConstruction::m_outerSteelThickness
double m_outerSteelThickness
Definition: EMECAccordionConstruction.h:160
LArGeo::EMECAccordionConstruction::m_innerSlice
std::array< GeoPhysVol *, s_innerNoBlades > m_innerSlice
Definition: EMECAccordionConstruction.h:215
LArGeo::EMECAccordionConstruction::m_outerWheelZmin
double m_outerWheelZmin
Definition: EMECAccordionConstruction.h:195
LArGeo::EMECAccordionConstruction::m_innerGlue
std::array< GeoPhysVol *, s_innerNoBlades > m_innerGlue
Definition: EMECAccordionConstruction.h:200
LArGeo::EMECAccordionConstruction::m_rMaxInner
std::array< double, 2 > m_rMaxInner
Definition: EMECAccordionConstruction.h:173
LArGeo::EMECAccordionConstruction::m_outerWheelRmaxIncrement
std::array< double, 2 > m_outerWheelRmaxIncrement
Definition: EMECAccordionConstruction.h:194
LArGeo::EMECAccordionConstruction::m_innerAbsorberThickness
double m_innerAbsorberThickness
Definition: EMECAccordionConstruction.h:153
LArGeo::EMECAccordionConstruction::m_innerLeadThickness
double m_innerLeadThickness
Definition: EMECAccordionConstruction.h:150
LArGeo::EMECAccordionConstruction::setOuterWheelSlices
void setOuterWheelSlices()
Definition: EMECAccordionConstruction.cxx:277
LArGeo::EMECAccordionConstruction::m_outerSliceOffset
std::array< GeoThreeVector, s_outerNoBlades > m_outerSliceOffset
Definition: EMECAccordionConstruction.h:221
LArGeo::EMECAccordionConstruction::m_rMaxOuter
std::array< double, 3 > m_rMaxOuter
Definition: EMECAccordionConstruction.h:178
LArGeo::EMECAccordionConstruction::getBladeCorners
void getBladeCorners(double wmin, double wmax, double thickness, double rmin, double rmax, double zdel, GeoThreeVector corners[8]) const
Definition: EMECAccordionConstruction.cxx:492
LArGeo::EMECAccordionConstruction::m_outerQuaterWaveWidth
double m_outerQuaterWaveWidth
Definition: EMECAccordionConstruction.h:147
LArGeo::EMECAccordionConstruction::m_nameOuterWheel
std::string m_nameOuterWheel
Definition: EMECAccordionConstruction.h:121
LArGeo::EMECAccordionConstruction::m_nameElectrode
std::string m_nameElectrode
Definition: EMECAccordionConstruction.h:126
LArGeo::EMECAccordionConstruction::m_innerWheelRmin
std::array< double, s_innerNoBlades+1 > m_innerWheelRmin
Definition: EMECAccordionConstruction.h:182
LArGeo::EMECAccordionConstruction::m_innerHalfWaveWidth
double m_innerHalfWaveWidth
Definition: EMECAccordionConstruction.h:138
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
LArGeo::EMECAccordionConstruction::m_innerSector
std::array< GeoPhysVol *, s_innerNoBlades > m_innerSector
Definition: EMECAccordionConstruction.h:224
LArGeo::EMECAccordionConstruction::placeInnerGlueAndLead
void placeInnerGlueAndLead()
Definition: EMECAccordionConstruction.cxx:967
LArGeo::EMECAccordionConstruction::m_outerElectrodeOffset
std::array< GeoThreeVector, s_outerNoBlades > m_outerElectrodeOffset
Definition: EMECAccordionConstruction.h:212
A
LArGeo::EMECAccordionConstruction::constructOuterBlades
void constructOuterBlades(const GeoThreeVector outerCorners[8], const GeoThreeVector outerElectrodeCorners[8])
Definition: EMECAccordionConstruction.cxx:920
LArGeo::EMECAccordionConstruction::m_outerNoWaves
int m_outerNoWaves
Definition: EMECAccordionConstruction.h:116
LArGeo::EMECAccordionConstruction::m_innerWheelWidth
double m_innerWheelWidth
Definition: EMECAccordionConstruction.h:134
LArGeo::EMECAccordionConstruction::constructInnerSlices
void constructInnerSlices()
Definition: EMECAccordionConstruction.cxx:683
LArGeo::EMECAccordionConstruction::m_outerElectrodeThickness
double m_outerElectrodeThickness
Definition: EMECAccordionConstruction.h:163
LArGeo::EMECAccordionConstruction::placeInnerSlices
void placeInnerSlices(bool makeSlices)
Definition: EMECAccordionConstruction.cxx:993
lumiFormat.i
int i
Definition: lumiFormat.py:85
xmin
double xmin
Definition: listroot.cxx:60
z
#define z
LArGeo::EMECAccordionConstruction::m_innerWheelRmaxIncrement
double m_innerWheelRmaxIncrement
Definition: EMECAccordionConstruction.h:185
LArGeo::EMECAccordionConstruction::m_nameSlice
std::string m_nameSlice
Definition: EMECAccordionConstruction.h:122
LArGeo::EMECAccordionConstruction::m_outerWheel
GeoFullPhysVol * m_outerWheel
Definition: EMECAccordionConstruction.h:101
LArGeo::EMECAccordionConstruction::m_rMinInner
std::array< double, 2 > m_rMinInner
Definition: EMECAccordionConstruction.h:172
xAOD::rotation
rotation
Definition: TrackSurface_v1.cxx:15
DecodeVersionKey
This is a helper class to query the version tags from GeoModelSvc and determine the appropriate tag a...
Definition: DecodeVersionKey.h:18
LArGeo::EMECAccordionConstruction::m_zWheelInner
std::array< double, 2 > m_zWheelInner
Definition: EMECAccordionConstruction.h:171
LArGeo::EMECAccordionConstruction::m_innerElectrodeOffset
std::array< GeoThreeVector, s_innerNoBlades > m_innerElectrodeOffset
Definition: EMECAccordionConstruction.h:204
PixelAthClusterMonAlgCfg.zmax
zmax
Definition: PixelAthClusterMonAlgCfg.py:169
LArGeo::EMECAccordionConstruction::m_outerWaveWidth
double m_outerWaveWidth
Definition: EMECAccordionConstruction.h:145
LArGeo::EMECAccordionConstruction::s_outerNoBlades
static constexpr int s_outerNoBlades
Definition: EMECAccordionConstruction.h:117
LArGeo::EMECAccordionConstruction::placeInnerAccordion
void placeInnerAccordion(int innerNoSectors, bool makeSlices, bool makeSectors)
Definition: EMECAccordionConstruction.cxx:1028
GeoTwoVector
GeoTrf::Vector2D GeoTwoVector
Definition: EMECAccordionConstruction.h:21
LArGeo::EMECAccordionConstruction::m_innerAbsorberOffset
std::array< GeoThreeVector, s_innerNoBlades > m_innerAbsorberOffset
Definition: EMECAccordionConstruction.h:203
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
IRDBRecordset_ptr
std::shared_ptr< IRDBRecordset > IRDBRecordset_ptr
Definition: IRDBAccessSvc.h:25
LArGeo::EMECAccordionConstruction::m_nameInnerWheel
std::string m_nameInnerWheel
Definition: EMECAccordionConstruction.h:120
twopi
constexpr double twopi
Definition: VertexPointEstimator.cxx:16
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
LArGeo::EMECAccordionConstruction::m_outerGlueThickness
double m_outerGlueThickness
Definition: EMECAccordionConstruction.h:161
LArGeo::EMECAccordionConstruction::m_kContraction
double m_kContraction
Definition: EMECAccordionConstruction.h:168
LArGeo::EMECAccordionConstruction::m_nameAbsorber
std::string m_nameAbsorber
Definition: EMECAccordionConstruction.h:123
LArGeo::EMECAccordionConstruction::m_outerAbsorberThickness
double m_outerAbsorberThickness
Definition: EMECAccordionConstruction.h:162
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
LArGeo::EMECAccordionConstruction::getTopCutPlane
CutPlane getTopCutPlane(double zmin, double rmin, double zmax, double rmax, const GeoThreeVector corners[8]) const
Definition: EMECAccordionConstruction.cxx:541
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
LArGeo::EMECAccordionConstruction::m_outerGlue
std::array< GeoPhysVol *, s_outerNoBlades > m_outerGlue
Definition: EMECAccordionConstruction.h:208
dqt_zlumi_alleff_HIST.B
B
Definition: dqt_zlumi_alleff_HIST.py:110
LArGeo::EMECAccordionConstruction::m_outerWheelRmin
std::array< double, s_outerNoBlades+1 > m_outerWheelRmin
Definition: EMECAccordionConstruction.h:191
LArGeo::EMECAccordionConstruction::m_innerLeadRatio
double m_innerLeadRatio
Definition: EMECAccordionConstruction.h:156
LArGeo::EMECAccordionConstruction::m_outerLipWidth
double m_outerLipWidth
Definition: EMECAccordionConstruction.h:143
GeoThreeVector
GeoTrf::Vector3D GeoThreeVector
Definition: EMECAccordionConstruction.h:22
LArGeo::EMECAccordionConstruction::m_outerWheelWidth
double m_outerWheelWidth
Definition: EMECAccordionConstruction.h:142
LArGeo::EMECAccordionConstruction::m_nameGlue
std::string m_nameGlue
Definition: EMECAccordionConstruction.h:125
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
ReadCellNoiseFromCoolCompare.v2
v2
Definition: ReadCellNoiseFromCoolCompare.py:364
python.PyAthena.v
v
Definition: PyAthena.py:154
makeTRTBarrelCans.dy
tuple dy
Definition: makeTRTBarrelCans.py:21
LArGeo::EMECAccordionConstruction::CutPlane
Definition: EMECAccordionConstruction.h:50
LArGeo::EMECAccordionConstruction::m_innerQuaterWaveWidth
double m_innerQuaterWaveWidth
Definition: EMECAccordionConstruction.h:139
LArGeo::EMECAccordionConstruction::constructOuterLips
void constructOuterLips(double outerLipLength1, double outerLipPosition1, double outerLipLength2, double outerLipPosition2)
Definition: EMECAccordionConstruction.cxx:798
LArGeo::EMECAccordionConstruction::m_innerLipWidth
double m_innerLipWidth
Definition: EMECAccordionConstruction.h:135
y
#define y
LArGeo::EMECAccordionConstruction::m_outerNoElectrodes
int m_outerNoElectrodes
Definition: EMECAccordionConstruction.h:114
LArGeo::EMECAccordionConstruction::m_rMinOuter
std::array< double, 3 > m_rMinOuter
Definition: EMECAccordionConstruction.h:177
LArGeo::EMECAccordionConstruction::m_outerWheelZ
std::array< double, s_outerNoBlades+1 > m_outerWheelZ
Definition: EMECAccordionConstruction.h:190
LArGeo::EMECAccordionConstruction::m_innerAbsorber
std::array< GeoPhysVol *, s_innerNoBlades > m_innerAbsorber
Definition: EMECAccordionConstruction.h:199
LArGeo::EMECAccordionConstruction::m_innerWheelZmax
double m_innerWheelZmax
Definition: EMECAccordionConstruction.h:187
LArGeo::EMECAccordionConstruction::s_innerNoBlades
static constexpr int s_innerNoBlades
Definition: EMECAccordionConstruction.h:112
dq_defect_virtual_defect_validation.d2
d2
Definition: dq_defect_virtual_defect_validation.py:81
makeTRTBarrelCans.dx
tuple dx
Definition: makeTRTBarrelCans.py:20
LArGeo::EMECAccordionConstruction::m_outerSector
std::array< GeoPhysVol *, s_outerNoBlades > m_outerSector
Definition: EMECAccordionConstruction.h:227
xmax
double xmax
Definition: listroot.cxx:61
LArGeo::EMECAccordionConstruction::m_outerWheelZmax
double m_outerWheelZmax
Definition: EMECAccordionConstruction.h:196
LArGeo::EMECAccordionConstruction::m_innerSliceOffset
std::array< GeoThreeVector, s_innerNoBlades > m_innerSliceOffset
Definition: EMECAccordionConstruction.h:216
LArGeo::EMECAccordionConstruction::placeOuterGlueAndLead
void placeOuterGlueAndLead()
Definition: EMECAccordionConstruction.cxx:980
LArGeo::EMECAccordionConstruction::m_materialKapton
const GeoMaterial * m_materialKapton
Definition: EMECAccordionConstruction.h:104
LArGeo::EMECAccordionConstruction::m_innerNoWaves
int m_innerNoWaves
Definition: EMECAccordionConstruction.h:111
LArGeo::EMECAccordionConstruction::m_zWheelOuter
std::array< double, 3 > m_zWheelOuter
Definition: EMECAccordionConstruction.h:176
LArGeo::EMECAccordionConstruction::m_outerElectrode
std::array< GeoPhysVol *, s_outerNoBlades > m_outerElectrode
Definition: EMECAccordionConstruction.h:210
LArGeo::EMECAccordionConstruction::m_outerSlice
std::array< GeoPhysVol *, s_outerNoBlades > m_outerSlice
Definition: EMECAccordionConstruction.h:220
LArGeo::EMECAccordionConstruction::m_outerNoAbsorbes
int m_outerNoAbsorbes
Definition: EMECAccordionConstruction.h:115
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
LArGeo::EMECAccordionConstruction::m_innerWheelRmax
std::array< double, s_innerNoBlades+1 > m_innerWheelRmax
Definition: EMECAccordionConstruction.h:183
python.PhysicalConstants.halfpi
float halfpi
Definition: PhysicalConstants.py:51
LArGeo::EMECAccordionConstruction::m_outerWaveZoneWidth
double m_outerWaveZoneWidth
Definition: EMECAccordionConstruction.h:144
LArGeo::EMECAccordionConstruction::m_innerWaveZoneWidth
double m_innerWaveZoneWidth
Definition: EMECAccordionConstruction.h:136
LArGeo::EMECAccordionConstruction::setInnerWheelSlices
void setInnerWheelSlices()
Definition: EMECAccordionConstruction.cxx:245
LArGeo::EMECAccordionConstruction::m_materialSteel
const GeoMaterial * m_materialSteel
Definition: EMECAccordionConstruction.h:106
LArGeo::EMECAccordionConstruction::m_innerSteelThickness
double m_innerSteelThickness
Definition: EMECAccordionConstruction.h:151
LArGeo::EMECAccordionConstruction::m_innerWheelRminIncrement
double m_innerWheelRminIncrement
Definition: EMECAccordionConstruction.h:184
LArGeo::EMECAccordionConstruction::constructOuterSlices
void constructOuterSlices()
Definition: EMECAccordionConstruction.cxx:703
LArGeo::EMECAccordionConstruction::placeOuterSlices
void placeOuterSlices(bool makeSlices)
Definition: EMECAccordionConstruction.cxx:1010
LArGeo::EMECAccordionConstruction::m_innerWheelZ
std::array< double, s_innerNoBlades+1 > m_innerWheelZ
Definition: EMECAccordionConstruction.h:181
LArGeo::EMECAccordionConstruction::m_innerGlueRatio
double m_innerGlueRatio
Definition: EMECAccordionConstruction.h:155
ymax
double ymax
Definition: listroot.cxx:64
LArGeo::EMECAccordionConstruction::m_innerElectrodeThickness
double m_innerElectrodeThickness
Definition: EMECAccordionConstruction.h:154
Generated on Sun Dec 22 2024 22:01:48 for ATLAS Offline Software by   doxygen 1.8.18