SCT_Layer Class Reference

#include <SCT_Layer.h>

Inheritance diagram for SCT_Layer:

Public Member Functions
	SCT_Layer (const std::string &name, int iLayer, SCT_Module *module, InDetDD::SCT_DetectorManager *detectorManager, SCT_GeometryManager *geometryManager, SCT_MaterialManager *materials, GeoModelIO::ReadGeoModel *sqliteReader, std::shared_ptr< std::map< std::string, GeoFullPhysVol * > > mapFPV, std::shared_ptr< std::map< std::string, GeoAlignableTransform * > > mapAX)
virtual	~SCT_Layer ()
	SCT_Layer (const SCT_Layer &)=delete
SCT_Layer &	operator= (const SCT_Layer &)=delete
virtual GeoVPhysVol *	build (SCT_Identifier id)
int	skisPerLayer () const
double	tilt () const
int	stereoSign () const
double	radius () const
double	innerRadius () const
double	outerRadius () const
double	length () const
double	skiPhiStart () const
const std::string &	getName () const

Protected Member Functions
double	epsilon () const

Protected Attributes
const GeoLogVol *	m_logVolume {}
GeoModelIO::ReadGeoModel *	m_sqliteReader {}
std::shared_ptr< std::map< std::string, GeoFullPhysVol * > >	m_mapFPV
std::shared_ptr< std::map< std::string, GeoAlignableTransform * > >	m_mapAX
InDetDD::SCT_DetectorManager *	m_detectorManager {}
SCT_GeometryManager *	m_geometryManager {}
SCT_MaterialManager *	m_materials {}

Private Member Functions
void	getParameters ()
virtual const GeoLogVol *	preBuild ()
void	activeEnvelopeExtent (double &rmin, double &rmax)
double	calcSkiPhiOffset ()

Private Attributes
int	m_iLayer
int	m_skisPerLayer = 0
double	m_tilt = 0.0
int	m_stereoSign = 0
double	m_radius = 0.0
double	m_safety = 0.0
double	m_innerRadius = 0.0
double	m_outerRadius = 0.0
double	m_cylinderLength = 0.0
double	m_activeLength = 0.0
double	m_innerRadiusActive = 0.0
double	m_outerRadiusActive = 0.0
double	m_outerRadiusOfSupport = 0.0
double	m_skiPhiStart = 0.0
double	m_skiAuxPhiStart = 0.0
double	m_bracketPhiOffset = 0.0
double	m_phiRefModule = 0.0
bool	m_includeFSI = false
int	m_nRepeatEndJewel = 0
double	m_phiEndJewel = 0.0
double	m_zEndJewel = 0.0
int	m_nRepeatScorpion = 0
double	m_phiScorpion = 0.0
double	m_zScorpion = 0.0
SCT_Module *	m_module
std::unique_ptr< SCT_Ski >	m_ski
std::unique_ptr< SCT_Clamp >	m_clamp
std::unique_ptr< SCT_CoolingEnd >	m_coolingEnd
std::unique_ptr< SCT_Bracket >	m_bracket
std::unique_ptr< SCT_Harness >	m_harness
std::unique_ptr< SCT_SkiPowerTape >	m_skiPowerTape
std::unique_ptr< SCT_SkiAux >	m_skiAux
std::unique_ptr< SCT_Flange >	m_flange
std::unique_ptr< SCT_SupportCyl >	m_supportCyl
std::unique_ptr< SCT_FSIEndJewel >	m_endJewel
std::unique_ptr< SCT_FSIScorpion >	m_scorpion
std::unique_ptr< SCT_FSIFibreMask >	m_fibreMask
std::string	m_name

Static Private Attributes
static const double	s_epsilon = 1.0e-6 * Gaudi::Units::mm

Detailed Description

Definition at line 36 of file SCT_Layer.h.

Constructor & Destructor Documentation

SCT_Layer() [1/2]

SCT_Layer::SCT_Layer	(	const std::string &	name,
		int	iLayer,
		SCT_Module *	module,
		InDetDD::SCT_DetectorManager *	detectorManager,
		SCT_GeometryManager *	geometryManager,
		SCT_MaterialManager *	materials,
		GeoModelIO::ReadGeoModel *	sqliteReader,
		std::shared_ptr< std::map< std::string, GeoFullPhysVol * > >	mapFPV,
		std::shared_ptr< std::map< std::string, GeoAlignableTransform * > >	mapAX )

