CompositeTECWedge.cc

Go to the documentation of this file.

#include "CompositeTECWedge.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "ForwardDiskSectorBuilderFromDet.h"
#include "LayerCrossingSide.h"
#include "DetGroupMerger.h"
#include "CompatibleDetToGroupAdder.h"

#include "TrackingTools/DetLayers/interface/DetLayerException.h"

#include "TrackingTools/DetLayers/interface/rangesIntersect.h"
#include "TrackingTools/DetLayers/interface/MeasurementEstimator.h"
#include "TrackingTools/GeomPropagators/interface/HelixForwardPlaneCrossing.h"

#include "TkDetUtil.h"
#include "DataFormats/GeometryVector/interface/VectorUtil.h"
#include <boost/function.hpp>

using namespace std;

typedef GeometricSearchDet::DetWithState DetWithState;

// --------- Temporary solution. DetSorting.h has to be used.
namespace {
  class DetPhiLess {
  public:
    bool operator()(const GeomDet* a,const GeomDet* b) 
    {
      return Geom::phiLess(a->surface(), b->surface());
    } 
  };
}
// ---------------------

CompositeTECWedge::CompositeTECWedge(vector<const GeomDet*>& innerDets,
                     vector<const GeomDet*>& outerDets):
  theFrontDets(innerDets.begin(),innerDets.end()), theBackDets(outerDets.begin(),outerDets.end())
{  
  theDets.assign(theFrontDets.begin(),theFrontDets.end());
  theDets.insert(theDets.end(),theBackDets.begin(),theBackDets.end());


  // 
  std::sort( theFrontDets.begin(), theFrontDets.end(), DetPhiLess() );
  std::sort( theBackDets.begin(),  theBackDets.end(),  DetPhiLess() );
  
  theFrontSector = ForwardDiskSectorBuilderFromDet()( theFrontDets );
  theBackSector  = ForwardDiskSectorBuilderFromDet()( theBackDets );
  theDiskSector = ForwardDiskSectorBuilderFromDet()( theDets );

  //--------- DEBUG INFO --------------
  LogDebug("TkDetLayers") << "DEBUG INFO for CompositeTECWedge" << "\n"
              << "TECWedge z, perp,innerRadius,outerR: " 
              << this->position().z() << " , "
              << this->position().perp() << " , "
              << theDiskSector->innerRadius() << " , "
              << theDiskSector->outerRadius() ;


  for(vector<const GeomDet*>::const_iterator it=theFrontDets.begin(); 
      it!=theFrontDets.end(); it++){
    LogDebug("TkDetLayers") << "frontDet phi,z,r: " 
                << (*it)->surface().position().phi() << " , "
                << (*it)->surface().position().z() <<   " , "
                << (*it)->surface().position().perp();
  }

  for(vector<const GeomDet*>::const_iterator it=theBackDets.begin(); 
      it!=theBackDets.end(); it++){
    LogDebug("TkDetLayers") << "backDet phi,z,r: " 
                << (*it)->surface().phi() << " , "
                << (*it)->surface().position().z() <<   " , "
                << (*it)->surface().position().perp() ;
  }
  //----------------------------------- 


}

CompositeTECWedge::~CompositeTECWedge(){

} 


const vector<const GeometricSearchDet*>& 
CompositeTECWedge::components() const{
  throw DetLayerException("CompositeTECWedge doesn't have GeometricSearchDet components");
}

  
pair<bool, TrajectoryStateOnSurface>
CompositeTECWedge::compatible( const TrajectoryStateOnSurface& ts, const Propagator&, 
                   const MeasurementEstimator&) const{
  edm::LogError("TkDetLayers") << "temporary dummy implementation of CompositeTECWedge::compatible()!!" ;
  return pair<bool,TrajectoryStateOnSurface>();
}


void
CompositeTECWedge::groupedCompatibleDetsV( const TrajectoryStateOnSurface& tsos,
                      const Propagator& prop,
                       const MeasurementEstimator& est,
                       std::vector<DetGroup> & result) const{

  SubLayerCrossings  crossings = computeCrossings( tsos, prop.propagationDirection());
  if(! crossings.isValid()) return;

  std::vector<DetGroup> closestResult;
  addClosest( tsos, prop, est, crossings.closest(), closestResult);

  LogDebug("TkDetLayers") 
    << "in CompositeTECWedge::groupedCompatibleDets,closestResult.size(): "
    << closestResult.size() ;

  if (closestResult.empty()) return;
  
  DetGroupElement closestGel( closestResult.front().front());
  auto window = tkDetUtil::computeWindowSize( closestGel.det(), closestGel.trajectoryState(), est);

  searchNeighbors( tsos, prop, est, crossings.closest(), window,
           closestResult, false);

  std::vector<DetGroup> nextResult;
  searchNeighbors( tsos, prop, est, crossings.other(), window,
           nextResult, true);

  int crossingSide = LayerCrossingSide().endcapSide( closestGel.trajectoryState(), prop);
  DetGroupMerger::orderAndMergeTwoLevels( std::move(closestResult), std::move(nextResult), result,
                      crossings.closestIndex(), crossingSide);
}



// private methods for the implementation of groupedCompatibleDets()



