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
double	m_innerLipWidth
double	m_innerWaveZoneWidth
double	m_innerWaveWidth
double	m_innerHalfWaveWidth
double	m_innerQuaterWaveWidth
double	m_outerWheelWidth
double	m_outerLipWidth
double	m_outerWaveZoneWidth
double	m_outerWaveWidth
double	m_outerHalfWaveWidth
double	m_outerQuaterWaveWidth
double	m_innerLeadThickness
double	m_innerSteelThickness
double	m_innerGlueThickness
double	m_innerAbsorberThickness
double	m_innerElectrodeThickness
double	m_innerGlueRatio
double	m_innerLeadRatio
double	m_outerLeadThickness
double	m_outerSteelThickness
double	m_outerGlueThickness
double	m_outerAbsorberThickness
double	m_outerElectrodeThickness
double	m_outerGlueRatio
double	m_outerLeadRatio
double	m_kContraction
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
double	m_innerWheelRmaxIncrement
double	m_innerWheelZmin
double	m_innerWheelZmax
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
double	m_outerWheelZmax
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

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.

{
  double z1 = pz1, r1min = pr1min, r1max = pr1max;
  double z2 = pz2, r2min = pr2min, r2max = pr2max;
  if (icase == 1) // First quater-wave blade
  {
    z1 -= (z2 - z1);
    r1min -= (r2min - r1min);
    r1max -= (r2max - r1max);
  }
  if (icase == 4) // Last quater-wave blade
  {
    z2 += (z2 - z1);
    r2min += (r2min - r1min);
    r2max += (r2max - r1max);
  }
 
  // Prepare Blade for cutting
  std::vector<GeoThreeVector> v3(8);
  double kx = (icase == 2) ? 1 : -1; // set inclination
 
  // Move Blade to required position
  for (int i = 0; i < 8; ++i)
  {
    v3[i] = GeoThreeVector(kx*corners[i].x(), corners[i].y(), corners[i].z() + (z1 + z2)/2.);
  }
 
  // Change order vertices in case of negative inclination
  if (kx < 0)
  {
    std::swap(v3[0],v3[1]);
    std::swap(v3[2],v3[3]);
    std::swap(v3[4],v3[5]);
    std::swap(v3[6],v3[7]);
  }
 
  // Cut Blade by bottom plane
  LArGeo::EMECAccordionConstruction::CutPlane botPlane = getBottomCutPlane(z1, r1min, z2, r2min);
  v3[0] = IntersectionPoint(v3[0], v3[3], botPlane);
  v3[1] = IntersectionPoint(v3[1], v3[2], botPlane);
  v3[4] = IntersectionPoint(v3[4], v3[7], botPlane);
  v3[5] = IntersectionPoint(v3[5], v3[6], botPlane);
 
  // Cut Blade by top plane
  LArGeo::EMECAccordionConstruction::CutPlane topPlane = getTopCutPlane(z1, r1max, z2, r2max, corners);
  v3[3] = IntersectionPoint(v3[0], v3[3], topPlane);
  v3[2] = IntersectionPoint(v3[1], v3[2], topPlane);
  v3[7] = IntersectionPoint(v3[4], v3[7], topPlane);
  v3[6] = IntersectionPoint(v3[5], v3[6], topPlane);
 
  if (icase == 1) // First quater-wave blade
  {
    v3[0] = (v3[0] + v3[4])/2.;
    v3[1] = (v3[1] + v3[5])/2.;
    v3[2] = (v3[2] + v3[6])/2.;
    v3[3] = (v3[3] + v3[7])/2.;
  }
 
  if (icase == 4) // Last quater-wave blade
  {
    v3[4] = (v3[0] + v3[4])/2.;
    v3[5] = (v3[1] + v3[5])/2.;
    v3[6] = (v3[2] + v3[6])/2.;
    v3[7] = (v3[3] + v3[7])/2.;
  }
 
  // Construct GenericTrap solid
  //
  //  +--------Z
  //  |
  //  |          3 +----------+ 7
  //  |   0 +------|---+ 4    |
  //  X     |    2 +----------+ 6
  //      1 +----------+ 5
  //
  std::vector<GeoTwoVector> v2(8);
  for (int i = 0; i < 8; i += 2)
  {
    double xmid = (v3[i + 1].x() + v3[i].x())/2.;
    double xdel = (v3[i + 1].x() - v3[i].x())*xscale/2.;
    v2[i + 0] = GeoTwoVector(xmid - xdel, v3[i + 0].y());
    v2[i + 1] = GeoTwoVector(xmid + xdel, v3[i + 1].y());
  }
  return new GeoGenericTrap((pz2 - pz1)/2., v2);
}

constructInnerBlades()

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

private

Definition at line 872 of file EMECAccordionConstruction.cxx.

{
  std::string name;
  GeoShape* solid;
 
  for (int iblade = 1; iblade < s_innerNoBlades - 1; ++iblade)
  {
    int icase = (iblade%2 == 0) ? 2 : 3;        // positive/negative inclination
    if (iblade == 1) icase = 1;                 // first quater-wave
    if (iblade == s_innerNoBlades - 2) icase = 4; // last quater-wave
 
    double z1 = m_innerWheelZ[iblade];
    double r1min = m_innerWheelRmin[iblade];
    double r1max = m_innerWheelRmax[iblade];
    double z2 = m_innerWheelZ[iblade + 1];
    double r2min = m_innerWheelRmin[iblade + 1];
    double r2max = m_innerWheelRmax[iblade + 1];
 
    // Construct volumes for Absorber, Glue, Lead and Electrode
    name = m_nameInnerWheel + m_nameAbsorber + m_nameSuffix[iblade];
    solid = constructBlade(icase, innerCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
    m_innerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
 
    name = m_nameInnerWheel + m_nameGlue + m_nameSuffix[iblade];
    solid = constructBlade(icase, innerCorners, m_innerGlueRatio, z1, r1min, r1max, z2, r2min, r2max);
    m_innerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
 
    name = m_nameInnerWheel + m_nameLead + m_nameSuffix[iblade];
    solid = constructBlade(icase, innerCorners, m_innerLeadRatio, z1, r1min, r1max, z2, r2min, r2max);
    m_innerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
 
    name = m_nameInnerWheel + m_nameElectrode + m_nameSuffix[iblade];
    solid = constructBlade(icase, innerElectrodeCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
    m_innerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
 
    // Set offsets
    m_innerAbsorberOffset[iblade]  = GeoThreeVector(0., 0., (z1 + z2)/2.);
    m_innerElectrodeOffset[iblade] = GeoThreeVector(0., 0., (z1 + z2)/2.);
  }
}

constructInnerLips()

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

private

Definition at line 725 of file EMECAccordionConstruction.cxx.

{
  double dx, dy, dz, xoffset, yoffset, zoffset;
  std::string name;
  GeoShape* solid;
 
  // Contruct logical volumes for 1st lip
  int iblade = 0;
  dx = 0.5*m_innerAbsorberThickness;
  dy = 0.5*innerLipLength1;
  dz = 0.5*m_innerLipWidth;
  name = m_nameInnerWheel + m_nameAbsorber + m_nameSuffix[iblade];
  solid = new GeoBox(dx, dy, dz);
  m_innerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
 
  name = m_nameInnerWheel + m_nameGlue + m_nameSuffix[iblade];
  solid = new GeoBox(dx*m_innerGlueRatio, dy, dz);
  m_innerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
 
  name = m_nameInnerWheel + m_nameLead + m_nameSuffix[iblade];
  solid = new GeoBox(dx*m_innerLeadRatio, dy, dz);
  m_innerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
 
  name = m_nameInnerWheel + m_nameElectrode + m_nameSuffix[iblade];
  dx = 0.5*m_innerElectrodeThickness;
  solid = new GeoBox(dx, dy, dz);
  m_innerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
 
  // Set offsets
  xoffset = 0.;
  yoffset = m_innerWheelRmin[1] + innerLipPosition1;
  zoffset = m_innerWheelZmin + dz;
  m_innerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
  m_innerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
 
  // Contruct logical volumes for 2nd lip
  iblade = s_innerNoBlades - 1;
  dx = 0.5*m_innerAbsorberThickness;
  dy = 0.5*innerLipLength2;
  dz = 0.5*m_innerLipWidth;
  name = m_nameInnerWheel + m_nameAbsorber + m_nameSuffix[iblade];
  solid = new GeoBox(dx, dy, dz);
  m_innerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
 
  name = m_nameInnerWheel + m_nameGlue + m_nameSuffix[iblade];
  solid = new GeoBox(dx*m_innerGlueRatio, dy, dz);
  m_innerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
 
  name = m_nameInnerWheel + m_nameLead + m_nameSuffix[iblade];
  solid = new GeoBox(dx*m_innerLeadRatio, dy, dz);
  m_innerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
 
  name = m_nameInnerWheel + m_nameElectrode + m_nameSuffix[iblade];
  dx = 0.5*m_innerElectrodeThickness;
  solid = new GeoBox(dx, dy, dz);
  m_innerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
 
  // Set offsets
  xoffset = 0.;
  yoffset = m_innerWheelRmin[s_innerNoBlades - 1] + innerLipPosition2;
  zoffset = m_innerWheelZmax - dz;
  m_innerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
  m_innerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
}

constructInnerSlices()

void LArGeo::EMECAccordionConstruction::constructInnerSlices ( )

private

Definition at line 683 of file EMECAccordionConstruction.cxx.

{
  std::string name;
  GeoShape* solid;
  for (int islice = 0; islice < s_innerNoBlades; ++islice)
  {
    name = m_nameInnerWheel + m_nameSlice + m_nameSuffix[islice];
    double dz = 0.5*(m_innerWheelZ[islice+1] - m_innerWheelZ[islice]);
    solid = new GeoCons(m_innerWheelRmin[islice], m_innerWheelRmin[islice+1],
                        m_innerWheelRmax[islice], m_innerWheelRmax[islice+1],
                        dz, 0.*SI::deg, 360.*SI::deg);
    m_innerSlice[islice] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLiquidArgon));
    m_innerSliceOffset[islice] = GeoThreeVector(0., 0., m_innerWheelZ[islice] + dz);
  }
}