Definition at line 52 of file SCT_Layer.cxx.

: SCT_UniqueComponentFactory(name, detectorManager, geometryManager, materials, sqliteReader, std::move(mapFPV), std::move(mapAX)),
    m_iLayer(iLayer), 
    m_module(module)
{
  getParameters();
  m_logVolume = SCT_Layer::preBuild();
}

~SCT_Layer()

SCT_Layer::~SCT_Layer ( )

virtual

Definition at line 69 of file SCT_Layer.cxx.

{
}

SCT_Layer() [2/2]

SCT_Layer::SCT_Layer ( const SCT_Layer & )

delete

Member Function Documentation

activeEnvelopeExtent()

void SCT_Layer::activeEnvelopeExtent ( double & rmin, double & rmax )

private

Definition at line 395 of file SCT_Layer.cxx.

{
 
  // These are the coordinates of the corners of the ski envelope.
  // x is in the radial direction and x is in the phi direction.
 
  GeoTrf::Vector3D c1(-(m_ski->env1RefPointVector()->x()) - 0.5*(m_ski->env1Thickness()),
                       -(m_ski->env1RefPointVector()->y()) + 0.5*(m_ski->env1Width()),
                       0.0);
  GeoTrf::Vector3D c2(-(m_ski->env2RefPointVector()->x()) - 0.5*(m_ski->env2Thickness()),
                       -(m_ski->env2RefPointVector()->y()) + 0.5*(m_ski->env2Width()),
                       0.0);
  GeoTrf::Vector3D c4(-(m_ski->env1RefPointVector()->x()) + 0.5*(m_ski->env1Thickness()),
                       -(m_ski->env1RefPointVector()->y()) - 0.5*(m_ski->env1Width()),
  0.0);
 
  c1 = GeoTrf::RotateZ3D(m_tilt)*c1;
  c2 = GeoTrf::RotateZ3D(m_tilt)*c2;
  c4 = GeoTrf::RotateZ3D(m_tilt)*c4;
 
  GeoTrf::Vector3D vxmax = std::move(c4);
  GeoTrf::Vector3D vxmin;
  if (c1.x() < c2.x()) {
    vxmin = std::move(c1);
  }
  else {
    vxmin = std::move(c2);
  }
 
  double xmax = vxmax.x();
  double xmin = vxmin.x();
  double ymax = vxmax.y();
  double ymin = vxmin.y();
 
  rmax = sqrt(sqr(m_radius + xmax) + sqr(ymax));
  rmin = sqrt(sqr(m_radius + xmin) + sqr(ymin));
}

build()

GeoVPhysVol * SCT_Layer::build ( SCT_Identifier id )

virtual

Implements SCT_UniqueComponentFactory.

Definition at line 253 of file SCT_Layer.cxx.

