BeamHaloNavigationSchool Class Reference

Inheritance diagram for BeamHaloNavigationSchool:

Public Member Functions
	BeamHaloNavigationSchool (const GeometricSearchTracker *theTracker, const MagneticField *field)
	~BeamHaloNavigationSchool ()
Public Member Functions inherited from SimpleNavigationSchool
virtual StateType	navigableLayers () override
	SimpleNavigationSchool ()
	SimpleNavigationSchool (const GeometricSearchTracker *theTracker, const MagneticField *field)
	~SimpleNavigationSchool ()
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 ()

Protected Member Functions
void	addInward (const DetLayer *det, const FDLC &news)
void	addInward (const DetLayer *det, const ForwardDetLayer *newF)
void	establishInverseRelations ()
void	linkOtherEndLayers (SymmetricLayerFinder &symFinder)
FDLC	reachableFromHorizontal ()
Protected Member Functions inherited from SimpleNavigationSchool
virtual float	barrelLength ()
void	cleanMemory ()
virtual void	linkBarrelLayers (SymmetricLayerFinder &symFinder)
virtual void	linkForwardLayers (SymmetricLayerFinder &symFinder)
virtual void	linkNextBarrelLayer (ForwardDetLayer const *fl, BDLC &)
virtual void	linkNextForwardLayer (BarrelDetLayer const *, FDLC &)
virtual void	linkNextLargerLayer (BDLI, BDLI, BDLC &)
virtual void	linkNextLayerInGroup (FDLI fli, const FDLC &group, FDLC &reachableFL)
virtual void	linkOuterGroup (ForwardDetLayer const *fl, const FDLC &group, FDLC &reachableFL)
virtual void	linkWithinGroup (FDLI fl, const FDLC &group, FDLC &reachableFL)
virtual ConstFDLI	outerRadiusIncrease (FDLI fl, const FDLC &group)
virtual std::vector< FDLC >	splitForwardLayers ()
Protected Member Functions inherited from NavigationSchool
void	setState (const StateType &state)

Additional Inherited Members
Public Types inherited from NavigationSchool
typedef std::vector < NavigableLayer * >	StateType
Protected Types inherited from SimpleNavigationSchool
typedef std::vector< const BarrelDetLayer * >	BDLC
typedef BDLC::iterator	BDLI
typedef std::vector < SimpleBarrelNavigableLayer * >	BNLCType
typedef BDLC::const_iterator	ConstBDLI
typedef FDLC::const_iterator	ConstFDLI
typedef std::vector< const DetLayer * >	DLC
typedef DLC::iterator	DLI
typedef std::vector< const ForwardDetLayer * >	FDLC
typedef FDLC::iterator	FDLI
typedef std::vector < SimpleForwardNavigableLayer * >	FNLCType
Protected Attributes inherited from SimpleNavigationSchool
BDLC	theBarrelLayers
float	theBarrelLength
BNLCType	theBarrelNLC
const MagneticField *	theField
FDLC	theForwardLayers
FNLCType	theForwardNLC
FDLC	theLeftLayers
FDLC	theRightLayers
const GeometricSearchTracker *	theTracker
Protected Attributes inherited from NavigationSchool
const std::vector< const DetLayer * > *	theAllDetLayersInSystem
StateType	theAllNavigableLayer

Detailed Description

Concrete navigation school for the Tracker, connecting disks only for traversing tracks : moslty beam halo muon

Definition at line 8 of file BeamHaloNavigationSchool.cc.

Constructor & Destructor Documentation

BeamHaloNavigationSchool::BeamHaloNavigationSchool	(	const GeometricSearchTracker *	theTracker,
		const MagneticField *	field
	)

Definition at line 39 of file BeamHaloNavigationSchool.cc.

References GeometricSearchTracker::allLayers(), prof2calltree::l, LogDebug, and SimpleNavigableLayer::setCheckCrossingSide().