constructInnerWheelStructure()

void LArGeo::EMECAccordionConstruction::constructInnerWheelStructure

(

bool

makeSlices = true

)

Definition at line 1184 of file EMECAccordionConstruction.cxx.

{
  bool makeSectors = false;
  int innerNoSectors = 0;
 
  //   P R E L I M I N A R Y   C A L C U L A T I O N S
  //
  setInnerWheelSlices(); // define thickness of slices in Inner Wheel
 
  // Get enginneering data of absorbers
  double innerUncutBladeWidthMin, innerUncutBladeWidthMax;
  double innerLipLength1, innerLipPosition1;
  double innerLipLength2, innerLipPosition2;
  getInnerAbsorberData(innerUncutBladeWidthMin, innerUncutBladeWidthMax,
                       innerLipLength1, innerLipPosition1,
                       innerLipLength2, innerLipPosition2);
  innerUncutBladeWidthMin *= m_kContraction;
  innerUncutBladeWidthMax *= m_kContraction;
  innerLipLength1         *= m_kContraction;
  innerLipPosition1       *= m_kContraction;
  innerLipLength2         *= m_kContraction;
  innerLipPosition2       *= m_kContraction;
 
  //   C O M P U T E   U N C U T   B L A D E   C O R N E R S
  //
  double wmin, wmax, thickness, rmin, rmax, zdel;
 
  // Compute Inner Absorber Blade corners
  GeoThreeVector innerCorners[8];
  wmin = innerUncutBladeWidthMin;
  wmax = innerUncutBladeWidthMax;
  thickness = m_innerAbsorberThickness;
  rmin = m_innerWheelRmin[1];
  rmax = m_innerWheelRmax[s_innerNoBlades - 1];
  zdel = m_innerHalfWaveWidth; // slice width
  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, innerCorners);
 
  // Compute Inner Electrode Blade corners
  GeoThreeVector innerElectrodeCorners[8];
  thickness = m_innerElectrodeThickness;
  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, innerElectrodeCorners);
 
  //   C O N S T R U C T   L O G I C A L   V O L U M E S
  //
  // Compute X-scale factors for glue and lead in absorbers
  // Needed for construction of corresponding volumes
  m_innerGlueRatio = (m_innerLeadThickness + 2*m_innerGlueThickness)/m_innerAbsorberThickness;
  m_innerLeadRatio = m_innerLeadThickness/m_innerAbsorberThickness;
 
  // Construct Lips, set offsets for the case "no Slices, no Sectors"
  constructInnerLips(innerLipLength1, innerLipPosition1, innerLipLength2, innerLipPosition2);
 
  // Construct Blades, set offsets for the case "no Slices, no Sectors"
  constructInnerBlades(innerCorners, innerElectrodeCorners);
 
  // Construct Slices, set offsets
  constructInnerSlices();
 
  // Construct Sectors (disabled)
  // constructInnerSectors(innerNoSectors);
 
  //   C O N S T R U C T   P H Y S I C A L   V O L U M E S
  //
  placeInnerGlueAndLead();      // place Glue and Lead in Inner Wheel Absorbers
  placeInnerSlices(makeSlices); // place Slices, if needed
  // PlaceInnerSectors(innerNoSectors, makeSlices, makeSectors); // disabled
  placeInnerAccordion(innerNoSectors, makeSlices, makeSectors); // place Absorbers and Electrodes
}

constructOuterBlades()

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

private

Definition at line 920 of file EMECAccordionConstruction.cxx.

