#include <MTDNavigationSchool.h>

Inheritance diagram for MTDNavigationSchool:

Classes
struct	delete_layer

Public Member Functions
	MTDNavigationSchool (const MTDDetLayerGeometry *, bool enableBTL=true, bool enableETL=true)
	Constructor. More...

StateType	navigableLayers () override
	return navigable layers, from base class More...

	~MTDNavigationSchool () override
	Destructor. More...

Public Member Functions inherited from NavigationSchool
const std::vector< const DetLayer * > &	allLayersInSystem () const

template<typename... Args>
std::vector< const DetLayer * >	compatibleLayers (const DetLayer &detLayer, Args &&...args) const
	Returns all layers compatible. More...

	NavigationSchool ()

template<typename... Args>
std::vector< const DetLayer * >	nextLayers (const DetLayer &detLayer, Args &&...args) const
	NavigationDirection. More...

virtual	~NavigationSchool ()

Private Member Functions
void	addBarrelLayer (const BarrelDetLayer *)
	add barrel layer More...

void	addEndcapLayer (const ForwardDetLayer *)
	add endcap layer (backward and forward) More...

float	calculateEta (const float &, const float &) const
	calculate pseudorapidity from r and z More...

void	createInverseLinks ()
	establish inward links More...

void	linkBarrelLayers ()
	link barrel layers More...

void	linkEndcapLayers (const MapE &, std::vector< ETLNavigableLayer * > &)
	link endcap layers More...

Private Attributes
MapE	theBackwardLayers
	+z endcap More...

std::vector< ETLNavigableLayer * >	theBackwardNLC

MapB	theBarrelLayers

std::vector< BTLNavigableLayer * >	theBarrelNLC
	-z endcap More...

MapE	theForwardLayers
	barrel More...

std::vector< ETLNavigableLayer * >	theForwardNLC

const MTDDetLayerGeometry *	theMTDDetLayerGeometry

Additional Inherited Members
Public Types inherited from NavigationSchool
typedef std::vector< NavigableLayer * >	StateType

Protected Member Functions inherited from NavigationSchool
void	setState (const StateType &state)

Protected Attributes inherited from NavigationSchool
const std::vector< const DetLayer * > *	theAllDetLayersInSystem

StateType	theAllNavigableLayer

Detailed Description

Description: Navigation school for the MTD system This class defines which DetLayers are reacheable from each MTD DetLayer ( BTL and ETL ). The reacheableness is based on an eta range criteria.

Author: : L. Gray

Modification:

Description: Navigation school for the MTD system This class defines which DetLayers are reacheable from each MTD DetLayer (BTL and ETL). The reacheableness is based on an eta range criteria.

Author: : L. Gray - FNAL

Modification:

Definition at line 32 of file MTDNavigationSchool.h.

Constructor & Destructor Documentation

MTDNavigationSchool::MTDNavigationSchool	(	const MTDDetLayerGeometry *	mtdLayout,
		bool	enableBTL = `true`,
		bool	enableETL = `true`
	)

Constructor.

Definition at line 34 of file MTDNavigationSchool.cc.