{
  edm::LogInfo("BeamHaloNavigationSchool")<<"*********Running BeamHaloNavigationSchool *********";
  theBarrelLength = 0;theField = field; theTracker = theInputTracker;
  theAllDetLayersInSystem=&theInputTracker->allLayers();
  theAllNavigableLayer.resize(theInputTracker->allLayers().size(),nullptr);




  // Get barrel layers
  /*sideways does not need barrels*/
  /*  vector<BarrelDetLayer*> blc = theTracker->barrelLayers(); 
      for ( vector<BarrelDetLayer*>::iterator i = blc.begin(); i != blc.end(); i++) {
      theBarrelLayers.push_back( (*i) );
      }*/

  // get forward layers
  for( auto const& l : theTracker->forwardLayers()) {
    theForwardLayers.push_back(l);
  }
  
  FDLI middle = find_if( theForwardLayers.begin(), theForwardLayers.end(),
             not1(DetBelowZ(0)));
  theLeftLayers  = FDLC( theForwardLayers.begin(), middle);
  theRightLayers = FDLC( middle, theForwardLayers.end());
  
  SymmetricLayerFinder symFinder( theForwardLayers);

  // only work on positive Z side; negative by mirror symmetry later
  /*sideways does not need barrels*/
  //  linkBarrelLayers( symFinder);

  linkForwardLayers( symFinder);
 
  setState(navigableLayers());

  LogDebug("BeamHaloNavigationSchool")<<"inverse relation";
  establishInverseRelations();


  //add the necessary inward links to end caps
  LogDebug("BeamHaloNavigationSchool")<<"linkOtherEndLayer";

  linkOtherEndLayers( symFinder);

  //set checkCrossing = false to all layers
  SimpleNavigationSchool::StateType allLayers=navigableLayers();
  SimpleNavigationSchool::StateType::iterator layerIt=allLayers.begin();
  SimpleNavigationSchool::StateType::iterator layerIt_end=allLayers.end();
  for (;layerIt!=layerIt_end;++layerIt)
    {
      //convert to SimpleNavigableLayer
      SimpleNavigableLayer* snl=dynamic_cast<SimpleNavigableLayer*>(*layerIt);
      if (!snl){
    edm::LogError("BeamHaloNavigationSchool")<<"navigable layer not casting to simplenavigablelayer.";
    continue;}
      snl->setCheckCrossingSide(false);
    }

}

BeamHaloNavigationSchool::~BeamHaloNavigationSchool ( )

inline

Definition at line 13 of file BeamHaloNavigationSchool.cc.

References SimpleNavigationSchool::cleanMemory().

{ cleanMemory();}

Member Function Documentation

void BeamHaloNavigationSchool::addInward ( const DetLayer *  det, const FDLC &  news  )

protected

Definition at line 206 of file BeamHaloNavigationSchool.cc.

References GeomDetEnumerators::barrel, LogDebug, NavigableLayer::nextLayers(), outsideIn, and SimpleNavigableLayer::setInwardLinks().

                                                 {
  //get the navigable layer for this DetLayer
  SimpleNavigableLayer* navigableLayer =
    dynamic_cast<SimpleNavigableLayer*>(theAllNavigableLayer[(det)->seqNum()]);

  LogDebug("BeamHaloNavigationSchool")<<"retreive the nextlayer outsidein";
  //get the inward reachable layers.
  DLC inwardsLayers(navigableLayer->nextLayers(outsideIn));

  LogDebug("BeamHaloNavigationSchool")<<"split them barrel/forward";
  // split barrel and forward layers
  BDLC inwardsBarrel;
  FDLC inwardsForward;
  for ( DLC::iterator dli=inwardsLayers.begin();dli!=inwardsLayers.end();dli++)
    {
      if ((**dli).location()==GeomDetEnumerators::barrel)
    inwardsBarrel.push_back(static_cast<const BarrelDetLayer*>(*dli));
      else
    inwardsForward.push_back(static_cast<const ForwardDetLayer*>(*dli));
    }
  
  LogDebug("BeamHaloNavigationSchool")<<"add the new ones";
  //add the other forward layers provided
  inwardsForward.insert( inwardsForward.end(), news.begin(), news.end());

  LogDebug("BeamHaloNavigationSchool")<<"no duplicate please";
  FDLI new_end =unique(inwardsForward.begin(),inwardsForward.end());
  inwardsForward.erase(new_end,inwardsForward.end());

  LogDebug("BeamHaloNavigationSchool")<<"set back the inward links (no duplicate)";
  //  set them back to the navigable layer
  navigableLayer->setInwardLinks( inwardsBarrel, inwardsForward, TkLayerLess(outsideIn, det));
}