{
  std::string name;
  GeoShape* solid;
 
  for (int iblade = 1; iblade < s_outerNoBlades - 1; ++iblade)
  {
    int icase = (iblade%2 == 0) ? 2 : 3;        // positive/negative inclination
    if (iblade == 1) icase = 1;                 // first quater-wave
    if (iblade == s_outerNoBlades - 2) icase = 4; // last quater-wave
 
    double z1 = m_outerWheelZ[iblade];
    double r1min = m_outerWheelRmin[iblade];
    double r1max = m_outerWheelRmax[iblade];
    double z2 = m_outerWheelZ[iblade + 1];
    double r2min = m_outerWheelRmin[iblade + 1];
    double r2max = m_outerWheelRmax[iblade + 1];
 
    // Construct volumes for Absorber, Glue, Lead and Electrode
    name = m_nameOuterWheel + m_nameAbsorber + m_nameSuffix[iblade];
    solid = constructBlade(icase, outerCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
    m_outerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
 
    name = m_nameOuterWheel + m_nameGlue + m_nameSuffix[iblade];
    solid = constructBlade(icase, outerCorners, m_outerGlueRatio, z1, r1min, r1max, z2, r2min, r2max);
    m_outerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
 
    name = m_nameOuterWheel + m_nameLead + m_nameSuffix[iblade];
    solid = constructBlade(icase, outerCorners, m_outerLeadRatio, z1, r1min, r1max, z2, r2min, r2max);
    m_outerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
 
    // Construct solid for Electrode
    name = m_nameOuterWheel + m_nameElectrode + m_nameSuffix[iblade];
    solid = constructBlade(icase, outerElectrodeCorners, 1., z1, r1min, r1max, z2, r2min, r2max);
    m_outerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
 
    // Set offsets
    m_outerAbsorberOffset[iblade]  = GeoThreeVector(0., 0., (z1 + z2)/2.);
    m_outerElectrodeOffset[iblade] = GeoThreeVector(0., 0., (z1 + z2)/2.);
  }
}

constructOuterLips()

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

private

Definition at line 798 of file EMECAccordionConstruction.cxx.

{
  double dx, dy, dz, xoffset, yoffset, zoffset;
  std::string name;
  GeoShape* solid;
 
  // Contruct logical volumes for 1st lip
  int iblade = 0;
  dx = 0.5*m_outerAbsorberThickness;
  dy = 0.5*outerLipLength1;
  dz = 0.5*m_outerLipWidth;
  name = m_nameOuterWheel + m_nameAbsorber + m_nameSuffix[iblade];
  solid = new GeoBox(dx, dy, dz);
  m_outerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
 
  name = m_nameOuterWheel + m_nameGlue + m_nameSuffix[iblade];
  solid = new GeoBox(dx*m_outerGlueRatio, dy, dz);
  m_outerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
 
  name = m_nameOuterWheel + m_nameLead + m_nameSuffix[iblade];
  solid = new GeoBox(dx*m_outerLeadRatio, dy, dz);
  m_outerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
 
  name = m_nameOuterWheel + m_nameElectrode + m_nameSuffix[iblade];
  dx = 0.5*m_outerElectrodeThickness;
  solid = new GeoBox(dx, dy, dz);
  m_outerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
 
  // Set offsets
  xoffset = 0.;
  yoffset = m_outerWheelRmin[1] + outerLipPosition1;
  zoffset = m_outerWheelZmin + dz;
  m_outerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
  m_outerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
 
  // Contruct logical volumes for 2nd lip
  iblade = s_outerNoBlades - 1;
  dx = 0.5*m_outerAbsorberThickness;
  dy = 0.5*outerLipLength2;
  dz = 0.5*m_outerLipWidth;
  name = m_nameOuterWheel + m_nameAbsorber + m_nameSuffix[iblade];
  solid = new GeoBox(dx, dy, dz);
  m_outerAbsorber[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialSteel));
 
  name = m_nameOuterWheel + m_nameGlue + m_nameSuffix[iblade];
  solid = new GeoBox(dx*m_outerGlueRatio, dy, dz);
  m_outerGlue[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialGlue));
 
  name = m_nameOuterWheel + m_nameLead + m_nameSuffix[iblade];
  solid = new GeoBox(dx*m_outerLeadRatio, dy, dz);
  m_outerLead[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLead));
 
  name = m_nameOuterWheel + m_nameElectrode + m_nameSuffix[iblade];
  dx = 0.5*m_outerElectrodeThickness;
  solid = new GeoBox(dx, dy, dz);
  m_outerElectrode[iblade] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialKapton));
 
  // Set offsets
  xoffset = 0.;
  yoffset = m_outerWheelRmin[s_outerNoBlades -1] + outerLipPosition2;
  zoffset = m_outerWheelZmax - dz;
  m_outerAbsorberOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
  m_outerElectrodeOffset[iblade] = GeoThreeVector(xoffset, yoffset, zoffset);
}

constructOuterSlices()

void LArGeo::EMECAccordionConstruction::constructOuterSlices ( )

private

Definition at line 703 of file EMECAccordionConstruction.cxx.

{
  std::string name;
  GeoShape* solid;
  for (int islice = 0; islice < s_outerNoBlades; ++islice)
  {
    name = m_nameOuterWheel + m_nameSlice + m_nameSuffix[islice];
    double dz = 0.5*(m_outerWheelZ[islice+1] - m_outerWheelZ[islice]);
    solid = new GeoCons(m_outerWheelRmin[islice], m_outerWheelRmin[islice+1],
                        m_outerWheelRmax[islice], m_outerWheelRmax[islice+1],
                        dz, 0.*SI::deg, 360.*SI::deg);
    m_outerSlice[islice] = new GeoPhysVol(new GeoLogVol(name, solid, m_materialLiquidArgon));
    m_outerSliceOffset[islice] = GeoThreeVector(0., 0., m_outerWheelZ[islice] + dz);
  }
}

constructOuterWheelStructure()

void LArGeo::EMECAccordionConstruction::constructOuterWheelStructure

(

bool

makeSlices = true

)

Definition at line 1258 of file EMECAccordionConstruction.cxx.

{
  bool makeSectors = false;
  int outerNoSectors = 0;
 
  //   P R E L I M I N A R Y   C A L C U L A T I O N S
  //
  setOuterWheelSlices(); // define thickness of slices in Outer Wheel
 
  // Get enginneering data of absorbers
  double outerUncutBladeWidthMin, outerUncutBladeWidthMax;
  double outerLipLength1, outerLipPosition1;
  double outerLipLength2, outerLipPosition2;
  getOuterAbsorberData(outerUncutBladeWidthMin, outerUncutBladeWidthMax,
                       outerLipLength1, outerLipPosition1,
                       outerLipLength2, outerLipPosition2);
  outerUncutBladeWidthMin *= m_kContraction;
  outerUncutBladeWidthMax *= m_kContraction;
  outerLipLength1         *= m_kContraction;
  outerLipPosition1       *= m_kContraction;
  outerLipLength2         *= m_kContraction;
  outerLipPosition2       *= m_kContraction;
 
  //   C O M P U T E   U N C U T   B L A D E   C O R N E R S
  //
  double wmin, wmax, thickness, rmin, rmax, zdel;
 
  // Compute Outer Absorber Blade corners
  GeoThreeVector outerCorners[8];
  wmin = outerUncutBladeWidthMin;
  wmax = outerUncutBladeWidthMax;
  thickness = m_outerAbsorberThickness;
  rmin = m_outerWheelRmin[1];
  rmax = m_outerWheelRmax[s_outerNoBlades - 1];
  zdel = m_outerHalfWaveWidth; // slice width
  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, outerCorners);
 
  // Compute Outer Electrode Blade corners
  GeoThreeVector outerElectrodeCorners[8];
  thickness = m_outerElectrodeThickness;
  getBladeCorners(wmin, wmax, thickness, rmin, rmax, zdel, outerElectrodeCorners);
 
  //   C O N S T R U C T   L O G I C A L   V O L U M E S
  //
  // Compute X-scale factors for glue and lead in absorbers
  // Needed for construction of corresponding volumes
  m_outerGlueRatio = (m_outerLeadThickness + 2*m_outerGlueThickness)/m_outerAbsorberThickness;
  m_outerLeadRatio = m_outerLeadThickness/m_outerAbsorberThickness;
 
  // Construct Lips, set offsets for the case "no Slices, no Sectors"
  constructOuterLips(outerLipLength1, outerLipPosition1, outerLipLength2, outerLipPosition2);
 
  // Construct Blades, set offsets for the case "no Slices, no Sectors"
  constructOuterBlades(outerCorners, outerElectrodeCorners);
 
  // Construct Slices, set offsets
  constructOuterSlices();
 
  // Construct Sectors (disabled)
  // constructOuterSectors(outerNoSectors);
 
  //   C O N S T R U C T   P H Y S I C A L   V O L U M E S
  //
  placeOuterGlueAndLead();      // place Glue and Lead in Outer Wheel Absorbers
  placeOuterSlices(makeSlices); // place Slices, if needed
  // PlaceOuterSectors(outerNoSectors, makeSlices, makeSectors); // disabled
  placeOuterAccordion(outerNoSectors, makeSlices, makeSectors); // place Absorbers and Electrodes
}

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.

{
  double z = zdel/2.;
 
  double xmin = std::sqrt(wmin*wmin - zdel*zdel)/2.;
  double dxmin = (thickness/2.)*(wmin/zdel);
  double ymin = rmin;
 
  double xmax = std::sqrt(wmax*wmax - zdel*zdel)/2.;
  double dxmax = (thickness/2.)*(wmax/zdel);
  double xtmp = (xmax + dxmax);
  double ymax = std::sqrt(rmax*rmax - xtmp*xtmp);
 
  corners[0] = GeoThreeVector(-xmin + dxmin, ymin, -z);
  corners[1] = GeoThreeVector(-xmin - dxmin, ymin, -z);
  corners[2] = GeoThreeVector(-xmax - dxmax, ymax, -z);
  corners[3] = GeoThreeVector(-xmax + dxmax, ymax, -z);
 
  corners[4] = GeoThreeVector(+xmin + dxmin, ymin, +z);
  corners[5] = GeoThreeVector(+xmin - dxmin, ymin, +z);
  corners[6] = GeoThreeVector(+xmax - dxmax, ymax, +z);
  corners[7] = GeoThreeVector(+xmax + dxmax, ymax, +z);
}

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.

