SCT_Module Class Reference

#include <SCT_Module.h>

Inheritance diagram for SCT_Module:

Collaboration diagram for SCT_Module:

Public Member Functions
	SCT_Module (const std::string &name, 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_Module ()
	SCT_Module (const SCT_Module &)=delete
SCT_Module &	operator= (const SCT_Module &)=delete
virtual GeoVPhysVol *	build (SCT_Identifier id)
double	thickness () const
double	width () const
double	length () const
double	env1Thickness () const
double	env1Width () const
double	env1Length () const
double	env2Thickness () const
double	env2Width () const
double	env2Length () const
const GeoTrf::Vector3D *	env1RefPointVector () const
const GeoTrf::Vector3D *	env2RefPointVector () const
double	sensorGap () const
double	stereoInner () const
double	stereoOuter () const
double	stereoAngle () const
double	activeWidth () const
double	baseBoardOffsetY () const
double	baseBoardOffsetZ () const
const SCT_InnerSide *	innerSide () const
const SCT_OuterSide *	outerSide () const
const SCT_BaseBoard *	baseBoard () const
const std::string &	getName () const
std::string	intToString (int i) 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
double	m_thickness = 0.0
double	m_width = 0.0
double	m_length = 0.0
double	m_env1Thickness = 0.0
double	m_env1Width = 0.0
double	m_env1Length = 0.0
double	m_env2Thickness = 0.0
double	m_env2Width = 0.0
double	m_env2Length = 0.0
double	m_activeWidth = 0.0
double	m_baseBoardOffsetY = 0.0
double	m_baseBoardOffsetZ = 0.0
double	m_sensorGap = 0.0
double	m_stereoInner = 0.0
double	m_stereoOuter = 0.0
double	m_stereoAngle = 0.0
int	m_upperSide = 0
double	m_safety = 0.0
std::unique_ptr< SCT_InnerSide >	m_innerSide
std::unique_ptr< SCT_OuterSide >	m_outerSide
std::unique_ptr< SCT_BaseBoard >	m_baseBoard
std::unique_ptr< GeoTrf::Transform3D >	m_innerSidePos
std::unique_ptr< GeoTrf::Transform3D >	m_outerSidePos
std::unique_ptr< GeoTrf::Translate3D >	m_baseBoardPos
std::unique_ptr< GeoTrf::Vector3D >	m_env1RefPointVector
std::unique_ptr< GeoTrf::Vector3D >	m_env2RefPointVector
std::string	m_name

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

Detailed Description

Definition at line 23 of file SCT_Module.h.

Constructor & Destructor Documentation

SCT_Module() [1/2]

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

: SCT_UniqueComponentFactory(name, detectorManager, geometryManager, materials, sqliteReader, mapFPV, mapAX)
{
  getParameters();
  m_logVolume = SCT_Module::preBuild();
}

~SCT_Module()

SCT_Module::~SCT_Module

(

)

Definition at line 56 of file SCT_Module.cxx.

{
}

SCT_Module() [2/2]

SCT_Module::SCT_Module ( const SCT_Module &  )

delete

Member Function Documentation

activeWidth()

double SCT_Module::activeWidth ( ) const

inline

Definition at line 63 of file SCT_Module.h.

{return m_activeWidth;}

baseBoard()

const SCT_BaseBoard* SCT_Module::baseBoard ( ) const

inline

Definition at line 70 of file SCT_Module.h.

{return m_baseBoard.get();}

baseBoardOffsetY()

double SCT_Module::baseBoardOffsetY ( ) const

inline

Definition at line 65 of file SCT_Module.h.

{return m_baseBoardOffsetY;}

baseBoardOffsetZ()

double SCT_Module::baseBoardOffsetZ ( ) const

inline

Definition at line 66 of file SCT_Module.h.

{return m_baseBoardOffsetZ;}

build()

GeoVPhysVol * SCT_Module::build ( SCT_Identifier  id )

virtual

Implements SCT_UniqueComponentFactory.

Definition at line 316 of file SCT_Module.cxx.

{
    GeoFullPhysVol * module=nullptr;
    
    if(!m_sqliteReader){
        
        module=new GeoFullPhysVol(m_logVolume);
        
        
        // We make these fullPhysVols for the alignment code.
        // We probably should make the transform for the sensor
        // alignable rather than the "side" to save making an extra full phys volume.
        
        //
        // Build the module
        //
        // Add Baseboard
        GeoTransform * baseBoardTransform = new GeoTransform(*m_baseBoardPos);
        module->add(baseBoardTransform);
        module->add(m_baseBoard->getVolume());
        
        // Add innerside
        GeoAlignableTransform * innerTransform = new GeoAlignableTransform(*m_innerSidePos);
        module->add(innerTransform);
        int innerSideNumber = (m_upperSide) ? 0 : 1;
        module->add(new GeoNameTag("Side#"+intToString(innerSideNumber))); // Identifier side=0
        module->add(new GeoIdentifierTag(innerSideNumber));
        id.setSide(innerSideNumber);
        Identifier innerId = id.getWaferId();
        GeoVPhysVol * innerSide = m_innerSide->build(id);
        module->add(innerSide);
        // Store alignable transform
        m_detectorManager->addAlignableTransform(0, innerId, innerTransform, innerSide);
        
        // Add outerside
        GeoAlignableTransform * outerTransform = new GeoAlignableTransform(*m_outerSidePos);
        module->add(outerTransform);
        int outerSideNumber = m_upperSide;
        module->add(new GeoNameTag("Side#"+intToString(outerSideNumber))); // Identifier side=1
        module->add(new GeoIdentifierTag(outerSideNumber));
        id.setSide(outerSideNumber);
        Identifier outerId = id.getWaferId();
        GeoVPhysVol * outerSide = m_outerSide->build(id);
        module->add(outerSide);
        // Store alignable transform
        m_detectorManager->addAlignableTransform(0, outerId, outerTransform, outerSide);
    } else
    {
        
        // Add innerside
        int innerSideNumber = (m_upperSide) ? 0 : 1;
        id.setSide(innerSideNumber);
        // Store alignable transform
        Identifier innerId = id.getWaferId();
        m_innerSide->build(id);
        
        std::string key="Side#"+intToString(innerSideNumber)+"_"+std::to_string(id.getBarrelEC())+"_"+std::to_string(id.getLayerDisk())+"_"+std::to_string(id.getEtaModule())+"_"+std::to_string(id.getPhiModule());
        m_detectorManager->addAlignableTransform(0, innerId, (*m_mapAX)[key], (*m_mapFPV)[key]);
       
        
        // Add outerside
        int outerSideNumber = m_upperSide;
        id.setSide(outerSideNumber);
        // Store alignable transform
        Identifier outerId = id.getWaferId();
        m_outerSide->build(id);
        
        key="Side#"+intToString(outerSideNumber)+"_"+std::to_string(id.getBarrelEC())+"_"+std::to_string(id.getLayerDisk())+"_"+std::to_string(id.getEtaModule())+"_"+std::to_string(id.getPhiModule());
        m_detectorManager->addAlignableTransform(0, outerId, (*m_mapAX)[key], (*m_mapFPV)[key]);
        
    }
    return module;
}

env1Length()

double SCT_Module::env1Length ( ) const

inline

Definition at line 50 of file SCT_Module.h.

{return m_env1Length;}

env1RefPointVector()

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

inline

Definition at line 55 of file SCT_Module.h.

{return m_env1RefPointVector.get();}

env1Thickness()

double SCT_Module::env1Thickness ( ) const

inline

Definition at line 48 of file SCT_Module.h.

{return m_env1Thickness;}

env1Width()

double SCT_Module::env1Width ( ) const

inline

Definition at line 49 of file SCT_Module.h.

{return m_env1Width;}

env2Length()

double SCT_Module::env2Length ( ) const

inline

Definition at line 53 of file SCT_Module.h.

{return m_env2Length;}

env2RefPointVector()

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

inline

Definition at line 56 of file SCT_Module.h.

{return m_env2RefPointVector.get();}

env2Thickness()

double SCT_Module::env2Thickness ( ) const

inline

Definition at line 51 of file SCT_Module.h.

{return m_env2Thickness;}

env2Width()

double SCT_Module::env2Width ( ) const

inline

Definition at line 52 of file SCT_Module.h.

{return m_env2Width;}

epsilon()

double SCT_ComponentFactory::epsilon ( ) const

protectedinherited

Definition at line 37 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_Module::getParameters ( )

private

Definition at line 62 of file SCT_Module.cxx.

{
  const SCT_BarrelModuleParameters       * parameters = m_geometryManager->barrelModuleParameters();
  const SCT_GeneralParameters     * generalParameters = m_geometryManager->generalParameters();
  m_safety       = generalParameters->safety();
 
  m_sensorGap    = parameters->moduleSensorToSensorGap();
  
  m_stereoAngle = parameters->moduleStereoAngle();
  int      sign = parameters->moduleStereoUpperSign();
  m_upperSide   = parameters->moduleUpperSideNumber();
  m_stereoInner = -0.5*sign*m_stereoAngle;
  m_stereoOuter =  0.5*sign*m_stereoAngle;
 
  m_baseBoardOffsetY = parameters->baseBoardOffsetY();
  m_baseBoardOffsetZ = parameters->baseBoardOffsetZ();
}

innerSide()

const SCT_InnerSide* SCT_Module::innerSide ( ) const

inline

Definition at line 68 of file SCT_Module.h.

{return m_innerSide.get();}

intToString()

std::string SCT_ComponentFactory::intToString ( int  i ) const

inherited

Definition at line 29 of file SCT_ComponentFactory.cxx.

{
  std::ostringstream str;
  str << i;
  return str.str();
}

length()

double SCT_Module::length ( ) const

inline

Definition at line 46 of file SCT_Module.h.

{return m_length;}

operator=()

SCT_Module& SCT_Module::operator= ( const SCT_Module &  )

delete

outerSide()

const SCT_OuterSide* SCT_Module::outerSide ( ) const

inline

Definition at line 69 of file SCT_Module.h.

{return m_outerSide.get();}

preBuild()

const GeoLogVol * SCT_Module::preBuild ( )

privatevirtual

Implements SCT_UniqueComponentFactory.

Definition at line 82 of file SCT_Module.cxx.

{
  // Create child components
  m_outerSide = std::make_unique<SCT_OuterSide>("OuterSide", m_detectorManager, m_geometryManager, m_materials, m_sqliteReader, m_mapFPV, m_mapAX);
  m_innerSide = std::make_unique<SCT_InnerSide>("InnerSide", m_detectorManager, m_geometryManager, m_materials, m_sqliteReader, m_mapFPV, m_mapAX);
 
  if(m_sqliteReader) return nullptr;
    
  m_baseBoard = std::make_unique<SCT_BaseBoard>("BaseBoard", m_detectorManager, m_geometryManager, m_materials);
  //
  // We have 2 envelopes.
  // 1. It contains two sensors and baseBoard.
  // 2. It contains hybrid and pigtail.
  //
  // See "doc/cornerName.ps".
  //
 
  // We need to take into account the safety incorporated in the inner and outer side 
  // envelopes. 
  double sensorWidth   =  m_innerSide->sensor()->width() + m_safety;
  double sensorLength  =  m_innerSide->sensor()->length() + m_safety;
  double innerSideHybridWidth   =  m_innerSide->hybrid()->width() + m_safety;
  double innerSideHybridLength  =  m_innerSide->hybrid()->length() + m_safety;
  double outerSideHybridWidth   =  m_outerSide->hybrid()->width() + m_safety;
  double outerSideHybridLength  =  m_outerSide->hybrid()->length() + m_safety;
  double baseBoardWidth         =  m_baseBoard->width() + m_safety;
  double baseBoardLength        =  m_baseBoard->length() + m_safety;
  double outerSidePigtailLength =  m_outerSide->pigtail()->length() + m_safety;
 
 
  // Define constants for convenience.
  // for corner of outer side sensor.
  GeoTrf::Vector3D a(0.0, 0.5 * sensorWidth, 0.5 * sensorLength);
  GeoTrf::Vector3D b(0.0, -0.5 * sensorWidth, a.z());
  GeoTrf::Vector3D c(0.0, b.y(),-0.5 * sensorLength);
  GeoTrf::Vector3D d(0.0, a.y(), c.z());
 
  // for corner of inner side sensor.
  GeoTrf::Vector3D e(0.0, a.y(), a.z());
  GeoTrf::Vector3D f(0.0, b.y(), b.z());
  GeoTrf::Vector3D g(0.0, c.y(), c.z());
  GeoTrf::Vector3D h(0.0, d.y(), d.z());
 
  // for corner of base board.
  GeoTrf::Vector3D u(0.0,
                      m_baseBoardOffsetY + 0.5*baseBoardWidth,
                      m_baseBoardOffsetZ + 0.5*baseBoardLength);
  GeoTrf::Vector3D v(0.0, m_baseBoardOffsetY - 0.5*baseBoardWidth, u.z());
  GeoTrf::Vector3D w(0.0, v.y(), m_baseBoardOffsetZ - 0.5*baseBoardLength);
  GeoTrf::Vector3D x(0.0, u.y(),w.z());
  
  // for corner of hybrid, connectorouter and pigtail of outer side.
  GeoTrf::Vector3D i(0.0, 
                      0.5*outerSideHybridWidth,
                      m_outerSide->hybridOffsetZ() + 0.5*outerSidePigtailLength);
  GeoTrf::Vector3D l(0.0,
                      -0.5*outerSideHybridWidth - m_outerSide->pigtail()->width(), i.z());
  GeoTrf::Vector3D m(0.0, l.y(),
                      m_outerSide->hybridOffsetZ() - 0.5*outerSidePigtailLength);
  GeoTrf::Vector3D p(0.0, i.y(),
                      m.z());
 
 
 
  // for corner of hybrid and interConnect of inner side.
  GeoTrf::Vector3D q(0.0, 0.5*outerSideHybridWidth, m_outerSide->hybridOffsetZ() + 0.5*outerSideHybridLength );
  GeoTrf::Vector3D r(0.0, -0.5*innerSideHybridWidth, q.z());
  GeoTrf::Vector3D s(0.0, r.y(), m_innerSide->hybridOffsetZ() - 0.5*innerSideHybridLength);
  GeoTrf::Vector3D t(0.0, q.y(), s.z());
 
  // All points turn +-20 mGaudi::Units::rad around physical center of module.
  a = GeoTrf::RotateX3D(m_stereoOuter/Gaudi::Units::radian)*a;
  b = GeoTrf::RotateX3D(m_stereoOuter/Gaudi::Units::radian)*b;
  c = GeoTrf::RotateX3D(m_stereoOuter/Gaudi::Units::radian)*c;
  d = GeoTrf::RotateX3D(m_stereoOuter/Gaudi::Units::radian)*d;
 
  e = GeoTrf::RotateX3D(m_stereoInner/Gaudi::Units::radian)*e;
  f = GeoTrf::RotateX3D(m_stereoInner/Gaudi::Units::radian)*f;
  g = GeoTrf::RotateX3D(m_stereoInner/Gaudi::Units::radian)*g;
  h = GeoTrf::RotateX3D(m_stereoInner/Gaudi::Units::radian)*h;
 
  i = GeoTrf::RotateX3D(m_stereoOuter/Gaudi::Units::radian)*i;
  //k.rotateX(m_stereoOuter/Gaudi::Units::radian);
  l = GeoTrf::RotateX3D(m_stereoOuter/Gaudi::Units::radian)*l;
  m = GeoTrf::RotateX3D(m_stereoOuter/Gaudi::Units::radian)*m;
  //n.rotateX(m_stereoOuter/Gaudi::Units::radian);
  p = GeoTrf::RotateX3D(m_stereoOuter/Gaudi::Units::radian)*p;
 
  q = GeoTrf::RotateX3D(m_stereoInner/Gaudi::Units::radian)*q;
  r = GeoTrf::RotateX3D(m_stereoInner/Gaudi::Units::radian)*r;
  s = GeoTrf::RotateX3D(m_stereoInner/Gaudi::Units::radian)*s;
  t = GeoTrf::RotateX3D(m_stereoInner/Gaudi::Units::radian)*t;
 
  // Calculate demension of envelope1.
  const double z_ab = std::max(a.z(), b.z());
  const double z_ef = std::max(e.z(), f.z());
  const double z_cd = std::min(c.z(), d.z());
  const double z_gh = std::min(g.z(), h.z());
 
  const double y_ad = std::max(a.y(), d.y());
  const double y_eh = std::max(e.y(), h.y());
  const double y_bc = std::min(b.y(), c.y());
  const double y_fg = std::min(f.y(), g.y());
 
  const double zmaxEnv1 = std::max(z_ab, z_ef);
  const double zminEnv1 = std::min(z_cd, z_gh);
 
  const double ypre_maxEnv1 = std::max(y_ad, y_eh);
  const double ypre_minEnv1 = std::min(y_bc, y_fg);
 
  const double ymaxEnv1 = std::max(ypre_maxEnv1, u.y());
  const double yminEnv1 = std::min(ypre_minEnv1, v.y());
 
  // some temporary value.
  const double thicknessEnv1 = m_sensorGap + 2.0*m_outerSide->sensor()->thickness();
  const double lengthEnv1 = zmaxEnv1 - zminEnv1;
  const double widthEnv1  = ymaxEnv1 - yminEnv1;
 
  // Center of evnelope1.
  const double xCenterEnv1 = 0.0;
  const double yCenterEnv1 = yminEnv1 + 0.5*widthEnv1;
  const double zCenterEnv1 = zmaxEnv1 - 0.5*lengthEnv1;
 
  m_env1RefPointVector = std::make_unique<GeoTrf::Vector3D>(-xCenterEnv1, -yCenterEnv1, -zCenterEnv1);
 
  // Calculate demension of envelope2.
  const double z_ikl = std::max(i.z(), l.z());
  const double z_qr = std::max(q.z(), r.z());
  const double z_mnp = std::min(m.z(), p.z());
  const double z_st = std::min(s.z(), t.z());
 
  const double y_ip = std::max(i.y(), p.y());
  const double y_qt = std::max(q.y(), t.y());
  const double y_lm = std::min(l.y(), m.y());
  const double y_rs = std::min(r.y(), s.y());
 
  const double zmaxEnv2 = std::max(z_ikl, z_qr);
  const double zminEnv2 = std::min(z_mnp, z_st);
 
  const double ymaxEnv2 = std::max(y_ip, y_qt);
  const double yminEnv2 = std::min(y_lm, y_rs);
 
  const double thicknessEnv2 = 2.0*(m_outerSide->hybridOffsetX() + 
                                    0.5*m_innerSide->sensor()->thickness() + 
                                    0.5*m_sensorGap + 
                                    0.5*m_outerSide->hybrid()->thickness());
  const double lengthEnv2 = zmaxEnv2 - zminEnv2;
  const double widthEnv2  = ymaxEnv2 - yminEnv2;
 
  // Center of envelope2.
  const double xCenterEnv2 = 0.0;
  const double yCenterEnv2 = ymaxEnv2 - 0.5*widthEnv2;
  const double zCenterEnv2 = zmaxEnv2 - 0.5*lengthEnv2;
 
  m_env2RefPointVector = std::make_unique<GeoTrf::Vector3D>(-xCenterEnv2, -yCenterEnv2, -zCenterEnv2);
 
  // Calculate dimension of subbox 
  const double xmaxSubBox = - 0.5*m_baseBoard->thickness() - m_safety;
  const double xminSubBox = - 0.5*thicknessEnv2 - 2.0*m_safety;
 
  const double ymaxSubBox = std::min(r.y(), s.y()) - m_safety;
  const double yminSubBox = yminEnv2 - 2.0*m_safety;
 
  const double zmaxSubBox = zmaxEnv1 + 2.0*m_safety;
  const double zminSubBox = zminEnv1 - 2.0*m_safety; 
  
  const double thicknessSubBox = xmaxSubBox - xminSubBox;
  const double widthSubBox = ymaxSubBox - yminSubBox;
  const double lengthSubBox = zmaxSubBox - zminSubBox;
 
  // Center of subbox.
  const double xCenterSubBox = xmaxSubBox - 0.5*thicknessSubBox;
  const double yCenterSubBox = ymaxSubBox - 0.5*widthSubBox;
  const double zCenterSubBox = zmaxSubBox - 0.5*lengthSubBox;
 
 
  m_env1Thickness = thicknessEnv1 + 2*m_safety;
  m_env1Width     = widthEnv1     + 2*m_safety;
  m_env1Length    = lengthEnv1    + 2*m_safety;
 
  m_env2Thickness = thicknessEnv2 + 2*m_safety;
  m_env2Width     = widthEnv2     + 2*m_safety;
  m_env2Length    = lengthEnv2    + 2*m_safety;
 
  // Envelope 2 defines the overall thickness. NB. The ski assumes the 
  // the envelope "thickness" is centered on x, which it is.
  m_thickness   = m_env2Thickness;
  m_activeWidth = m_env2Width;
  m_width       = m_env2Width;
  m_length      = m_env1Length;
 
  // Calculate a few things.
  const double OSPosX =   0.5*m_sensorGap + 0.5*m_innerSide->sensor()->thickness();
  const double ISPosX = -(0.5*m_sensorGap + 0.5*m_innerSide->sensor()->thickness());
 
  //
  // Make an envelope for the whole module.
  //
  const GeoBox * envelope1 = new GeoBox(0.5*m_env1Thickness, 0.5*m_env1Width, 0.5*m_env1Length);
  const GeoBox * envelope2 = new GeoBox(0.5*m_env2Thickness, 0.5*m_env2Width, 0.5*m_env2Length);
 
  const GeoBox * subBox = new GeoBox(0.5*thicknessSubBox, 0.5*widthSubBox, 0.6*lengthSubBox);
 
  // In the following, envelope1 and envelope2 are added and SUBBOX is pulled. 
  const GeoShape & moduleEnvelope = (*envelope1 << GeoTrf::Translate3D(xCenterEnv1, yCenterEnv1, zCenterEnv1)).
    add(*envelope2 << GeoTrf::Translate3D(xCenterEnv2, yCenterEnv2, zCenterEnv2)).
    subtract(*subBox << GeoTrf::Translate3D(xCenterSubBox, yCenterSubBox, zCenterSubBox));
 
  const GeoLogVol * moduleLog           = new GeoLogVol(getName(), &moduleEnvelope, m_materials->gasMaterial());
  
  //
  // inner side
  //
  GeoTrf::Transform3D rotInner = GeoTrf::RotateX3D(m_stereoInner) * GeoTrf::RotateZ3D(180*Gaudi::Units::deg);
  m_innerSidePos = std::make_unique<GeoTrf::Transform3D>(GeoTrf::Transform3D(GeoTrf::Translation3D(ISPosX, 0.0, 0.0)*rotInner));
 
  //
  // outer side
  //
  GeoTrf::RotateX3D rotOuter(m_stereoOuter);
  m_outerSidePos = std::make_unique<GeoTrf::Transform3D>(GeoTrf::Transform3D(GeoTrf::Translation3D(OSPosX, 0.0, 0.0)*rotOuter));
 
  //
  // base board
  //
  const double baseBoardPosY = m_baseBoardOffsetY;
  const double baseBoardPosZ = m_baseBoardOffsetZ;
  m_baseBoardPos = std::make_unique<GeoTrf::Translate3D>(0.0, baseBoardPosY, baseBoardPosZ);
 
  return moduleLog;
}

sensorGap()

double SCT_Module::sensorGap ( ) const

inline

Definition at line 58 of file SCT_Module.h.

{return m_sensorGap;}

stereoAngle()

double SCT_Module::stereoAngle ( ) const

inline

Definition at line 61 of file SCT_Module.h.

{return m_stereoAngle;}

stereoInner()

double SCT_Module::stereoInner ( ) const

inline

Definition at line 59 of file SCT_Module.h.

{return m_stereoInner;}

stereoOuter()

double SCT_Module::stereoOuter ( ) const

inline

Definition at line 60 of file SCT_Module.h.

{return m_stereoOuter;}

thickness()

double SCT_Module::thickness ( ) const

inline

Definition at line 44 of file SCT_Module.h.

{return m_thickness;}

width()

double SCT_Module::width ( ) const

inline

Definition at line 45 of file SCT_Module.h.

{return m_width;}

Member Data Documentation

m_activeWidth

double SCT_Module::m_activeWidth = 0.0

private

Definition at line 88 of file SCT_Module.h.

m_baseBoard

std::unique_ptr<SCT_BaseBoard> SCT_Module::m_baseBoard

private

Definition at line 102 of file SCT_Module.h.

m_baseBoardOffsetY

double SCT_Module::m_baseBoardOffsetY = 0.0

private

Definition at line 90 of file SCT_Module.h.

m_baseBoardOffsetZ

double SCT_Module::m_baseBoardOffsetZ = 0.0

private

Definition at line 91 of file SCT_Module.h.

m_baseBoardPos

std::unique_ptr<GeoTrf::Translate3D> SCT_Module::m_baseBoardPos

private

Definition at line 106 of file SCT_Module.h.

m_detectorManager

InDetDD::SCT_DetectorManager* SCT_ComponentFactory::m_detectorManager

protectedinherited

Definition at line 41 of file SCT_ComponentFactory.h.

m_env1Length

double SCT_Module::m_env1Length = 0.0

private

Definition at line 83 of file SCT_Module.h.

m_env1RefPointVector

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

private

Definition at line 108 of file SCT_Module.h.

m_env1Thickness

double SCT_Module::m_env1Thickness = 0.0

private

Definition at line 81 of file SCT_Module.h.

m_env1Width

double SCT_Module::m_env1Width = 0.0

private

Definition at line 82 of file SCT_Module.h.

m_env2Length

double SCT_Module::m_env2Length = 0.0

private

Definition at line 86 of file SCT_Module.h.

m_env2RefPointVector

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

private

Definition at line 109 of file SCT_Module.h.

m_env2Thickness

double SCT_Module::m_env2Thickness = 0.0

private

Definition at line 84 of file SCT_Module.h.

m_env2Width

double SCT_Module::m_env2Width = 0.0

private

Definition at line 85 of file SCT_Module.h.

m_geometryManager

SCT_GeometryManager* SCT_ComponentFactory::m_geometryManager

protectedinherited

Definition at line 42 of file SCT_ComponentFactory.h.

m_innerSide

std::unique_ptr<SCT_InnerSide> SCT_Module::m_innerSide

private

Definition at line 100 of file SCT_Module.h.

m_innerSidePos

std::unique_ptr<GeoTrf::Transform3D> SCT_Module::m_innerSidePos

private

Definition at line 104 of file SCT_Module.h.

m_length

double SCT_Module::m_length = 0.0

private

Definition at line 79 of file SCT_Module.h.

m_logVolume

const GeoLogVol* SCT_UniqueComponentFactory::m_logVolume

protectedinherited

Definition at line 90 of file SCT_ComponentFactory.h.

m_mapAX

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

protectedinherited

Definition at line 96 of file SCT_ComponentFactory.h.

m_mapFPV

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

protectedinherited

Definition at line 95 of file SCT_ComponentFactory.h.

m_materials

SCT_MaterialManager* SCT_ComponentFactory::m_materials

protectedinherited

Definition at line 43 of file SCT_ComponentFactory.h.

m_name

std::string SCT_ComponentFactory::m_name

privateinherited

Definition at line 49 of file SCT_ComponentFactory.h.

m_outerSide

std::unique_ptr<SCT_OuterSide> SCT_Module::m_outerSide

private

Definition at line 101 of file SCT_Module.h.

m_outerSidePos

std::unique_ptr<GeoTrf::Transform3D> SCT_Module::m_outerSidePos

private

Definition at line 105 of file SCT_Module.h.

m_safety

double SCT_Module::m_safety = 0.0

private

Definition at line 98 of file SCT_Module.h.

m_sensorGap

double SCT_Module::m_sensorGap = 0.0

private

Definition at line 93 of file SCT_Module.h.

m_sqliteReader

GeoModelIO::ReadGeoModel* SCT_UniqueComponentFactory::m_sqliteReader

protectedinherited

Definition at line 91 of file SCT_ComponentFactory.h.

m_stereoAngle

double SCT_Module::m_stereoAngle = 0.0

private

Definition at line 96 of file SCT_Module.h.

m_stereoInner

double SCT_Module::m_stereoInner = 0.0

private

Definition at line 94 of file SCT_Module.h.

m_stereoOuter

double SCT_Module::m_stereoOuter = 0.0

private

Definition at line 95 of file SCT_Module.h.

m_thickness

double SCT_Module::m_thickness = 0.0

private

Definition at line 77 of file SCT_Module.h.

m_upperSide

int SCT_Module::m_upperSide = 0

private

Definition at line 97 of file SCT_Module.h.

m_width

double SCT_Module::m_width = 0.0

private

Definition at line 78 of file SCT_Module.h.

s_epsilon

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

staticprivateinherited

Definition at line 50 of file SCT_ComponentFactory.h.

---

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

• SCT_Module.h
• SCT_Module.cxx