#include <SCT_Forward.h>

Inheritance diagram for SCT_Forward:

Collaboration diagram for SCT_Forward:

Public Member Functions
	SCT_Forward (const std::string &name, 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_Forward ()
int	numModuleTypes () const
int	numWheels () const
double	innerRadius () const
double	outerRadius () const
double	zMax () const
double	zMin () const
double	trtGapPos () const
double	length () const
double	zCenter () 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_endcap
int	m_numModuleTypes = 0
int	m_numWheels = 0
double	m_innerRadius = 0.0
double	m_outerRadius = 0.0
double	m_zMin = 0.0
double	m_zMax = 0.0
double	m_trtGapPos = 0.0
double	m_coolingPipeRadius = 0.0
int	m_numThermalShieldElements = 0
bool	m_cylinderServicesPresent = false
double	m_length = 0.0
double	m_outerRadiusCylinderServices = 0.0
std::vector< std::unique_ptr< SCT_FwdWheel > >	m_wheels
std::vector< std::unique_ptr< SCT_FwdModule > >	m_modules
std::string	m_name

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

Detailed Description

Definition at line 17 of file SCT_Forward.h.

Constructor & Destructor Documentation

◆ SCT_Forward()

SCT_Forward::SCT_Forward	(	const std::string &	name,
		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 40 of file SCT_Forward.cxx.

: SCT_UniqueComponentFactory(name,
                 detectorManager,
                 geometryManager,
                 materials,
                 sqliteReader,
                 std::move(mapFPV),
                 std::move(mapAX)),
  m_endcap(ec)
{
  getParameters();
  m_logVolume = SCT_Forward::preBuild();
}

◆ ~SCT_Forward()

SCT_Forward::~SCT_Forward ( )

default

Member Function Documentation

◆ build()

GeoVPhysVol * SCT_Forward::build ( SCT_Identifier id )

virtual

Implements SCT_UniqueComponentFactory.

Definition at line 135 of file SCT_Forward.cxx.

{
    GeoFullPhysVol * forward=nullptr;
    if(!m_sqliteReader)
    {
        forward = new GeoFullPhysVol(m_logVolume);
        
        for (int iWheel = 0; iWheel < m_numWheels; iWheel++){
            
            SCT_FwdWheel * wheel = m_wheels[iWheel].get();
            double zpos = wheel->zPosition() - zCenter();
            forward->add(new GeoNameTag(std::format("Wheel#{}",iWheel)));
            forward->add(new GeoIdentifierTag(iWheel));
            GeoAlignableTransform * transform = new GeoAlignableTransform(GeoTrf::TranslateZ3D(zpos));
            forward->add(transform);
            id.setLayerDisk(iWheel);
            GeoVPhysVol * wheelPV = wheel->build(id);
            forward->add(wheelPV);
            
            // Store the alignable transform
            m_detectorManager->addAlignableTransform(2, id.getWaferId(), transform, wheelPV);
        }
        
        //
        // Place SupportFrame
        //
        SCT_FwdSupportFrame supportFrame("SupportFrame", m_detectorManager, m_geometryManager, m_materials);
        double supportFrameZPos = supportFrame.zPosition() - zCenter();
        forward->add(new GeoTransform(GeoTrf::TranslateZ3D(supportFrameZPos)));
        forward->add(supportFrame.getVolume());
        
        // Make and Place Cylinder Services
        
        if(m_cylinderServicesPresent) {
            
            // New phi-dependent services
            SCT_FwdCylinderServices cylinderServices("CylinderServices",
                                                     supportFrame.outerRadius(),
                                                     m_outerRadiusCylinderServices,
                                                     supportFrame.length(),
                                                     m_detectorManager, m_geometryManager, m_materials);
            forward->add(new GeoTransform(GeoTrf::TranslateZ3D(supportFrameZPos)));
            forward->add(cylinderServices.getVolume());
            
        } else {
            
            // Old cylindrical services
            //
            // Make cooling pipes. These extend from the wheel to the TRT Gap.
            //
            {
                // End position of the pipes.
                double endPos = m_trtGapPos;
                
                // Calculate radius to start placing cooling pipes. This is equal to the
                // outer radius of the support frame + the pipe radius (The pipe radius is to just
                // give a small gap - it is not really necessary)
                double innerRadiusCooling = supportFrame.outerRadius() + m_coolingPipeRadius;
                
                // Inner radius of cylinder representing pipes. Gets incremented for each wheel.
                double rStart = innerRadiusCooling;
                
                for (int iWheel = 0; iWheel < m_numWheels; iWheel++){
                    // Start position of the pipes.
                    double startPos = m_wheels[iWheel]->zPosition();
                    
                    // Assume one cooling circuit per quadrant of each ring. ie 8 pipes per ring.
                    int numPipes = 8 * m_wheels[iWheel]->numRings();
                    
                    // Label Cooling pipe with W# at end of string
                    SCT_FwdCoolingPipe coolingPipe(std::format("OffDiskCoolingPipeW{}",iWheel),
                                                   numPipes, rStart, startPos, endPos,
                                                   m_detectorManager, m_geometryManager, m_materials);
                    
                    // Place the cooling pipes
                    double coolingPipeZPos = coolingPipe.zPosition() - zCenter();
                    forward->add(new GeoTransform(GeoTrf::TranslateZ3D(coolingPipeZPos)));
                    forward->add(coolingPipe.getVolume());
                    
                    // Set rStart for next cooling pipe equal to outer radius of this cooling pipe.
                    rStart = coolingPipe.outerRadius();
                    
                }
            }
            
            //
            // Make Power Tapes. These extend from the wheel to the TRT Gap.
            //
            {
                
                // End position of the power tapes.
                double endPos = m_trtGapPos;
                
                // Calculate radius to start placing power tapes. This is half way bewteen outer radius
                // of support fram and outer radius of forward envelope.
                // The -1 mm is to avoid a clash with the thermal shield.
                double innerRadiusPowerTapes = 0.5*(supportFrame.outerRadius() + m_outerRadius) - 1*Gaudi::Units::mm;
                
                // Inner radius of cylinder representing power tapes. Gets incremented for each wheel.
                double rStart = innerRadiusPowerTapes;
                
                for (int iWheel = 0; iWheel < m_numWheels; iWheel++){
                    
                    // Start position of the power tapes.
                    double startPos = m_wheels[iWheel]->zPosition();
                    
                    // Get total number of modules in wheel
                    int numModules = m_wheels[iWheel]->totalModules();
                    
                    // Label power tape with W# at end of string
                    SCT_FwdPowerTape powerTape(std::format("OffDiskPowerTapeW{}",iWheel),
                                               numModules, rStart, startPos, endPos,
                                               m_detectorManager, m_geometryManager, m_materials);
                    
                    // Place Power Tapes
                    double powerTapeZPos = powerTape.zPosition() - zCenter();
                    forward->add(new GeoTransform(GeoTrf::TranslateZ3D(powerTapeZPos)));
                    forward->add(powerTape.getVolume());
                    
                    // Set rStart for next power tape equal to outer radius of this power tape.
                    rStart = powerTape.outerRadius();
                } // end loop over wheels
            }
        }
        
        //
        // Place Thermal Shield Elements
        //
        for (int iElement = 0; iElement < m_numThermalShieldElements; iElement++){
      SCT_FwdThermalShieldElement thermalShieldElement(std::format("FwdThermalShieldElement{}",iElement),
                               iElement, m_detectorManager, m_geometryManager, m_materials);
      double elementZPos = thermalShieldElement.zPosition() - zCenter();
      forward->add(new GeoTransform(GeoTrf::TranslateZ3D(elementZPos)));
      forward->add(thermalShieldElement.getVolume());
        }
        
        // Extra Material
        InDetDD::ExtraMaterial xMat(m_geometryManager->distortedMatManager());
        xMat.add(forward, "SCTEndcap", zCenter());
        if (m_endcap > 0) {
      xMat.add(forward, "SCTEndcapA", zCenter());
        } else {
      xMat.add(forward, "SCTEndcapC", zCenter());
        }
 
    }
    else {
      for (int iWheel = 0; iWheel < m_numWheels; iWheel++){
    SCT_FwdWheel * wheel = m_wheels[iWheel].get();
    id.setLayerDisk(iWheel);
    wheel->build(id);
 
    // Store the alignable transform
    std::string key = std::format("Wheel#{}_{}",iWheel,id.getBarrelEC());
    m_detectorManager->addAlignableTransform(2, id.getWaferId(), (*m_mapAX)[key], (*m_mapFPV)[key]);
      }
      if (m_endcap > 0) {
    forward= (*m_mapFPV)["SCTEndcapA"];
      } else {
    forward= (*m_mapFPV)["SCTEndcapC"];
      }
 
    }
    return forward;
}

◆ 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.

35{return m_name;}

SCT_ComponentFactory::m_name

std::string m_name

Definition SCT_ComponentFactory.h:46

◆ getParameters()

void SCT_Forward::getParameters ( )

private

Definition at line 64 of file SCT_Forward.cxx.

{
  const SCT_ForwardParameters * parameters = m_geometryManager->forwardParameters();
  const SCT_ForwardModuleParameters * moduleParameters = m_geometryManager->forwardModuleParameters();
    
  //m_numRingTypes = parameters->fwdNumRingTypes();
  m_numModuleTypes = moduleParameters->fwdModuleNumTypes();
  m_numWheels    = parameters->fwdNumWheels();
  m_innerRadius  = parameters->fwdInnerRadius();
  m_outerRadius  = parameters->fwdOuterRadius();
  m_zMin         = parameters->fwdZMin();
  m_zMax         = parameters->fwdZMax();
  m_trtGapPos    = parameters->fwdTrtGapPos();
  m_coolingPipeRadius        = parameters->fwdCoolingPipeRadius();
  m_numThermalShieldElements = parameters->fwdNumThermalShieldElements();
  m_cylinderServicesPresent  = parameters->fwdCylinderServicePresent();
  
  // Outer radius of cylinder services is given by inner radius of OTE
  if(m_cylinderServicesPresent) {
    for (int iElement = 0; iElement < m_numThermalShieldElements; iElement++){
      if(parameters->fwdThermalShieldMaterial(iElement) == "sct::FwdOTE") {
        m_outerRadiusCylinderServices = parameters->fwdThermalShieldInnerRadius(iElement);
      }
    }
  }
 
  // Length of forward envelope
  m_length = m_zMax - m_zMin;  
 
 
  // Set numerology
  m_detectorManager->numerology().setNumDisks(m_numWheels);
 
 
}

◆ innerRadius()

double SCT_Forward::innerRadius ( ) const

inline

Definition at line 39 of file SCT_Forward.h.

39{return m_innerRadius;}

◆ length()

double SCT_Forward::length ( ) const

inline

Definition at line 48 of file SCT_Forward.h.

48{return m_length;}

◆ numModuleTypes()

int SCT_Forward::numModuleTypes ( ) const

inline

Definition at line 37 of file SCT_Forward.h.

37{return m_numModuleTypes;}

◆ numWheels()

int SCT_Forward::numWheels ( ) const

inline

Definition at line 38 of file SCT_Forward.h.

38{return m_numWheels;}

◆ outerRadius()

double SCT_Forward::outerRadius ( ) const

inline

Definition at line 40 of file SCT_Forward.h.

40{return m_outerRadius;}

◆ preBuild()

const GeoLogVol * SCT_Forward::preBuild ( )

privatevirtual

Implements SCT_UniqueComponentFactory.

Definition at line 103 of file SCT_Forward.cxx.

{
  // Create the elements we need for the forward
  // We make all the module types here. There is a outer, middle, truncated middle and inner type module.
  std::vector<SCT_FwdModule*> modules;
  for (int iModuleType = 0; iModuleType < m_numModuleTypes; iModuleType++){
    
    std::unique_ptr<SCT_FwdModule> module = std::make_unique<SCT_FwdModule>(std::format("FwdModule{}",iModuleType), iModuleType,
                                                                            m_detectorManager, m_geometryManager, m_materials, m_sqliteReader, m_mapFPV, m_mapAX);
    modules.push_back(module.get());
    m_modules.push_back(std::move(module));
  }
 
  for (int iWheel = 0; iWheel < m_numWheels; iWheel++){
    // Build Wheels
    std::string name = std::format("Wheel{}{}",iWheel,((m_endcap > 0) ? "A" : "C"));
    m_wheels.push_back(std::make_unique<SCT_FwdWheel>(name, iWheel, modules, m_endcap,
                                                      m_detectorManager, m_geometryManager, m_materials, m_sqliteReader, m_mapFPV, m_mapAX));
  }
 
  if(m_sqliteReader) return nullptr;
    
  // Make one end of the Forward tracker
  //  Tube envelope containing the forward
  const GeoTube * forwardEnvelopeShape = new GeoTube(m_innerRadius, m_outerRadius, 0.5 * m_length);
  const GeoLogVol * forwardLog = 
    new GeoLogVol(getName(), forwardEnvelopeShape, m_materials->gasMaterial());
  
  return forwardLog;
}

◆ trtGapPos()

double SCT_Forward::trtGapPos ( ) const

inline

Definition at line 43 of file SCT_Forward.h.

43{return m_trtGapPos;}

◆ zCenter()

double SCT_Forward::zCenter ( ) const

inline

Definition at line 49 of file SCT_Forward.h.

49{return 0.5*(m_zMin+m_zMax);}

◆ zMax()

double SCT_Forward::zMax ( ) const

inline

Definition at line 41 of file SCT_Forward.h.

41{return m_zMax;}

◆ zMin()

double SCT_Forward::zMin ( ) const

inline

Definition at line 42 of file SCT_Forward.h.

42{return m_zMin;}

Member Data Documentation

◆ m_coolingPipeRadius

double SCT_Forward::m_coolingPipeRadius = 0.0

private

Definition at line 68 of file SCT_Forward.h.

◆ m_cylinderServicesPresent

bool SCT_Forward::m_cylinderServicesPresent = false

private

Definition at line 70 of file SCT_Forward.h.

◆ m_detectorManager

InDetDD::SCT_DetectorManager* SCT_ComponentFactory::m_detectorManager {}

protectedinherited

Definition at line 38 of file SCT_ComponentFactory.h.

38{};

◆ m_endcap

int SCT_Forward::m_endcap

private

Definition at line 60 of file SCT_Forward.h.

◆ m_geometryManager

SCT_GeometryManager* SCT_ComponentFactory::m_geometryManager {}

protectedinherited

Definition at line 39 of file SCT_ComponentFactory.h.

39{};

◆ m_innerRadius

double SCT_Forward::m_innerRadius = 0.0

private

Definition at line 63 of file SCT_Forward.h.

◆ m_length

double SCT_Forward::m_length = 0.0

private

Definition at line 73 of file SCT_Forward.h.

◆ m_logVolume

const GeoLogVol* SCT_UniqueComponentFactory::m_logVolume {}

protectedinherited

Definition at line 86 of file SCT_ComponentFactory.h.

86{};

◆ 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.

40{};

◆ m_modules

std::vector<std::unique_ptr<SCT_FwdModule> > SCT_Forward::m_modules

private

Definition at line 79 of file SCT_Forward.h.

◆ m_name

std::string SCT_ComponentFactory::m_name

privateinherited

Definition at line 46 of file SCT_ComponentFactory.h.

◆ m_numModuleTypes

int SCT_Forward::m_numModuleTypes = 0

private

Definition at line 61 of file SCT_Forward.h.

◆ m_numThermalShieldElements

int SCT_Forward::m_numThermalShieldElements = 0

private

Definition at line 69 of file SCT_Forward.h.

◆ m_numWheels

int SCT_Forward::m_numWheels = 0

private

Definition at line 62 of file SCT_Forward.h.

◆ m_outerRadius

double SCT_Forward::m_outerRadius = 0.0

private

Definition at line 64 of file SCT_Forward.h.

◆ m_outerRadiusCylinderServices

double SCT_Forward::m_outerRadiusCylinderServices = 0.0

private

Definition at line 74 of file SCT_Forward.h.

◆ m_sqliteReader

GeoModelIO::ReadGeoModel* SCT_UniqueComponentFactory::m_sqliteReader {}

protectedinherited

Definition at line 87 of file SCT_ComponentFactory.h.

87{};

◆ m_trtGapPos

double SCT_Forward::m_trtGapPos = 0.0

private

Definition at line 67 of file SCT_Forward.h.

◆ m_wheels

std::vector<std::unique_ptr<SCT_FwdWheel> > SCT_Forward::m_wheels

private

Definition at line 77 of file SCT_Forward.h.

◆ m_zMax

double SCT_Forward::m_zMax = 0.0

private

Definition at line 66 of file SCT_Forward.h.

◆ m_zMin

double SCT_Forward::m_zMin = 0.0

private

Definition at line 65 of file SCT_Forward.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:

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SCT_Forward()

◆ ~SCT_Forward()

Member Function Documentation

◆ build()

◆ epsilon()

◆ getName()

◆ getParameters()

◆ innerRadius()

◆ length()

◆ numModuleTypes()

◆ numWheels()

◆ outerRadius()

◆ preBuild()

◆ trtGapPos()

◆ zCenter()

◆ zMax()

◆ zMin()

Member Data Documentation

◆ m_coolingPipeRadius

◆ m_cylinderServicesPresent

◆ m_detectorManager

◆ m_endcap

◆ m_geometryManager

◆ m_innerRadius

◆ m_length

◆ m_logVolume

◆ m_mapAX

◆ m_mapFPV

◆ m_materials

◆ m_modules

◆ m_name

◆ m_numModuleTypes

◆ m_numThermalShieldElements

◆ m_numWheels

◆ m_outerRadius

◆ m_outerRadiusCylinderServices

◆ m_sqliteReader

◆ m_trtGapPos

◆ m_wheels

◆ m_zMax

◆ m_zMin

◆ s_epsilon