{
    
    double divisionAngle  = 360 * Gaudi::Units::degree / m_skisPerLayer;
    
    if(m_sqliteReader) {
        for (int iSki = 0; iSki < m_skisPerLayer; iSki++){
            id.setPhiModule(iSki);
            m_ski->build(id);
            
        }
        return nullptr;
    }
    
    
    // We make this a fullPhysVol for alignment code.
    GeoFullPhysVol * layer = new GeoFullPhysVol(m_logVolume);
    
 
    //
    // Active Layer
    //
    // Make envelope for active layer
    //
    const GeoTube * activeLayerEnvelopeShape = new GeoTube(m_innerRadiusActive, m_outerRadiusActive, 0.5 * m_cylinderLength);
    GeoLogVol * activeLayerLog = new GeoLogVol(getName()+"Active", activeLayerEnvelopeShape, m_materials->gasMaterial());
    GeoPhysVol * activeLayer = new GeoPhysVol(activeLayerLog);
    
    for (int iSki = 0; iSki < m_skisPerLayer; iSki++){
        std::ostringstream name; name << "Ski#" << iSki;
        
        double phi = m_skiPhiStart + iSki * divisionAngle;
        
        GeoTrf::Vector3D pos(m_radius, 0, 0);
        pos = GeoTrf::RotateZ3D(phi)*pos;
        GeoTrf::Transform3D rot = GeoTrf::RotateZ3D(m_tilt)*GeoTrf::RotateZ3D(phi);
        
        // Because the ski envelope center is not positioned at the rotation axis for the ski we must first
        // apply the inverse of refPointTransform() of the ski.
        GeoTrf::Transform3D trans(GeoTrf::Transform3D(GeoTrf::Translate3D(pos.x(),pos.y(),pos.z())*rot) * m_ski->getRefPointTransform()->getTransform().inverse());
        
        activeLayer->add(new GeoAlignableTransform(trans));
        activeLayer->add(new GeoNameTag(name.str()));
        activeLayer->add(new GeoIdentifierTag(iSki));
        id.setPhiModule(iSki);
        activeLayer->add(m_ski->build(id));
    }
    
    // And add the service material
    double clampZPos = 0.5 * m_cylinderLength - 0.5 *  m_clamp->length();
    activeLayer->add(new GeoTransform(GeoTrf::TranslateZ3D(clampZPos)));
    activeLayer->add(m_clamp->getVolume());
    activeLayer->add(new GeoTransform(GeoTrf::TranslateZ3D(-clampZPos)));
    activeLayer->add(m_clamp->getVolume());
    
    double coolingZPos = 0.5 * m_cylinderLength - 0.5 *  m_coolingEnd->length();
    activeLayer->add(new GeoTransform(GeoTrf::TranslateZ3D(coolingZPos)));
    activeLayer->add(m_coolingEnd->getVolume());
    activeLayer->add(new GeoTransform(GeoTrf::TranslateZ3D(-coolingZPos)));
    activeLayer->add(m_coolingEnd->getVolume());
    
    //
    // Aux Layer
    // Envelope for brackets and powertapes.
    //
    const GeoTube * auxLayerEnvelopeShape = new GeoTube(m_skiAux->innerRadius(), m_skiAux->outerRadius(),
                                                        0.5*m_skiAux->length());
    GeoLogVol * auxLayerLog = new GeoLogVol(getName()+"Aux", auxLayerEnvelopeShape, m_materials->gasMaterial());
    GeoPhysVol * auxLayer = new GeoPhysVol(auxLayerLog);
    
    for (int iSki = 0; iSki < m_skisPerLayer; iSki++){
        //for (int iSki = 0; iSki < 2; iSki++){
        double phi =  m_skiAuxPhiStart + iSki * divisionAngle;
        auxLayer->add(new GeoTransform(GeoTrf::RotateZ3D(phi)));
        auxLayer->add(m_skiAux->getVolume());
    }
    
    
    //
    // Support Layer
    //
    
    // Envelope for support cylinder, flanges and FSI.
    // Layer0 no longer needs cut-out
    //
    const GeoTube * supportLayerTube = new GeoTube(m_innerRadius, m_outerRadiusOfSupport, 0.5 * m_cylinderLength);
    GeoLogVol * supportLayerLog = new GeoLogVol(getName()+"Support", supportLayerTube,
                                                m_materials->gasMaterial());
    GeoPhysVol * supportLayer = new GeoPhysVol(supportLayerLog);
    
    // Position flanges. One at each end.
    double flangeZPos = 0.5 * m_cylinderLength - 0.5 *  m_flange->length();
    supportLayer->add(new GeoTransform(GeoTrf::TranslateZ3D(flangeZPos)));
    supportLayer->add(m_flange->getVolume());
    supportLayer->add(new GeoTransform(GeoTrf::TranslateZ3D(-flangeZPos)));
    supportLayer->add(m_flange->getVolume());
    
    // Position supportCyl
    supportLayer->add(m_supportCyl->getVolume());
    
    if(m_includeFSI) {
        // Position FSI fibre masks
        double fibreMaskZPos = 0.5 * m_cylinderLength - m_flange->length() - 0.5 * m_fibreMask->length();
        supportLayer->add(new GeoTransform(GeoTrf::TranslateZ3D(fibreMaskZPos)));
        supportLayer->add(m_fibreMask->getVolume());
        supportLayer->add(new GeoTransform(GeoTrf::TranslateZ3D(-fibreMaskZPos)));
        supportLayer->add(m_fibreMask->getVolume());
        
        // Position FSI End jewels
        double jewelRadius = std::sqrt(m_fibreMask->innerRadius()*m_fibreMask->innerRadius() - 0.25 * m_endJewel->rPhiWidth()*m_endJewel->rPhiWidth()) - 0.5 * m_endJewel->radialWidth();
        for ( int i=0; i<m_nRepeatEndJewel; i++) {
            double jewelAngle = m_phiEndJewel + i * 360.*Gaudi::Units::degree/m_nRepeatEndJewel;
            supportLayer->add(new GeoTransform(GeoTrf::RotateZ3D(jewelAngle)*GeoTrf::TranslateX3D(jewelRadius)*GeoTrf::TranslateZ3D(m_zEndJewel)));
            supportLayer->add(m_endJewel->getVolume());
            supportLayer->add(new GeoTransform(GeoTrf::RotateZ3D(jewelAngle)*GeoTrf::TranslateX3D(jewelRadius)*GeoTrf::TranslateZ3D(-m_zEndJewel)));
            supportLayer->add(m_endJewel->getVolume());
        }
        
        // Position FSI Scorpions
        double scorpionRadius = std::sqrt(m_supportCyl->innerRadius()*m_supportCyl->innerRadius() - 0.25 * m_scorpion->rPhiWidth()*m_scorpion->rPhiWidth()) - 0.5 * m_scorpion->radialWidth();
        for ( int i=0; i<m_nRepeatScorpion; i++) {
            double scorpionAngle = m_phiScorpion + i * 360.*Gaudi::Units::degree/m_nRepeatScorpion;
            supportLayer->add(new GeoTransform(GeoTrf::RotateZ3D(scorpionAngle)*GeoTrf::TranslateX3D(scorpionRadius)*GeoTrf::TranslateZ3D(m_zScorpion)));
            supportLayer->add(m_scorpion->getVolume());
            supportLayer->add(new GeoTransform(GeoTrf::RotateZ3D(scorpionAngle)*GeoTrf::TranslateX3D(scorpionRadius)*GeoTrf::TranslateZ3D(-m_zScorpion)));
            supportLayer->add(m_scorpion->getVolume());
        }
    }
    
    // Extra Material
    InDetDD::ExtraMaterial xMat(m_geometryManager->distortedMatManager());
    xMat.add(supportLayer, std::format("SCTLayer{}",m_iLayer));
    
    // Now place all the sub layers into the overall layer.
    layer->add(activeLayer);
    layer->add(auxLayer);
    layer->add(supportLayer);
    
    return layer;
}