{
  GeoThreeVector pmin(0, rmin, zmin);
  GeoThreeVector pmax(0, rmax, zmax);
  GeoThreeVector v = (pmax - pmin).normalized();
 
  LArGeo::EMECAccordionConstruction::CutPlane plane;
  plane.m_n = GeoThreeVector(0., -v.z(), v.y());
  plane.m_d = -plane.m_n.dot(pmin);
  return plane;
}

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.

{
  // Points taken from technical drawing
  GeoTwoVector A[14+1] = {};               // A[0] is not used
  A[1]  = GeoTwoVector(  1.700, 1019.908) * SI::mm;
  A[2]  = GeoTwoVector( 36.595, 1022.643) * SI::mm;
  A[3]  = GeoTwoVector(110.351, 1024.416) * SI::mm;
  A[4]  = GeoTwoVector(184.545, 1020.841) * SI::mm;
  A[5]  = GeoTwoVector(258.785, 1011.865) * SI::mm;
  A[6]  = GeoTwoVector(332.678,  997.463) * SI::mm;
  A[7]  = GeoTwoVector(405.824,  977.640) * SI::mm;
  A[8]  = GeoTwoVector(477.824,  952.430) * SI::mm;
  A[9]  = GeoTwoVector(548.280,  921.895) * SI::mm;
  A[10] = GeoTwoVector(616.797,  886.130) * SI::mm;
  A[11] = GeoTwoVector(682.985,  845.257) * SI::mm;
  A[12] = GeoTwoVector(746.463,  799.426) * SI::mm;
  A[13] = GeoTwoVector(806.859,  748.819) * SI::mm;
  A[14] = GeoTwoVector(835.788,  723.065) * SI::mm;
 
  GeoTwoVector B[14+1] = {};               // B[0] is not used
  B[1]  = GeoTwoVector(  1.132, 710.702) * SI::mm;
  B[2]  = GeoTwoVector( 25.476, 711.930) * SI::mm;
  B[3]  = GeoTwoVector( 76.670, 711.749) * SI::mm;
  B[4]  = GeoTwoVector(127.967, 707.873) * SI::mm;
  B[5]  = GeoTwoVector(179.099, 700.288) * SI::mm;
  B[6]  = GeoTwoVector(229.797, 688.988) * SI::mm;
  B[7]  = GeoTwoVector(279.791, 674.025) * SI::mm;
  B[8]  = GeoTwoVector(328.814, 655.414) * SI::mm;
  B[9]  = GeoTwoVector(376.600, 633.227) * SI::mm;
  B[10] = GeoTwoVector(422.886, 607.546) * SI::mm;
  B[11] = GeoTwoVector(467.418, 578.473) * SI::mm;
  B[12] = GeoTwoVector(509.946, 546.127) * SI::mm;
  B[13] = GeoTwoVector(550.228, 510.649) * SI::mm;
  B[14] = GeoTwoVector(568.629, 492.593) * SI::mm;
 
  GeoTwoVector C[4+1] = {};               // C[0] is not used
  C[1]  = GeoTwoVector( -1.754, 978.281) * SI::mm;
  C[2]  = GeoTwoVector(  1.668, 978.279) * SI::mm;
  C[3]  = GeoTwoVector(803.643, 696.378) * SI::mm;
  C[4]  = GeoTwoVector(805.917, 693.745) * SI::mm;
 
  GeoTwoVector D[4+1] = {};               // D[0] is not used
  D[1]  = GeoTwoVector( -1.894, 786.281) * SI::mm;
  D[2]  = GeoTwoVector(  1.186, 786.279) * SI::mm;
  D[3]  = GeoTwoVector(610.986, 529.319) * SI::mm;
  D[4]  = GeoTwoVector(613.041, 526.940) * SI::mm;
 
  // Compute angle between rays
  int k1 = 2, k2 = 13; // take rays 2 and 13
  double cosa = A[k1].dot(A[k2])/(A[k1].norm()*A[k2].norm());
  double ang = std::acos(cosa)/(k2 - k1);
 
  // Compute bottom and top width of the accordion blade
  double rmin = B[1].norm();
  double rmax = A[14].norm();
  wmin = 2.*rmin*std::sin(ang/2.);
  wmax = 2.*rmax*std::sin(ang/2.);
 
  // Compute length and position of the first lip
  llip1 = (C[2] - D[2]).norm();
  ylip1 = (D[2] - B[1]).norm() + llip1/2.;
 
  // Compute length and position of the last lip
  llip2 = (C[3] - D[3]).norm();
  ylip2 = (D[3] - B[14]).norm() + llip2/2.;
}

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.

{
  // Points taken from technical drawing
  GeoTwoVector A[20+1] = {};               // A[0] is not used
  A[1]  = GeoTwoVector(  1.773, 3438.343) * SI::mm;
  A[2]  = GeoTwoVector( 26.515, 3445.688) * SI::mm;
  A[3]  = GeoTwoVector( 79.893, 3460.218) * SI::mm;
  A[4]  = GeoTwoVector(133.523, 3468.701) * SI::mm;
  A[5]  = GeoTwoVector(186.888, 3466.236) * SI::mm;
  A[6]  = GeoTwoVector(240.209, 3462.949) * SI::mm;
  A[7]  = GeoTwoVector(293.473, 3458.842) * SI::mm;
  A[8]  = GeoTwoVector(346.668, 3453.916) * SI::mm;
  A[9]  = GeoTwoVector(399.780, 3448.172) * SI::mm;
  A[10] = GeoTwoVector(452.798, 3441.612) * SI::mm;
  A[11] = GeoTwoVector(505.708, 3434.236) * SI::mm;
  A[12] = GeoTwoVector(558.499, 3426.047) * SI::mm;
  A[13] = GeoTwoVector(611.157, 3417.046) * SI::mm;
  A[14] = GeoTwoVector(663.670, 3407.236) * SI::mm;
  A[15] = GeoTwoVector(716.027, 3396.619) * SI::mm;
  A[16] = GeoTwoVector(768.214, 3385.198) * SI::mm;
  A[17] = GeoTwoVector(820.219, 3372.975) * SI::mm;
  A[18] = GeoTwoVector(872.029, 3359.953) * SI::mm;
  A[19] = GeoTwoVector(923.633, 3346.135) * SI::mm;
  A[20] = GeoTwoVector(947.625, 3339.413) * SI::mm;
 
  GeoTwoVector B[20+1] = {};               // B[0] is not used
  B[1]  = GeoTwoVector(  0.810, 2046.995) * SI::mm;
  B[2]  = GeoTwoVector( 15.769, 2049.165) * SI::mm;
  B[3]  = GeoTwoVector( 47.410, 2053.375) * SI::mm;
  B[4]  = GeoTwoVector( 79.185, 2057.095) * SI::mm;
  B[5]  = GeoTwoVector(111.086, 2060.323) * SI::mm;
  B[6]  = GeoTwoVector(143.105, 2063.055) * SI::mm;
  B[7]  = GeoTwoVector(175.234, 2065.288) * SI::mm;
  B[8]  = GeoTwoVector(207.466, 2067.020) * SI::mm;
  B[9]  = GeoTwoVector(239.792, 2068.248) * SI::mm;
  B[10] = GeoTwoVector(272.205, 2068.969) * SI::mm;
  B[11] = GeoTwoVector(304.697, 2069.181) * SI::mm;
  B[12] = GeoTwoVector(337.260, 2068.883) * SI::mm;
  B[13] = GeoTwoVector(369.885, 2068.071) * SI::mm;
  B[14] = GeoTwoVector(402.566, 2066.744) * SI::mm;
  B[15] = GeoTwoVector(435.293, 2064.899) * SI::mm;
  B[16] = GeoTwoVector(468.058, 2062.536) * SI::mm;
  B[17] = GeoTwoVector(500.853, 2059.653) * SI::mm;
  B[18] = GeoTwoVector(533.670, 2056.247) * SI::mm;
  B[19] = GeoTwoVector(566.501, 2052.318) * SI::mm;
  B[20] = GeoTwoVector(582.048, 2050.271) * SI::mm;
 
  GeoTwoVector C[4+1] = {};                // C[0] is not used
  C[1]  = GeoTwoVector( -1.682, 3416.858) * SI::mm;
  C[2]  = GeoTwoVector(  1.756, 3416.858) * SI::mm;
  C[3]  = GeoTwoVector(932.782, 3287.070) * SI::mm;
  C[3]  = GeoTwoVector(936.090, 3286.130) * SI::mm;
 
  GeoTwoVector D[4+1] = {};                // D[0] is not used
  D[1]  = GeoTwoVector( -1.975, 2088.411) * SI::mm;
  D[2]  = GeoTwoVector(  0.839, 2088.410) * SI::mm;
  D[3]  = GeoTwoVector(593.526, 2090.743) * SI::mm;
  D[4]  = GeoTwoVector(596.271, 2089.963) * SI::mm;
 
  // Compute angle between rays
  int k1 = 4, k2 = 19; // take rays 4 and 19
  double cosa = A[k1].dot(A[k2])/(A[k1].norm()*A[k2].norm());
  double ang = std::acos(cosa)/(k2 - k1);
 
  // Compute bottom and top width of the accordion blade
  double rmin = B[1].norm();
  double rmax = A[19].norm(); // A[19] has slightly bigger radius than A[20]
  wmin = 2.*rmin*std::sin(ang/2.);
  wmax = 2.*rmax*std::sin(ang/2.);
 
  // Compute length and position of the first lip
  llip1 = (C[2] - D[2]).norm();
  ylip1 = (D[2] - B[1]).norm() + llip1/2.;
 
  // Compute length and position of the last lip
  llip2 = (C[3] - D[3]).norm();
  ylip2 = (D[3] - B[20]).norm() + llip2/2.;
}

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.

