Routing2 Class Reference

#include <Routing2.h>

Inheritance diagram for Routing2:

Collaboration diagram for Routing2:

Public Types
typedef ServicesTracker::LayerContainer	LayerContainer

Public Member Functions
	Routing2 ()
void	createRoutingVolumes (ServicesTracker &tracker)
const std::vector< ServiceVolume * > &	volumes () const
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
double	eosTolerance (DetType::Type type, DetType::Part part) const
double	eosLength (DetType::Type type, DetType::Part part) const
double	eosHalfThickness (DetType::Type type, DetType::Part part) const
void	connect (ServiceVolume *prev, ServiceVolume *newv)
void	routeBarrelLayer (LayerContainer::const_iterator bl, LayerContainer::const_iterator blend, ServicesTracker &tracker, VRoute &route)
void	routeEndcapLayer (LayerContainer::const_iterator bl, LayerContainer::const_iterator blend, ServicesTracker &tracker, HRoute &route)
bool	isRoutedOutsideSupportTube (LayerContainer::const_iterator bl, HRoute &route)
void	routeOuterBarrelPixel (ServicesTracker &tracker)
void	routeEndcapPixel (ServicesTracker &tracker)
void	routeBarrelStrip (ServicesTracker &tracker)
void	routeInnerBarrelPixel (ServicesTracker &tracker)
void	createRoutes (ServicesTracker &tracker)
void	createRoutesInIST (ServicesTracker &tracker)
void	createOuterPixelRoutes (ServicesTracker &tracker)
void	addVolume (ServiceVolume *v)
ServiceVolume *	createSingleRouteVolume (Route &rt)
void	connectRoutes (Route &in, Route &out)
void	dumpRoute (const Route &route)
std::string	nextVolumeName (const Route &route) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
bool	m_routePixelBarrelOnPST
bool	m_pixelAlongBarrelStrip
bool	m_ISTexists
int	m_c_nInnerPixelLayers
double	m_c_bpEosLength
double	m_c_epEosLength
double	m_c_bsEosLength
double	m_c_safetyGap
double	m_c_EosTolerance
double	m_c_halfEosThick
double	m_c_EosTolerance2
double	m_c_ServiceDiskThickness
double	m_c_ServiceCylinderThickness
double	m_c_LayerLengthTolerance
std::vector< ServiceVolume * >	m_volumes
VRoute	m_bpVRoute
HRoute	m_bpHRoute
HRoute	m_epHRoute
VRoute	m_pixelV2Route
HRoute	m_pixelH2Route
VRoute	m_bsVRoute
VRoute	m_istVRoute
HRoute	m_istHRoute
HRoute	m_ISTouter_HRoute
HRoute	m_MSTinside_HRoute
HRoute	m_MSTO_HRoute
HRoute	m_MSTM_HRoute
HRoute	m_MSTM_HRouteInner
HRoute	m_MSTI_HRoute
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

Definition at line 15 of file Routing2.h.

Member Typedef Documentation

LayerContainer

typedef ServicesTracker::LayerContainer Routing2::LayerContainer

Definition at line 18 of file Routing2.h.

Constructor & Destructor Documentation

Routing2()

Routing2::Routing2

(

)

Definition at line 12 of file Routing2.cxx.

                  :
  AthMessaging("Routing2")
{
  m_routePixelBarrelOnPST = false;
  m_pixelAlongBarrelStrip = false;
  m_c_nInnerPixelLayers = 2;
 
  m_c_bpEosLength = 40; // mm
  m_c_epEosLength = 30;
  m_c_bsEosLength = 50;
  m_c_safetyGap = 0.001;
 
  // all units in cm
  m_c_EosTolerance = 1.; // mm
  m_c_halfEosThick = 3;
  m_c_EosTolerance2 = 0.1;
  m_c_ServiceDiskThickness = 10;
  m_c_ServiceCylinderThickness = 6;
  m_c_LayerLengthTolerance = 1;
 
  m_ISTexists = false;
 
}

Member Function Documentation

addVolume()

void Routing2::addVolume ( ServiceVolume * v )

inlineprivate

Definition at line 85 of file Routing2.h.

{ m_volumes.push_back( v);}

connect()

void Routing2::connect ( ServiceVolume * prev, ServiceVolume * newv )

private

Definition at line 505 of file Routing2.cxx.

{
  // checks on geometrical compatibility should be done by the caller
  newv->addPrevious(prev);
  prev->setNext(newv);
  newv->addLayers(prev->layers());
}

connectRoutes()

void Routing2::connectRoutes ( Route & in, Route & out )

private

Definition at line 513 of file Routing2.cxx.