References addBarrelLayer(), addEndcapLayer(), MTDDetLayerGeometry::allBarrelLayers(), MTDDetLayerGeometry::allEndcapLayers(), MTDDetLayerGeometry::allLayers(), Reference_intrackfit_cff::barrel, createInverseLinks(), makeMuonMisalignmentScenario::endcap, Exception, mps_fire::i, linkBarrelLayers(), linkEndcapLayers(), NavigationSchool::theAllDetLayersInSystem, NavigationSchool::theAllNavigableLayer, theBackwardLayers, theBackwardNLC, theForwardLayers, and theForwardNLC.

                                                                                                                : theMTDDetLayerGeometry(mtdLayout) {
 
   theAllDetLayersInSystem=&mtdLayout->allLayers(); 
   theAllNavigableLayer.resize(mtdLayout->allLayers().size(),nullptr);
 
 
 
   // get all barrel DetLayers (BTL) 
   vector<const DetLayer*> barrel;
   if ( enableBTL ) barrel = mtdLayout->allBarrelLayers();
   else barrel = mtdLayout->allBarrelLayers();
 
   for ( auto i = barrel.begin(); i != barrel.end(); i++ ) {
     const BarrelDetLayer* mbp = dynamic_cast<const BarrelDetLayer*>(*i);
     if ( mbp == nullptr ) throw cms::Exception("MTDNavigationSchool", "Bad BarrelDetLayer");
     addBarrelLayer(mbp);
   }
 
 
   // get all endcap DetLayers (ETL)
   vector<const DetLayer*> endcap;
   if ( enableETL ) endcap = mtdLayout->allEndcapLayers();   
   else endcap = mtdLayout->allEndcapLayers();
 
   for ( auto i = endcap.begin(); i != endcap.end(); i++ ) {
     const ForwardDetLayer* mep = dynamic_cast<const ForwardDetLayer*>(*i);
     if ( mep == nullptr ) throw cms::Exception("MTDNavigationSchool", "Bad ForwardDetLayer");
     addEndcapLayer(mep);
   }
 
   // create outward links for all DetLayers
   linkBarrelLayers();
   linkEndcapLayers(theForwardLayers,theForwardNLC);
   linkEndcapLayers(theBackwardLayers,theBackwardNLC);
 
   // create inverse links
   createInverseLinks();
 
 }

MTDNavigationSchool::~MTDNavigationSchool ( )

override

Destructor.

Definition at line 76 of file MTDNavigationSchool.cc.

References theBackwardNLC, theBarrelNLC, and theForwardNLC.

                                           {
 
    for_each(theBarrelNLC.begin(),theBarrelNLC.end(), delete_layer());
    for_each(theForwardNLC.begin(),theForwardNLC.end(), delete_layer());
    for_each(theBackwardNLC.begin(),theBackwardNLC.end(), delete_layer());
 
 }

Member Function Documentation

void MTDNavigationSchool::addBarrelLayer ( const BarrelDetLayer * mbp )

private

add barrel layer

create barrel layer map

Definition at line 112 of file MTDNavigationSchool.cc.

References calculateEta(), MuonTCMETValueMapProducer_cff::eta_max, MuonME0RecHits_cfi::eta_min, TCMET_cfi::radius, BarrelDetLayer::specificSurface(), and theBarrelLayers.

Referenced by MTDNavigationSchool().

                                                                   {
 
   const BoundCylinder& bc = mbp->specificSurface();
   float radius = bc.radius();
   float length = bc.bounds().length()/2.;
 
   float eta_max = calculateEta(radius, length);
   float eta_min = -eta_max;
 
   theBarrelLayers[mbp] = MTDEtaRange(eta_max, eta_min);
 
 }

void MTDNavigationSchool::addEndcapLayer ( const ForwardDetLayer * mep )

private

add endcap layer (backward and forward)

create forwrad/backward layer maps

Definition at line 127 of file MTDNavigationSchool.cc.

References calculateEta(), MuonTCMETValueMapProducer_cff::eta_max, MuonME0RecHits_cfi::eta_min, ForwardDetLayer::specificSurface(), theBackwardLayers, theForwardLayers, and z.

Referenced by MTDNavigationSchool().

                                                                    {
 
   const BoundDisk& bd = mep->specificSurface();
   float outRadius = bd.outerRadius();
   float inRadius = bd.innerRadius();
   float thick = bd.bounds().length()/2.;
   float z = bd.position().z();
 
   if ( z > 0. ) {
     float eta_min = calculateEta(outRadius, z-thick);
     float eta_max = calculateEta(inRadius, z+thick);
     theForwardLayers[mep] = MTDEtaRange(eta_max, eta_min);
   } else {
     float eta_max = calculateEta(outRadius, z+thick);
     float eta_min = calculateEta(inRadius, z-thick);
     theBackwardLayers[mep] = MTDEtaRange(eta_max, eta_min);
   }
 
 }

float MTDNavigationSchool::calculateEta	(	const float &	r,
		const float &	z
	)		const

private

calculate pseudorapidity from r and z

Definition at line 149 of file MTDNavigationSchool.cc.

References cmsBatch::log, and funct::tan().

Referenced by addBarrelLayer(), and addEndcapLayer().

                                                                             {
 
   if ( z > 0 ) return -log((tan(atan(r/z)/2.)));
   return log(-(tan(atan(r/z)/2.)));
 
 }

