SCT_Ski Class Reference

#include <SCT_Ski.h>

Inheritance diagram for SCT_Ski:

Public Member Functions
	SCT_Ski (const std::string &name, SCT_Module *module, int stereoSign, double tilt, double length, 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)
	~SCT_Ski ()
virtual GeoVPhysVol *	build (SCT_Identifier id)
double	thickness () const
double	width () const
double	length () const
double	zPos (int i) const
int	identifier (int i) const
double	radialSep () const
int	firstStagger () const
int	modulesPerSki () const
double	tilt () const
int	stereoSign () const
const SCT_Module *	module () const
const SCT_Dogleg *	dogleg () const
const SCT_CoolingBlock *	coolingBlock () const
const SCT_CoolingPipe *	coolingPipe () const
const GeoTransform *	getRefPointTransform () const
const GeoTrf::Vector3D *	env1RefPointVector () const
const GeoTrf::Vector3D *	env2RefPointVector () const
double	env1Thickness () const
double	env1Width () const
double	env2Thickness () const
double	env2Width () const
double	coolingBlockOffsetX () const
double	coolingBlockOffsetY () const
double	coolingBlockOffsetZ () const
double	coolingPipeOffsetX () const
double	coolingPipeOffsetY () const
double	doglegOffsetX () const
double	doglegOffsetY () 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
	SCT_Ski (const SCT_Ski &ski)
SCT_Ski &	operator= (const SCT_Ski &ski)
void	getParameters ()
virtual const GeoLogVol *	preBuild ()

Private Attributes
double	m_radialSep = 0.0
int	m_firstStagger = 0
int	m_modulesPerSki = 0
double	m_safety = 0.0
std::vector< double >	m_zPos
std::vector< int >	m_id
int	m_stereoSign
double	m_tilt
double	m_length
double	m_width = 0.0
double	m_thickness = 0.0
double	m_doglegPhiOffset = 0.0
double	m_doglegRadialOffset = 0.0
double	m_coolingBlockPhiOffset = 0.0
double	m_coolingBlockRadialOffset = 0.0
double	m_coolingPipeRadialOffset = 0.0
double	m_coolingPipePhiOffset = 0.0
double	m_coolingBlockOffsetX = 0.0
double	m_coolingBlockOffsetY = 0.0
double	m_coolingBlockOffsetZ = 0.0
double	m_coolingPipeOffsetX = 0.0
double	m_coolingPipeOffsetY = 0.0
double	m_doglegOffsetX = 0.0
double	m_doglegOffsetY = 0.0
SCT_Module *	m_module
std::unique_ptr< SCT_Dogleg >	m_dogleg
std::unique_ptr< SCT_CoolingBlock >	m_coolingBlock
std::unique_ptr< SCT_CoolingPipe >	m_coolingPipe
GeoIntrusivePtr< GeoTransform >	m_refPointTransform {}
GeoIntrusivePtr< GeoTransform >	m_coolingPipePos {}
std::unique_ptr< GeoTrf::Vector3D >	m_env1RefPointVector
	For calculations of envelopes of SCT_DetailLayer.
std::unique_ptr< GeoTrf::Vector3D >	m_env2RefPointVector
	For calculations of envelopes of SCT_DetailLayer.
double	m_env1Thickness = 0.0
double	m_env1Width = 0.0
double	m_env2Thickness = 0.0
double	m_env2Width = 0.0
std::vector< GeoNameTag * >	m_nameTag
std::vector< GeoTrf::Transform3D >	m_modulePos
std::vector< GeoTransform * >	m_doglegPos
std::vector< GeoTransform * >	m_coolingBlockPos
std::string	m_name

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

Detailed Description

Definition at line 28 of file SCT_Ski.h.

Constructor & Destructor Documentation

SCT_Ski() [1/2]