{
  GeoThreeVector pbot(std::min(corners[0].x(), corners[1].x()), corners[0].y(), 0);
  GeoThreeVector ptop(std::min(corners[2].x(), corners[3].x()), corners[3].y(), 0);
 
  GeoThreeVector v = (ptop - pbot).normalized();
  double d = v.x()*pbot.y() - v.y()*pbot.x();
  double r = ptop.norm();
  double l = std::sqrt(r*r - d*d);
  double wmin = std::sqrt(rmin*rmin - d*d);
  double wmax = std::sqrt(rmax*rmax - d*d);
  double ymin = ptop.y() - v.y()*(l - wmin);
  double ymax = ptop.y() - v.y()*(l - wmax);
 
  GeoThreeVector pmin(0, ymin, zmin);
  GeoThreeVector pmax(0, ymax, zmax);
  v = (pmax - pmin).normalized();
 
  LArGeo::EMECAccordionConstruction::CutPlane plane;
  plane.m_n = GeoThreeVector(0., -v.z(), v.y());
  plane.m_d = -plane.m_n.dot(pmin);
  return plane;
}

IntersectionPoint()

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

private

Definition at line 572 of file EMECAccordionConstruction.cxx.

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

placeInnerAccordion()

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

private

Definition at line 1028 of file EMECAccordionConstruction.cxx.

{
  int nphi = (makeSectors) ? m_innerNoElectrodes/innerNoSectors : m_innerNoElectrodes;
  double dphi = SI::twopi/m_innerNoElectrodes;
  GeoPhysVol* mother = nullptr;
 
  // Place Electordes
  for (int iphi = 0; iphi < nphi; ++iphi)
  {
    GeoTrf::RotateZ3D rotation(dphi*iphi - SI::halfpi);
    int copyNo = iphi + 1;
    for (int iblade = 0; iblade < s_innerNoBlades; ++iblade)
    {
      if (makeSlices)  mother = m_innerSlice[iblade];
      if (makeSectors) mother = m_innerSector[iblade];
      if (makeSlices || makeSectors)
      {
        double x = m_innerElectrodeOffset[iblade].x();
        double y = m_innerElectrodeOffset[iblade].y();
        double z = 0;
        GeoTrf::Translate3D translation(x, y, z);
        mother->add(new GeoIdentifierTag(copyNo));
        mother->add(new GeoTransform(rotation*translation));
        mother->add(m_innerElectrode[iblade]);
      }
      else
      {
        double x = m_innerElectrodeOffset[iblade].x();
        double y = m_innerElectrodeOffset[iblade].y();
        double z = m_innerElectrodeOffset[iblade].z();
        GeoTrf::Translate3D translation(x, y, z);
        m_innerWheel->add(new GeoIdentifierTag(copyNo));
        m_innerWheel->add(new GeoTransform(rotation*translation));
        m_innerWheel->add(m_innerElectrode[iblade]);
      }
    }
  }
 
  // Place Absorbers
  for (int iphi = 0; iphi < nphi; ++iphi)
  {
    GeoTrf::RotateZ3D rotation(dphi*(iphi+0.5) - SI::halfpi);
    int copyNo = iphi + 1;
    for (int iblade = 0; iblade < s_innerNoBlades; ++iblade)
    {
      if (makeSlices)  mother = m_innerSlice[iblade];
      if (makeSectors) mother = m_innerSector[iblade];
      if (makeSlices || makeSectors)
      {
        double x = m_innerAbsorberOffset[iblade].x();
        double y = m_innerAbsorberOffset[iblade].y();
        double z = 0;
        GeoTrf::Translate3D translation(x, y, z);
        mother->add(new GeoIdentifierTag(copyNo));
        mother->add(new GeoTransform(rotation*translation));
        mother->add(m_innerAbsorber[iblade]);
      }
      else
      {
        double x = m_innerAbsorberOffset[iblade].x();
        double y = m_innerAbsorberOffset[iblade].y();
        double z = m_innerAbsorberOffset[iblade].z();
        GeoTrf::Translate3D translation(x, y, z);
        m_innerWheel->add(new GeoIdentifierTag(copyNo));
        m_innerWheel->add(new GeoTransform(rotation*translation));
        m_innerWheel->add(m_innerAbsorber[iblade]);
      }
    }
  }
}

placeInnerGlueAndLead()

void LArGeo::EMECAccordionConstruction::placeInnerGlueAndLead ( )

private

Definition at line 967 of file EMECAccordionConstruction.cxx.

{
  for (int iblade = 0; iblade < s_innerNoBlades; ++iblade)
  {
    m_innerGlue[iblade]->add(m_innerLead[iblade]);
    m_innerAbsorber[iblade]->add(m_innerGlue[iblade]);
  }
}

placeInnerSlices()

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

private

Definition at line 993 of file EMECAccordionConstruction.cxx.

{
  if (!makeSlices) return;
  for (int islice = 0; islice < s_innerNoBlades; ++islice)
  {
    double x = m_innerSliceOffset[islice].x();
    double y = m_innerSliceOffset[islice].y();
    double z = m_innerSliceOffset[islice].z();
    m_innerWheel->add(new GeoTransform(GeoTrf::Translate3D(x, y, z)));
    m_innerWheel->add(m_innerSlice[islice]);
  }
}

placeOuterAccordion()

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

private

Definition at line 1106 of file EMECAccordionConstruction.cxx.

