SimpleNavigableLayer Class Reference

#include <SimpleNavigableLayer.h>

Inheritance diagram for SimpleNavigableLayer:

Public Types
typedef std::vector< const BarrelDetLayer * >	BDLC
typedef std::vector< const DetLayer * >	DLC
typedef std::vector< const ForwardDetLayer * >	FDLC

Public Member Functions
virtual std::vector< const DetLayer * >	compatibleLayers (const FreeTrajectoryState &fts, PropagationDirection timeDirection) const
virtual std::vector< const DetLayer * >	compatibleLayers (const FreeTrajectoryState &fts, PropagationDirection timeDirection, int &counter) const
std::vector< const DetLayer * >	compatibleLayers (const FreeTrajectoryState &fts, PropagationDirection timeDirection, int &counter) const final
virtual std::vector< const DetLayer * >	compatibleLayers (NavigationDirection direction) const=0
virtual void	setAdditionalLink (const DetLayer *, NavigationDirection direction=insideOut)=0
void	setCheckCrossingSide (bool docheck)
virtual void	setInwardLinks (const BDLC &, const FDLC &, TkLayerLess sorter=TkLayerLess(outsideIn))=0
	SimpleNavigableLayer (const MagneticField *field, float eps, bool checkCrossingSide=true)
Public Member Functions inherited from NavigableLayer
virtual std::vector< const DetLayer * >	compatibleLayers (const FreeTrajectoryState &fts, PropagationDirection timeDirection) const
virtual std::vector< const DetLayer * >	compatibleLayers (NavigationDirection direction) const =0
virtual DetLayer const *	detLayer () const =0
virtual std::vector< const DetLayer * >	nextLayers (const FreeTrajectoryState &fts, PropagationDirection timeDirection) const =0
virtual std::vector< const DetLayer * >	nextLayers (NavigationDirection direction) const =0
virtual void	setDetLayer (DetLayer const *dl)=0
void	setSchool (NavigationSchool const *sh)
virtual	~NavigableLayer ()

Public Attributes
bool	theSelfSearch

Protected Types
typedef BDLC::iterator	BDLI
typedef BDLC::const_iterator	ConstBDLI
typedef FDLC::const_iterator	ConstFDLI
typedef FDLC::iterator	FDLI
typedef TrajectoryStateOnSurface	TSOS

Protected Member Functions
TSOS	crossingState (const FreeTrajectoryState &fts, PropagationDirection dir) const
AnalyticalPropagator	propagator (PropagationDirection dir) const
bool	wellInside (const FreeTrajectoryState &fts, PropagationDirection dir, const BarrelDetLayer *bl, DLC &result) const
bool	wellInside (const FreeTrajectoryState &fts, PropagationDirection dir, const DLC &layers, DLC &result) const
bool	wellInside (const FreeTrajectoryState &fts, PropagationDirection dir, const ForwardDetLayer *bl, DLC &result) const
bool	wellInside (const FreeTrajectoryState &fts, PropagationDirection dir, ConstBDLI begin, ConstBDLI end, DLC &result) const
bool	wellInside (const FreeTrajectoryState &fts, PropagationDirection dir, ConstFDLI begin, ConstFDLI end, DLC &result) const

Protected Attributes
bool	theCheckCrossingSide
float	theEpsilon
const MagneticField *	theField
Protected Attributes inherited from NavigableLayer
NavigationSchool const *	school = nullptr

Detailed Description

A partial implementation of the NavigableLayer

Definition at line 20 of file SimpleNavigableLayer.h.

Member Typedef Documentation

BDLC

typedef std::vector<const BarrelDetLayer*> SimpleNavigableLayer::BDLC

Definition at line 23 of file SimpleNavigableLayer.h.

BDLI

typedef BDLC::iterator SimpleNavigableLayer::BDLI

protected

Definition at line 49 of file SimpleNavigableLayer.h.

ConstBDLI

typedef BDLC::const_iterator SimpleNavigableLayer::ConstBDLI

protected

Definition at line 51 of file SimpleNavigableLayer.h.

ConstFDLI

typedef FDLC::const_iterator SimpleNavigableLayer::ConstFDLI

protected

Definition at line 52 of file SimpleNavigableLayer.h.

DLC

typedef std::vector<const DetLayer*> SimpleNavigableLayer::DLC

Definition at line 22 of file SimpleNavigableLayer.h.

FDLC

typedef std::vector<const ForwardDetLayer*> SimpleNavigableLayer::FDLC

Definition at line 24 of file SimpleNavigableLayer.h.

FDLI