calcSkiPhiOffset()

double SCT_Layer::calcSkiPhiOffset ( )

private

Definition at line 435 of file SCT_Layer.cxx.

{
  // Calculate skiPhiOffset such that active silicon touches edge of division
  // This is what is done in AGE.
 
  // First calculated for abs(m_tilt). 
 
  double divisionAngle  = 360 * Gaudi::Units::degree / m_skisPerLayer;
 
  // double activeHalfWidth =     0.5 * m_skiAux->ski()->module()->activeWidth();
  // double moduleHalfThickness = 0.5 * m_skiAux->ski()->module()->thickness();
  double activeHalfWidth =     0.5 * m_module->activeWidth();
  double moduleHalfThickness = 0.5 * m_module->thickness();
 
  // rotate top points by tilt xin,yin (-X,+Y) and xout,yout (+X,+Y)
  double ctilt = std::abs(cos(m_tilt));
  double stilt = std::abs(sin(m_tilt));
  double xin  = m_radius
                - ctilt * moduleHalfThickness - stilt * activeHalfWidth;
  double yin  = - stilt * moduleHalfThickness + ctilt * activeHalfWidth;
  double xout = m_radius 
                + ctilt * moduleHalfThickness - stilt * activeHalfWidth;
  double yout =   stilt * moduleHalfThickness + ctilt * activeHalfWidth;
  double alpha_in  = atan(yin/xin);
  double alpha_out = atan(yout/xout);
  double alpha = std::max(alpha_in, alpha_out);
  
  int tiltSign = (m_tilt < 0) ? -1 : 1;
  // As ski is larger than (ie alpha > divisionAngle/2) 
  // skiPhiOffset < 0 for +ve tilt and > 0 for -ve tilt.
  double skiPhiOffset = tiltSign * (0.5 * divisionAngle - alpha);
 
  return skiPhiOffset;
}

epsilon()

double SCT_ComponentFactory::epsilon ( ) const

protectedinherited

Definition at line 28 of file SCT_ComponentFactory.cxx.

{
  return s_epsilon;
}

getName()

const std::string & SCT_ComponentFactory::getName ( ) const

inlineinherited

Definition at line 35 of file SCT_ComponentFactory.h.

{return m_name;}

getParameters()

