InDetServMatFactory Class Reference

#include <InDetServMatFactory.h>

Inheritance diagram for InDetServMatFactory:

Collaboration diagram for InDetServMatFactory:

Public Member Functions
	InDetServMatFactory (InDetDD::AthenaComps *athenaComps)
const InDetServMatFactory &	operator= (const InDetServMatFactory &right)=delete
	InDetServMatFactory (const InDetServMatFactory &right)=delete
	~InDetServMatFactory ()=default
virtual void	create (GeoPhysVol *world) override
virtual const InDetDD::InDetServMatManager *	getDetectorManager () const override
StoreGateSvc *	detStore ()
const StoreGateSvc *	detStore () const
const IGeoDbTagSvc *	geoDbTagSvc () const
IRDBAccessSvc *	rdbAccessSvc ()
const IGeometryDBSvc *	geomDB () const
MsgStream &	msg (MSG::Level lvl) const
bool	msgLvl (MSG::Level lvl)
InDetDD::AthenaComps *	getAthenaComps ()

Private Attributes
InDetDD::InDetServMatManager *	m_manager {nullptr}
InDetDD::AthenaComps *	m_athenaComps

Detailed Description

Definition at line 15 of file InDetServMatFactory.h.

Constructor & Destructor Documentation

InDetServMatFactory() [1/2]

InDetServMatFactory::InDetServMatFactory

(

InDetDD::AthenaComps *

athenaComps

)

Definition at line 44 of file InDetServMatFactory.cxx.

  : InDetDD::DetectorFactoryBase(athenaComps)
{  
}

InDetServMatFactory() [2/2]

InDetServMatFactory::InDetServMatFactory ( const InDetServMatFactory &  right )

delete

~InDetServMatFactory()

InDetServMatFactory::~InDetServMatFactory ( )

default

Member Function Documentation

create()

void InDetServMatFactory::create ( GeoPhysVol *  world )

overridevirtual

Definition at line 50 of file InDetServMatFactory.cxx.