SubLayerCrossings 
CompositeTECWedge::computeCrossings( const TrajectoryStateOnSurface& startingState,
                     PropagationDirection propDir) const
{
  HelixPlaneCrossing::PositionType startPos( startingState.globalPosition() );
  HelixPlaneCrossing::DirectionType startDir( startingState.globalMomentum() );
 
  auto rho = startingState.transverseCurvature();

  HelixForwardPlaneCrossing crossing( startPos, startDir, rho, propDir);

  pair<bool,double> frontPath = crossing.pathLength( *theFrontSector);
  if (!frontPath.first) return SubLayerCrossings();

  pair<bool,double> backPath = crossing.pathLength( *theBackSector);
  if (!backPath.first) return SubLayerCrossings();

  GlobalPoint gFrontPoint( crossing.position(frontPath.second));
  GlobalPoint gBackPoint( crossing.position(backPath.second));


  LogDebug("TkDetLayers") 
    << "in TECWedge,front crossing r,z,phi: (" 
    << gFrontPoint.perp() << ","
    << gFrontPoint.z() << "," 
    << gFrontPoint.phi() << ")" ;
  
  LogDebug("TkDetLayers") 
    << "in TECWedge,back crossing r,z,phi: (" 
    << gBackPoint.perp() << ","
    << gBackPoint.z() << "," 
    << gBackPoint.phi() << ")" << endl;
  
 
  int frontIndex = findClosestDet(gFrontPoint,0); 
  SubLayerCrossing frontSLC( 0, frontIndex, gFrontPoint);
  
  int backIndex = findClosestDet(gBackPoint,1);
  SubLayerCrossing backSLC( 1, backIndex, gBackPoint);


  auto frontDist = std::abs(Geom::deltaPhi( gFrontPoint.barePhi(), 
                        theFrontDets[frontIndex]->surface().phi()));
  /*
    float frontDist = theFrontDets[frontIndex]->surface().phi()  - gFrontPoint.phi(); 
    frontDist *= Geom::phiLess( theFrontDets[frontIndex]->surface().phi(),gFrontPoint.barePhi()) ? -1. : 1.; 
    if (frontDist < 0.) { frontDist += 2.*Geom::pi();}
  */
  auto backDist = std::abs(Geom::deltaPhi( gBackPoint.barePhi(), 
                       theBackDets[backIndex]->surface().phi()) );
  /*
    float backDist = theBackDets[backIndex]->surface().phi()  - gBackPoint.phi(); 
    backDist  *= Geom::phiLess( theBackDets[backIndex]->surface().phi(),gBackPoint.barePhi()) ? -1. : 1.;
    if ( backDist < 0.) { backDist  += 2.*Geom::pi();}
  */
  
  if (frontDist < backDist) {
    return SubLayerCrossings( frontSLC, backSLC, 0);
  }
  else {
    return SubLayerCrossings( backSLC, frontSLC, 1);
  } 
}


bool CompositeTECWedge::addClosest( const TrajectoryStateOnSurface& tsos,
                    const Propagator& prop,
                    const MeasurementEstimator& est,
                    const SubLayerCrossing& crossing,
                    vector<DetGroup>& result) const
{
  const vector<const GeomDet*>& sWedge( subWedge( crossing.subLayerIndex()));

  LogDebug("TkDetLayers")  
    << "in CompositeTECWedge,adding GeomDet at r,z,phi: (" 
    << sWedge[crossing.closestDetIndex()]->position().perp() << "," 
    << sWedge[crossing.closestDetIndex()]->position().z() << "," 
    << sWedge[crossing.closestDetIndex()]->position().phi() << ")" ;

  return CompatibleDetToGroupAdder().add( *sWedge[crossing.closestDetIndex()], 
                      tsos, prop, est, result);
}


void CompositeTECWedge::searchNeighbors( const TrajectoryStateOnSurface& tsos,
                     const Propagator& prop,
                     const MeasurementEstimator& est,
                     const SubLayerCrossing& crossing,
                     float window, 
                     vector<DetGroup>& result,
                     bool checkClosest) const
{
  GlobalPoint gCrossingPos = crossing.position();

  const vector<const GeomDet*>& sWedge( subWedge( crossing.subLayerIndex()));
 
  int closestIndex = crossing.closestDetIndex();
  int negStartIndex = closestIndex-1;
  int posStartIndex = closestIndex+1;

  if (checkClosest) { // must decide if the closest is on the neg or pos side
    if ( Geom::phiLess(gCrossingPos.barePhi(), sWedge[closestIndex]->surface().phi()) ) {
      posStartIndex = closestIndex;
    }
    else {
      negStartIndex = closestIndex;
    }
  }

  typedef CompatibleDetToGroupAdder Adder;
  for (int idet=negStartIndex; idet >= 0; idet--) {
    //if(idet <0 || idet>=sWedge.size()) {edm::LogInfo(TkDetLayers) << "==== warning! gone out vector bounds.idet: " << idet ;break;}
    if (!tkDetUtil::overlapInPhi( gCrossingPos, *sWedge[idet], window)) break;
    if (!Adder::add( *sWedge[idet], tsos, prop, est, result)) break;
  }
  for (int idet=posStartIndex; idet < static_cast<int>(sWedge.size()); idet++) {
    //if(idet <0 || idet>=sWedge.size()) {edm::LogInfo(TkDetLayers) << "==== warning! gone out vector bounds.idet: " << idet ;break;}
    if (!tkDetUtil::overlapInPhi( gCrossingPos, *sWedge[idet], window)) break;
    if (!Adder::add( *sWedge[idet], tsos, prop, est, result)) break;
  }
}



int
CompositeTECWedge::findClosestDet( const GlobalPoint& startPos,int sectorId) const
{
  vector<const GeomDet*> const & myDets = sectorId==0 ? theFrontDets : theBackDets;

  int close = 0;
  auto closeDist = std::abs( (myDets.front()->toLocal(startPos)).x());
  for (unsigned int i = 1; i < myDets.size(); i++ ) {
    auto dist = std::abs((myDets[i]->toLocal(startPos)).x());
    if ( dist < closeDist ) {
      close = i;
      closeDist = dist;
    }
  }
  return close;
}