void SCT_Layer::getParameters ( )

private

Definition at line 74 of file SCT_Layer.cxx.

{
  const SCT_BarrelParameters * parameters = m_geometryManager->barrelParameters();
  const SCT_GeneralParameters * generalParameters = m_geometryManager->generalParameters();
    
  m_safety       = generalParameters->safety();
  m_radius       = parameters->radius(m_iLayer);
  m_skisPerLayer = parameters->skisPerLayer(m_iLayer);
  m_tilt         = parameters->tilt(m_iLayer);
  m_stereoSign   = parameters->layerStereoSign(m_iLayer);
  m_bracketPhiOffset = parameters->layerBracketPhiOffset(m_iLayer);
  m_phiRefModule = parameters->layerPhiOfRefModule(m_iLayer);
 
  m_outerRadiusOfSupport = parameters->supportCylOuterRadius(m_iLayer);
  m_activeLength = parameters->activeLength();
  m_cylinderLength = parameters->cylinderLength();
 
  m_includeFSI = parameters->includeFSI();
  if (m_includeFSI) {
    m_nRepeatEndJewel = parameters->fsiEndJewelNRepeat(m_iLayer);
    m_phiEndJewel = parameters->fsiEndJewelPhi(m_iLayer);
    m_zEndJewel = parameters->fsiEndJewelZ(m_iLayer);
    m_nRepeatScorpion = parameters->fsiScorpionNRepeat(m_iLayer);
    m_phiScorpion = parameters->fsiScorpionPhi(m_iLayer);
    m_zScorpion = parameters->fsiScorpionZ(m_iLayer);
  }
 
  // Set numerology
  m_detectorManager->numerology().setNumPhiModulesForLayer(m_iLayer,m_skisPerLayer);
  m_detectorManager->numerology().setNumEtaModulesForLayer(m_iLayer,parameters->modulesPerSki());
 
}

innerRadius()

double SCT_Layer::innerRadius ( ) const

inline

Definition at line 63 of file SCT_Layer.h.

{return m_innerRadius;}

length()

double SCT_Layer::length ( ) const

inline

Definition at line 65 of file SCT_Layer.h.

{return m_cylinderLength;}

operator=()

SCT_Layer & SCT_Layer::operator= ( const SCT_Layer & )

delete

outerRadius()

double SCT_Layer::outerRadius ( ) const

inline

Definition at line 64 of file SCT_Layer.h.

{return m_outerRadius;}

preBuild()

const GeoLogVol * SCT_Layer::preBuild ( )

privatevirtual

Implements SCT_UniqueComponentFactory.

Definition at line 110 of file SCT_Layer.cxx.

