MTDNavigationSchool Class Reference

#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
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 31 of file MTDNavigationSchool.h.

Constructor & Destructor Documentation

MTDNavigationSchool()

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

Constructor.

Definition at line 34 of file MTDNavigationSchool.cc.

    : 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();
}

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.

~MTDNavigationSchool()

MTDNavigationSchool::~MTDNavigationSchool ( )

override

Destructor.

Definition at line 77 of file MTDNavigationSchool.cc.

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

References theBackwardNLC, theBarrelNLC, and theForwardNLC.

Member Function Documentation

addBarrelLayer()

void MTDNavigationSchool::addBarrelLayer ( const BarrelDetLayer *  mbp )

private

add barrel layer

create barrel layer map

Definition at line 106 of file MTDNavigationSchool.cc.

                                                                  {
  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);
}

References calculateEta(), distMuonTCMETValueMapProducer_cff::eta_max, egammaIdentification::eta_min, CosmicsPD_Skims::radius, BarrelDetLayer::specificSurface(), and theBarrelLayers.

Referenced by MTDNavigationSchool().

addEndcapLayer()

void MTDNavigationSchool::addEndcapLayer ( const ForwardDetLayer *  mep )

private

add endcap layer (backward and forward)

create forwrad/backward layer maps

Definition at line 118 of file MTDNavigationSchool.cc.

                                                                   {
  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);
  }
}

References calculateEta(), distMuonTCMETValueMapProducer_cff::eta_max, egammaIdentification::eta_min, ForwardDetLayer::specificSurface(), theBackwardLayers, theForwardLayers, and z.

Referenced by MTDNavigationSchool().

calculateEta()

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

private

calculate pseudorapidity from r and z

Definition at line 137 of file MTDNavigationSchool.cc.

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

References dqm-mbProfile::log, alignCSCRings::r, funct::tan(), and z.

Referenced by addBarrelLayer(), and addEndcapLayer().

createInverseLinks()

void MTDNavigationSchool::createInverseLinks ( )

private

establish inward links

create inverse links (i.e. inwards)

Definition at line 234 of file MTDNavigationSchool.cc.

                                             {
  // 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]);
  }
}

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().

linkBarrelLayers()

void MTDNavigationSchool::linkBarrelLayers ( )

private

link barrel layers

linking barrel layers outwards

Definition at line 144 of file MTDNavigationSchool.cc.

                                           {
  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));
  }
}

References FastTimerService_cff::range, theBackwardLayers, theBarrelLayers, theBarrelNLC, and theForwardLayers.

Referenced by MTDNavigationSchool().

linkEndcapLayers()

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

private

link endcap layers

linking forward/backward layers outwards

Definition at line 198 of file MTDNavigationSchool.cc.

                                                                                                 {
  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));
  }
}

References cmsLHEtoEOSManager::l, hgcalTopologyTester_cfi::layers, SiStripPI::max, GetRecoTauVFromDQM_MC_cff::next, FastTimerService_cff::range, and mps_fire::result.

Referenced by MTDNavigationSchool().

navigableLayers()

MTDNavigationSchool::StateType MTDNavigationSchool::navigableLayers ( )

overridevirtual

return navigable layers, from base class

return all Navigable layers

Implements NavigationSchool.

Definition at line 84 of file MTDNavigationSchool.cc.

                                                                  {
  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;
}

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

Referenced by createInverseLinks().

Member Data Documentation

theBackwardLayers

MapE MTDNavigationSchool::theBackwardLayers

private

+z endcap

Definition at line 66 of file MTDNavigationSchool.h.

Referenced by addEndcapLayer(), createInverseLinks(), linkBarrelLayers(), and MTDNavigationSchool().

theBackwardNLC

std::vector<ETLNavigableLayer*> MTDNavigationSchool::theBackwardNLC

private

Definition at line 70 of file MTDNavigationSchool.h.

Referenced by MTDNavigationSchool(), navigableLayers(), and ~MTDNavigationSchool().

theBarrelLayers

MapB MTDNavigationSchool::theBarrelLayers

private

Definition at line 64 of file MTDNavigationSchool.h.

Referenced by addBarrelLayer(), createInverseLinks(), and linkBarrelLayers().

theBarrelNLC

std::vector<BTLNavigableLayer*> MTDNavigationSchool::theBarrelNLC

private

-z endcap

Definition at line 68 of file MTDNavigationSchool.h.

Referenced by linkBarrelLayers(), navigableLayers(), and ~MTDNavigationSchool().

theForwardLayers

MapE MTDNavigationSchool::theForwardLayers

private

barrel

Definition at line 65 of file MTDNavigationSchool.h.

Referenced by addEndcapLayer(), createInverseLinks(), linkBarrelLayers(), and MTDNavigationSchool().

theForwardNLC

std::vector<ETLNavigableLayer*> MTDNavigationSchool::theForwardNLC

private

Definition at line 69 of file MTDNavigationSchool.h.

Referenced by MTDNavigationSchool(), navigableLayers(), and ~MTDNavigationSchool().

theMTDDetLayerGeometry

const MTDDetLayerGeometry* MTDNavigationSchool::theMTDDetLayerGeometry

private

Definition at line 72 of file MTDNavigationSchool.h.