void MTDNavigationSchool::createInverseLinks ( )

private

establish inward links

create inverse links (i.e. inwards)

Definition at line 260 of file MTDNavigationSchool.cc.

References BTLNavigableLayer::getAllOuterBackwardLayers(), BTLNavigableLayer::getAllOuterBarrelLayers(), BTLNavigableLayer::getAllOuterForwardLayers(), BTLNavigableLayer::getOuterBackwardLayers(), BTLNavigableLayer::getOuterBarrelLayers(), BTLNavigableLayer::getOuterForwardLayers(), mps_fire::i, navigableLayers(), ETLNavigableLayer::setInwardCompatibleLinks(), BTLNavigableLayer::setInwardCompatibleLinks(), ETLNavigableLayer::setInwardLinks(), BTLNavigableLayer::setInwardLinks(), NavigationSchool::setState(), NavigationSchool::theAllNavigableLayer, theBackwardLayers, theBarrelLayers, and theForwardLayers.

Referenced by MTDNavigationSchool().

                                               {
 
   // set outward link
   // NavigationSetter setter(*this);
 
   setState(navigableLayers());
 
 
   // find for each layer which are the layers pointing to it
   typedef map<const DetLayer*, MapB, less<const DetLayer*> > BarrelMapType;
   typedef map<const DetLayer*, MapE, less<const DetLayer*> > ForwardMapType;
 
   // map of all DetLayers which can reach a specific DetLayer
   BarrelMapType reachedBarrelLayersMap;
   ForwardMapType reachedForwardLayersMap;
 
   // map of all DetLayers which is compatible with a specific DetLayer
   BarrelMapType compatibleBarrelLayersMap;
   ForwardMapType compatibleForwardLayersMap;
 
   // collect all reacheable layers starting from a barrel layer
   for ( MapBI bli  = theBarrelLayers.begin(); 
               bli != theBarrelLayers.end(); bli++ ) {
     // barrel
     BTLNavigableLayer* mbnl =
       dynamic_cast<BTLNavigableLayer*>(theAllNavigableLayer[((*bli).first)->seqNum()]);
     MapB reacheableB = mbnl->getOuterBarrelLayers();
     for (MapBI i = reacheableB.begin(); i != reacheableB.end(); i++ ) {
       reachedBarrelLayersMap[(*i).first].insert(*bli);
     }
     MapB compatibleB = mbnl->getAllOuterBarrelLayers();
     for (MapBI i = compatibleB.begin(); i != compatibleB.end(); i++ ) {
       compatibleBarrelLayersMap[(*i).first].insert(*bli);
     }
     MapE reacheableE = mbnl->getOuterBackwardLayers();
     for (MapEI i = reacheableE.begin(); i != reacheableE.end(); i++ ) {
       reachedBarrelLayersMap[(*i).first].insert(*bli);
     }
     reacheableE = mbnl->getOuterForwardLayers();
     for (MapEI i = reacheableE.begin(); i != reacheableE.end(); i++ ) {
       reachedBarrelLayersMap[(*i).first].insert(*bli);
     }
     MapE compatibleE = mbnl->getAllOuterBackwardLayers();
     for (MapEI i = compatibleE.begin(); i != compatibleE.end(); i++ ) {
       compatibleBarrelLayersMap[(*i).first].insert(*bli);
     }
     compatibleE = mbnl->getAllOuterForwardLayers();
     for (MapEI i = compatibleE.begin(); i != compatibleE.end(); i++ ) {
       compatibleBarrelLayersMap[(*i).first].insert(*bli);
     }
 
   }
 
   // collect all reacheable layer starting from a backward layer
   for ( MapEI eli  = theBackwardLayers.begin(); 
               eli != theBackwardLayers.end(); eli++ ) {
     MapE reacheableE =
       dynamic_cast<ETLNavigableLayer*>(theAllNavigableLayer[((*eli).first)->seqNum()])->getOuterEndcapLayers();
     for (MapEI i = reacheableE.begin(); i != reacheableE.end(); i++ ) {
       reachedForwardLayersMap[(*i).first].insert(*eli);
     }
   // collect all compatible layer starting from a backward layer
     MapE compatibleE =
       dynamic_cast<ETLNavigableLayer*>(theAllNavigableLayer[((*eli).first)->seqNum()])->getAllOuterEndcapLayers();
     for (MapEI i = compatibleE.begin(); i != compatibleE.end(); i++ ) {
       compatibleForwardLayersMap[(*i).first].insert(*eli);
     }
   }
 
   for ( MapEI eli  = theForwardLayers.begin(); 
               eli != theForwardLayers.end(); eli++ ) {
   // collect all reacheable layer starting from a forward layer
     MapE reacheableE =
       dynamic_cast<ETLNavigableLayer*>(theAllNavigableLayer[((*eli).first)->seqNum()])->getOuterEndcapLayers();
     for (MapEI i = reacheableE.begin(); i != reacheableE.end(); i++ ) {
       reachedForwardLayersMap[(*i).first].insert(*eli);
     }
   // collect all compatible layer starting from a forward layer
     MapE compatibleE =
       dynamic_cast<ETLNavigableLayer*>(theAllNavigableLayer[((*eli).first)->seqNum()])->getAllOuterEndcapLayers();
     for (MapEI i = compatibleE.begin(); i != compatibleE.end(); i++ ) {
       compatibleForwardLayersMap[(*i).first].insert(*eli);
     }
   }
 
   // now set inverse link for barrel layers
   for ( MapBI bli  = theBarrelLayers.begin(); 
               bli != theBarrelLayers.end(); bli++ ) {
     BTLNavigableLayer* mbnl =
       dynamic_cast<BTLNavigableLayer*>(theAllNavigableLayer[((*bli).first)->seqNum()]);
     mbnl->setInwardLinks(reachedBarrelLayersMap[(*bli).first]);
     mbnl->setInwardCompatibleLinks(compatibleBarrelLayersMap[(*bli).first]);
 
   }
   //BACKWARD
   for ( MapEI eli  = theBackwardLayers.begin(); 
               eli != theBackwardLayers.end(); eli++ ) {
     ETLNavigableLayer* mfnl =      
       dynamic_cast<ETLNavigableLayer*>(theAllNavigableLayer[((*eli).first)->seqNum()]);
     // for backward next layers
     mfnl->setInwardLinks(reachedBarrelLayersMap[(*eli).first],
                          reachedForwardLayersMap[(*eli).first]);
   // for backward compatible layers
     mfnl->setInwardCompatibleLinks(compatibleBarrelLayersMap[(*eli).first],
                          compatibleForwardLayersMap[(*eli).first]);
   }
   //FORWARD
   for ( MapEI eli  = theForwardLayers.begin(); 
               eli != theForwardLayers.end(); eli++ ) {
     ETLNavigableLayer* mfnl = 
       dynamic_cast<ETLNavigableLayer*>(theAllNavigableLayer[((*eli).first)->seqNum()]);
     // and for forward next layers
     mfnl->setInwardLinks(reachedBarrelLayersMap[(*eli).first],
                          reachedForwardLayersMap[(*eli).first]);
   // and for forward compatible layers
     mfnl->setInwardCompatibleLinks(compatibleBarrelLayersMap[(*eli).first],
                          compatibleForwardLayersMap[(*eli).first]);
   }
 
 }