{
  // choose volume to connect to
  ServiceVolume* entryVol = out.entryVolume(in.position(),true,msg());
  if (entryVol == nullptr) entryVol = createSingleRouteVolume( out);
  ServiceVolume* exitVol = in.exitVolume(true,msg());
  // maybe check volumes are connectable?
  entryVol->addPrevious(exitVol);
  exitVol->setNext(entryVol);
 
  // add the services of the in route to all volumes of out route, up to it's exit
  ServiceVolume* nextVol = entryVol;
  while (true) {
    nextVol->addLayers( exitVol->layers());
    nextVol = nextVol->next();
    if (nextVol == nullptr) break;
  }
}

createOuterPixelRoutes()

void Routing2::createOuterPixelRoutes ( ServicesTracker & tracker )

private

Definition at line 172 of file Routing2.cxx.

{
  if (!m_ISTexists) { // PST is actually IST, and there is no PST
    // we need to reduce the route radius after the pixel disks to avoid conflict with SCT disks
    double routeRadius = tracker.geoMgr()->pixelEnvelopeRMax() - m_c_safetyGap - m_c_ServiceCylinderThickness/2;
    //double zpos = 0.5 * (tracker.endcapPixelLayers().back()->zPos() + tracker.endcapStripLayers().front()->zPos());
    double zpos = m_epHRoute.zMax() + m_c_ServiceDiskThickness/2 + m_c_safetyGap;
 
    m_pixelV2Route = VRoute( zpos, routeRadius, m_bpHRoute.radius(), routeRadius, "OuterPixelRPath2");
 
    double pstLen = tracker.geoMgr()->SupportTubeZMax("PST");
    m_pixelH2Route = HRoute( routeRadius, zpos + m_c_ServiceDiskThickness/2 + m_c_safetyGap, pstLen, pstLen,"OuterPixelZPath2");
    m_epHRoute.setNextRoute( &m_pixelV2Route);
    m_pixelV2Route.setNextRoute( &m_pixelH2Route);
  }
}

createRoutes()

void Routing2::createRoutes ( ServicesTracker & tracker )

private

Assume same length barrel, the loop is to make sure there are no volume overlaps in case strip barrel layers are slightly different

Definition at line 75 of file Routing2.cxx.