{
  int nphi = (makeSectors) ? m_outerNoElectrodes/outerNoSectors : m_outerNoElectrodes;
  double dphi = SI::twopi/m_outerNoElectrodes;
  GeoPhysVol* mother = nullptr;
 
  // Place Electordes
  for (int iphi = 0; iphi < nphi; ++iphi)
  {
    GeoTrf::RotateZ3D rotation(dphi*iphi - SI::halfpi);
    int copyNo = iphi + 1;
    for (int iblade = 0; iblade < s_outerNoBlades; ++iblade)
    {
      if (makeSlices)  mother = m_outerSlice[iblade];
      if (makeSectors) mother = m_outerSector[iblade];
      if (makeSlices || makeSectors)
      {
        double x = m_outerElectrodeOffset[iblade].x();
        double y = m_outerElectrodeOffset[iblade].y();
        double z = 0;
        GeoTrf::Translate3D translation(x, y, z);
        mother->add(new GeoIdentifierTag(copyNo));
        mother->add(new GeoTransform(rotation*translation));
        mother->add(m_outerElectrode[iblade]);
      }
      else
      {
        double x = m_outerElectrodeOffset[iblade].x();
        double y = m_outerElectrodeOffset[iblade].y();
        double z = m_outerElectrodeOffset[iblade].z();
        GeoTrf::Translate3D translation(x, y, z);
        m_outerWheel->add(new GeoIdentifierTag(copyNo));
        m_outerWheel->add(new GeoTransform(rotation*translation));
        m_outerWheel->add(m_outerElectrode[iblade]);
      }
    }
  }
 
  // Place Absorbers
  for (int iphi = 0; iphi < nphi; ++iphi)
  {
    GeoTrf::RotateZ3D rotation(dphi*(iphi+0.5) - SI::halfpi);
    int copyNo = iphi + 1;
    for (int iblade = 0; iblade < s_outerNoBlades; ++iblade)
    {
      if (makeSlices)  mother = m_outerSlice[iblade];
      if (makeSectors) mother = m_outerSector[iblade];
      if (makeSlices || makeSectors)
      {
        double x = m_outerAbsorberOffset[iblade].x();
        double y = m_outerAbsorberOffset[iblade].y();
        double z = 0;
        GeoTrf::Translate3D translation(x, y, z);
        mother->add(new GeoIdentifierTag(copyNo));
        mother->add(new GeoTransform(rotation*translation));
        mother->add(m_outerAbsorber[iblade]);
      }
      else
      {
        double x = m_outerAbsorberOffset[iblade].x();
        double y = m_outerAbsorberOffset[iblade].y();
        double z = m_outerAbsorberOffset[iblade].z();
        GeoTrf::Translate3D translation(x, y, z);
        m_outerWheel->add(new GeoIdentifierTag(copyNo));
        m_outerWheel->add(new GeoTransform(rotation*translation));
        m_outerWheel->add(m_outerAbsorber[iblade]);
      }
    }
  }
}

placeOuterGlueAndLead()

void LArGeo::EMECAccordionConstruction::placeOuterGlueAndLead ( )

private

Definition at line 980 of file EMECAccordionConstruction.cxx.

{
  for (int iblade = 0; iblade < s_outerNoBlades; ++iblade)
  {
    m_outerGlue[iblade]->add(m_outerLead[iblade]);
    m_outerAbsorber[iblade]->add(m_outerGlue[iblade]);
  }
}

placeOuterSlices()

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

private

Definition at line 1010 of file EMECAccordionConstruction.cxx.

{
  if (!makeSlices) return;
  for (int islice = 0; islice < s_outerNoBlades; ++islice)
  {
    double x = m_outerSliceOffset[islice].x();
    double y = m_outerSliceOffset[islice].y();
    double z = m_outerSliceOffset[islice].z();
    m_outerWheel->add(new GeoTransform(GeoTrf::Translate3D(x, y, z)));
    m_outerWheel->add(m_outerSlice[islice]);
  }
}

setInnerWheel()

void LArGeo::EMECAccordionConstruction::setInnerWheel

(

GeoFullPhysVol *

innerWheel

)

Definition at line 192 of file EMECAccordionConstruction.cxx.

{
  m_innerWheel = innerWheel;
  const GeoShape* shape = innerWheel->getLogVol()->getShape();
    if (shape->type() != "Pcon") {
      throw std::runtime_error( "LArGeo::EMECAccordionConstruction::setInnerWheel: unexpected shape type '"+ shape->type() + "', expected 'Pcon'!");
  }
  const GeoPcon* pcon = (GeoPcon *)shape;
  auto nplanes = pcon->getNPlanes();
  if (nplanes != 2) {
    throw std::runtime_error("LArGeo::EMECAccordionConstruction::setInnerWheel: wrong number of Z planes '" + std::to_string(nplanes) + "', expected '2'!");
  }
  for (unsigned int i = 0; i < nplanes; ++i)
  {
    m_zWheelInner[i] = pcon->getZPlane(i);
    m_rMinInner[i] = pcon->getRMinPlane(i);
    m_rMaxInner[i] = pcon->getRMaxPlane(i);
  }
  // Set Inner Wheel base name
  m_nameInnerWheel = innerWheel->getLogVol()->getName();
}

setInnerWheelSlices()

void LArGeo::EMECAccordionConstruction::setInnerWheelSlices ( )

private

Definition at line 245 of file EMECAccordionConstruction.cxx.

{
  if (!m_innerWheel)
  {
    throw std::runtime_error("LArGeo::EMECAccordionConstruction::setInnerWheelSlices: Inner Wheel volume is not set!" );
  }
  // Compute slices
  m_innerWheelRminIncrement = (m_rMinInner[1] - m_rMinInner[0])/(m_zWheelInner[1] - m_zWheelInner[0]);
  m_innerWheelRmaxIncrement = (m_rMaxInner[1] - m_rMaxInner[0])/(m_zWheelInner[1] - m_zWheelInner[0]);
  m_innerWheelZmin = m_zWheelInner[0];
  m_innerWheelZmax = m_zWheelInner[1];
 
  m_innerWheelZ[0] = m_innerWheelZmin;
  m_innerWheelZ[1] = m_innerWheelZ[0] + m_innerLipWidth;
  m_innerWheelZ[2] = m_innerWheelZ[1] + m_innerQuaterWaveWidth;
  for (int i = 3; i < s_innerNoBlades - 1; ++i)
  {
    m_innerWheelZ[i] = m_innerWheelZ[i - 1] + m_innerHalfWaveWidth;
  }
  m_innerWheelZ[s_innerNoBlades] = m_innerWheelZmax;
  m_innerWheelZ[s_innerNoBlades - 1] = m_innerWheelZ[s_innerNoBlades] - m_innerLipWidth;
  for (int i = 0; i < s_innerNoBlades + 1; ++i)
  {
    m_innerWheelRmin[i] = m_rMinInner[0] + (m_innerWheelZ[i] - m_innerWheelZ[0])*m_innerWheelRminIncrement;
    m_innerWheelRmax[i] = m_rMaxInner[0] + (m_innerWheelZ[i] - m_innerWheelZ[0])*m_innerWheelRmaxIncrement;
  }
}

setMaterial()

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

Definition at line 313 of file EMECAccordionConstruction.cxx.

{
  if (name == "LiquidArgon") m_materialLiquidArgon = material;
  else if (name == "Kapton") m_materialKapton      = material;
  else if (name == "Lead"  ) m_materialLead        = material;
  else if (name == "Steel" ) m_materialSteel       = material;
  else if (name == "Glue"  ) m_materialGlue        = material;
  else
  {
    throw std::runtime_error("LArGeo::EMECAccordionConstruction::setMaterial: unexpected material name '" + name + "'!");
  }
}

setOuterWheel()

void LArGeo::EMECAccordionConstruction::setOuterWheel

(

GeoFullPhysVol *

outerWheel

)

Definition at line 218 of file EMECAccordionConstruction.cxx.