{
 
  // create a new det manager
  m_manager = new InDetDD::InDetServMatManager();
 
  // Get the material manager:  
  DecodeVersionKey sctVersionKey(geoDbTagSvc(),"SCT");
  DecodeVersionKey trtVersionKey(geoDbTagSvc(),"TRT");
  DecodeVersionKey indetVersionKey(geoDbTagSvc(),"InnerDetector");
  DecodeVersionKey atlasVersionKey(geoDbTagSvc(),"ATLAS");
 
 
  msg(MSG::DEBUG) << "Building InDet Service Material with ATLAS Version Tag: " << atlasVersionKey.tag() << endmsg;
  msg(MSG::DEBUG) << "                                with InDet Version Tag: " << indetVersionKey.tag() << " at Node: "
      << indetVersionKey.node() << endmsg;
  msg(MSG::DEBUG) << "                                with TRT   Version Tag: " << trtVersionKey.tag() << " at Node: "
      << trtVersionKey.node() << endmsg;
  msg(MSG::DEBUG) << "                                with SCT   Version Tag: " << sctVersionKey.tag() << " at Node: "
      << sctVersionKey.node() << endmsg;
  msg(MSG::DEBUG) << " InDetServices Version " << rdbAccessSvc()->getChildTag("InDetServices", indetVersionKey.tag(), indetVersionKey.node()) << endmsg;
  msg(MSG::DEBUG) << " TRT           Version " << rdbAccessSvc()->getChildTag("TRT", trtVersionKey.tag(), trtVersionKey.node()) << endmsg;
  msg(MSG::DEBUG) << " SCT           Version " << rdbAccessSvc()->getChildTag("SCT", sctVersionKey.tag(), sctVersionKey.node()) << endmsg;
 
  IRDBRecordset_ptr atls = rdbAccessSvc()->getRecordsetPtr("AtlasMother",  atlasVersionKey.tag(), atlasVersionKey.node());
 
  IRDBRecordset_ptr servEnvelopeTable = 
    rdbAccessSvc()->getRecordsetPtr("InDetServEnvelope", indetVersionKey.tag(), indetVersionKey.node());
  const IRDBRecord *envelopes = (*servEnvelopeTable)[0];
 
  IRDBRecordset_ptr scalingTable = rdbAccessSvc()->getRecordsetPtr("InDetServMatScaling", indetVersionKey.tag(), indetVersionKey.node());
 
  InDetMaterialManager * materialManager = new InDetMaterialManager("InDetServMatMaterialManager", getAthenaComps());
  materialManager->addScalingTable(scalingTable);
 
  double safety = 0.001 * Gaudi::Units::mm;
 
  double ZMaxBrlTRT =        envelopes->getDouble("ZMAXBRLTRT") * Gaudi::Units::mm;
  double ZMaxBrlSCT =        envelopes->getDouble("ZMAXBRLSCT") * Gaudi::Units::mm;
  double ZMinFwdSCTandTRT =  envelopes->getDouble("ZMINFWDSCTANDTRT") * Gaudi::Units::mm;
  double ZMinSCTServInTRT =  envelopes->getDouble("ZMINSCTSERVINTRT") * Gaudi::Units::mm;
  double ZMaxSCTServInTRT =  envelopes->getDouble("ZMAXSCTSERVINTRT") * Gaudi::Units::mm;
  double ZMinPixServ    =    envelopes->getDouble("ZMINPIXSERV") * Gaudi::Units::mm;
  double ZMaxFwdTRTC =       envelopes->getDouble("ZMAXFWDTRTC") * Gaudi::Units::mm;
  double ZMaxIDet =          (*atls)[0]->getDouble("IDETZMX") * Gaudi::Units::cm + safety;  // 3470 mm
 
  double RMinBrlSCT =        envelopes->getDouble("RMINBRLSCT") * Gaudi::Units::mm;
  double RMaxBrlTRT =        envelopes->getDouble("RMAXBRLTRT") * Gaudi::Units::mm;
  double RMinBrlTRT =        envelopes->getDouble("RMINBRLTRT") * Gaudi::Units::mm;
  double RMaxFwdTRT =        envelopes->getDouble("RMAXFWDTRT") * Gaudi::Units::mm;
  double RMaxFwdSCT =        envelopes->getDouble("RMAXFWDSCT") * Gaudi::Units::mm;
  double RMaxFwdTRTC =       envelopes->getDouble("RMAXFWDTRTC") * Gaudi::Units::mm;
  double RMinPixServ =       envelopes->getDouble("RMINPIXSERV") * Gaudi::Units::mm;
  double RMaxPixServ =       envelopes->getDouble("RMAXPIXSERV") * Gaudi::Units::mm;
  double RMaxIDet =          (*atls)[0]->getDouble("IDETOR") * Gaudi::Units::cm + safety; // 1147 mm
 
  // Since the TRT Wheel C space is not used in some versions and is used by some 
  // other services we simplify the volume.
  // The 1mm is just to ensure the dimensions are considered equal if they differ
  // by less than 1mm.
 
  // join1 is True if the pixel service volume and SCT/TRT volume are joined 
  //       (ie boolean volume not needed) 
  // join2 is True if RMaxFwdTRTC and RMaxPixServ are ~ the same as RMinPixServ
  //       in which case a couple of planes are not needed in the PCON.
 
  bool join1 = false; 
  bool join2 = false; 
 
  if (std::abs(RMaxFwdTRTC - RMinPixServ) <= 1*Gaudi::Units::mm){
    join1 = true;
    join2 = true;
    RMaxFwdTRTC = RMinPixServ;
    RMaxPixServ = RMinPixServ;
  } else if ((RMaxFwdTRTC - 1*Gaudi::Units::mm) <=  RMaxPixServ) {
    join1 = true;
    RMaxPixServ = RMaxFwdTRTC;
  }
    
 
  //
  // Create the envelope for the Pixel Services:
  // Only need if join1 if false.
 
  const GeoShapeUnion *ServVolAux = nullptr;
    
  if (!join1) { 
    GeoPcon* pixServP = new GeoPcon(0.,2*Gaudi::Units::pi);
    GeoPcon* pixServM = new GeoPcon(0.,2*Gaudi::Units::pi);
    
    // Plane 1: Start at the end of the SCT endcap
    pixServP->addPlane(ZMinPixServ,  RMinPixServ, RMaxPixServ);
    pixServM->addPlane(-ZMinPixServ, RMinPixServ, RMaxPixServ);
 
    // Plane 2 and 3: at the end of the TRT endcap 
    pixServP->addPlane(ZMaxFwdTRTC, RMinPixServ, RMaxPixServ);
    pixServP->addPlane(ZMaxFwdTRTC, RMinPixServ, RMaxIDet);  
    pixServM->addPlane(-ZMaxFwdTRTC, RMinPixServ, RMaxPixServ);
    pixServM->addPlane(-ZMaxFwdTRTC, RMinPixServ, RMaxIDet);  
    
    // Plane 4 at the end of the ID
    pixServP->addPlane(ZMaxIDet, RMinPixServ, RMaxIDet);
    pixServM->addPlane(-ZMaxIDet, RMinPixServ, RMaxIDet);
 
    ServVolAux = new GeoShapeUnion(pixServP, pixServM);
  }
 
  // This is the volume for the TRT/SCT services
  GeoPcon *sctTrtServ = new GeoPcon(0.,2*Gaudi::Units::pi);
  
  // Pixel Services
  if (join1) {
    // THE BEGINNING
    sctTrtServ->addPlane(-ZMaxIDet,    RMinPixServ, RMaxIDet);
    // PP1 region. 
    if (!join2) { 
      sctTrtServ->addPlane(-ZMinPixServ, RMinPixServ, RMaxIDet);
      sctTrtServ->addPlane(-ZMinPixServ, RMaxPixServ, RMaxIDet);
    }
  } else {
    // THE BEGINNING
    sctTrtServ->addPlane(-ZMaxIDet, RMaxFwdTRTC, RMaxIDet);
  }
 
  // SCT services in TRT endcap
  sctTrtServ->addPlane(-ZMaxSCTServInTRT, RMaxFwdTRTC, RMaxIDet);
  sctTrtServ->addPlane(-ZMaxSCTServInTRT, RMaxFwdSCT, RMaxIDet);
  sctTrtServ->addPlane(-ZMinSCTServInTRT, RMaxFwdSCT, RMaxIDet);
  sctTrtServ->addPlane(-ZMinSCTServInTRT, RMaxFwdTRT, RMaxIDet);
 
  // Beginning of Ecap SCT and TRT
  sctTrtServ->addPlane(-ZMinFwdSCTandTRT, RMaxFwdTRT, RMaxIDet);
  sctTrtServ->addPlane(-ZMinFwdSCTandTRT, RMinBrlSCT, RMaxIDet);
 
  // End of Barrel SCT (SCT barrel services)
  sctTrtServ->addPlane(-ZMaxBrlSCT, RMinBrlSCT, RMaxIDet);
  sctTrtServ->addPlane(-ZMaxBrlSCT, RMinBrlTRT, RMaxIDet);
 
  // Plane, end of barrel TRT (TRT barrel services)
  sctTrtServ->addPlane(-ZMaxBrlTRT, RMinBrlTRT, RMaxIDet);
  sctTrtServ->addPlane(-ZMaxBrlTRT, RMaxBrlTRT, RMaxIDet);
 
 
  // THE OTHER SIDE
  // Plane, end of barrel TRT (TRT barrel services)
  sctTrtServ->addPlane(ZMaxBrlTRT, RMaxBrlTRT, RMaxIDet);
  sctTrtServ->addPlane(ZMaxBrlTRT, RMinBrlTRT, RMaxIDet);
 
  // End of Barrel SCT (SCT barrel services)
  sctTrtServ->addPlane(ZMaxBrlSCT, RMinBrlTRT, RMaxIDet);
  sctTrtServ->addPlane(ZMaxBrlSCT, RMinBrlSCT, RMaxIDet);
 
  // Beginning of Ecap SCT and TRT 
  sctTrtServ->addPlane(ZMinFwdSCTandTRT, RMinBrlSCT, RMaxIDet);
  sctTrtServ->addPlane(ZMinFwdSCTandTRT, RMaxFwdTRT, RMaxIDet);
 
  // SCT services in TRT endcap
  sctTrtServ->addPlane(ZMinSCTServInTRT, RMaxFwdTRT, RMaxIDet);
  sctTrtServ->addPlane(ZMinSCTServInTRT, RMaxFwdSCT, RMaxIDet);
  sctTrtServ->addPlane(ZMaxSCTServInTRT, RMaxFwdSCT, RMaxIDet);
  sctTrtServ->addPlane(ZMaxSCTServInTRT, RMaxFwdTRTC, RMaxIDet);
 
  // Pixel Services
  if (join1) {
    // PP1 region
    if (!join2) { 
      sctTrtServ->addPlane(ZMinPixServ, RMaxPixServ, RMaxIDet);
      sctTrtServ->addPlane(ZMinPixServ, RMinPixServ, RMaxIDet);    
    }
    // The end
    sctTrtServ->addPlane(ZMaxIDet,    RMinPixServ, RMaxIDet);
  } else {
 
    // The end
    sctTrtServ->addPlane(ZMaxIDet, RMaxFwdTRTC, RMaxIDet);
  }
 
  const GeoShape * ServVol = nullptr;
  if (ServVolAux == nullptr) {
    ServVol = sctTrtServ;
  } else {
    ServVol = new GeoShapeUnion(sctTrtServ, ServVolAux);
  }
  const GeoMaterial* air = materialManager->getMaterial("std::Air");
  const GeoLogVol* ServLog = new GeoLogVol("ServLog",ServVol,air);
  GeoPhysVol* ServPhys = new GeoPhysVol(ServLog);
 
  // Add this to the world and register it to the manager so GeoG4 will 
  // find it.
  //
  GeoNameTag *tag = new GeoNameTag("InDetServMat");         
  world->add(tag);
  world->add(ServPhys);
  m_manager->addTreeTop(ServPhys);
  // Pixel Services:
  PixelServMatFactory PSMF(getAthenaComps());
  PSMF.create(ServPhys);
 
  // SCT Services:
  SCT_ServMatFactory SSMF(getAthenaComps());
  SSMF.create(ServPhys);
 
  // TRT Services:
  TRT_ServMatFactory TSMF(getAthenaComps());
  TSMF.create(ServPhys);
 
  // EP:
  EndPlateFactory EPMF(getAthenaComps(), materialManager);
  EPMF.create(ServPhys);
 
  // Rails:
  SupportRailFactory RAMF(getAthenaComps(), materialManager);
  RAMF.create(ServPhys);
 
  // SquirrelCage:
  SquirrelCageFactory SQCF(getAthenaComps(), materialManager);
  SQCF.create(ServPhys);
 
  // Extra material
  InDetDD::DistortedMaterialManager xMatManager;
  InDetDD::ExtraMaterial xMat(&xMatManager);
  xMat.add(ServPhys, "InDetServMat");
 
  delete materialManager;
 
}