typedef FDLC::iterator SimpleNavigableLayer::FDLI

protected

Definition at line 50 of file SimpleNavigableLayer.h.

TSOS

typedef TrajectoryStateOnSurface SimpleNavigableLayer::TSOS

protected

Definition at line 53 of file SimpleNavigableLayer.h.

Constructor & Destructor Documentation

SimpleNavigableLayer()

SimpleNavigableLayer::SimpleNavigableLayer ( const MagneticField *  field, float  eps, bool  checkCrossingSide = true  )

inline

Definition at line 26 of file SimpleNavigableLayer.h.

      : theField(field), theEpsilon(eps), theCheckCrossingSide(checkCrossingSide), theSelfSearch(false) {}

Member Function Documentation

compatibleLayers() [1/4]

virtual std::vector<const DetLayer*> NavigableLayer::compatibleLayers

inline

Definition at line 33 of file NavigableLayer.h.

                                                                                                  {
    int counter = 0;
    return compatibleLayers(fts, timeDirection, counter);
  };

compatibleLayers() [2/4]

virtual std::vector<const DetLayer*> NavigableLayer::compatibleLayers

inline

Definition at line 39 of file NavigableLayer.h.

                                                                            {
    edm::LogWarning("DetLayers") << "compatibleLayers(fts,dir,counter) not implemented. returning empty vector";
    return std::vector<const DetLayer*>();
  }

compatibleLayers() [3/4]

std::vector< const DetLayer * > SimpleNavigableLayer::compatibleLayers ( const FreeTrajectoryState &  fts, PropagationDirection  timeDirection, int &  counter  ) const

finalvirtual

Reimplemented from NavigableLayer.

Definition at line 216 of file SimpleNavigableLayer.cc.

                                                                                        {
  typedef std::vector<const DetLayer*> Lvect;
  typedef std::set<const DetLayer*> Lset;
 
  //initiate the first iteration
  const Lvect& someLayers = nextLayers(fts, timeDirection);
  if (someLayers.empty()) {
    LogDebug("SimpleNavigableLayer") << "Number of compatible layers: " << 0;
    return someLayers;
  }
 
  Lset collect;                     //a container of unique instances. to avoid duplicates
  Lset layerToTry, nextLayerToTry;  //set used for iterations
  layerToTry.insert(someLayers.begin(), someLayers.end());
 
  while (!layerToTry.empty() && (counter++) <= 150) {
    LogDebug("SimpleNavigableLayer") << counter << "] going to check on : " << layerToTry.size() << " next layers.";
    //clear this set first, it will be swaped with layerToTry
    nextLayerToTry.clear();
    for (auto toTry : layerToTry) {
      //add the layer you tried.
      LogDebug("SimpleNavigableLayer") << counter << "] adding layer with pointer: " << (toTry)
                                       << " first detid: " << (toTry)->basicComponents().front()->geographicalId();
      if (!collect.insert(toTry).second)
        continue;
 
      //find the next layers from it
      Lvect&& nextLayers = school->nextLayers(*toTry, fts, timeDirection);
      LogDebug("SimpleNavigableLayer") << counter << "] this layer has : " << nextLayers.size() << " next layers.";
      nextLayerToTry.insert(nextLayers.begin(), nextLayers.end());
    }  // layerToTry
    //swap now that you where to go next.
    layerToTry.swap(nextLayerToTry);
  }
  if (counter >= 150) {
    edm::LogWarning("SimpleNavigableLayer") << "WARNING: compatibleLayers() more than 150 iterations!!! Bailing out..";
    counter = -1;
    return Lvect();
  }
 
  LogDebug("SimpleNavigableLayer") << "Number of compatible layers: " << collect.size();
 
  return Lvect(collect.begin(), collect.end());
}

References LogDebug.

Referenced by SimpleForwardNavigableLayer::compatibleLayers(), and SimpleBarrelNavigableLayer::compatibleLayers().

compatibleLayers() [4/4]

virtual std::vector<const DetLayer*> NavigableLayer::compatibleLayers

crossingState()

TrajectoryStateOnSurface SimpleNavigableLayer::crossingState ( const FreeTrajectoryState &  fts, PropagationDirection  dir  ) const

protected