{
  m_outerWheel = outerWheel;
  const GeoShape* shape = outerWheel->getLogVol()->getShape();
    if (shape->type() != "Pcon") {
    throw std::runtime_error( "LArGeo::EMECAccordionConstruction::setOuterWheel: unexpected shape type '"+ shape->type() + "', expected 'Pcon'!");
   
  }
  const GeoPcon* pcon = (GeoPcon *)shape;
  auto nplanes = pcon->getNPlanes();
  if (nplanes != 3) {
      throw std::runtime_error("LArGeo::EMECAccordionConstruction::setOuterWheel: wrong number of Z planes" + std::to_string(nplanes) + "', expected '3'!" );
  }
  for (unsigned int i = 0; i < nplanes; ++i)
  {
    m_zWheelOuter[i] = pcon->getZPlane(i);
    m_rMinOuter[i] = pcon->getRMinPlane(i);
    m_rMaxOuter[i] = pcon->getRMaxPlane(i);
  }
  // Set Outer Wheel base name
  m_nameOuterWheel = outerWheel->getLogVol()->getName();
}

setOuterWheelSlices()

void LArGeo::EMECAccordionConstruction::setOuterWheelSlices ( )

private

Definition at line 277 of file EMECAccordionConstruction.cxx.

{
  if (!m_outerWheel)
  {
    throw std::runtime_error( "LArGeo::EMECAccordionConstruction::setOuterWheelSlices: Outer Wheel volume is not set!");
  }
  // Compute slices
  m_outerWheelRminIncrement[0] = (m_rMinOuter[1] - m_rMinOuter[0])/(m_zWheelOuter[1] - m_zWheelOuter[0]);
  m_outerWheelRminIncrement[1] = (m_rMinOuter[2] - m_rMinOuter[1])/(m_zWheelOuter[2] - m_zWheelOuter[1]);
  m_outerWheelRmaxIncrement[0] = (m_rMaxOuter[1] - m_rMaxOuter[0])/(m_zWheelOuter[1] - m_zWheelOuter[0]);
  m_outerWheelRmaxIncrement[1] = (m_rMaxOuter[2] - m_rMaxOuter[1])/(m_zWheelOuter[2] - m_zWheelOuter[1]);
  m_outerWheelZmin = m_zWheelOuter[0];
  m_outerWheelZmax = m_zWheelOuter[2];
 
  m_outerWheelZ[0] = m_outerWheelZmin;
  m_outerWheelZ[1] = m_outerWheelZ[0] + m_outerLipWidth;
  m_outerWheelZ[2] = m_outerWheelZ[1] + m_outerQuaterWaveWidth;
  for (int i = 3; i < s_outerNoBlades - 1; ++i)
  {
    m_outerWheelZ[i] = m_outerWheelZ[i - 1] + m_outerHalfWaveWidth;
  }
  m_outerWheelZ[s_outerNoBlades] = m_outerWheelZmax;
  m_outerWheelZ[s_outerNoBlades - 1] = m_outerWheelZ[s_outerNoBlades] - m_outerLipWidth;
  for (int i = 0; i < s_outerNoBlades + 1; ++i)
  {
    m_outerWheelRmin[i] = m_rMinOuter[0] + (m_outerWheelZ[i] - m_outerWheelZ[0])*m_outerWheelRminIncrement[0];
    m_outerWheelRmax[i] = m_rMaxOuter[0] + (m_outerWheelZ[i] - m_outerWheelZ[0])*m_outerWheelRmaxIncrement[0];
    if (m_outerWheelRmax[i] > m_rMaxOuter[2]) m_outerWheelRmax[i] = m_rMaxOuter[2]; // 2034 mm starting from i = 3
  }
}

setWheelParameters()

void LArGeo::EMECAccordionConstruction::setWheelParameters

(

)

Definition at line 51 of file EMECAccordionConstruction.cxx.