{
  // barrel pixel vertical route
  const LayerContainer& bplc = tracker.barrelPixelLayers();
  const LayerContainer& eplc = tracker.endcapPixelLayers();
  const LayerContainer& bslc = tracker.barrelStripLayers();
 
  double bpZmax = 0;
  for (LayerContainer::const_iterator bl=bplc.begin()+m_c_nInnerPixelLayers; bl!=bplc.end(); ++bl)
    bpZmax = std::max( bpZmax, (**bl).zPos() + (**bl).halfLength());
 
  double bpVertRouteZpos = bpZmax+m_c_EosTolerance+m_c_bpEosLength +  0.5*m_c_ServiceDiskThickness + m_c_safetyGap;
  double bpVertRouteRmin = bplc[m_c_nInnerPixelLayers]->radius(); // change if along PST
 
  // Find max endcap pixel layer radius
  double epRmax = 0;
  for (LayerContainer::const_iterator i=eplc.begin(); i!=eplc.end(); ++i) 
    epRmax = std::max( epRmax, (**i).rMax());
 
  // Find max radius for vertical route
  double bpVertRouteRmax;
  if (!m_ISTexists) {
    bpVertRouteRmax = 0.5*(epRmax + m_c_epEosLength + tracker.geoMgr()->sctInnerSupport());
    // Pixel horizontal route in the middle between pixel disks and first strip layer
    if ( epRmax + m_c_epEosLength + m_c_ServiceCylinderThickness > tracker.geoMgr()->sctInnerSupport())
      ATH_MSG_WARNING("No space for services between pixel diskd and sct support");
  }
  else {
    // services along PST, as close as they can get
    bpVertRouteRmax = tracker.geoMgr()->SupportTubeRMin("PST") - m_c_safetyGap - 0.5*m_c_ServiceCylinderThickness;
  }
 
  double bpHorRouteR = bpVertRouteRmax;
  double bpHRouteZmin = bpVertRouteZpos +  0.5*m_c_ServiceDiskThickness + m_c_safetyGap;
  double bpHRouteZmax = eplc.back()->zPos(); // prolong if along PST ?
  ATH_MSG_INFO("Route2: setting bpHRouteZmax to " << bpHRouteZmax);

  double bsZmax = 0;
  for (LayerContainer::const_iterator i=bslc.begin(); i!=bslc.end(); ++i)
    bsZmax = std::max( bsZmax, (**i).zPos() + (**i).halfLength());
 
  double bsVertRouteZpos = bsZmax+m_c_EosTolerance+m_c_bsEosLength + 0.5*m_c_ServiceDiskThickness + m_c_safetyGap;
 
  bpHRouteZmax = tracker.geoMgr()->SupportTubeZMax("PST");
  
  double bpHRouteZmax_mode = tracker.geoMgr()->SupportTubeZMin("mode");
 
  bool bMSTI = tracker.geoMgr()->SupportTubeExists("MSTI");
  bool bMSTM = tracker.geoMgr()->SupportTubeExists("MSTM");
  bool bMSTO = tracker.geoMgr()->SupportTubeExists("MSTO");
  if(bMSTI||bMSTM||bMSTO)
    if(bpHRouteZmax_mode>0.1&&bpHRouteZmax_mode<bpHRouteZmax) bpHRouteZmax = bpHRouteZmax_mode-0.001;
 
  ATH_MSG_INFO("Changing bpHRouteZmax to " << bpHRouteZmax);
 
  double bsVertRouteRmin = bpHorRouteR + 0.5*m_c_ServiceCylinderThickness + m_c_safetyGap;
  double bsVertRouteRmax = bslc.back()->radius() + m_c_ServiceCylinderThickness; // approx
 
  m_bpVRoute = VRoute( bpVertRouteZpos, bpVertRouteRmin, bpVertRouteRmax, bpVertRouteRmax, "OuterPixelRPath");
 
  if (m_pixelAlongBarrelStrip)
    m_bpHRoute = HRoute( bpHorRouteR, bpHRouteZmin, bpHRouteZmax, bsVertRouteZpos,"OuterPixelZPath"); // different if along PST
  else 
    m_bpHRoute = HRoute( bpHorRouteR, bpHRouteZmin, bpHRouteZmax, bpHRouteZmax,"OuterPixelZPath");
 
  m_epHRoute = m_bpHRoute;  // different if along PST
  m_bsVRoute = VRoute( bsVertRouteZpos, bsVertRouteRmin, bsVertRouteRmax, bsVertRouteRmax,"BarrelStripRPath");
 
  m_bpVRoute.setNextRoute(&m_bpHRoute);
  if (m_pixelAlongBarrelStrip) m_bpHRoute.setNextRoute(&m_bsVRoute);
 
 // Additional Routes:
  // Outside MSTOuter
  double bpMSTO_R =  tracker.geoMgr()->SupportTubeRMax("MSTO") + m_c_safetyGap + 0.5*m_c_ServiceCylinderThickness;
  m_MSTO_HRoute = HRoute( bpMSTO_R, bpHRouteZmin, bpHRouteZmax, bpHRouteZmax, "MSTOPixelZPath"); 
 
  // Outside MSTMiddle
  double bpMSTM_R =  tracker.geoMgr()->SupportTubeRMax("MSTM") + m_c_safetyGap + 0.5*m_c_ServiceCylinderThickness;
  m_MSTM_HRoute = HRoute( bpMSTM_R, bpHRouteZmin, bpHRouteZmax, bpHRouteZmax, "MSTMPixelZPath"); 
 
  // Outside MSTInner
  double bpMSTI_R =  tracker.geoMgr()->SupportTubeRMax("MSTI") + m_c_safetyGap + 0.5*m_c_ServiceCylinderThickness;
  m_MSTI_HRoute = HRoute( bpMSTI_R, bpHRouteZmin, bpHRouteZmax, bpHRouteZmax, "MSTIPixelZPath"); 
 
  // Inside MSTMiddle
  double bpMSTM_RI =  tracker.geoMgr()->SupportTubeRMin("MSTM") - m_c_safetyGap - 0.5*m_c_ServiceCylinderThickness;
  m_MSTM_HRouteInner = HRoute( bpMSTM_RI, bpHRouteZmin, bpHRouteZmax, bpHRouteZmax, "MSTMPixelZPathInner"); 
 
  // Exit route for pixel
  if (!m_pixelAlongBarrelStrip) createOuterPixelRoutes(tracker);
 
  // route inside PST
  createRoutesInIST(tracker);
}

createRoutesInIST()

void Routing2::createRoutesInIST ( ServicesTracker & tracker )

private

Definition at line 189 of file Routing2.cxx.