void BeamHaloNavigationSchool::addInward ( const DetLayer *  det, const ForwardDetLayer *  newF  )

protected

Definition at line 165 of file BeamHaloNavigationSchool.cc.

References GeomDetEnumerators::barrel, LogDebug, NavigableLayer::nextLayers(), outsideIn, SimpleNavigableLayer::setInwardLinks(), and python.multivaluedict::sort().

                                                             {
  //get the navigable layer for this DetLayer
  SimpleNavigableLayer* navigableLayer =
    dynamic_cast<SimpleNavigableLayer*>(theAllNavigableLayer[(det)->seqNum()]);

  LogDebug("BeamHaloNavigationSchool")<<"retreive the nextlayer outsidein";
  //get the inward reachable layers.
  DLC inwardsLayers(navigableLayer->nextLayers(outsideIn));
  
  LogDebug("BeamHaloNavigationSchool")<<"split them barrel/forward";
  // split barrel and forward layers
  BDLC inwardsBarrel;
  FDLC inwardsForward;
  for ( DLC::iterator dli=inwardsLayers.begin();dli!=inwardsLayers.end();dli++)
    {
      if ((**dli).location()==GeomDetEnumerators::barrel)
        inwardsBarrel.push_back(static_cast<const BarrelDetLayer*>(*dli));
      else
        inwardsForward.push_back(static_cast<const ForwardDetLayer*>(*dli));
    }
  LogDebug("BeamHaloNavigationSchool")<<"add the new ones";
  //add the other forward layers provided
  inwardsForward.push_back(newF);

  LogDebug("BeamHaloNavigationSchool")<<"no duplicate please";
  sort(inwardsForward.begin(),inwardsForward.end()); //if you don't sort, unique will not work
  //  FDLI read = inwardsForward.begin();
  //  std::stringstream showMe;
  //  for (;read !=inwardsForward.end();++read)  showMe<<" layer p: "<<*read<<"\n";
  //  LogDebug("BeamHaloNavigationSchool")<<"list of layer pointers: \n"<<showMe.str();

  FDLI new_end =unique(inwardsForward.begin(),inwardsForward.end());
  //  if (new_end!=inwardsForward.end()) LogDebug("BeamHaloNavigationSchool")<<"removing duplicates here";
  inwardsForward.erase(new_end,inwardsForward.end());

  LogDebug("BeamHaloNavigationSchool")<<"set back the inward links (no duplicate)";
  //  set them back to the navigable layer
  navigableLayer->setInwardLinks( inwardsBarrel, inwardsForward, TkLayerLess(outsideIn, det));
}

void BeamHaloNavigationSchool::establishInverseRelations ( )

protectedvirtual

Reimplemented from SimpleNavigationSchool.

Definition at line 102 of file BeamHaloNavigationSchool.cc.