{
    // Build the components required for the layer.
    // Make the ski
    // The ski length is now reduced to m_activeLength to make room for the cooling inlet/outlet volumes
    m_ski = std::make_unique<SCT_Ski>(std::format("Ski{}",m_iLayer), m_module, m_stereoSign, m_tilt, m_activeLength,
                                      m_detectorManager, m_geometryManager, m_materials, m_sqliteReader, m_mapFPV, m_mapAX);
    
    
    //
    // Calculations for making active layer components - called ski.
    // This is the modules + doglegs + cooling blocks + coolingpipe
    //
    double divisionAngle  = 360. * Gaudi::Units::degree / m_skisPerLayer;
       
    // We define here the first module(id = 0) as the nearest module to phi = 0 with positive phi.
    // We allow slightly negative in case of rounding errors.
       
    double moduleCount = m_phiRefModule / divisionAngle;
    m_skiPhiStart = divisionAngle * (moduleCount - floor(moduleCount +0.5 -0.0001));
    
    if(m_sqliteReader) return nullptr;
    
    // Build the Flanges
    m_flange     = std::make_unique<SCT_Flange>(std::format("Flange{}",m_iLayer), m_iLayer, m_detectorManager, m_geometryManager, m_materials);
    
    // Build the SupportCyl
    m_supportCyl = std::make_unique<SCT_SupportCyl>(std::format("SupportCyl",m_iLayer), m_iLayer, m_cylinderLength,
                                                    m_detectorManager, m_geometryManager, m_materials);
    
    // Build the FSI end jewel, scorpion and fibre mask
    // Mask runs between scorpions and flange in z - must be built after these
    if (m_includeFSI) {
      m_endJewel = std::make_unique<SCT_FSIEndJewel>(std::format("FSIEndJewel",m_iLayer), m_detectorManager, m_geometryManager, m_materials);
      m_scorpion = std::make_unique<SCT_FSIScorpion>(std::format("FSIScorpion",m_iLayer), m_detectorManager, m_geometryManager, m_materials);
      double length_mask = 0.5*m_cylinderLength - m_flange->length() - m_zScorpion - 0.5*m_scorpion->length();
      m_fibreMask = std::make_unique<SCT_FSIFibreMask>(std::format("FSIFibreMask",m_iLayer), m_iLayer, length_mask,
                               m_detectorManager, m_geometryManager, m_materials);
    }
    
    m_skiAuxPhiStart = 0;
    
    //
    // Make SkiAux -  This is the brackets, harness and power tape.
    //
    // Bracket is placed at edge of division.
    // -tiltSign * (r*divisionAngle/2 - bracket_width/2)
    // Works for both +ve and -ve tilt.
    m_bracket = std::make_unique<SCT_Bracket>(std::format("Bracket",m_iLayer), m_detectorManager, m_geometryManager, m_materials);
    
    m_harness = std::make_unique<SCT_Harness>(std::format("Harness",m_iLayer), m_cylinderLength,
                                              m_detectorManager, m_geometryManager, m_materials);
    m_skiPowerTape = std::make_unique<SCT_SkiPowerTape>(std::format("SkiPowerTape",m_iLayer), m_ski.get(), m_cylinderLength,
                                                        m_detectorManager, m_geometryManager, m_materials);
    
    int tiltSign = (m_tilt < 0) ? -1 : +1;
    
    double bracketOffset   = m_skiPhiStart - tiltSign * m_bracketPhiOffset;
    double powerTapeOffset = bracketOffset - tiltSign * 0.5*divisionAngle;
    // tiltSign not really necessary in powerTapeOffset calculate
    // - but keeps the bracket and powertape pair associated with the same ski
    
    
    // Make the SkiAux. This is layer dependent.
    m_skiAux = std::make_unique<SCT_SkiAux>(std::format("SkiAux",m_iLayer),
                                            m_ski.get(),
                                            m_bracket.get(),
                                            m_harness.get(),
                                            m_skiPowerTape.get(),
                                            m_outerRadiusOfSupport,
                                            bracketOffset,
                                            powerTapeOffset,
                                            divisionAngle,
                                            m_detectorManager,
                                            m_geometryManager,
                                            m_materials);
    
    // Build the clamp: we cannot do this until we have the dimensions of SkiAux
    m_clamp = std::make_unique<SCT_Clamp>(std::format("Clamp",m_iLayer), m_iLayer, m_skiAux->outerRadius(),
                                          m_detectorManager, m_geometryManager, m_materials);
    
    // Build the volume representing the cooling inlets, outlet and U-bends.
    // We cannot do this until we have the dimensions of the clamp
    double coolingInnerRadius = m_clamp->outerRadius();
    double clearance = 1*Gaudi::Units::mm;
    double coolingLength = 0.5*m_cylinderLength - 0.5*m_activeLength - clearance;
    m_coolingEnd = std::make_unique<SCT_CoolingEnd>(std::format("CoolingEnd",m_iLayer), m_iLayer, coolingInnerRadius, coolingLength,
                                                    m_detectorManager, m_geometryManager, m_materials);
    
    //
    //  Calculate the envelopes.
    //
    
    
    //
    // Active Layer Envelope extent
    // Envelope for the active part (ie containing all the skis for the layer)
    //
    double rMinActive, rMaxActive;
    
    // Returns the min and max radius for the active envelope
    activeEnvelopeExtent(rMinActive, rMaxActive);
    
    // Add some safety
    rMinActive  -= m_safety;
    rMaxActive  += m_safety;
    
    // But active layer now includes clamp....
    rMinActive = m_skiAux->outerRadius();
    
    m_innerRadiusActive = rMinActive;
    m_outerRadiusActive = rMaxActive;
    
    //
    // Extent Envelope for support cyl, flanges and close-outs.
    //
    double rMinSupport = std::min(m_supportCyl->innerRadius(),m_flange->innerRadius());
    //
    // Overall Layer Envelope extent
    //
    // Inner radius is inner radius of support.
    m_innerRadius = rMinSupport;
    m_outerRadius = m_outerRadiusActive;
    
    //
    // Make envelope for layer; length is now same as support cylinder
    //
    double length = m_cylinderLength;
    //  double length = m_layerLength;
    //  if (m_iLayer == 0) {length = m_cylinderLength + m_safety;}
    const GeoTube * layerEnvelopeTube = new GeoTube(m_innerRadius, m_outerRadius, 0.5 * length);
    
    GeoLogVol * layerLog = new GeoLogVol(getName(), layerEnvelopeTube, m_materials->gasMaterial());
    
    // Check for overlap.
    if (m_skiAux->outerRadius() > rMinActive) {
        std::cout << "----> WARNING: SCT_Layer: Overlap between active layer and aux layer." << std::endl;
    }
    
    return layerLog;
}