Definition at line 15 of file SimpleNavigableLayer.cc.

                                                                                             {
  //self propagating. step one: go close to the center
  GlobalPoint initialPoint = fts.position();
  TransverseImpactPointExtrapolator middle;
  GlobalPoint center(0, 0, 0);
  TSOS propState = middle.extrapolate(fts, center, propagator(dir));
  if (!propState.isValid())
    return TrajectoryStateOnSurface();
 
  FreeTrajectoryState const& dest = *propState.freeState();
  GlobalPoint middlePoint = dest.position();
  const float toCloseToEachOther2 = 1e-4 * 1e-4;
  if
    UNLIKELY((middlePoint - initialPoint).mag2() < toCloseToEachOther2) {
      LogDebug("SimpleNavigableLayer")
          << "initial state and PCA are identical. Things are bound to fail. Do not add the link.";
      return TrajectoryStateOnSurface();
    }
 
  /*
  std::string dirS;
  if (dir==alongMomentum) dirS = "alongMomentum";
  else if (dir==oppositeToMomentum) dirS = "oppositeToMomentum";
  else dirS = "anyDirection";
  */
 
  LogDebug("SimpleNavigableLayer") << "self propagating(" << dir << ") from:\n"
                                   << fts << "\n"
                                   << dest << "\n"
                                   << " and the direction is: " << dir;
 
  //second propagation to go on the other side of the barrel
  //propState = propagator(dir).propagate( dest, detLayer()->specificSurface());
  propState = propagator(dir).propagate(dest, detLayer()->surface());
  if (!propState.isValid())
    return TrajectoryStateOnSurface();
 
  const FreeTrajectoryState& dest2 = *propState.freeState();
  GlobalPoint finalPoint = dest2.position();
  LogDebug("SimpleNavigableLayer") << "second propagation(" << dir << ") to: \n" << dest2;
  double finalDot = (middlePoint - initialPoint).basicVector().dot((finalPoint - middlePoint).basicVector());
  if
    UNLIKELY(finalDot < 0) {  // check that before and after are in different side.
      LogDebug("SimpleNavigableLayer") << "switch side back: ABORT.";
      return TrajectoryStateOnSurface();
    }
  return propState;
}

References mps_fire::dest, DeadROC_duringRun::dir, MillePedeFileConverter_cfg::e, TransverseImpactPointExtrapolator::extrapolate(), TrajectoryStateOnSurface::freeState(), TrajectoryStateOnSurface::isValid(), LogDebug, mag2(), FreeTrajectoryState::position(), TrackCandidateProducer_cfi::propagator, and UNLIKELY.

propagator()

AnalyticalPropagator SimpleNavigableLayer::propagator ( PropagationDirection  dir ) const

inlineprotected

Definition at line 82 of file SimpleNavigableLayer.h.

                                                                  {
    AnalyticalPropagator aPropagator(theField);
    aPropagator.setPropagationDirection(dir);
    return aPropagator;
  }

References DeadROC_duringRun::dir, and Propagator::setPropagationDirection().

setAdditionalLink()

virtual void SimpleNavigableLayer::setAdditionalLink ( const DetLayer *  , NavigationDirection  direction = insideOut  )

pure virtual

Implemented in SimpleBarrelNavigableLayer, and SimpleForwardNavigableLayer.

Referenced by CosmicNavigationSchool::buildAdditionalBarrelLinks().

setCheckCrossingSide()

void SimpleNavigableLayer::setCheckCrossingSide ( bool  docheck )

inline

Definition at line 33 of file SimpleNavigableLayer.h.

{ theCheckCrossingSide = docheck; }

Referenced by BeamHaloNavigationSchool::BeamHaloNavigationSchool(), and CosmicNavigationSchool::buildAdditionalForwardLinks().

setInwardLinks()

virtual void SimpleNavigableLayer::setInwardLinks ( const BDLC &  , const FDLC &  , TkLayerLess  sorter = TkLayerLess(outsideIn)  )

pure virtual

Implemented in SimpleBarrelNavigableLayer, and SimpleForwardNavigableLayer.

Referenced by BeamHaloNavigationSchool::addInward(), and BeamHaloNavigationSchool::establishInverseRelations().

wellInside() [1/5]

bool SimpleNavigableLayer::wellInside ( const FreeTrajectoryState &  fts, PropagationDirection  dir, const BarrelDetLayer *  bl, DLC &  result  ) const

protected

