SCT_FwdWheel Class Reference

#include <SCT_FwdWheel.h>

Inheritance diagram for SCT_FwdWheel:

Public Member Functions
	SCT_FwdWheel (const std::string &name, int iWheel, const std::vector< SCT_FwdModule * > &modules, int ec, 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_FwdWheel ()
	SCT_FwdWheel (const SCT_FwdWheel &)=delete
SCT_FwdWheel &	operator= (const SCT_FwdWheel &)=delete
int	wheelNum () const
double	zPosition () const
int	numRings () const
int	ringType (int i) const
const SCT_FwdRing *	ring (int i)
double	thickness () const
double	innerRadius () const
double	outerRadius () const
int	totalModules () const
virtual GeoVPhysVol *	build (SCT_Identifier id)
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 ()

Private Attributes
int	m_iWheel
int	m_endcap
int	m_numRings = 0
double	m_zPosition = 0.0
std::vector< int >	m_ringType
std::vector< int >	m_patchPanelType
std::vector< double >	m_patchPanelLocAngle
std::vector< bool >	m_patchPanelRepeatQuadrant
int	m_numPatchPanelLocs = 0
int	m_numPatchPanelTypes = 0
int	m_numFSITypes = 0
int	m_numWheels = 0
bool	m_optoHarnessPresent = false
bool	m_pPConnectorPresent = false
bool	m_pPCoolingPresent = false
bool	m_discFixationPresent = false
std::vector< double >	m_discFixationLocAngle
double	m_innerRadius = 0.0
double	m_outerRadius = 0.0
double	m_thickness = 0.0
double	m_thicknessFront = 0.0
double	m_thicknessBack = 0.0
int	m_totalModules = 0
int	m_rotateWheel = 0
double	m_ringMaxRadius = 0.0
double	m_safety = 0.0
std::vector< std::unique_ptr< SCT_FwdRing > >	m_rings
std::unique_ptr< SCT_FwdDiscSupport >	m_discSupport
std::vector< std::unique_ptr< SCT_FwdPatchPanel > >	m_patchPanel
std::unique_ptr< SCT_FwdPPConnector >	m_pPConnector
std::unique_ptr< SCT_FwdPPCooling >	m_pPCooling
std::vector< std::unique_ptr< SCT_FwdFSI > >	m_fsiType
std::unique_ptr< SCT_FwdDiscFixation >	m_discFixation
const std::vector< SCT_FwdModule * > &	m_modules
const std::vector< const FSIDetails * > *	m_fsiVector = nullptr
std::string	m_name

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

Detailed Description

Definition at line 25 of file SCT_FwdWheel.h.

Constructor & Destructor Documentation

SCT_FwdWheel() [1/2]

SCT_FwdWheel::SCT_FwdWheel	(	const std::string &	name,
		int	iWheel,
		const std::vector< SCT_FwdModule * > &	modules,
		int	ec,
		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_FwdWheel.cxx.

  : SCT_UniqueComponentFactory(name, detectorManager, geometryManager, materials, sqliteReader, std::move(mapFPV), std::move(mapAX)),
    m_iWheel(iWheel), 
    m_endcap(ec),
    m_modules(modules)
{
  getParameters();
  m_logVolume = SCT_FwdWheel::preBuild();
}

~SCT_FwdWheel()

SCT_FwdWheel::~SCT_FwdWheel ( )

default

SCT_FwdWheel() [2/2]

SCT_FwdWheel::SCT_FwdWheel ( const SCT_FwdWheel & )

delete

Member Function Documentation

build()

GeoVPhysVol * SCT_FwdWheel::build ( SCT_Identifier id )

virtual

Implements SCT_UniqueComponentFactory.

Definition at line 252 of file SCT_FwdWheel.cxx.

{
    
    if(m_sqliteReader) {
        
        for (int iRing = 0; iRing < m_numRings; iRing++){
            
            SCT_FwdRing * ring = m_rings[iRing].get();
            id.setEtaModule(ring->identifier());
            ring->build(id);
        
        }
        return nullptr;
        
    }
    
    GeoFullPhysVol * wheel= new GeoFullPhysVol(m_logVolume);
    
    
    // Add discsupport. Its centered so no need for a transform
    wheel->add(m_discSupport->getVolume());
    
    //
    // Loop over rings and put in rings, cooling and power tapes.
    //
    double powerTapeZPlusMax = 0.5 * m_discSupport->thickness();
    double powerTapeZMinusMax = -0.5 * m_discSupport->thickness();
    
    double maxZOfRingsFront = 0;
    
    for (int iRing = 0; iRing < m_numRings; iRing++){
        
        SCT_FwdRing * ring = m_rings[iRing].get();
        
        // Position ring
        double ringZpos = ring->ringSide() * ring->ringOffset();
        double ringOuterZ = ring->ringOffset() +  ring->thicknessOuter();
        maxZOfRingsFront = std::max(maxZOfRingsFront, ringOuterZ);
        
        std::string ringNameTag = std::format("Ring#{}",ring->identifier());
        wheel->add(new GeoNameTag(ringNameTag));
        wheel->add(new GeoIdentifierTag(ring->identifier()));
        wheel->add(new GeoTransform(GeoTrf::Translate3D(0, 0, ringZpos)));
        id.setEtaModule(ring->identifier());
        wheel->add(ring->build(id));
        
        // Position cooling
        // Get a pointer to the cooling ring.
        SCT_FwdRingCooling cooling(std::format("RingCoolingW{}R{}",m_iWheel,iRing),
                                   iRing, m_detectorManager, m_geometryManager, m_materials);
        double coolingZpos = ring->ringSide() * (0.5*(m_discSupport->thickness() + cooling.thickness()));
        wheel->add(new GeoTransform(GeoTrf::TranslateZ3D(coolingZpos)));
        wheel->add(cooling.getVolume());
        
        // Power Tapes
        // Get a pointer to the power tape
        SCT_FwdDiscPowerTape powerTape(std::format("PowerTapeW{}R{}",m_iWheel,iRing), iRing,
                                       m_detectorManager, m_geometryManager, m_materials);
        
        double powerTapeZpos = ring->ringSide() * (0.5*(m_discSupport->thickness() + powerTape.thickness()) +
                                                   cooling.thickness());
        // Make sure we don't overlap with powertape from outer rings
        // We store max extent of power tape for each side (Plus, Minus)
        // This is really only ever an issue for ring2 but we keep it general.
        if (ring->ringSide() > 0) {
            double powerTapeZstart = powerTapeZpos -  0.5 * powerTape.thickness();
            if (powerTapeZstart < powerTapeZPlusMax) {
                powerTapeZpos = powerTapeZPlusMax +  0.5 * powerTape.thickness();
            }
            powerTapeZPlusMax = powerTapeZpos +  0.5 * powerTape.thickness();
        } else {
            double powerTapeZstart = powerTapeZpos +  0.5 * powerTape.thickness();
            if (powerTapeZstart > powerTapeZMinusMax) {
                powerTapeZpos = powerTapeZMinusMax -  0.5 * powerTape.thickness();
            }
            powerTapeZMinusMax = powerTapeZpos -  0.5 * powerTape.thickness();
        }
        if ((std::abs(powerTapeZpos)+0.5*powerTape.thickness()) > (std::abs(ringZpos) -  0.5*ring->thicknessInner())) {
            std::cout << "ERROR:  Power tapes clash with modules!!!" << std::endl;
        }
        wheel->add(new GeoTransform(GeoTrf::TranslateZ3D(powerTapeZpos)));
        wheel->add(powerTape.getVolume());
        
        
    } // End Ring loop
    
    
    //
    // Put in the patch Panel
    //
    // Put it on opposide side of outer ring (ring 0).
    int patchPanelSide = m_rotateWheel;
    
    
    // Get outer position of power tape on that side.
    // In case there are no rings on that side (and hence no powertapes) this will be 1/2 disc support thickness
    double powerTapeZMax = 0;
    if (patchPanelSide > 0) {
        powerTapeZMax =  powerTapeZPlusMax;
    } else {
        powerTapeZMax =  -powerTapeZMinusMax;
    }
    
    
    
    // Loop over patch panel locations
    for (int iPPLoc = 0; iPPLoc < m_numPatchPanelLocs ; iPPLoc++) {
        
        // The patchpanels generally repeat in the four quadrants.
        int numRepeat = 1;
        if (m_patchPanelRepeatQuadrant[iPPLoc]) numRepeat = 4;
        int ppType = m_patchPanelType[iPPLoc];
        if (ppType >= m_numPatchPanelTypes) std::cout << "ERROR: Patch Panel type number out of range!" << std::endl;
        for (int iRepeat = 0; iRepeat < numRepeat; iRepeat++) {
            
            // Calculate the location.
            double patchPanelAngle = m_patchPanelLocAngle[iPPLoc] + iRepeat * 90*Gaudi::Units::degree;
            double patchPanelZpos =  patchPanelSide * (powerTapeZMax + 0.5*m_patchPanel[ppType]->thickness() + m_safety);
            double patchPanelR = m_patchPanel[ppType]->midRadius();
            
            // Check for overlap with middle ring.
            if (m_numRings >= 2 && (m_patchPanel[ppType]->innerRadius() <= m_rings[1]->outerRadius())) {
                std::cout << "ERROR: Patch Panel clashes with middle ring" << std::endl;
                std::cout << " PatchPanel inner radius: " << m_patchPanel[ppType]->innerRadius() << std::endl;
                std::cout << " Ring outer radius: " << m_rings[1]->outerRadius() << std::endl;
            }
            
            // Add it to the wheel
            wheel->add(new GeoTransform(GeoTrf::RotateZ3D(patchPanelAngle)*GeoTrf::TranslateX3D(patchPanelR)*GeoTrf::TranslateZ3D(patchPanelZpos)));
            wheel->add(m_patchPanel[ppType]->getVolume());
            
            // Make and add the connector for PPF0e (type 0)
            // Positioned immediately outside PatchPanel at same angle
            if(ppType == 0 && m_pPConnectorPresent) {
                double ppConnectorZpos =  patchPanelSide * (powerTapeZMax + 0.5*m_pPConnector->thickness() + m_safety);
                double ppConnectorR = m_patchPanel[ppType]->outerRadius() + 0.5*m_pPConnector->deltaR() + m_safety;
                // Check is within wheel
                if (ppConnectorR + 0.5*m_pPConnector->deltaR() >= m_outerRadius) {
                    std::cout << "ERROR: Patch Panel Connector clashes outside wheel" << std::endl;
                    std::cout << " PatchPanel Connector outer radius: " << ppConnectorR + 0.5*m_pPConnector->deltaR() << std::endl;
                    std::cout << " Wheel outer radius: " << m_outerRadius << std::endl;
                }
                // Add it to the wheel
                wheel->add(new GeoTransform(GeoTrf::RotateZ3D(patchPanelAngle)*GeoTrf::TranslateX3D(ppConnectorR)*GeoTrf::TranslateZ3D(ppConnectorZpos)));
                wheel->add(m_pPConnector->getVolume());
            }
            
            // Make and add the cooling for PPF0c (type 2)
            // Positioned immediately outside PatchPanel at same angle
            if(ppType == 2 && m_pPCoolingPresent) {
                double ppCoolingZpos =  patchPanelSide * (powerTapeZMax + 0.5*m_pPCooling->thickness() + m_safety);
                double ppCoolingR = m_patchPanel[ppType]->outerRadius() + 0.5*m_pPCooling->deltaR() + m_safety;
                // Check is within wheel
                if (ppCoolingR + 0.5*m_pPCooling->deltaR() >= m_outerRadius) {
                    std::cout << "ERROR: Patch Panel Cooling clashes outside wheel" << std::endl;
                    std::cout << " PatchPanel Cooling outer radius: " << ppCoolingR + 0.5*m_pPCooling->deltaR() << std::endl;
                    std::cout << " Wheel outer radius: " << m_outerRadius << std::endl;
                }
                // Add it to the wheel
                wheel->add(new GeoTransform(GeoTrf::RotateZ3D(patchPanelAngle)*GeoTrf::TranslateX3D(ppCoolingR)*GeoTrf::TranslateZ3D(ppCoolingZpos)));
                wheel->add(m_pPCooling->getVolume());
            }
        }
        
    } // end loop over patch panel locations
    
    
    // Add the optoharness - type depends on number of rings
    // The optoharness is always on the back side (except if the wheel is rotates)
    double optoHarnessZMax = 0.5 * m_discSupport->thickness();
    if (m_optoHarnessPresent) {
        std::string optoharnessName = "OptoHarnessO";
        if(m_numRings > 1) {optoharnessName+="M";}
        if(m_numRings > 2) {optoharnessName+="I";}
        SCT_FwdOptoHarness optoharness(std::format("{}W{}",optoharnessName,m_iWheel), m_numRings,
                                       m_detectorManager, m_geometryManager, m_materials);
        double optoHarnessZpos = 0.5*m_rotateWheel*(m_discSupport->thickness() + optoharness.thickness());
        wheel->add(new GeoTransform(GeoTrf::TranslateZ3D(optoHarnessZpos)));
        wheel->add(optoharness.getVolume());
        optoHarnessZMax = optoHarnessZpos + 0.5*optoharness.thickness();
    }
    
    // Loop over FSI locations.
    for (unsigned int iFSI = 0; iFSI < m_fsiVector->size(); iFSI++) {
        int type = (*m_fsiVector)[iFSI]->simType();
        double fsiRadius = (*m_fsiVector)[iFSI]->location().radius();
        double fsiPhi    = (*m_fsiVector)[iFSI]->location().phi();
        int fsiUsualSide = (*m_fsiVector)[iFSI]->location().side();
        int fsiSide =   fsiUsualSide * m_rotateWheel;
        double fsiZpos = fsiSide * m_fsiType[type]->zOffset();
        
        // Check for clashes on front side
        if (fsiUsualSide < 0) {
            double zMin =  std::abs(fsiZpos) -  0.5*m_fsiType[type]->thickness();
            if (maxZOfRingsFront > zMin) {
                std::cout << "WARNING: FSI probably clashes with ring" << std::endl;
                std::cout << " maxZOfRingsFront = " << maxZOfRingsFront << std::endl;
                std::cout << " fsiZMin = " << zMin << std::endl;
            }
        } else {   // ... and backside
            // Check radius of fsi.
            // If outer radii check for overlap with powertape
            // If inner radii check for overlap with optoharness (disksupport if no optoharness)
            double diskMidRadius = 0.5*(m_outerRadius + m_innerRadius);
            double servicesZMax = (fsiRadius > diskMidRadius) ? powerTapeZMax : optoHarnessZMax;
            double zMin =  std::abs(fsiZpos) -  0.5*m_fsiType[type]->thickness();
            if (servicesZMax > zMin) {
                std::cout << "WARNING: FSI probably clashes with disc services" << std::endl;
                std::cout << " servicesZMax = " << servicesZMax << std::endl;
                std::cout << " fsiZMin = " << zMin << std::endl;
                std::cout << " fsiRadius = " << fsiRadius << std::endl;
            }
        }
        
        wheel->add(new GeoTransform(GeoTrf::RotateZ3D(fsiPhi)*GeoTrf::TranslateX3D(fsiRadius)*GeoTrf::TranslateZ3D(fsiZpos)));
        wheel->add(m_fsiType[type]->getVolume());
        
        
    } // end loop over FSI.
    
    // Loop over disc fixation locations
    if(m_discFixationPresent) {
        for (unsigned int iLoc = 0; iLoc < m_discFixationLocAngle.size() ; iLoc++) {
            // The disc fixations repeat in the four quadrants.
            for (int iRepeat = 0; iRepeat < 4; iRepeat++) {
                // Calculate the location.
                double discFixationAngle = m_discFixationLocAngle[iLoc] + iRepeat * 90*Gaudi::Units::degree;
                double discFixationR = m_ringMaxRadius + 0.5*m_discFixation->thickness() + m_safety;
                // Check is within wheel
                if (discFixationR + 0.5*m_discFixation->thickness() >= m_outerRadius) {
                    std::cout << "ERROR: Disc Fixation outside wheel" << std::endl;
                    std::cout << "Disc fixation outer radius: " << discFixationR + 0.5*m_discFixation->thickness() << std::endl;
                    std::cout << " Wheel outer radius: " << m_outerRadius << std::endl;
                }
                // Add it to the wheel
                wheel->add(new GeoTransform(GeoTrf::RotateY3D(90.*Gaudi::Units::degree)*GeoTrf::RotateX3D(discFixationAngle)*GeoTrf::TranslateZ3D(discFixationR)));
                wheel->add(m_discFixation->getVolume());
            }
        }
    }
    
    // Extra Material
    InDetDD::ExtraMaterial xMat(m_geometryManager->distortedMatManager());
    xMat.add(wheel, "SCTDisc");
    xMat.add(wheel, std::format("SCTDisc{}",m_iWheel));
    if (m_endcap > 0) {
      xMat.add(wheel, "SCTDiscA");
      xMat.add(wheel, std::format("SCTDiscA{}",m_iWheel));
    }
    else {
      xMat.add(wheel, "SCTDiscC");
      xMat.add(wheel, std::format("SCTDiscC{}",m_iWheel));
    }
    
    return wheel;
}

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_FwdWheel::getParameters ( )

private

Definition at line 74 of file SCT_FwdWheel.cxx.

{
    const SCT_ForwardParameters * parameters = m_geometryManager->forwardParameters();
    
    m_zPosition = parameters->fwdWheelZPosition(m_iWheel);
    m_numRings  = parameters->fwdWheelNumRings(m_iWheel);
    for (int iRing = 0; iRing < m_numRings; iRing++) {
        m_ringType.push_back(parameters->fwdWheelModuleType(m_iWheel,iRing, m_endcap));
    }
    
    if(!m_sqliteReader){
        
        m_numPatchPanelLocs =  parameters->fwdNumPatchPanelLocs();
        m_numPatchPanelTypes = parameters->fwdNumPatchPanelTypes();
        
        for (int iPPLoc = 0; iPPLoc < m_numPatchPanelLocs; iPPLoc++) {
            m_patchPanelType.push_back(parameters->fwdPatchPanelType(iPPLoc));
            m_patchPanelLocAngle.push_back(parameters->fwdPatchPanelLocAngle(iPPLoc));
            m_patchPanelRepeatQuadrant.push_back(parameters->fwdPatchPanelRepeatQuadrant(iPPLoc));
        }
        
        // FIXME: Check and put these in DB or calculate them
        // We have a maximum width of 80.2. Make it 75 for some clearance.
        //m_innerRadius = 267 * Gaudi::Units::mm;
        //m_outerRadius = 590 * Gaudi::Units::mm;
        //m_thickness = 100 * Gaudi::Units::mm;
        // These get swapped later if the wheel is rotated.
        m_thicknessFront = 30 * Gaudi::Units::mm;
        m_thicknessBack  = 45 * Gaudi::Units::mm;
        
        m_numFSITypes = parameters->fwdFSINumGeomTypes();
        m_fsiVector =  &(parameters->fsiVector(m_iWheel));
        
        m_numWheels    = parameters->fwdNumWheels();
        
        m_optoHarnessPresent = parameters->fwdOptoHarnessPresent();
        m_pPConnectorPresent = parameters->fwdPPConnectorPresent();
        m_pPCoolingPresent = parameters->fwdPPCoolingPresent();
        
        m_discFixationPresent = parameters->fwdDiscFixationPresent();
        if(m_discFixationPresent) {
            for (int iLoc = 0; iLoc < parameters->fwdNumCylinderServiceLocs(); iLoc++) {
                // Disc fixations are at same locations at as N2 pipes
                if(parameters->fwdCylinderServiceLocName(iLoc) == "NPipe") {
                    m_discFixationLocAngle.push_back(parameters->fwdCylinderServiceLocAngle(iLoc));
                }
            }
        }
        
        m_safety = m_geometryManager->generalParameters()->safety();
    }
    
    // Set numerology
    m_detectorManager->numerology().setNumRingsForDisk(m_iWheel,m_numRings);
 
}

innerRadius()

double SCT_FwdWheel::innerRadius ( ) const

inline

Definition at line 57 of file SCT_FwdWheel.h.

{return m_innerRadius;} 

numRings()

int SCT_FwdWheel::numRings ( ) const

inline

Definition at line 49 of file SCT_FwdWheel.h.

{return m_numRings;}

operator=()

SCT_FwdWheel & SCT_FwdWheel::operator= ( const SCT_FwdWheel & )

delete

outerRadius()

double SCT_FwdWheel::outerRadius ( ) const

inline

Definition at line 58 of file SCT_FwdWheel.h.

{return m_outerRadius;} 

preBuild()

const GeoLogVol * SCT_FwdWheel::preBuild ( )

privatevirtual

Implements SCT_UniqueComponentFactory.

Definition at line 132 of file SCT_FwdWheel.cxx.

{
  // The rings
  for (int iRing = 0; iRing < m_numRings; iRing++){
    std::string ringName = std::format("Ring{}For{}",iRing,getName());
    int ringType = m_ringType[iRing];
    m_rings.push_back(std::make_unique<SCT_FwdRing>(ringName, m_modules[ringType], m_iWheel, iRing, m_endcap,m_detectorManager, m_geometryManager, m_materials, m_sqliteReader, m_mapFPV,m_mapAX));
  }
 
  if(m_sqliteReader) return nullptr;
 
  // Calculate total number of modules
  m_totalModules = 0;
  for (int iRing = 0; iRing < m_numRings; iRing++){
    m_totalModules += m_rings[iRing]->numModules();
  }
 
  // Create disc support.
  m_discSupport = std::make_unique<SCT_FwdDiscSupport>(std::format("DiscSupport{}",m_iWheel), m_iWheel,
                               m_detectorManager, m_geometryManager, m_materials);
 
  // Create Patch Panel
  for (int iPPType = 0; iPPType < m_numPatchPanelTypes; iPPType++) {
    m_patchPanel.push_back(std::make_unique<SCT_FwdPatchPanel>(std::format("PatchPanel{}",iPPType), iPPType,
                                   m_detectorManager, m_geometryManager, m_materials));
  }
 
  // Create Patch Pannel Connector and Cooling, and disc Fixations
  if (m_pPConnectorPresent) {
    m_pPConnector = std::make_unique<SCT_FwdPPConnector>("PPConnector",
                             m_detectorManager, m_geometryManager, m_materials);
  }
  if (m_pPCoolingPresent) {
    m_pPCooling = std::make_unique<SCT_FwdPPCooling>("PPCooling",
                             m_detectorManager, m_geometryManager, m_materials);
  }
  if (m_discFixationPresent) {
    m_discFixation = std::make_unique<SCT_FwdDiscFixation>("DiscFixation",
                               m_detectorManager, m_geometryManager, m_materials);
  }
 
  // Create the FSI types
  m_fsiType.resize(m_numFSITypes);
  for (unsigned int iFSI = 0; iFSI < m_fsiVector->size(); iFSI++) {
    int type = (*m_fsiVector)[iFSI]->simType();
    if (!m_fsiType[type]) {
      m_fsiType[type] = std::make_unique<SCT_FwdFSI>(std::format("FSI{}",type), type,
                             m_detectorManager, m_geometryManager, m_materials);
    }
  }
 
  // Calculate the extent of the envelope
  // Use support disc as starting values.
  double maxOuterRadius = m_discSupport->outerRadius();
  double minInnerRadius = m_discSupport->innerRadius();
  double maxModuleThickness = 0.5 * m_discSupport->thickness();
 
  // Extend min max accounting for rings
  for (int iRing = 0; iRing < m_numRings; iRing++){
    maxOuterRadius = std::max(m_rings[iRing]->outerRadius(), maxOuterRadius);
    minInnerRadius = std::min(m_rings[iRing]->innerRadius(), minInnerRadius);
    maxModuleThickness = std::max(maxModuleThickness, m_rings[iRing]->thicknessOuter() +  m_rings[iRing]->ringOffset());
  }
  m_ringMaxRadius = maxOuterRadius;
 
  // If first or last wheel there is nothing protruding beyond the rings so we reduce the
  // envelope size. Comes to about 20 mm. Note the front becomes the back later for the last wheel.
  if ((m_iWheel == 0) || (m_iWheel == m_numWheels - 1)) {
    m_thicknessFront = maxModuleThickness + 1*Gaudi::Units::mm; // We give plenty of safety as we have the room.
    // But now modified by disc fixations
    if(m_discFixationPresent) {
      m_thicknessFront = std::max(m_thicknessFront,m_discFixation->radius() + m_safety);
    }
  }
 
  // The outer radius is now defined by the patch panel cooling if present
  if(m_pPCoolingPresent) {
    double ppCoolingOuterRadius = sqrt(sqr(m_patchPanel[2]->outerRadius() + m_pPCooling->deltaR()) + sqr(m_pPCooling->rphi())) + m_safety;
    maxOuterRadius = std::max(ppCoolingOuterRadius, maxOuterRadius);
  }
 
  // Or maybe by the disc fixations...
  if(m_discFixationPresent) {
    double discFixationOuterRadius = sqrt(sqr(m_ringMaxRadius + m_discFixation->thickness() + m_safety) + sqr(m_discFixation->radius())) + m_safety;
    maxOuterRadius = std::max(discFixationOuterRadius, maxOuterRadius);
  }
 
  m_rotateWheel = +1; // +1 normal, -1 rotate (ie last wheel)
  if (m_numRings > 0) { // Should always be true
    m_rotateWheel = (m_rings[0]->discRotated()) ? -1 : +1 ;
  }
 
  // swap thickness front/back (this only happens for the last wheel).
  if (m_rotateWheel < 0) {
    double tmp = m_thicknessFront;
    m_thicknessFront = m_thicknessBack;
    m_thicknessBack  = tmp;
  }
 
  m_thickness =  m_thicknessFront +  m_thicknessBack;
 
  m_innerRadius = minInnerRadius - m_safety;
  m_outerRadius = maxOuterRadius + m_safety;
 
  // TODO. Have to account for FSI and patch panels
  //m_thickness   = 2. * maxRingOffset + maxThickness;
  // m_thickness  = 100 * Gaudi::Units::mm;
  
  // Make envelope for the wheel
  double envelopeShift = 0.5*(m_thicknessBack - m_thicknessFront);
  const GeoTube * tmpShape = new GeoTube(m_innerRadius, m_outerRadius, 0.5 * m_thickness);
  const GeoShape & fwdWheelEnvelopeShape = *tmpShape <<  GeoTrf::Translate3D(0, 0, envelopeShift);
 
  const GeoLogVol * fwdWheelLog =
    new GeoLogVol(getName(), &fwdWheelEnvelopeShape, m_materials->gasMaterial());
 
  return fwdWheelLog;
}

ring()

const SCT_FwdRing * SCT_FwdWheel::ring ( int i )

inline

Definition at line 51 of file SCT_FwdWheel.h.

{return m_rings[i].get();}

ringType()

int SCT_FwdWheel::ringType ( int i ) const

inline

Definition at line 50 of file SCT_FwdWheel.h.

{return m_ringType[i];} 

thickness()

double SCT_FwdWheel::thickness ( ) const

inline

Definition at line 56 of file SCT_FwdWheel.h.

{return m_thickness;}

totalModules()

int SCT_FwdWheel::totalModules ( ) const

inline

Definition at line 59 of file SCT_FwdWheel.h.

{return m_totalModules;}

wheelNum()

int SCT_FwdWheel::wheelNum ( ) const

inline

Definition at line 44 of file SCT_FwdWheel.h.

{return m_iWheel;}

zPosition()

double SCT_FwdWheel::zPosition ( ) const

inline

Definition at line 48 of file SCT_FwdWheel.h.

{return m_zPosition;} 

Member Data Documentation

m_detectorManager

InDetDD::SCT_DetectorManager* SCT_ComponentFactory::m_detectorManager {}

protectedinherited

Definition at line 38 of file SCT_ComponentFactory.h.

{};

m_discFixation

std::unique_ptr<SCT_FwdDiscFixation> SCT_FwdWheel::m_discFixation

private

Definition at line 107 of file SCT_FwdWheel.h.

m_discFixationLocAngle

std::vector<double> SCT_FwdWheel::m_discFixationLocAngle

private

Definition at line 86 of file SCT_FwdWheel.h.

m_discFixationPresent

bool SCT_FwdWheel::m_discFixationPresent = false

private

Definition at line 85 of file SCT_FwdWheel.h.

m_discSupport

std::unique_ptr<SCT_FwdDiscSupport> SCT_FwdWheel::m_discSupport

private

Definition at line 102 of file SCT_FwdWheel.h.

m_endcap

int SCT_FwdWheel::m_endcap

private

Definition at line 69 of file SCT_FwdWheel.h.

m_fsiType

std::vector<std::unique_ptr<SCT_FwdFSI> > SCT_FwdWheel::m_fsiType

private

Definition at line 106 of file SCT_FwdWheel.h.

m_fsiVector

const std::vector<const FSIDetails *>* SCT_FwdWheel::m_fsiVector = nullptr

private

Definition at line 112 of file SCT_FwdWheel.h.

m_geometryManager

SCT_GeometryManager* SCT_ComponentFactory::m_geometryManager {}

protectedinherited

Definition at line 39 of file SCT_ComponentFactory.h.

{};

m_innerRadius

double SCT_FwdWheel::m_innerRadius = 0.0

private

Definition at line 89 of file SCT_FwdWheel.h.

m_iWheel

int SCT_FwdWheel::m_iWheel

private

Definition at line 68 of file SCT_FwdWheel.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_modules

const std::vector<SCT_FwdModule*>& SCT_FwdWheel::m_modules

private

Definition at line 109 of file SCT_FwdWheel.h.

m_name

std::string SCT_ComponentFactory::m_name

privateinherited

Definition at line 46 of file SCT_ComponentFactory.h.

m_numFSITypes

int SCT_FwdWheel::m_numFSITypes = 0

private

Definition at line 80 of file SCT_FwdWheel.h.

m_numPatchPanelLocs

int SCT_FwdWheel::m_numPatchPanelLocs = 0

private

Definition at line 78 of file SCT_FwdWheel.h.

m_numPatchPanelTypes

int SCT_FwdWheel::m_numPatchPanelTypes = 0

private

Definition at line 79 of file SCT_FwdWheel.h.

m_numRings

int SCT_FwdWheel::m_numRings = 0

private

Definition at line 72 of file SCT_FwdWheel.h.

m_numWheels

int SCT_FwdWheel::m_numWheels = 0

private

Definition at line 81 of file SCT_FwdWheel.h.

m_optoHarnessPresent

bool SCT_FwdWheel::m_optoHarnessPresent = false

private

Definition at line 82 of file SCT_FwdWheel.h.

m_outerRadius

double SCT_FwdWheel::m_outerRadius = 0.0

private

Definition at line 90 of file SCT_FwdWheel.h.

m_patchPanel

std::vector<std::unique_ptr<SCT_FwdPatchPanel> > SCT_FwdWheel::m_patchPanel

private

Definition at line 103 of file SCT_FwdWheel.h.

m_patchPanelLocAngle

std::vector<double> SCT_FwdWheel::m_patchPanelLocAngle

private

Definition at line 76 of file SCT_FwdWheel.h.

m_patchPanelRepeatQuadrant

std::vector<bool> SCT_FwdWheel::m_patchPanelRepeatQuadrant

private

Definition at line 77 of file SCT_FwdWheel.h.

m_patchPanelType

std::vector<int> SCT_FwdWheel::m_patchPanelType

private

Definition at line 75 of file SCT_FwdWheel.h.

m_pPConnector

std::unique_ptr<SCT_FwdPPConnector> SCT_FwdWheel::m_pPConnector

private

Definition at line 104 of file SCT_FwdWheel.h.

m_pPConnectorPresent

bool SCT_FwdWheel::m_pPConnectorPresent = false

private

Definition at line 83 of file SCT_FwdWheel.h.

m_pPCooling

std::unique_ptr<SCT_FwdPPCooling> SCT_FwdWheel::m_pPCooling

private

Definition at line 105 of file SCT_FwdWheel.h.

m_pPCoolingPresent

bool SCT_FwdWheel::m_pPCoolingPresent = false

private

Definition at line 84 of file SCT_FwdWheel.h.

m_ringMaxRadius

double SCT_FwdWheel::m_ringMaxRadius = 0.0

private

Definition at line 96 of file SCT_FwdWheel.h.

m_rings

std::vector<std::unique_ptr<SCT_FwdRing> > SCT_FwdWheel::m_rings

private

Definition at line 101 of file SCT_FwdWheel.h.

m_ringType

std::vector<int> SCT_FwdWheel::m_ringType

private

Definition at line 74 of file SCT_FwdWheel.h.

m_rotateWheel

int SCT_FwdWheel::m_rotateWheel = 0

private

Definition at line 95 of file SCT_FwdWheel.h.

m_safety

double SCT_FwdWheel::m_safety = 0.0

private

Definition at line 98 of file SCT_FwdWheel.h.

m_sqliteReader

GeoModelIO::ReadGeoModel* SCT_UniqueComponentFactory::m_sqliteReader {}

protectedinherited

Definition at line 87 of file SCT_ComponentFactory.h.

{};

m_thickness

double SCT_FwdWheel::m_thickness = 0.0

private

Definition at line 91 of file SCT_FwdWheel.h.

m_thicknessBack

double SCT_FwdWheel::m_thicknessBack = 0.0

private

Definition at line 93 of file SCT_FwdWheel.h.

m_thicknessFront

double SCT_FwdWheel::m_thicknessFront = 0.0

private

Definition at line 92 of file SCT_FwdWheel.h.

m_totalModules

int SCT_FwdWheel::m_totalModules = 0

private

Definition at line 94 of file SCT_FwdWheel.h.

m_zPosition

double SCT_FwdWheel::m_zPosition = 0.0

private

Definition at line 73 of file SCT_FwdWheel.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_FwdWheel.h
• SCT_FwdWheel.cxx