ConversionSeedFinder.cc

Go to the documentation of this file.

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "RecoEgamma/EgammaPhotonAlgos/interface/ConversionSeedFinder.h"
// Field
// Geometry
#include "Geometry/Records/interface/IdealGeometryRecord.h"
//
#include "RecoTracker/MeasurementDet/interface/StartingLayerFinder.h"
#include "RecoTracker/MeasurementDet/interface/LayerCollector.h"
//

#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h"
#include "RecoTracker/Record/interface/CkfComponentsRecord.h"

ConversionSeedFinder::ConversionSeedFinder(const edm::ParameterSet& config,edm::ConsumesCollector & iC ): 
  //  conf_(config),
  theUpdator_()
{

  measurementTrkToken_=iC.consumes<MeasurementTrackerEvent>(edm::InputTag("MeasurementTrackerEvent")); //hardcoded because the original was and no time to fix (sigh)
  beamSpotToken_=iC.consumes<reco::BeamSpot>(edm::InputTag("offlineBeamSpot"));  //hardcoded because the original was and no time to fix (sigh)

  LogDebug("ConversionSeedFinder")  << " CTOR " << "\n";

  theMeasurementTrackerName_=config.getParameter<std::string>("MeasurementTrackerName");
}



void ConversionSeedFinder::setEvent(const edm::Event& evt  )  {
 
  theTrackerGeom_= this->getMeasurementTracker()->geomTracker();

  //get the BeamSpot
  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
  evt.getByToken(beamSpotToken_,recoBeamSpotHandle);
  theBeamSpot_ = *recoBeamSpotHandle;

  evt.getByToken(measurementTrkToken_, theTrackerData_);

}

void ConversionSeedFinder::setEventSetup(const edm::EventSetup& es  )  {
  es.get<TrackerRecoGeometryRecord>().get( theGeomSearchTracker_);
  es.get<IdealMagneticFieldRecord>().get( theMF_ );


  edm::ESHandle<MeasurementTracker> measurementTrackerHandle;
  es.get<CkfComponentsRecord>().get(theMeasurementTrackerName_,measurementTrackerHandle);
  theMeasurementTracker_ = measurementTrackerHandle.product();
  
  edm::ESHandle<Propagator>  propagatorAlongMomHandle;
  es.get<TrackingComponentsRecord>().get("alongMomElePropagator",propagatorAlongMomHandle);
  thePropagatorAlongMomentum_ = &(*propagatorAlongMomHandle);
 

  edm::ESHandle<Propagator>  propagatorOppoToMomHandle;
  es.get<TrackingComponentsRecord>().get("oppositeToMomElePropagator",propagatorOppoToMomHandle);
  thePropagatorOppositeToMomentum_ = &(*propagatorOppoToMomHandle);




}


void ConversionSeedFinder::findLayers() {
  

  int charge;
  //List the DetLayers crossed by a straight line from the centre of the 
  //detector to the supercluster position
  //  GlobalPoint  vertex(0.,0.,0.);
  GlobalPoint  vertex(theBeamSpot_.position().x(),theBeamSpot_.position().y(),theBeamSpot_.position().z()); 
  charge=-1;  
  FreeTrajectoryState theStraightLineFTS = trackStateFromClusters(charge, vertex, alongMomentum, 1.);
  
  findLayers( theStraightLineFTS  );
  
  
}

FreeTrajectoryState ConversionSeedFinder::trackStateFromClusters( int charge, const GlobalPoint  & theOrigin, 
                                  PropagationDirection dir, float scaleFactor) const {
  
  

  double caloEnergy = theSCenergy_ * scaleFactor ;
  
  GlobalVector radiusCalo = theSCPosition_ - theOrigin ;
  
  GlobalVector momentumWithoutCurvature = radiusCalo.unit() * caloEnergy;
  
  
  GlobalTrajectoryParameters gtp;
  if(dir == alongMomentum) {
    gtp = GlobalTrajectoryParameters(theOrigin, momentumWithoutCurvature, charge, &(*theMF_) ) ;
  } else {
    gtp = GlobalTrajectoryParameters(theSCPosition_, momentumWithoutCurvature, charge, &(*theMF_) ) ;
  }



  
  // now create error matrix
  // dpos = 4mm/sqrt(E), dtheta = move vertex by 1sigma
  float dpos = 0.4/sqrt(theSCenergy_);
  dpos *= 2.;
  float dphi = dpos/theSCPosition_.perp();
  //  float dp = 0.03 * sqrt(theCaloEnergy);
  //  float dp = theCaloEnergy / sqrt(12.); // for fun
  float theta1 = theSCPosition_.theta();
  float theta2 = atan2(double(theSCPosition_.perp()), theSCPosition_.z()-5.5);
  float dtheta = theta1 - theta2;
  AlgebraicSymMatrix55  m;
  m[0][0] = 1.; m[1][1] = dpos*dpos ; m[2][2] = dpos*dpos ;
  m[3][3] = dphi*dphi ; m[4][4] = dtheta * dtheta ;

  FreeTrajectoryState fts(gtp, CurvilinearTrajectoryError(m)) ;

  return fts ;


}

void ConversionSeedFinder::findLayers(const FreeTrajectoryState & traj) {



  theLayerList_.clear();


  StraightLinePropagator prop( &(*theMF_), alongMomentum);

  StartingLayerFinder starter(&prop, this->getMeasurementTracker() );
 
  LayerCollector collector(theNavigationSchool_, &prop, &starter, 5., 5.);

  theLayerList_ = collector.allLayers(traj);

  
  for(unsigned int i = 0; i < theLayerList_.size(); ++i) {
    printLayer(i);
  }
  

}


void ConversionSeedFinder::printLayer(int i) const {
  const DetLayer * layer = theLayerList_[i];
  if (layer->location() == GeomDetEnumerators::barrel ) {
    //    const BarrelDetLayer * barrelLayer = dynamic_cast<const BarrelDetLayer*>(layer);
    //float r = barrelLayer->specificSurface().radius();
    //    std::cout   <<  " barrel layer radius " << r << " " << barrelLayer->specificSurface().bounds().length()/2. << "\n";

  } else {
    //    const ForwardDetLayer * forwardLayer = dynamic_cast<const ForwardDetLayer*>(layer);
    // float z =  fabs(forwardLayer->surface().position().z());
    //    std::cout   << " forward layer position " << z << " " << forwardLayer->specificSurface().innerRadius() << " " << forwardLayer->specificSurface().outerRadius() << "\n";
  }
}