detStore() [1/2]

StoreGateSvc* InDetDD::DetectorFactoryBase::detStore ( )

inlineinherited

Definition at line 27 of file InDetDetectorFactoryBase.h.

{return m_athenaComps->detStore();}

detStore() [2/2]

const StoreGateSvc* InDetDD::DetectorFactoryBase::detStore ( ) const

inlineinherited

Definition at line 28 of file InDetDetectorFactoryBase.h.

{return std::as_const(*m_athenaComps).detStore();}

geoDbTagSvc()

const IGeoDbTagSvc* InDetDD::DetectorFactoryBase::geoDbTagSvc ( ) const

inlineinherited

Definition at line 30 of file InDetDetectorFactoryBase.h.

{return std::as_const(*m_athenaComps).geoDbTagSvc();}

geomDB()

const IGeometryDBSvc* InDetDD::DetectorFactoryBase::geomDB ( ) const

inlineinherited

Definition at line 34 of file InDetDetectorFactoryBase.h.

{return m_athenaComps->geomDB();}

getAthenaComps()

InDetDD::AthenaComps* InDetDD::DetectorFactoryBase::getAthenaComps ( )

inlineinherited

Definition at line 42 of file InDetDetectorFactoryBase.h.

{return m_athenaComps;}

getDetectorManager()