Definition at line 65 of file SimpleNavigableLayer.cc.

                                                         {
  TSOS propState = (bl == detLayer()) ? crossingState(fts, dir) : propagator(dir).propagate(fts, bl->specificSurface());
 
  if (!propState.isValid())
    return false;
 
  //if requested check that the layer is crossed on the right side
  if (theCheckCrossingSide) {
    bool backTobackTransverse =
        (fts.position().x() * propState.globalPosition().x() + fts.position().y() * propState.globalPosition().y()) < 0;
    bool backToback = propState.globalPosition().basicVector().dot(fts.position().basicVector()) < 0;
 
    if (backTobackTransverse || backToback) {
      LogTrace("TkNavigation") << "Crossing over prevented!\nStaring from (x,y,z,r) (" << fts.position().x() << ","
                               << fts.position().y() << "," << fts.position().z() << "," << fts.position().perp()
                               << ") going to TSOS (x,y,z,r)" << propState.globalPosition().x() << ","
                               << propState.globalPosition().y() << "," << propState.globalPosition().z() << ","
                               << propState.globalPosition().perp() << ")";
      return false;
 
      /*
    //we have to check the crossing side only if we are going to something smaller
    if (fts.position().perp()>bl->specificSurface().radius() || 
    fabs(fts.position().z())>bl->surface().bounds().length()/2. ){
    if (propState.globalPosition().basicVector().dot(fts.position().basicVector())<0){
    LogTrace("TkNavigation") << "Crossing over prevented!\nStaring from (x,y,z,r) (" 
    << fts.position().x()<<","<< fts.position().y()<<","<< fts.position().z()<<","<<fts.position().perp()
    << ") going to TSOS (x,y,z,r)" 
    << propState.globalPosition().x()<<","<< propState.globalPosition().y()<<","<< propState.globalPosition().z()<<","<<propState.globalPosition().perp()<<")";; 
    return false;
    }
    }   
    */
    }
  }
 
  const Bounds& bounds(bl->specificSurface().bounds());
  float length = bounds.length() * 0.5f;
 
  // take into account the thickness of the layer
  float deltaZ =
      0.5f * bounds.thickness() * std::abs(propState.globalDirection().z()) / propState.globalDirection().perp();
 
  // take into account the error on the predicted state
  const float nSigma = theEpsilon;  // temporary reuse of epsilon
  if (propState.hasError()) {
    deltaZ += nSigma * sqrt(fts.cartesianError().position().czz());
  }
 
  // cout << "SimpleNavigableLayer BarrelDetLayer deltaZ = " << deltaZ << endl;
 
  float zpos = propState.globalPosition().z();
  if (std::abs(zpos) < length + deltaZ)
    result.push_back(bl);
 
  return std::abs(zpos) < length - deltaZ;
}