{
  const LayerContainer& bplc = tracker.barrelPixelLayers();
  double bpZmax = 0;
  for (LayerContainer::const_iterator bl=bplc.begin(); bl!=bplc.begin()+m_c_nInnerPixelLayers; ++bl) {
    bpZmax = std::max( bpZmax, (**bl).zPos() + (**bl).halfLength());
  }
 
  double istVRouteZpos = bpZmax+m_c_EosTolerance+m_c_bpEosLength +
    0.5*m_c_ServiceDiskThickness + m_c_safetyGap;
  double istVRouteRmin = bplc.front()->radius();
 
  double istRmin;
  double istZmax;
  if (m_ISTexists) { 
    // use IST if it exists
   // use IST if it exists
    istRmin = tracker.geoMgr()->SupportTubeRMin("IST");
    istZmax = tracker.geoMgr()->SupportTubeZMax("IST");
  }
  else { 
    // use PST as IST for backward compatibility
   // use PST as IST for backward compatibility
    istRmin = tracker.geoMgr()->SupportTubeRMin("PST");
    istZmax = tracker.geoMgr()->SupportTubeZMax("PST");
  }
 
  double istVRouteRmax = istRmin - 0.5*m_c_ServiceCylinderThickness - m_c_safetyGap;
  m_istVRoute = VRoute( istVRouteZpos, istVRouteRmin, istVRouteRmax, istVRouteRmax, "InnerPixelRPath");
 
  double istHRouteZmin = istVRouteZpos + 0.5*m_c_ServiceDiskThickness + m_c_safetyGap;
  double istHRouteZmax = istZmax;
  m_istHRoute = HRoute( istVRouteRmax, istHRouteZmin, istHRouteZmax, istHRouteZmax, "InnerPixelZPath");
  m_istVRoute.setNextRoute(&m_istHRoute);
}

createRoutingVolumes()

void Routing2::createRoutingVolumes

(

ServicesTracker &

tracker

)

Definition at line 36 of file Routing2.cxx.

{
  m_ISTexists = (tracker.geoMgr()->SupportTubeRMin("IST") > 0.1); 
 
  createRoutes(tracker);
 
  routeOuterBarrelPixel(tracker);
  routeEndcapPixel( tracker);
 
  // Link routes
  connectRoutes( m_bpVRoute, m_epHRoute);
  if (!m_pixelAlongBarrelStrip && !m_ISTexists) {
    connectRoutes( m_epHRoute, m_pixelV2Route);
    connectRoutes( m_pixelV2Route, m_pixelH2Route);
  }
 
  // Create Strip layer routes
  routeBarrelStrip( tracker);
  if (m_pixelAlongBarrelStrip) connectRoutes( m_epHRoute, m_bsVRoute);
  
  // Create pixel layer routes
  routeInnerBarrelPixel(tracker);
  connectRoutes( m_istVRoute, m_istHRoute);
 
  // Output route details in debug mode
  if(msgLvl(MSG::DEBUG)){
    dumpRoute( m_bpVRoute);
    dumpRoute( m_epHRoute);
    dumpRoute( m_bsVRoute);
    dumpRoute( m_istVRoute);
    dumpRoute( m_istHRoute);
    if (!m_pixelAlongBarrelStrip && !m_ISTexists) {
      dumpRoute( m_pixelV2Route);
      dumpRoute( m_pixelH2Route);
    }
  }
  tracker.setServiceVolumes(m_volumes);
}

createSingleRouteVolume()

ServiceVolume * Routing2::createSingleRouteVolume ( Route & rt )

private

Definition at line 532 of file Routing2.cxx.

{
  ServiceVolume* vol(nullptr);
  HRoute* hrt = dynamic_cast<HRoute*>(&rt);
  if (hrt != nullptr) {
    vol = new ServiceVolume( ServiceVolume::Cylinder,  
                 rt.position()-0.5*m_c_ServiceCylinderThickness,
                 rt.position()+0.5*m_c_ServiceCylinderThickness,
                 hrt->zMin(), hrt->zMax(), rt.name());
  }
  else {
    VRoute* vrt = dynamic_cast<VRoute*>(&rt);
    if(vrt) vol = new ServiceVolume( ServiceVolume::Disk, vrt->rMin(), vrt->rMax(),
                     rt.position()-0.5*m_c_ServiceDiskThickness,
                     rt.position()+0.5*m_c_ServiceDiskThickness, rt.name());
  }
  rt.addVolume( vol);
  addVolume(vol);
  return vol;
}

dumpRoute()

void Routing2::dumpRoute ( const Route & route )

private

Definition at line 577 of file Routing2.cxx.

{
  ATH_MSG_INFO("Dumping route at pos " << route.position() << " with exit at " << route.exit());
  for ( Route::VolumeContainer::const_iterator iv = route.volumes().begin(); 
    iv != route.volumes().end(); ++iv) {
    (**iv).dump(false);
  }
}

eosHalfThickness()

double Routing2::eosHalfThickness ( DetType::Type type, DetType::Part part ) const

private

Definition at line 572 of file Routing2.cxx.

{
  return m_c_halfEosThick;
}

eosLength()

double Routing2::eosLength ( DetType::Type type, DetType::Part part ) const

private

Definition at line 558 of file Routing2.cxx.

