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 589 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 871 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 724 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 682 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 1183 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 919 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 797 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 702 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 1257 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 491 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 522 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 331 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 405 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 540 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 571 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 1027 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 966 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 992 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 1105 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 979 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 1009 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 191 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 = static_cast<const 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 244 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 312 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 217 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 = static_cast<const 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 276 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 50 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 = 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:

• EMECAccordionConstruction.h
• EMECAccordionConstruction.cxx