References i, insideOut, outsideIn, and SimpleNavigableLayer::setInwardLinks().

                                                         {

  // find for each layer which are the barrel and forward
  // layers that point to it
  typedef map<const DetLayer*, vector<BarrelDetLayer const*>, less<const DetLayer*> > BarrelMapType;
  typedef map<const DetLayer*, vector<ForwardDetLayer const*>, less<const DetLayer*> > ForwardMapType;


  BarrelMapType reachedBarrelLayersMap;
  ForwardMapType reachedForwardLayersMap;

  for ( BDLI bli = theBarrelLayers.begin();
        bli!=theBarrelLayers.end(); bli++) {
    DLC reachedLC = nextLayers(**bli, insideOut);
    for ( DLI i = reachedLC.begin(); i != reachedLC.end(); i++) {
      reachedBarrelLayersMap[*i].push_back( *bli);
    }
  }

  for ( FDLI fli = theForwardLayers.begin();
        fli!=theForwardLayers.end(); fli++) {
    DLC reachedLC = nextLayers(**fli, insideOut);
    for ( DLI i = reachedLC.begin(); i != reachedLC.end(); i++) {
      reachedForwardLayersMap[*i].push_back( *fli);
    }
  }


  for ( auto const i : theTracker->allLayers()) {
    SimpleNavigableLayer* navigableLayer =
     dynamic_cast<SimpleNavigableLayer*>(theAllNavigableLayer[i->seqNum()]);
    if (!navigableLayer) {edm::LogInfo("BeamHaloNavigationSchool")<<"a detlayer does not have a navigable layer, which is normal in beam halo navigation.";}
    if (navigableLayer){navigableLayer->setInwardLinks( reachedBarrelLayersMap[i],reachedForwardLayersMap[i], TkLayerLess(outsideIn, i) );}
  }

}

void BeamHaloNavigationSchool::linkOtherEndLayers ( SymmetricLayerFinder &  symFinder )

protected

Definition at line 141 of file BeamHaloNavigationSchool.cc.

References LogDebug, and SymmetricLayerFinder::mirror().

                                                     {

  LogDebug("BeamHaloNavigationSchool")<<"reachable from horizontal";
  //generally, on the right side, what are the forward layers reachable from the horizontal
  FDLC reachableFL= reachableFromHorizontal();

  //even simpler navigation from end to end.
  //for each of them
  for (FDLI fl=reachableFL.begin();fl!=reachableFL.end();fl++)
    {
      LogDebug("BeamHaloNavigationSchool")<<"adding inward from right";
      //link it inward to the mirror reachable from horizontal
      addInward(static_cast<DetLayer const*>(*fl),symFinder.mirror(*fl));
      
      LogDebug("BeamHaloNavigationSchool")<<"adding inward from mirror of right (left?)";
      addInward(static_cast<DetLayer const*>(symFinder.mirror(*fl)),*fl);
    }




}

BeamHaloNavigationSchool::FDLC BeamHaloNavigationSchool::reachableFromHorizontal ( )

protected

Definition at line 241 of file BeamHaloNavigationSchool.cc.

References begin, cond::rpcobimon::current, end, i, and python.multivaluedict::sort().

{    
  //determine which is the list of forward layers that can be reached from inside-out
  //at horizontal direction

  FDLC myRightLayers( theRightLayers);
  FDLI begin = myRightLayers.begin();
  FDLI end   = myRightLayers.end();

  //sort along Z to be sure
  sort(begin, end, DetLessZ());

  FDLC reachableFL;

  begin = myRightLayers.begin();
  end   = myRightLayers.end();

  //the first one is always reachable
  reachableFL.push_back(*begin);
  FDLI current = begin;
  for (FDLI i = begin+1; i!= end; i++)
    {
      //is the previous layer NOT masking this one
      //inner radius smaller OR outer radius bigger
      if ((**i).specificSurface().innerRadius() < (**current).specificSurface().innerRadius() ||
      (**i).specificSurface().outerRadius() > (**current).specificSurface().outerRadius())
    {     //not masked
      reachableFL.push_back(*i);
      current=i;
    }
    }
  return reachableFL;
}