SCT_Ski::SCT_Ski	(	const std::string &	name,
		SCT_Module *	module,
		int	stereoSign,
		double	tilt,
		double	length,
		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 38 of file SCT_Ski.cxx.

  : SCT_UniqueComponentFactory(name, detectorManager, geometryManager, materials, sqliteReader, std::move(mapFPV), std::move(mapAX)),
    m_stereoSign(stereoSign),
    m_tilt(tilt), 
    m_length(length), 
    m_module(module)
{
  getParameters();
  if(!m_sqliteReader) {
      m_logVolume = SCT_Ski::preBuild();
  }
}

~SCT_Ski()

SCT_Ski::~SCT_Ski ( )

default

SCT_Ski() [2/2]

SCT_Ski::SCT_Ski ( const SCT_Ski & ski )

private

Member Function Documentation

build()

GeoVPhysVol * SCT_Ski::build ( SCT_Identifier id )

virtual

Implements SCT_UniqueComponentFactory.

Definition at line 339 of file SCT_Ski.cxx.

{
    GeoPhysVol * ski=nullptr;
    
    if(!m_sqliteReader){
        
        ski= new GeoPhysVol(m_logVolume);
        
        for (int iModule = 0; iModule < m_modulesPerSki; iModule++) {
            
            // Add modules.
            ski->add(m_refPointTransform);
            GeoAlignableTransform * moduleTransform = new GeoAlignableTransform(m_modulePos[iModule]);
            ski->add(moduleTransform);
            ski->add(m_nameTag[iModule]);
            ski->add(new GeoIdentifierTag(m_id[iModule]));
            id.setEtaModule(m_id[iModule]); // Set identifier.
            GeoVPhysVol * modulePV = m_module->build(id);
            ski->add(modulePV);
            
            // Store alignable transform
            m_detectorManager->addAlignableTransform(1, id.getWaferId(), moduleTransform, modulePV);
            
            // Add dogleg
            ski->add(m_refPointTransform);
            ski->add(m_doglegPos[iModule]);
            ski->add(m_dogleg->getVolume());
            
            // and coolingblock
            ski->add(m_refPointTransform);
            ski->add(m_coolingBlockPos[iModule]);
            ski->add(m_coolingBlock->getVolume());
        }
        
        // Add Cooling pipe
        ski->add(m_refPointTransform);
        ski->add(m_coolingPipePos);
        ski->add(m_coolingPipe->getVolume());
    }
    else{
        
        for (int iModule = 0; iModule < m_modulesPerSki; iModule++) {
            
            // Add modules.
            id.setEtaModule(m_id[iModule]); // Set identifier.
            m_module->build(id);
            
            std::string key=std::format("ModuleSKI_{}_{}_{}",id.getLayerDisk(),id.getEtaModule(),id.getPhiModule());
            
            // Store alignable transform
            m_detectorManager->addAlignableTransform(1, id.getWaferId(), (*m_mapAX)[key], (*m_mapFPV)[key]);
            
        }
    }
    return ski;
}

coolingBlock()

const SCT_CoolingBlock * SCT_Ski::coolingBlock ( ) const

inline

Definition at line 63 of file SCT_Ski.h.

{return m_coolingBlock.get();}

coolingBlockOffsetX()

double SCT_Ski::coolingBlockOffsetX ( ) const

inline

Definition at line 73 of file SCT_Ski.h.

{return m_coolingBlockOffsetX;}

coolingBlockOffsetY()

double SCT_Ski::coolingBlockOffsetY ( ) const

inline

Definition at line 74 of file SCT_Ski.h.

{return m_coolingBlockOffsetY;}

coolingBlockOffsetZ()

double SCT_Ski::coolingBlockOffsetZ ( ) const

inline

Definition at line 75 of file SCT_Ski.h.

{return m_coolingBlockOffsetZ;}

coolingPipe()

const SCT_CoolingPipe * SCT_Ski::coolingPipe ( ) const

inline

Definition at line 64 of file SCT_Ski.h.

{return m_coolingPipe.get();}

coolingPipeOffsetX()

double SCT_Ski::coolingPipeOffsetX ( ) const

inline

Definition at line 76 of file SCT_Ski.h.

{return m_coolingPipeOffsetX;}

coolingPipeOffsetY()

double SCT_Ski::coolingPipeOffsetY ( ) const

inline

Definition at line 77 of file SCT_Ski.h.

{return m_coolingPipeOffsetY;}

dogleg()

const SCT_Dogleg * SCT_Ski::dogleg ( ) const

inline

Definition at line 62 of file SCT_Ski.h.

{return m_dogleg.get();}

doglegOffsetX()

double SCT_Ski::doglegOffsetX ( ) const

inline

Definition at line 79 of file SCT_Ski.h.

{return m_doglegOffsetX;}

doglegOffsetY()

double SCT_Ski::doglegOffsetY ( ) const

inline

Definition at line 80 of file SCT_Ski.h.

{return m_doglegOffsetY;}

env1RefPointVector()

const GeoTrf::Vector3D * SCT_Ski::env1RefPointVector ( ) const

inline

Definition at line 67 of file SCT_Ski.h.

{return m_env1RefPointVector.get();}

env1Thickness()

double SCT_Ski::env1Thickness ( ) const

inline

Definition at line 69 of file SCT_Ski.h.

{return m_env1Thickness;}

env1Width()

double SCT_Ski::env1Width ( ) const

inline

Definition at line 70 of file SCT_Ski.h.

{return m_env1Width;}

env2RefPointVector()

const GeoTrf::Vector3D * SCT_Ski::env2RefPointVector ( ) const

inline

Definition at line 68 of file SCT_Ski.h.

{return m_env2RefPointVector.get();}

env2Thickness()

double SCT_Ski::env2Thickness ( ) const

inline

Definition at line 71 of file SCT_Ski.h.

{return m_env2Thickness;}

env2Width()

double SCT_Ski::env2Width ( ) const

inline

Definition at line 72 of file SCT_Ski.h.

{return m_env2Width;}

epsilon()

double SCT_ComponentFactory::epsilon ( ) const

protectedinherited

Definition at line 28 of file SCT_ComponentFactory.cxx.

{
  return s_epsilon;
}

firstStagger()

int SCT_Ski::firstStagger ( ) const

inline

Definition at line 55 of file SCT_Ski.h.

{return m_firstStagger;}

getName()

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

inlineinherited

Definition at line 35 of file SCT_ComponentFactory.h.

{return m_name;}

getParameters()

void SCT_Ski::getParameters ( )

private

Definition at line 65 of file SCT_Ski.cxx.

{
 
  const SCT_BarrelParameters * parameters = m_geometryManager->barrelParameters();
  const SCT_GeneralParameters * generalParameters = m_geometryManager->generalParameters();
 
  m_safety       = generalParameters->safety();
  
  m_radialSep     = parameters->skiRadialSep();
  m_firstStagger  = parameters->skiFirstStagger();
  m_modulesPerSki = parameters->modulesPerSki();
  for (int iModule = 0; iModule < m_modulesPerSki; iModule++){
    m_zPos.push_back(parameters->skiZPosition(iModule));
    m_id.push_back(parameters->skiModuleIdentifier(iModule));
  }
 
  // Various offset for the doglegs, cooling blocks and cooling pipe.
  // These are not currently needed and are all set to zero.
  m_doglegRadialOffset = 0;
  m_doglegPhiOffset = 0;
  m_coolingBlockPhiOffset = 0;
  m_coolingBlockRadialOffset = 0;
  m_coolingPipeRadialOffset = 0;
  m_coolingPipePhiOffset = 0;
 
  m_coolingBlockOffsetX = parameters->coolingBlockOffsetX();
  m_coolingBlockOffsetY = parameters->coolingBlockOffsetY();
  m_coolingBlockOffsetZ = parameters->coolingBlockOffsetZ();
  m_coolingPipeOffsetX = parameters->coolingPipeOffsetX();
  m_coolingPipeOffsetY = parameters->coolingPipeOffsetY();
 
  m_doglegOffsetX = parameters->doglegOffsetX();
  m_doglegOffsetY = parameters->doglegOffsetY();
}

getRefPointTransform()

const GeoTransform * SCT_Ski::getRefPointTransform ( ) const

inline

Definition at line 66 of file SCT_Ski.h.

{return m_refPointTransform;}

identifier()

int SCT_Ski::identifier ( int i ) const

inline

Definition at line 53 of file SCT_Ski.h.

{return m_id[i];}

length()

double SCT_Ski::length ( ) const

inline

Definition at line 50 of file SCT_Ski.h.

{return m_length;}

module()

const SCT_Module * SCT_Ski::module ( ) const

inline

Definition at line 61 of file SCT_Ski.h.

{return m_module;}   

modulesPerSki()

int SCT_Ski::modulesPerSki ( ) const

inline

Definition at line 56 of file SCT_Ski.h.

{return m_modulesPerSki;}

operator=()

SCT_Ski & SCT_Ski::operator= ( const SCT_Ski & ski )

private

preBuild()

const GeoLogVol * SCT_Ski::preBuild ( )

privatevirtual

Implements SCT_UniqueComponentFactory.

Definition at line 101 of file SCT_Ski.cxx.

{
  const double rphiClearance = 0.5*Gaudi::Units::mm;
  const double radialClearance = 0.5*Gaudi::Units::mm;
 
 
  // Make components.
  m_dogleg = std::make_unique<SCT_Dogleg>(getName()+"Dogleg", m_detectorManager, m_geometryManager, m_materials);
  m_coolingBlock = std::make_unique<SCT_CoolingBlock>(getName()+"CoolingBlock",
                                        m_detectorManager, m_geometryManager, m_materials);
  m_coolingPipe = std::make_unique<SCT_CoolingPipe>(getName()+"CoolingPipe", m_length,
                                      m_detectorManager, m_geometryManager, m_materials);
 
  // We need the sign of the tilt in numerous places
  int tiltSign = (m_tilt < 0) ? -1 : +1;
 
 
  // The two modules are lined up in x in the unrotated ski. The ski then gets tilted
  // when placed in the layer.
  // So the x offset is just the raidal separation and the y offset is zero.
 
  double xModuleOffset = 0.5 * m_radialSep;
 
  double yModuleOffset = 0.0;
 
 
  //
  // Calculate position of cooling block
  //
  // Position the cooling block m_coolingBlockPhiOffset from the lower egde 
  // of the module and m_coolingBlockRadialOffset from surface of the module.
 
  double xCoolingBlockOffset = - m_coolingBlockRadialOffset + coolingBlockOffsetX();
  double yCoolingBlockOffset = tiltSign *(coolingBlockOffsetY() - m_coolingBlockPhiOffset);
  double zCoolingBlockOffset = coolingBlockOffsetZ(); 
 
  //
  // Calculate position of dogleg
  //
 
  double xDoglegOffset = doglegOffsetX() - m_doglegRadialOffset; 
 
  // NB length of dogleg runs in phi direction.
  double yDoglegOffset =  tiltSign * (doglegOffsetY() + m_doglegPhiOffset);
 
  double zDoglegOffset = coolingBlockOffsetZ();
 
  //
  // Calculate position of cooling pipe.
  //
  double xCoolingPipePos = coolingPipeOffsetX() - m_coolingPipeRadialOffset;
  double yCoolingPipePos = coolingPipeOffsetY() + m_coolingPipePhiOffset; 
  m_coolingPipePos = new GeoTransform(GeoTrf::Translate3D(xCoolingPipePos, yCoolingPipePos, 0));
  //
  //
  //
 
  int stagger_sign = m_firstStagger;
  // Loop over modules in ski as we need their z positions.
  for (int iModule = 0; iModule < m_modulesPerSki; iModule++) {
    
    // For compatibility with AGE we need to offset the module in y by -0.5*sep*sin(tilt) so that center 
    // of module lines up with radial line. (Not sure if this is what is done in reality)
 
    // Not sure if this needs to be alignable
    double xModulePos = stagger_sign * xModuleOffset;
    double yModulePos = yModuleOffset;
    double zModulePos = m_zPos[iModule];
    
    // There is only one type of module and this is rotated one way or the other
    // to get the phi-v (-ve), u-phi (+ve) orientations
    GeoTrf::RotateX3D rot(0.5 * m_stereoSign * m_module->stereoAngle());
    GeoTrf::Translation3D pos(xModulePos, yModulePos, zModulePos);
    m_modulePos.push_back(GeoTrf::Transform3D(pos*rot));
 
    //
    // Calculate position of cooling block
    //
 
    double  xCoolingBlockPos = xCoolingBlockOffset + xModulePos;
    double  yCoolingBlockPos = yCoolingBlockOffset + yModulePos;
    double  zCoolingBlockPos = zCoolingBlockOffset + zModulePos;
    m_coolingBlockPos.push_back(new GeoTransform(GeoTrf::Translate3D(xCoolingBlockPos, yCoolingBlockPos, zCoolingBlockPos))); 
 
    
    //
    // Calculate position of dogleg
    //
    double xDoglegPos = xDoglegOffset + xModulePos; 
    double yDoglegPos = yDoglegOffset + yModulePos; 
    double zDoglegPos = zDoglegOffset + zModulePos;
    m_doglegPos.push_back(new GeoTransform(GeoTrf::Translate3D(xDoglegPos, yDoglegPos, zDoglegPos))); 
 
    // alternate staggering
    stagger_sign = - stagger_sign; 
 
   
  }
 
  //
  // calculate envelope for ski with just modules. Not all these are used.
  // These are coordinates of corners of module's envelopes.
  //
 
  GeoTrf::Vector3D c0(0.0,
                       -(m_module->env1RefPointVector()->y()) + 0.5*(m_module->env1Width()),
                       -(m_module->env1RefPointVector()->z()) + 0.5*(m_module->env1Length()));
  GeoTrf::Vector3D c1(0.0,
                       -(m_module->env1RefPointVector()->y()) - 0.5*(m_module->env1Width()),
                       -(m_module->env1RefPointVector()->z()) + 0.5*(m_module->env1Length()));
  GeoTrf::Vector3D c2(0.0,
                       -(m_module->env1RefPointVector()->y()) - 0.5*(m_module->env1Width()),
                       -(m_module->env1RefPointVector()->z()) - 0.5*(m_module->env1Length()));
  GeoTrf::Vector3D c3(0.0,
                       -(m_module->env1RefPointVector()->y()) + 0.5*(m_module->env1Width()),
                       -(m_module->env1RefPointVector()->z()) - 0.5*(m_module->env1Length()));
  GeoTrf::Vector3D c4(0.0,
                       -(m_module->env2RefPointVector()->y()) + 0.5*(m_module->env2Width()),
                       -(m_module->env2RefPointVector()->z()) + 0.5*(m_module->env2Length()));
  GeoTrf::Vector3D c5(0.0,
                       -(m_module->env2RefPointVector()->y()) - 0.5*(m_module->env2Width()),
                       -(m_module->env2RefPointVector()->z()) + 0.5*(m_module->env2Length()));
  GeoTrf::Vector3D c6(0.0,
                       -(m_module->env2RefPointVector()->y()) - 0.5*(m_module->env2Width()),
                       -(m_module->env2RefPointVector()->z()) - 0.5*(m_module->env2Length()));
  GeoTrf::Vector3D c7(0.0,
                       -(m_module->env2RefPointVector()->y()) + 0.5*(m_module->env2Width()),
                       -(m_module->env2RefPointVector()->z()) - 0.5*(m_module->env2Length()));
 
  double moduleYMax = c4.y();
  double moduleYMin = c5.y();
  c0 = GeoTrf::RotateX3D(0.5 * m_stereoSign * m_module->stereoAngle())*c0;
  c1 = GeoTrf::RotateX3D(0.5 * m_stereoSign * m_module->stereoAngle())*c1;
  c2 = GeoTrf::RotateX3D(0.5 * m_stereoSign * m_module->stereoAngle())*c2;
  c3 = GeoTrf::RotateX3D(0.5 * m_stereoSign * m_module->stereoAngle())*c3;
  c4 = GeoTrf::RotateX3D(0.5 * m_stereoSign * m_module->stereoAngle())*c4;
  c5 = GeoTrf::RotateX3D(0.5 * m_stereoSign * m_module->stereoAngle())*c5;
  c6 = GeoTrf::RotateX3D(0.5 * m_stereoSign * m_module->stereoAngle())*c6;
  c7 = GeoTrf::RotateX3D(0.5 * m_stereoSign * m_module->stereoAngle())*c7;
  
  moduleYMax = std::max(std::max(c0.y(), c4.y()), std::max(c7.y(), c3.y()));
  moduleYMin = std::min(std::min(c1.y(), c5.y()), std::min(c6.y(), c2.y()));
  
  double skiWidth = moduleYMax - moduleYMin + 2*rphiClearance;
 
  //
  // NB. The envelope is centered on x.
  //
  double skiThickness = m_module->thickness() + 2 * std::abs(xModuleOffset) + radialClearance;
            
  // Due to the cooling block and dogleg being next to the module and
  // as the modules are staggered it is no longer possible to have a
  // simple envelope around the ski.
 
  // Calculate envelope needed. This is a boolean of two rectangles. 
  // 1. Contains the modules and dogleg.
  // 2. Contains the cooling pipe and cooling block.
 
  double xmax1 = 0.5*skiThickness;
  double xmin1 = -xModuleOffset + xDoglegOffset - 0.5*m_dogleg->thickness();
  double xmax2 = xmax1;  
  double xmin2 = xCoolingPipePos - m_coolingPipe->pipeRadius();
 
  // Take into account possiblity that the dogleg extends past the module.
 
  double ymax1 = moduleYMax + rphiClearance;
  double ymin1 = moduleYMin - rphiClearance;
  double ymin2,ymax2;
  if (tiltSign > 0) {
    ymax2 = std::max(-yModuleOffset + yCoolingBlockOffset + 0.5*m_coolingBlock->width(),
                     yCoolingPipePos + m_coolingPipe->pipeRadius());
    ymin2 = ymin1;
  } else {
    ymax2 = ymax1;
    ymin2 = std::min(-yModuleOffset + yCoolingBlockOffset - 0.5*m_coolingBlock->width(),
                     yCoolingPipePos - m_coolingPipe->pipeRadius());
  }
  
 
  // Add some safety
  xmin1 -= m_safety;
  xmax1 += m_safety;
  ymin1 -= m_safety;
  ymax1 += m_safety;
 
  xmin2 -= m_safety;
  xmax2 += m_safety;
  ymin2 -= m_safety;
  ymax2 += m_safety;
 
  double xCenter = 0.5*(xmin1+xmax1);
  double yCenter = 0.5*(ymin1+ymax1);
  double xShift2 = 0.5*(xmin2+xmax2) - xCenter;
  double yShift2 = 0.5*(ymin2+ymax2) - yCenter;
 
  m_refPointTransform = new GeoTransform(GeoTrf::Translate3D(-xCenter, -yCenter, 0));
 
  m_env1RefPointVector = std::make_unique<GeoTrf::Vector3D>(-xCenter, -yCenter, 0.0);
  m_env2RefPointVector = std::make_unique<GeoTrf::Vector3D>(-xShift2, -yShift2, 0.0);
  m_env1Thickness      = xmax1-xmin1;
  m_env1Width          = ymax1-ymin1;
  m_env2Thickness      = xmax2-xmin2;
  m_env2Width          = ymax2-ymin2;
 
  GeoBox * envelope1 = new GeoBox(0.5 * (xmax1-xmin1), 0.5 * (ymax1-ymin1), 0.5 * m_length);
  GeoBox * envelope2 = new GeoBox(0.5 * (xmax2-xmin2), 0.5 * (ymax2-ymin2), 0.5 * m_length);
 
  const GeoShape * skiEnvelopeShape = nullptr;
    
  const GeoShape & tmpShape = (*envelope1).
    add(*envelope2 << GeoTrf::Translate3D(xShift2, yShift2, 0));
  skiEnvelopeShape = &tmpShape;
  
  GeoLogVol * skiLog = new GeoLogVol(getName(), skiEnvelopeShape, m_materials->gasMaterial());
 
  // Make names once only so we don't recreate them again again.
  for (int iModule = 0; iModule < m_modulesPerSki; iModule++) {
    // Add identifier to name.
    std::string name = std::format("Module#{}",m_id[iModule]);
    m_nameTag.push_back(new GeoNameTag(name));
  }
 
 
  // Define thickness, width, and length. This is chosen as bounding box centered on the ski rotation axis
  // which contains the modules and dogleg (ie cooling blocks and cooling pipe is ignored.)
  m_thickness = 2 * std::abs(xmin1);
  m_width = skiWidth;
 
 
  // Calculate the clearances. Module envelope1 is the thickness up to the sensors. This is used for the module to 
  // module distance
 
  return skiLog;
 
}

radialSep()

double SCT_Ski::radialSep ( ) const

inline

Definition at line 54 of file SCT_Ski.h.

{return m_radialSep;}

stereoSign()

int SCT_Ski::stereoSign ( ) const

inline

Definition at line 59 of file SCT_Ski.h.

{return m_stereoSign;}

thickness()

double SCT_Ski::thickness ( ) const

inline

Definition at line 48 of file SCT_Ski.h.

{return m_thickness;}

tilt()

double SCT_Ski::tilt ( ) const

inline

Definition at line 58 of file SCT_Ski.h.

{return m_tilt;}

width()

double SCT_Ski::width ( ) const

inline

Definition at line 49 of file SCT_Ski.h.

{return m_width;}

zPos()

double SCT_Ski::zPos ( int i ) const

inline

Definition at line 52 of file SCT_Ski.h.

{return m_zPos[i];}

Member Data Documentation

m_coolingBlock

std::unique_ptr<SCT_CoolingBlock> SCT_Ski::m_coolingBlock

private

Definition at line 126 of file SCT_Ski.h.

m_coolingBlockOffsetX

double SCT_Ski::m_coolingBlockOffsetX = 0.0

private

Definition at line 115 of file SCT_Ski.h.

m_coolingBlockOffsetY

double SCT_Ski::m_coolingBlockOffsetY = 0.0

private

Definition at line 116 of file SCT_Ski.h.

m_coolingBlockOffsetZ

double SCT_Ski::m_coolingBlockOffsetZ = 0.0

private

Definition at line 117 of file SCT_Ski.h.

m_coolingBlockPhiOffset

double SCT_Ski::m_coolingBlockPhiOffset = 0.0

private

Definition at line 109 of file SCT_Ski.h.

m_coolingBlockPos

std::vector<GeoTransform *> SCT_Ski::m_coolingBlockPos

private

Definition at line 145 of file SCT_Ski.h.

m_coolingBlockRadialOffset

double SCT_Ski::m_coolingBlockRadialOffset = 0.0

private

Definition at line 110 of file SCT_Ski.h.

m_coolingPipe

std::unique_ptr<SCT_CoolingPipe> SCT_Ski::m_coolingPipe

private

Definition at line 127 of file SCT_Ski.h.

m_coolingPipeOffsetX

double SCT_Ski::m_coolingPipeOffsetX = 0.0

private

Definition at line 118 of file SCT_Ski.h.

m_coolingPipeOffsetY

double SCT_Ski::m_coolingPipeOffsetY = 0.0

private

Definition at line 119 of file SCT_Ski.h.

m_coolingPipePhiOffset

double SCT_Ski::m_coolingPipePhiOffset = 0.0

private

Definition at line 112 of file SCT_Ski.h.

m_coolingPipePos

GeoIntrusivePtr<GeoTransform> SCT_Ski::m_coolingPipePos {}

private

Definition at line 130 of file SCT_Ski.h.

{};

m_coolingPipeRadialOffset

double SCT_Ski::m_coolingPipeRadialOffset = 0.0

private

Definition at line 111 of file SCT_Ski.h.

m_detectorManager

InDetDD::SCT_DetectorManager* SCT_ComponentFactory::m_detectorManager {}

protectedinherited

Definition at line 38 of file SCT_ComponentFactory.h.

{};

m_dogleg

std::unique_ptr<SCT_Dogleg> SCT_Ski::m_dogleg

private

Definition at line 125 of file SCT_Ski.h.

m_doglegOffsetX

double SCT_Ski::m_doglegOffsetX = 0.0

private

Definition at line 121 of file SCT_Ski.h.

m_doglegOffsetY

double SCT_Ski::m_doglegOffsetY = 0.0

private

Definition at line 122 of file SCT_Ski.h.

m_doglegPhiOffset

double SCT_Ski::m_doglegPhiOffset = 0.0

private

Definition at line 107 of file SCT_Ski.h.

m_doglegPos

std::vector<GeoTransform *> SCT_Ski::m_doglegPos

private

Definition at line 144 of file SCT_Ski.h.

m_doglegRadialOffset

double SCT_Ski::m_doglegRadialOffset = 0.0

private

Definition at line 108 of file SCT_Ski.h.

m_env1RefPointVector

std::unique_ptr<GeoTrf::Vector3D> SCT_Ski::m_env1RefPointVector

private

For calculations of envelopes of SCT_DetailLayer.

Definition at line 133 of file SCT_Ski.h.

m_env1Thickness

double SCT_Ski::m_env1Thickness = 0.0

private

Definition at line 137 of file SCT_Ski.h.

m_env1Width

double SCT_Ski::m_env1Width = 0.0

private

Definition at line 138 of file SCT_Ski.h.

m_env2RefPointVector

std::unique_ptr<GeoTrf::Vector3D> SCT_Ski::m_env2RefPointVector

private

For calculations of envelopes of SCT_DetailLayer.

Definition at line 135 of file SCT_Ski.h.

m_env2Thickness

double SCT_Ski::m_env2Thickness = 0.0

private

Definition at line 139 of file SCT_Ski.h.

m_env2Width

double SCT_Ski::m_env2Width = 0.0

private

Definition at line 140 of file SCT_Ski.h.

m_firstStagger

int SCT_Ski::m_firstStagger = 0

private

Definition at line 91 of file SCT_Ski.h.

m_geometryManager

SCT_GeometryManager* SCT_ComponentFactory::m_geometryManager {}

protectedinherited

Definition at line 39 of file SCT_ComponentFactory.h.

{};

m_id

std::vector<int> SCT_Ski::m_id

private

Definition at line 96 of file SCT_Ski.h.

m_length

double SCT_Ski::m_length

private

Definition at line 101 of file SCT_Ski.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_Ski::m_module

private

Definition at line 124 of file SCT_Ski.h.

m_modulePos

std::vector<GeoTrf::Transform3D> SCT_Ski::m_modulePos

private

Definition at line 143 of file SCT_Ski.h.

m_modulesPerSki

int SCT_Ski::m_modulesPerSki = 0

private

Definition at line 92 of file SCT_Ski.h.

m_name

std::string SCT_ComponentFactory::m_name

privateinherited

Definition at line 46 of file SCT_ComponentFactory.h.

m_nameTag

std::vector<GeoNameTag *> SCT_Ski::m_nameTag

private

Definition at line 142 of file SCT_Ski.h.

m_radialSep

double SCT_Ski::m_radialSep = 0.0

private

Definition at line 90 of file SCT_Ski.h.

m_refPointTransform

GeoIntrusivePtr<GeoTransform> SCT_Ski::m_refPointTransform {}

private

Definition at line 129 of file SCT_Ski.h.

{};

m_safety

double SCT_Ski::m_safety = 0.0

private

Definition at line 93 of file SCT_Ski.h.

m_sqliteReader

GeoModelIO::ReadGeoModel* SCT_UniqueComponentFactory::m_sqliteReader {}

protectedinherited

Definition at line 87 of file SCT_ComponentFactory.h.

{};

m_stereoSign

int SCT_Ski::m_stereoSign

private

Definition at line 98 of file SCT_Ski.h.

m_thickness

double SCT_Ski::m_thickness = 0.0

private

Definition at line 103 of file SCT_Ski.h.

m_tilt

double SCT_Ski::m_tilt

private

Definition at line 99 of file SCT_Ski.h.

m_width

double SCT_Ski::m_width = 0.0

private

Definition at line 102 of file SCT_Ski.h.

m_zPos

std::vector<double> SCT_Ski::m_zPos

private

Definition at line 95 of file SCT_Ski.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_Ski.h
• SCT_Ski.cxx