radius()

double SCT_Layer::radius ( ) const

inline

Definition at line 61 of file SCT_Layer.h.

{return m_radius;}

skiPhiStart()

double SCT_Layer::skiPhiStart ( ) const

inline

Definition at line 67 of file SCT_Layer.h.

{return m_skiPhiStart;}

skisPerLayer()

int SCT_Layer::skisPerLayer ( ) const

inline

Definition at line 58 of file SCT_Layer.h.

{return m_skisPerLayer;}  

stereoSign()

int SCT_Layer::stereoSign ( ) const

inline

Definition at line 60 of file SCT_Layer.h.

{return m_stereoSign;}

tilt()

double SCT_Layer::tilt ( ) const

inline

Definition at line 59 of file SCT_Layer.h.

{return m_tilt;}

Member Data Documentation

m_activeLength

double SCT_Layer::m_activeLength = 0.0

private

Definition at line 89 of file SCT_Layer.h.

m_bracket

std::unique_ptr<SCT_Bracket> SCT_Layer::m_bracket

private

Definition at line 114 of file SCT_Layer.h.

m_bracketPhiOffset

double SCT_Layer::m_bracketPhiOffset = 0.0

private

Definition at line 99 of file SCT_Layer.h.

m_clamp

std::unique_ptr<SCT_Clamp> SCT_Layer::m_clamp

private

Definition at line 112 of file SCT_Layer.h.

m_coolingEnd

std::unique_ptr<SCT_CoolingEnd> SCT_Layer::m_coolingEnd

private

Definition at line 113 of file SCT_Layer.h.

m_cylinderLength

double SCT_Layer::m_cylinderLength = 0.0

private

Definition at line 88 of file SCT_Layer.h.

m_detectorManager

InDetDD::SCT_DetectorManager* SCT_ComponentFactory::m_detectorManager {}

protectedinherited

Definition at line 38 of file SCT_ComponentFactory.h.

{};

m_endJewel

std::unique_ptr<SCT_FSIEndJewel> SCT_Layer::m_endJewel

private

Definition at line 120 of file SCT_Layer.h.

m_fibreMask

std::unique_ptr<SCT_FSIFibreMask> SCT_Layer::m_fibreMask

private

Definition at line 122 of file SCT_Layer.h.

m_flange

std::unique_ptr<SCT_Flange> SCT_Layer::m_flange

private

Definition at line 118 of file SCT_Layer.h.

m_geometryManager

SCT_GeometryManager* SCT_ComponentFactory::m_geometryManager {}

protectedinherited

Definition at line 39 of file SCT_ComponentFactory.h.

{};

m_harness

std::unique_ptr<SCT_Harness> SCT_Layer::m_harness

private

Definition at line 115 of file SCT_Layer.h.

m_iLayer

int SCT_Layer::m_iLayer

private

Definition at line 78 of file SCT_Layer.h.

m_includeFSI

bool SCT_Layer::m_includeFSI = false

private

Definition at line 102 of file SCT_Layer.h.

m_innerRadius

double SCT_Layer::m_innerRadius = 0.0

private

Definition at line 86 of file SCT_Layer.h.

m_innerRadiusActive

double SCT_Layer::m_innerRadiusActive = 0.0

private

Definition at line 91 of file SCT_Layer.h.

m_logVolume

const GeoLogVol* SCT_UniqueComponentFactory::m_logVolume {}

protectedinherited

Definition at line 86 of file SCT_ComponentFactory.h.

{};

m_mapAX

std::shared_ptr<std::map<std::string, GeoAlignableTransform*> > SCT_UniqueComponentFactory::m_mapAX

protectedinherited

Definition at line 92 of file SCT_ComponentFactory.h.