const InDetDD::InDetServMatManager * InDetServMatFactory::getDetectorManager ( ) const

overridevirtual

Definition at line 278 of file InDetServMatFactory.cxx.

                                                                                 {
  return m_manager;
}

msg()

MsgStream& InDetDD::DetectorFactoryBase::msg ( MSG::Level  lvl ) const

inlineinherited

Definition at line 37 of file InDetDetectorFactoryBase.h.

{ return m_athenaComps->msg(lvl); }

msgLvl()

bool InDetDD::DetectorFactoryBase::msgLvl ( MSG::Level  lvl )

inlineinherited

Definition at line 40 of file InDetDetectorFactoryBase.h.

{ return m_athenaComps->msgLvl(lvl); }

operator=()

const InDetServMatFactory& InDetServMatFactory::operator= ( const InDetServMatFactory &  right )

delete

rdbAccessSvc()

IRDBAccessSvc* InDetDD::DetectorFactoryBase::rdbAccessSvc ( )

inlineinherited

Definition at line 32 of file InDetDetectorFactoryBase.h.

{return m_athenaComps->rdbAccessSvc();}

Member Data Documentation

m_athenaComps

InDetDD::AthenaComps* InDetDD::DetectorFactoryBase::m_athenaComps

privateinherited

Definition at line 46 of file InDetDetectorFactoryBase.h.

m_manager

InDetDD::InDetServMatManager* InDetServMatFactory::m_manager {nullptr}

private

Definition at line 36 of file InDetServMatFactory.h.

---

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

• InDetServMatFactory.h
• InDetServMatFactory.cxx