void MTDNavigationSchool::linkBarrelLayers ( )

private

link barrel layers

linking barrel layers outwards

Definition at line 157 of file MTDNavigationSchool.cc.

References theBackwardLayers, theBarrelLayers, theBarrelNLC, and theForwardLayers.

Referenced by MTDNavigationSchool().

                                            {
 
   for (MapBI bl  = theBarrelLayers.begin();
              bl != theBarrelLayers.end(); bl++) {
 
     MTDEtaRange range = (*bl).second;
 
     // first add next barrel layer
     MapBI plusOne(bl);
     plusOne++;
     MapB outerBarrel;
     MapB allOuterBarrel;
     if ( plusOne != theBarrelLayers.end() ) { outerBarrel.insert(*plusOne);}
     // add all outer barrel layers
     for ( MapBI iMBI = plusOne; iMBI!= theBarrelLayers.end(); iMBI++){
       allOuterBarrel.insert(*iMBI);
     }
     // then add all compatible backward layers with an eta criteria
     MapE allOuterBackward;
     for (MapEI el  = theBackwardLayers.begin();
                el != theBackwardLayers.end(); el++) {
       if ( (*el).second.isCompatible(range) ) {
         allOuterBackward.insert(*el);
       }
     }
     //add the backward next layer with an eta criteria
     MapE outerBackward;
     for (MapEI el  = theBackwardLayers.begin();
                el != theBackwardLayers.end(); el++) {
       if ( (*el).second.isCompatible(range) ) {
         outerBackward.insert(*el);
         break;
       }
     }
 
     // then add all compatible forward layers with an eta criteria
     MapE allOuterForward;
     for (MapEI el  = theForwardLayers.begin();
                el != theForwardLayers.end(); el++) {
       if ( (*el).second.isCompatible(range) ) {
         allOuterForward.insert(*el);
       }
     }
 
     // then add forward next layer with an eta criteria
     MapE outerForward;
     for (MapEI el  = theForwardLayers.begin();
                el != theForwardLayers.end(); el++) {
       if ( (*el).second.isCompatible(range) ) {
         outerForward.insert(*el);
         break;
       }
     }
 
     theBarrelNLC.push_back(new BTLNavigableLayer(
                        (*bl).first,outerBarrel, outerBackward, outerForward,
                        allOuterBarrel,allOuterBackward,allOuterForward));
 
   }
 
 }