{
  using namespace DetType;
  if (type == Pixel) {
    if (part == Barrel) return m_c_bpEosLength;
    else                return m_c_epEosLength;
  }
  else  {
    return m_c_bsEosLength; 
    // FIXME add part for endcap strip
  }
}

eosTolerance()

double Routing2::eosTolerance ( DetType::Type type, DetType::Part part ) const

private

Definition at line 553 of file Routing2.cxx.

{
  return m_c_EosTolerance;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

isRoutedOutsideSupportTube()

bool Routing2::isRoutedOutsideSupportTube ( LayerContainer::const_iterator bl, HRoute & route )

private

Definition at line 290 of file Routing2.cxx.

{
  return (**bl).rMax() > route.radius();
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

nextVolumeName()

std::string Routing2::nextVolumeName ( const Route & route ) const

private

Definition at line 586 of file Routing2.cxx.

{
  ostringstream os;
  os << route.volumes().size();
  return route.name() + "Vol" + os.str();
}

routeBarrelLayer()

void Routing2::routeBarrelLayer ( LayerContainer::const_iterator bl, LayerContainer::const_iterator blend, ServicesTracker & tracker, VRoute & route )

private

Definition at line 303 of file Routing2.cxx.

{
  // 1. construct end-of-stave volume 
  double zEosMin = (*bl)->halfLength() + eosTolerance( (*bl)->type(), DetType::Barrel);
  double zEosMax = zEosMin + eosLength( (*bl)->type(), DetType::Barrel);
 
  if (zEosMax < route.position() - 0.5*m_c_ServiceDiskThickness) {
    zEosMax = route.position() - 0.5*m_c_ServiceDiskThickness - m_c_safetyGap;
  }
  else {
    ATH_MSG_WARNING("not enough space for end of stave of barrel layer at radius "
                    << (**bl).radius());
  }
  double halfEosThick = eosHalfThickness( (*bl)->type(), DetType::Barrel);
  ServiceVolume* eosCylinder = new ServiceVolume( ServiceVolume::Cylinder,
                          (*bl)->radius()-halfEosThick,
                          (*bl)->radius()+halfEosThick,
                          zEosMin, zEosMax, (**bl).name() + "EOS");
  eosCylinder->addLayer(*bl);
  addVolume( eosCylinder);
  eosCylinder->addEosServices(*bl); // add all the stave EOS stuff
 
  // 2. Connect to route
  double rMin, rMax;
  if (route.volumes().empty()) rMin = route.rMin();
  else rMin = route.volumes().back()->rMax() + m_c_safetyGap;
 
  if (bl+1 != blend) {
    rMax = std::min((**(bl+1)).radius(), route.rExit());
  }
  else rMax = route.rExit();
 
  ServiceVolume* newDisk = new ServiceVolume( ServiceVolume::Disk, rMin, rMax, 
                          route.zPos()-0.5*m_c_ServiceDiskThickness,
                          route.zPos()+0.5*m_c_ServiceDiskThickness,
                          nextVolumeName(route));
  newDisk->dump(true);
  // newDisk->addLayer(*bl); // done by connect()
  connect( eosCylinder, newDisk);
  if (!route.volumes().empty()) connect( route.volumes().back(), newDisk);
  route.addVolume( newDisk);
  addVolume( newDisk);
}

routeBarrelStrip()

void Routing2::routeBarrelStrip ( ServicesTracker & tracker )

private

Definition at line 234 of file Routing2.cxx.

{
  const LayerContainer& bls = tracker.barrelStripLayers();
  for (LayerContainer::const_iterator bl=bls.begin(); bl!=bls.end(); ++bl) {
    routeBarrelLayer( bl, bls.end(), tracker, m_bsVRoute);
  }
}

routeEndcapLayer()

void Routing2::routeEndcapLayer ( LayerContainer::const_iterator bl, LayerContainer::const_iterator blend, ServicesTracker & tracker, HRoute & route )

private

Definition at line 349 of file Routing2.cxx.

{
  // 1. construct end-of-stave volume 
//   double rEosMin = (*bl)->rMax() + eosTolerance( (*bl)->type(), DetType::Endcap);
//   double rEosMax = rEosMin + eosLength( (*bl)->type(), DetType::Endcap);
//   if (rEosMax > route.position() - 0.5*m_c_ServiceCylinderThickness) {
//     msg(MSG::WARNING) << "not enough space for end of stave of endcap layer at Z = "
//            << (**bl).zPos() << endmsg;
//   }
//   rEosMax = route.position() - 0.5*m_c_ServiceCylinderThickness - m_c_safetyGap;
//   if (rEosMax < rEosMin) {
//     msg(MSG::WARNING) << "no space for routing of endcap layer at Z = "
//            << (**bl).zPos() << endmsg;
//   }
 
  double rEosMin = 0.0;
  double rEosMax = 0.0;
  std::string SupportName =  tracker.geoMgr()->pixelDiskServiceRoute( (*bl)->number() );
  double EOSZOffset = 0.0;
  
  bool bRoutedOutsideSupport = isRoutedOutsideSupportTube(bl, route);
 
  if (SupportName == "PST")
  {
    rEosMin = (*bl)->rMax() + eosTolerance( (*bl)->type(), DetType::Endcap);   // Disk outer edge + safety
    rEosMax = route.position() - 0.5*m_c_ServiceCylinderThickness - m_c_safetyGap; // support tube - safety
    EOSZOffset = tracker.geoMgr()->pixelDiskEOSZOffset( (*bl)->number() );
    if (rEosMax < rEosMin) ATH_MSG_WARNING("No space for routing of endcap layer at Z = " << (**bl).zPos());
  }
  else if (SupportName == "MST")
  {
    rEosMin = (*bl)->rMin() + eosTolerance( (*bl)->type(), DetType::Endcap); // EOS same size as Disk supports
    rEosMax = (*bl)->rMax() + eosTolerance( (*bl)->type(), DetType::Endcap);
    EOSZOffset = tracker.geoMgr()->pixelDiskEOSZOffset( (*bl)->number() );
  }
  else if (SupportName == "IST")
  {
    rEosMin = route.position() + 0.5*m_c_ServiceCylinderThickness + m_c_safetyGap; // support tube + safety
    rEosMax = (*bl)->rMin() - eosTolerance( (*bl)->type(), DetType::Endcap);   // Disk outer edge - safety
    EOSZOffset = tracker.geoMgr()->pixelDiskEOSZOffset( (*bl)->number() );
    if (rEosMax < rEosMin) ATH_MSG_WARNING("No space for routing of endcap layer at Z = " << (**bl).zPos());
  }
  else if (SupportName == "MSTO" || SupportName == "MSTM" || SupportName == "MSTI" )
  {
    // rEosMin/Max are different if disk runs inside or outside the support tube
    if (bRoutedOutsideSupport)
    {
      rEosMin = route.position() + 0.5*m_c_ServiceCylinderThickness + m_c_safetyGap;
      rEosMax = (*bl)->rMax() - eosTolerance( (*bl)->type(), DetType::Endcap);
    }
    else
    {
       rEosMax = route.position() - 0.5*m_c_ServiceCylinderThickness - m_c_safetyGap;
       rEosMin = (**bl).rMin() - eosTolerance( (**bl).type(), DetType::Endcap);
    }
    EOSZOffset = tracker.geoMgr()->pixelDiskEOSZOffset( (*bl)->number() );
  }
  else if (SupportName=="StdRoute")
    {
      rEosMin = (*bl)->rMax() + eosTolerance( (*bl)->type(), DetType::Endcap);
      rEosMax = rEosMin + eosLength( (*bl)->type(), DetType::Endcap);
      EOSZOffset = 0;
      if (rEosMax > route.position() - 0.5*m_c_ServiceCylinderThickness) {
        ATH_MSG_WARNING("not enough space for end of stave of endcap layer at Z = " << (**bl).zPos());
      }
      rEosMax = route.position() - 0.5*m_c_ServiceCylinderThickness - m_c_safetyGap;
      if (rEosMax < rEosMin) {
        ATH_MSG_WARNING("no space for routing of endcap layer at Z = " << (**bl).zPos());
      }
    }
  else
  {
    ATH_MSG_ERROR("Specified support name (" << SupportName<< ") not recognised - EOS not created!");
    return;
  }
 
  double halfEosThick = eosHalfThickness( (*bl)->type(), DetType::Endcap);
  ServiceVolume* eosVol = new ServiceVolume( ServiceVolume::Disk, rEosMin, rEosMax,
                         (*bl)->zPos()-halfEosThick+ EOSZOffset,
                         (*bl)->zPos()+halfEosThick+ EOSZOffset,
                         (**bl).name() + "EOS");
  eosVol->addLayer(*bl);
  addVolume( eosVol);
  eosVol->addEosServices(*bl); // add all the stave EOS stuff
 
  // 2. Connect to route
  double zMin, zMax;
  if (route.volumes().empty()) {
    zMin = (*bl)->zPos() + EOSZOffset;
    if ( zMin - route.zMin() > m_c_EosTolerance) { // FIXME use specific tolerance
      ServiceVolume* beg = new ServiceVolume( ServiceVolume::Cylinder,  
                          route.radius()-0.5*m_c_ServiceCylinderThickness,
                          route.radius()+0.5*m_c_ServiceCylinderThickness,
                          route.zMin(), zMin - m_c_safetyGap,
                          nextVolumeName(route));
      route.addVolume( beg); // beg has no services at this time
      addVolume( beg);
    }
  }
  else zMin = route.volumes().back()->zMax() + m_c_safetyGap;
 
  // Assume no further elements to link on the route then find next potential link 
  // Make sure next one is on the same support tube, and on the same side (inside or outside)
  zMax = route.zExit();
  for (LayerContainer::const_iterator blnext = bl+1; blnext != blend; ++blnext)
  {
    if ( tracker.geoMgr()->pixelDiskServiceRoute((*blnext)->number()) == SupportName     &&   isRoutedOutsideSupportTube(blnext, route) == bRoutedOutsideSupport ) 
    {
       zMax = std::min((**blnext).zPos() + EOSZOffset, route.zExit());
       break;
    }
  }
 
//   LayerContainer::const_iterator blnext = bl+1;
//   if (blnext != blend) {
//     zMax = std::min((**blnext).zPos(), route.zExit());
//   }
//   else zMax = route.zExit();
 
  bool reverse = false;
  //  if (route.zExit() < (**bl).zPos()) {
  if (route.zExit() < zMin) {
    // create a dedicated exit volume with zero length
    ServiceVolume* exitVol = new ServiceVolume( ServiceVolume::Cylinder,  
                        route.radius()-0.5*m_c_ServiceCylinderThickness,
                        route.radius()+0.5*m_c_ServiceCylinderThickness,
                        route.zExit(), route.zExit(),
                        route.name()+"ExitVol");
    // connect the last volume to the exit
    connect( route.volumes().back(), exitVol);
    route.setExitVolume( exitVol);
    zMin = max( route.zExit(), route.volumes().back()->zMax());
    zMax = (**bl).zPos();
    reverse = true;
  }
 
  ServiceVolume* newCyl = new ServiceVolume( ServiceVolume::Cylinder,  
                         route.radius()-0.5*m_c_ServiceCylinderThickness,
                         route.radius()+0.5*m_c_ServiceCylinderThickness,
                         zMin, zMax, nextVolumeName(route));
  newCyl->dump();
  connect( eosVol, newCyl);
  if (! reverse) {
    if (!route.volumes().empty()) connect( route.volumes().back(), newCyl);
  }
  else {
    // FIXME: the services of the new layer will not propagate thru all volumes
    if (!route.volumes().empty()) connect( newCyl, route.volumes().back());
  }
  route.addVolume( newCyl);
  addVolume( newCyl);
  
}

routeEndcapPixel()

void Routing2::routeEndcapPixel ( ServicesTracker & tracker )

private

Definition at line 242 of file Routing2.cxx.

{
 
//   const LayerContainer& lc = tracker.endcapPixelLayers();
//   for (LayerContainer::const_iterator bl=lc.begin(); bl!=lc.end(); ++bl) {
//     routeEndcapLayer( bl, lc.end(), tracker, m_epHRoute);
//   }
 
  const LayerContainer& lc = tracker.endcapPixelLayers();
  bool bMSTI = tracker.geoMgr()->SupportTubeExists("MSTI");
  bool bMSTM = tracker.geoMgr()->SupportTubeExists("MSTM");
  bool bMSTO = tracker.geoMgr()->SupportTubeExists("MSTO");
 
  for (LayerContainer::const_iterator bl=lc.begin(); bl!=lc.end(); ++bl)
  {
 
    if (bMSTI)
    {
      if (tracker.geoMgr()->pixelDiskServiceRoute( (*bl)->number() )  == "MSTI")
    routeEndcapLayer( bl, lc.end(), tracker, m_MSTI_HRoute);
    }
 
    // MSTM can have service on inside or outside
    if (bMSTM)
    {
      if (tracker.geoMgr()->pixelDiskServiceRoute( (*bl)->number() )  == "MSTM")
      {
    if (isRoutedOutsideSupportTube(bl, m_MSTM_HRoute))
      routeEndcapLayer( bl, lc.end(), tracker, m_MSTM_HRoute);
    else
      routeEndcapLayer( bl, lc.end(), tracker, m_MSTM_HRouteInner);
      }
    }
 
    if (bMSTO)
    {
      if (tracker.geoMgr()->pixelDiskServiceRoute( (*bl)->number() )  == "MSTO")
    routeEndcapLayer( bl, lc.end(), tracker, m_MSTO_HRoute);
    }
  }
 
  if(!bMSTI&&!bMSTM&&!bMSTO)
   for (LayerContainer::const_iterator bl=lc.begin(); bl!=lc.end(); ++bl) 
     routeEndcapLayer( bl, lc.end(), tracker, m_epHRoute);
 
}

routeInnerBarrelPixel()

void Routing2::routeInnerBarrelPixel ( ServicesTracker & tracker )

private

Definition at line 295 of file Routing2.cxx.

{
  const LayerContainer& bls = tracker.barrelPixelLayers();
  for (LayerContainer::const_iterator bl=bls.begin(); bl!=bls.begin()+m_c_nInnerPixelLayers; ++bl) {
    routeBarrelLayer( bl, bls.begin()+m_c_nInnerPixelLayers, tracker, m_istVRoute);
  }
}

routeOuterBarrelPixel()

void Routing2::routeOuterBarrelPixel ( ServicesTracker & tracker )

private

Definition at line 225 of file Routing2.cxx.

{
 
  const LayerContainer& bls = tracker.barrelPixelLayers();
  for (LayerContainer::const_iterator bl=bls.begin()+m_c_nInnerPixelLayers; bl!=bls.end(); ++bl) {
    routeBarrelLayer( bl, bls.end(), tracker, m_bpVRoute);
  }
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

volumes()

const std::vector< ServiceVolume * > & Routing2::volumes ( ) const

inline

Definition at line 24 of file Routing2.h.

{return m_volumes;}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_bpHRoute

HRoute Routing2::m_bpHRoute

private

Definition at line 49 of file Routing2.h.

m_bpVRoute

VRoute Routing2::m_bpVRoute

private

Definition at line 48 of file Routing2.h.

m_bsVRoute

VRoute Routing2::m_bsVRoute

private

Definition at line 55 of file Routing2.h.

m_c_bpEosLength

double Routing2::m_c_bpEosLength

private

Definition at line 34 of file Routing2.h.

m_c_bsEosLength

double Routing2::m_c_bsEosLength

private

Definition at line 36 of file Routing2.h.

m_c_EosTolerance

double Routing2::m_c_EosTolerance

private

Definition at line 39 of file Routing2.h.

m_c_EosTolerance2

double Routing2::m_c_EosTolerance2

private

Definition at line 41 of file Routing2.h.

m_c_epEosLength

double Routing2::m_c_epEosLength

private

Definition at line 35 of file Routing2.h.

m_c_halfEosThick

double Routing2::m_c_halfEosThick

private

Definition at line 40 of file Routing2.h.

m_c_LayerLengthTolerance

double Routing2::m_c_LayerLengthTolerance

private

Definition at line 44 of file Routing2.h.

m_c_nInnerPixelLayers

int Routing2::m_c_nInnerPixelLayers

private

Definition at line 32 of file Routing2.h.

m_c_safetyGap

double Routing2::m_c_safetyGap

private

Definition at line 37 of file Routing2.h.

m_c_ServiceCylinderThickness

double Routing2::m_c_ServiceCylinderThickness

private

Definition at line 43 of file Routing2.h.

m_c_ServiceDiskThickness

double Routing2::m_c_ServiceDiskThickness

private

Definition at line 42 of file Routing2.h.

m_epHRoute

HRoute Routing2::m_epHRoute

private

Definition at line 50 of file Routing2.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_ISTexists

bool Routing2::m_ISTexists

private

Definition at line 30 of file Routing2.h.

m_istHRoute

HRoute Routing2::m_istHRoute

private

Definition at line 57 of file Routing2.h.

m_ISTouter_HRoute

HRoute Routing2::m_ISTouter_HRoute

private

Definition at line 59 of file Routing2.h.

m_istVRoute

VRoute Routing2::m_istVRoute

private

Definition at line 56 of file Routing2.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_MSTI_HRoute

HRoute Routing2::m_MSTI_HRoute

private

Definition at line 65 of file Routing2.h.

m_MSTinside_HRoute

HRoute Routing2::m_MSTinside_HRoute

private

Definition at line 60 of file Routing2.h.

m_MSTM_HRoute

HRoute Routing2::m_MSTM_HRoute

private

Definition at line 63 of file Routing2.h.

m_MSTM_HRouteInner

HRoute Routing2::m_MSTM_HRouteInner

private

Definition at line 64 of file Routing2.h.

m_MSTO_HRoute

HRoute Routing2::m_MSTO_HRoute

private

Definition at line 62 of file Routing2.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_pixelAlongBarrelStrip

bool Routing2::m_pixelAlongBarrelStrip

private

Definition at line 29 of file Routing2.h.

m_pixelH2Route

HRoute Routing2::m_pixelH2Route

private

Definition at line 53 of file Routing2.h.

m_pixelV2Route

VRoute Routing2::m_pixelV2Route

private

Definition at line 52 of file Routing2.h.

m_routePixelBarrelOnPST

bool Routing2::m_routePixelBarrelOnPST

private

Definition at line 28 of file Routing2.h.

m_volumes

std::vector<ServiceVolume*> Routing2::m_volumes

private

Definition at line 46 of file Routing2.h.

---

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

• Routing2.h
• Routing2.cxx