{
    ISvcLocator *svcLocator = Gaudi::svcLocator();
    SmartIF<StoreGateSvc> detStore{svcLocator->service("DetectorStore")};
    if(!detStore.isValid()) {
      throw std::runtime_error("Error in EndcapCryostatConstruction, cannot access DetectorStore");
    }
 
    // Get GeoModelSvc and RDBAccessSvc
    
    SmartIF<IRDBAccessSvc> rdbAccess{svcLocator->service("RDBAccessSvc")};
    if(!rdbAccess.isValid()){
       throw std::runtime_error("EMECConstruction: cannot locate RDBAccessSvc!");
    }
    
    SmartIF<IGeoModelSvc> geoModelSvc{svcLocator->service("GeoModelSvc")};
    if(!geoModelSvc.isValid()) {
       throw std::runtime_error("EMECAccordionConstruction: cannot locate GeoModelSvc!");
    }
    
    DecodeVersionKey larVersionKey(geoModelSvc, "LAr");
    IRDBRecordset_ptr DB_EmecGeometry = rdbAccess->getRecordsetPtr("EmecGeometry", larVersionKey.tag(), larVersionKey.node());
    if(DB_EmecGeometry->size() == 0){
      DB_EmecGeometry = rdbAccess->getRecordsetPtr("EmecGeometry", "EmecGeometry-00");
    }
    
    IRDBRecordset_ptr emecWheelParameters = rdbAccess->getRecordsetPtr("EmecWheelParameters", larVersionKey.tag(), larVersionKey.node());
    if(emecWheelParameters->size() == 0){
      emecWheelParameters = rdbAccess->getRecordsetPtr("EmecWheelParameters", "EmecWheelParameters-00");
    }
 
 
    IRDBRecordset_ptr emecMagicNumbers = rdbAccess->getRecordsetPtr("EmecMagicNumbers", larVersionKey.tag(), larVersionKey.node());
    if(emecMagicNumbers->size() == 0){
      emecMagicNumbers = rdbAccess->getRecordsetPtr("EmecMagicNumbers", "EmecMagicNumbers-00");
    }
 
    IRDBRecordset_ptr coldContraction = rdbAccess->getRecordsetPtr("ColdContraction", larVersionKey.tag(), larVersionKey.node());
    if(coldContraction->size() == 0){
      coldContraction = rdbAccess->getRecordsetPtr("ColdContraction", "ColdContraction-00");
    }
 
    IRDBRecordset_ptr emecFan = rdbAccess->getRecordsetPtr("EmecFan", larVersionKey.tag(), larVersionKey.node());
    if(emecFan->size() == 0){
      emecFan = rdbAccess->getRecordsetPtr("EmecFan", "EmecFan-00");
    }
 
 
  // Inner wheel accordion wave parameters
  m_innerNoAbsorbes      = (*emecWheelParameters)[0]->getInt("NABS"); // 256
  m_innerNoElectrodes    = (*emecWheelParameters)[0]->getInt("NABS"); // 256
  m_innerNoWaves         = (*emecWheelParameters)[0]->getInt("NACC"); // 6
 
  m_innerLipWidth        = (*emecMagicNumbers)[0]->getDouble("STRAIGHTSTARTSECTION") * SI::mm; // 2 mm
  m_innerWaveZoneWidth   = (*emecMagicNumbers)[0]->getDouble("ACTIVELENGTH") * SI::mm;         // 510 mm
  m_innerWheelWidth      = m_innerWaveZoneWidth + 2*m_innerLipWidth;                          // 514 mm
  m_innerWaveWidth       = m_innerWaveZoneWidth/m_innerNoWaves; // 510/6 = 85 mm
  m_innerHalfWaveWidth   = m_innerWaveWidth/2;
  m_innerQuaterWaveWidth = m_innerWaveWidth/4;
 
  // Check values
  if (m_innerNoAbsorbes != 256) {
    throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of absorbers. (NABS = " + std::to_string( m_innerNoAbsorbes) + ") for Inner Wheel, expected 256!");
  }
  if (m_innerNoWaves != 6) {
    throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of waves. (NACC = " + std::to_string( m_innerNoAbsorbes ) + ") for Inner Wheel, expected 6!");
  }
  if (m_innerLipWidth != 2 * SI::mm) {
    throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong width of absorber lips. (STRAIGHTSTARTSECTION = " + std::to_string( m_innerNoAbsorbes/SI::mm) + "), expected 2 mm!" );
  }
  if (m_innerWaveZoneWidth != 510 * SI::mm) {
    throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong width of absorber active zone. (ACTIVELENGTH = " + std::to_string(m_innerWaveZoneWidth/SI::mm) + "), expected 510 mm!");
  }
 
  // Outer wheel accordion wave parameters
  m_outerNoAbsorbes      = (*emecWheelParameters)[1]->getInt("NABS"); // 768
  m_outerNoElectrodes    = (*emecWheelParameters)[1]->getInt("NABS"); // 768
  m_outerNoWaves         = (*emecWheelParameters)[1]->getInt("NACC"); // 9
 
  m_outerLipWidth        = m_innerLipWidth;                          // 2 mm
  m_outerWaveZoneWidth   = m_innerWaveZoneWidth;                     // 510 mm
  m_outerWheelWidth      = m_outerWaveZoneWidth + 2*m_outerLipWidth; // 514 mm
  m_outerWaveWidth       = m_outerWaveZoneWidth/m_outerNoWaves;      // 510/9 = 56.67 mm
  m_outerHalfWaveWidth   = m_outerWaveWidth/2;
  m_outerQuaterWaveWidth = m_outerWaveWidth/4;
 
  // Check values
  if (m_outerNoAbsorbes != 768) {
    throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of absorbers. (NABS = " + std::to_string (m_outerNoAbsorbes) + ") for Outer Wheel, expected 768!");
  }
  if (m_outerNoWaves != 9) {
     throw std::runtime_error("LArGeo::EMECAccordionConstruction::setWheelParameters: wrong number of waves. (NACC = " + std::to_string(m_outerNoAbsorbes) + ") for Outer Wheel, expected 9!" );
  }
 
  // Inner wheel thiknesses
  m_innerLeadThickness      = (*emecFan)[0]->getDouble("LEADTHICKNESSINNER") * SI::mm;      // 2.2 mm
  m_innerSteelThickness     = (*emecFan)[0]->getDouble("STEELTHICKNESS") * SI::mm;          // 0.2 mm
  m_innerGlueThickness      = (*emecFan)[0]->getDouble("GLUETHICKNESS") * SI::mm;           // 0.1 mm (TRD: 0.15 mm)
  m_innerElectrodeThickness = (*emecFan)[0]->getDouble("ELECTRODETOTALTHICKNESS") * SI::mm; // 0.275 mm
 
  // Outer wheel thiknesses
  m_outerLeadThickness      = (*emecFan)[0]->getDouble("LEADTHICKNESSOUTER") * SI::mm;      // 1.69 mm (TRD: 1.7 mm)
  m_outerSteelThickness     = m_innerSteelThickness;
  m_outerGlueThickness      = m_innerGlueThickness;
  m_outerElectrodeThickness = m_innerElectrodeThickness;
 
  // E.T. notes:
  // 1. In LArCustomShapeExtensionSolid.cxx the contraction factor was equal to 0.991, here 0.997
  // 2. There is a discrepancy between specified thickness of glue (0.1 mm) and its value in TDR (0.15 mm)
  // 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)
  // 4. Application of the contraction factor to the thicknesses (?) is under question
  // 5. Materials are specified at room temperature (?) instead of LAr temperature
  // 6. Iron (?) is used instead of Steel in absorbers
  //
  // for more information see:
  // https://indico.cern.ch/event/1236615/contributions/5313135/attachments/2610372/4509836/2023.03.13-EMEC_discrepancies.pdf
 
  // Contraction factor
  m_kContraction = (*coldContraction)[0]->getDouble("ABSORBERCONTRACTION"); // 0.997, in LArCustomShapeExtensionSolid.cxx was 0.991
 
  // Applying contraction factor to thicknesses (?)
  m_innerLeadThickness  *= m_kContraction;
  m_innerSteelThickness *= m_kContraction;
  m_innerGlueThickness  *= m_kContraction;
  m_innerAbsorberThickness = m_innerLeadThickness + 2*m_innerSteelThickness + 2*m_innerGlueThickness;
 
  m_outerLeadThickness  *= m_kContraction;
  m_outerSteelThickness *= m_kContraction;
  m_outerGlueThickness  *= m_kContraction;
  m_outerAbsorberThickness = m_outerLeadThickness + 2*m_outerSteelThickness + 2*m_outerGlueThickness;
 
  // 1./eleInvContraction = 0.99639
  double eleInvContraction = (*coldContraction)[0]->getDouble("ELECTRODEINVCONTRACTION"); // 1.0036256
  m_innerElectrodeThickness /= eleInvContraction;
  m_outerElectrodeThickness /= eleInvContraction;
}

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

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

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

private

Definition at line 155 of file EMECAccordionConstruction.h.

m_innerGlueThickness

double LArGeo::EMECAccordionConstruction::m_innerGlueThickness

private

Definition at line 152 of file EMECAccordionConstruction.h.

m_innerHalfWaveWidth

double LArGeo::EMECAccordionConstruction::m_innerHalfWaveWidth

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

private

Definition at line 156 of file EMECAccordionConstruction.h.

m_innerLeadThickness

double LArGeo::EMECAccordionConstruction::m_innerLeadThickness

private

Definition at line 150 of file EMECAccordionConstruction.h.

m_innerLipWidth

double LArGeo::EMECAccordionConstruction::m_innerLipWidth

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

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

private

Definition at line 151 of file EMECAccordionConstruction.h.

m_innerWaveWidth

double LArGeo::EMECAccordionConstruction::m_innerWaveWidth

private

Definition at line 137 of file EMECAccordionConstruction.h.

m_innerWaveZoneWidth

double LArGeo::EMECAccordionConstruction::m_innerWaveZoneWidth

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

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

private

Definition at line 184 of file EMECAccordionConstruction.h.

m_innerWheelWidth

double LArGeo::EMECAccordionConstruction::m_innerWheelWidth

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

private

Definition at line 187 of file EMECAccordionConstruction.h.

m_innerWheelZmin

double LArGeo::EMECAccordionConstruction::m_innerWheelZmin

private

Definition at line 186 of file EMECAccordionConstruction.h.

m_kContraction

double LArGeo::EMECAccordionConstruction::m_kContraction

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

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

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

private

Definition at line 164 of file EMECAccordionConstruction.h.

m_outerGlueThickness

double LArGeo::EMECAccordionConstruction::m_outerGlueThickness

private

Definition at line 161 of file EMECAccordionConstruction.h.

m_outerHalfWaveWidth

double LArGeo::EMECAccordionConstruction::m_outerHalfWaveWidth

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

private

Definition at line 165 of file EMECAccordionConstruction.h.

m_outerLeadThickness

double LArGeo::EMECAccordionConstruction::m_outerLeadThickness

private

Definition at line 159 of file EMECAccordionConstruction.h.

m_outerLipWidth

double LArGeo::EMECAccordionConstruction::m_outerLipWidth

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

private

Definition at line 147 of file EMECAccordionConstruction.h.

m_outerSector

std::array<GeoPhysVol*, s_outerNoBlades> LArGeo::EMECAccordionConstruction::m_outerSector

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

private

Definition at line 160 of file EMECAccordionConstruction.h.

m_outerWaveWidth

double LArGeo::EMECAccordionConstruction::m_outerWaveWidth

private

Definition at line 145 of file EMECAccordionConstruction.h.

m_outerWaveZoneWidth

double LArGeo::EMECAccordionConstruction::m_outerWaveZoneWidth

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

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

private

Definition at line 196 of file EMECAccordionConstruction.h.

m_outerWheelZmin

double LArGeo::EMECAccordionConstruction::m_outerWheelZmin

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:

• EMECAccordionConstruction.h
• EMECAccordionConstruction.cxx