References funct::abs(), PV3DBase< T, PVType, FrameType >::basicVector(), FreeTrajectoryState::cartesianError(), GlobalErrorBase< T, ErrorWeightType >::czz(), DeadROC_duringRun::dir, Basic3DVector< T >::dot(), TrajectoryStateOnSurface::globalDirection(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::hasError(), TrajectoryStateOnSurface::isValid(), Bounds::length(), LogTrace, HLTSiStripMonitoring_cff::nSigma, PV3DBase< T, PVType, FrameType >::perp(), CartesianTrajectoryError::position(), FreeTrajectoryState::position(), TrackCandidateProducer_cfi::propagator, mps_fire::result, BarrelDetLayer::specificSurface(), mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by SimpleForwardNavigableLayer::nextLayers(), and SimpleBarrelNavigableLayer::nextLayers().

wellInside() [2/5]

bool SimpleNavigableLayer::wellInside ( const FreeTrajectoryState &  fts, PropagationDirection  dir, const DLC &  layers, DLC &  result  ) const

protected

Definition at line 180 of file SimpleNavigableLayer.cc.

                                                         {
  for (auto l : layers) {
    if (l->isBarrel()) {
      const BarrelDetLayer* bl = reinterpret_cast<const BarrelDetLayer*>(l);
      if (wellInside(fts, dir, bl, result))
        return true;
    } else {
      const ForwardDetLayer* fl = reinterpret_cast<const ForwardDetLayer*>(l);
      if (wellInside(fts, dir, fl, result))
        return true;
    }
  }
  return false;
}

References DeadROC_duringRun::dir, cmsLHEtoEOSManager::l, hgcalTopologyTester_cfi::layers, and mps_fire::result.

wellInside() [3/5]

bool SimpleNavigableLayer::wellInside ( const FreeTrajectoryState &  fts, PropagationDirection  dir, const ForwardDetLayer *  bl, DLC &  result  ) const

protected

Definition at line 126 of file SimpleNavigableLayer.cc.

                                                         {
  TSOS propState = propagator(dir).propagate(fts, fl->specificSurface());
  if (!propState.isValid())
    return false;
 
  if (fl == detLayer()) {
    LogDebug("SimpleNavigableLayer") << "self propagating from:\n" << fts << "\n to \n" << *propState.freeState();
  }
 
  //if requested avoids crossing over the tracker
  if (theCheckCrossingSide) {
    bool backTobackTransverse =
        (fts.position().x() * propState.globalPosition().x() + fts.position().y() * propState.globalPosition().y()) < 0;
    bool backToback = propState.globalPosition().basicVector().dot(fts.position().basicVector()) < 0;
 
    if (backTobackTransverse || backToback) {
      LogTrace("TkNavigation") << "Crossing over prevented!\nStaring from (x,y,z,r) (" << fts.position().x() << ","
                               << fts.position().y() << "," << fts.position().z() << "," << fts.position().perp()
                               << ") going to TSOS (x,y,z,r)" << propState.globalPosition().x() << ","
                               << propState.globalPosition().y() << "," << propState.globalPosition().z() << ","
                               << propState.globalPosition().perp() << ")";
      ;
      return false;
 
      //    if (fts.position().z()*propState.globalPosition().z() < 0) return false;
    }
  }
 
  float rpos = propState.globalPosition().perp();
  float innerR = fl->specificSurface().innerRadius();
  float outerR = fl->specificSurface().outerRadius();
 
  // take into account the thickness of the layer
  float deltaR = 0.5f * fl->surface().bounds().thickness() * propState.localDirection().perp() /
                 std::abs(propState.localDirection().z());
 
  // take into account the error on the predicted state
  const float nSigma = theEpsilon;
  if (propState.hasError()) {
    LocalError err = propState.localError().positionError();
    // ignore correlation for the moment...
    deltaR += nSigma * sqrt(err.xx() + err.yy());
  }
 
  // cout << "SimpleNavigableLayer BarrelDetLayer deltaR = " << deltaR << endl;
 
  if (innerR - deltaR < rpos && rpos < outerR + deltaR)
    result.push_back(fl);
  return (innerR + deltaR < rpos && rpos < outerR - deltaR);
}

References funct::abs(), PV3DBase< T, PVType, FrameType >::basicVector(), Surface::bounds(), PbPb_ZMuSkimMuonDPG_cff::deltaR, DeadROC_duringRun::dir, Basic3DVector< T >::dot(), runTheMatrix::err, TrajectoryStateOnSurface::freeState(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::hasError(), TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localDirection(), TrajectoryStateOnSurface::localError(), LogDebug, LogTrace, HLTSiStripMonitoring_cff::nSigma, PV3DBase< T, PVType, FrameType >::perp(), FreeTrajectoryState::position(), LocalTrajectoryError::positionError(), TrackCandidateProducer_cfi::propagator, mps_fire::result, ForwardDetLayer::specificSurface(), mathSSE::sqrt(), ForwardDetLayer::surface(), Bounds::thickness(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

wellInside() [4/5]

bool SimpleNavigableLayer::wellInside ( const FreeTrajectoryState &  fts, PropagationDirection  dir, ConstBDLI  begin, ConstBDLI  end, DLC &  result  ) const

protected

Definition at line 198 of file SimpleNavigableLayer.cc.

                                                                                                                 {
  for (ConstBDLI i = begin; i < end; i++) {
    if (wellInside(fts, dir, *i, result))
      return true;
  }
  return false;
}

References begin, DeadROC_duringRun::dir, end, mps_fire::i, and mps_fire::result.

wellInside() [5/5]

bool SimpleNavigableLayer::wellInside ( const FreeTrajectoryState &  fts, PropagationDirection  dir, ConstFDLI  begin, ConstFDLI  end, DLC &  result  ) const

protected

Definition at line 207 of file SimpleNavigableLayer.cc.

                                                                                                                 {
  for (ConstFDLI i = begin; i < end; i++) {
    if (wellInside(fts, dir, *i, result))
      return true;
  }
  return false;
}

References begin, DeadROC_duringRun::dir, end, mps_fire::i, and mps_fire::result.

Member Data Documentation

theCheckCrossingSide

bool SimpleNavigableLayer::theCheckCrossingSide

protected

Definition at line 43 of file SimpleNavigableLayer.h.

theEpsilon

float SimpleNavigableLayer::theEpsilon

protected

Definition at line 42 of file SimpleNavigableLayer.h.

theField

const MagneticField* SimpleNavigableLayer::theField

protected

Definition at line 41 of file SimpleNavigableLayer.h.

theSelfSearch

bool SimpleNavigableLayer::theSelfSearch

Definition at line 46 of file SimpleNavigableLayer.h.

Referenced by CosmicNavigationSchool::build(), and SimpleBarrelNavigableLayer::nextLayers().