m_mapFPV

std::shared_ptr<std::map<std::string, GeoFullPhysVol*> > SCT_UniqueComponentFactory::m_mapFPV

protectedinherited

Definition at line 91 of file SCT_ComponentFactory.h.

m_materials

SCT_MaterialManager* SCT_ComponentFactory::m_materials {}

protectedinherited

Definition at line 40 of file SCT_ComponentFactory.h.

{};

m_module

SCT_Module* SCT_Layer::m_module

private

Definition at line 110 of file SCT_Layer.h.

m_name

std::string SCT_ComponentFactory::m_name

privateinherited

Definition at line 46 of file SCT_ComponentFactory.h.

m_nRepeatEndJewel

int SCT_Layer::m_nRepeatEndJewel = 0

private

Definition at line 103 of file SCT_Layer.h.

m_nRepeatScorpion

int SCT_Layer::m_nRepeatScorpion = 0

private

Definition at line 106 of file SCT_Layer.h.

m_outerRadius

double SCT_Layer::m_outerRadius = 0.0

private

Definition at line 87 of file SCT_Layer.h.

m_outerRadiusActive

double SCT_Layer::m_outerRadiusActive = 0.0

private

Definition at line 92 of file SCT_Layer.h.

m_outerRadiusOfSupport

double SCT_Layer::m_outerRadiusOfSupport = 0.0

private

Definition at line 94 of file SCT_Layer.h.

m_phiEndJewel

double SCT_Layer::m_phiEndJewel = 0.0

private

Definition at line 104 of file SCT_Layer.h.

m_phiRefModule

double SCT_Layer::m_phiRefModule = 0.0

private

Definition at line 100 of file SCT_Layer.h.

m_phiScorpion

double SCT_Layer::m_phiScorpion = 0.0

private

Definition at line 107 of file SCT_Layer.h.

m_radius

double SCT_Layer::m_radius = 0.0

private

Definition at line 83 of file SCT_Layer.h.

m_safety

double SCT_Layer::m_safety = 0.0

private

Definition at line 84 of file SCT_Layer.h.

m_scorpion

std::unique_ptr<SCT_FSIScorpion> SCT_Layer::m_scorpion

private

Definition at line 121 of file SCT_Layer.h.

m_ski

std::unique_ptr<SCT_Ski> SCT_Layer::m_ski

private

Definition at line 111 of file SCT_Layer.h.

m_skiAux

std::unique_ptr<SCT_SkiAux> SCT_Layer::m_skiAux

private

Definition at line 117 of file SCT_Layer.h.

m_skiAuxPhiStart

double SCT_Layer::m_skiAuxPhiStart = 0.0

private

Definition at line 97 of file SCT_Layer.h.

m_skiPhiStart

double SCT_Layer::m_skiPhiStart = 0.0

private

Definition at line 96 of file SCT_Layer.h.

m_skiPowerTape

std::unique_ptr<SCT_SkiPowerTape> SCT_Layer::m_skiPowerTape

private

Definition at line 116 of file SCT_Layer.h.

m_skisPerLayer

int SCT_Layer::m_skisPerLayer = 0

private

Definition at line 80 of file SCT_Layer.h.

m_sqliteReader

GeoModelIO::ReadGeoModel* SCT_UniqueComponentFactory::m_sqliteReader {}

protectedinherited

Definition at line 87 of file SCT_ComponentFactory.h.

{};

m_stereoSign

int SCT_Layer::m_stereoSign = 0

private

Definition at line 82 of file SCT_Layer.h.

m_supportCyl

std::unique_ptr<SCT_SupportCyl> SCT_Layer::m_supportCyl

private

Definition at line 119 of file SCT_Layer.h.

m_tilt

double SCT_Layer::m_tilt = 0.0

private

Definition at line 81 of file SCT_Layer.h.

m_zEndJewel

double SCT_Layer::m_zEndJewel = 0.0

private

Definition at line 105 of file SCT_Layer.h.

m_zScorpion

double SCT_Layer::m_zScorpion = 0.0

private

Definition at line 108 of file SCT_Layer.h.

s_epsilon

const double SCT_ComponentFactory::s_epsilon = 1.0e-6 * Gaudi::Units::mm

staticprivateinherited

Definition at line 47 of file SCT_ComponentFactory.h.

---

The documentation for this class was generated from the following files:

• SCT_Layer.h
• SCT_Layer.cxx