void MTDNavigationSchool::linkEndcapLayers	(	const MapE &	layers,
		std::vector< ETLNavigableLayer * > &	result
	)

private

link endcap layers

linking forward/backward layers outwards

Definition at line 219 of file MTDNavigationSchool.cc.

References MTDEtaRange::add(), MTDEtaRange::isCompatible(), MTDEtaRange::isInside(), checklumidiff::l, SiStripPI::max, GetRecoTauVFromDQM_MC_cff::next, and MTDEtaRange::subtract().

Referenced by MTDNavigationSchool().

                                                                                 {
 
   for (MapEI el = layers.begin(); el != layers.end(); el++) {
 
     MTDEtaRange range = (*el).second;
     // first add next endcap layer (if compatible)
     MapEI plusOne(el); 
     plusOne++;
     MapE outerLayers;
     if ( plusOne != layers.end() && (*plusOne).second.isCompatible(range) ) {
         outerLayers.insert(*plusOne);
       if ( !range.isInside((*plusOne).second) ) {
         // then look if the next layer has a wider eta range, if so add it
         MapEI tmpel(plusOne);
         tmpel++;
         MTDEtaRange max((*plusOne).second);
         for ( MapEI l = tmpel; l != layers.end(); l++ ) {
           MTDEtaRange next = (*l).second;
           if ( next.isCompatible(max) && !range.isInside(next) &&
                !next.isInside(max) && next.subtract(max).isInside(range) ) {
             max = max.add(next);
             outerLayers.insert(*l);
           }
         }
       }
     }
 
     MapE allOuterLayers;
     for (MapEI iMEI = plusOne; iMEI!=layers.end(); iMEI++){
       if ((*iMEI).second.isCompatible(range)) allOuterLayers.insert(*iMEI);
     }
     
     result.push_back(new ETLNavigableLayer(
                    (*el).first,outerLayers, allOuterLayers));
   }
 
 }

MTDNavigationSchool::StateType MTDNavigationSchool::navigableLayers ( )

overridevirtual

return navigable layers, from base class

return all Navigable layers

Implements NavigationSchool.

Definition at line 87 of file MTDNavigationSchool.cc.

References cuy::ib, mps_fire::result, theBackwardNLC, theBarrelNLC, and theForwardNLC.

Referenced by createInverseLinks().

                                      {
 
   StateType result;
   
   vector<BTLNavigableLayer*>::const_iterator ib;
   vector<ETLNavigableLayer*>::const_iterator ie;
 
   for ( ib = theBarrelNLC.begin(); ib != theBarrelNLC.end(); ib++ ) {
     result.push_back(*ib);
   }
 
   for ( ie = theForwardNLC.begin(); ie != theForwardNLC.end(); ie++ ) {
     result.push_back(*ie);
   }
 
   for ( ie = theBackwardNLC.begin(); ie != theBackwardNLC.end(); ie++ ) {
     result.push_back(*ie);
   }
   
   return result;
 
 }