/data/refman/pasoursint/CMSSW_6_1_2_SLHC4_patch1/src/SLHCUpgradeSimulations/L1TrackTrigger/interface/L1TkTrackBuilder.h

Go to the documentation of this file.

#ifndef L1TK_TRACK_BUILDER_H
#define L1TK_TRACK_BUILDER_H

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

//#include "SLHCUpgradeSimulations/Utilities/interface/StackedTrackerDetId.h"
#include "SLHCUpgradeSimulations/L1TrackTrigger/interface/TrackingAlgorithm.h"
#include "SLHCUpgradeSimulations/L1TrackTrigger/interface/TrackingAlgorithmRecord.h"
#include "classNameFinder.h"

#include <memory>
#include <map>
#include <vector>

template<  typename T  >
class L1TkTrackBuilder : public edm::EDProducer
{
  public:
/*
    typedef L1TkStub< T >                                     L1TkStubType;
    typedef edm::Ptr< L1TkStubType >                                       L1TkStubPtrType;
    typedef std::vector< L1TkStub< T > >                      L1TkStubCollectionType;
    typedef L1TkTracklet< T >                                 L1TkTrackletType;
    typedef edm::Ptr< L1TkTrackletType >                                   L1TkTrackletPtrType;
    typedef std::vector< L1TkTrackletType >                                L1TkTrackletCollectionType;
    typedef L1TkTrack< T >                                    L1TkTrackType;
    typedef std::vector< L1TkTrackType >                                   L1TkTrackCollectionType;
    typedef std::map< unsigned int, std::vector< L1TkStubPtrType > >       L1TkStubMapType;
    typedef std::map< unsigned int, std::vector< L1TkTrackletPtrType > >   L1TkTrackletMapType;
    typedef std::set< std::pair< unsigned int , L1TkStubPtrType > >        L1TkTrackletMap;
*/

    explicit L1TkTrackBuilder( const edm::ParameterSet& iConfig );

    ~L1TkTrackBuilder();

  private:
//    edm::ESHandle< StackedTrackerGeometry >        StackedTrackerGeomHandle;
    const StackedTrackerGeometry            *theStackedTracker;
//    StackedTrackerGeometry::StackContainerIterator StackedTrackerIterator;
    edm::ESHandle< TrackingAlgorithm< T > > TrackingAlgoHandle;
    edm::InputTag                                        L1TkStubsInputTag;
//    bool                                                 wantTrackletSeeds;




//    edm::InputTag                                          L1TkTrackletInputTag;

//    bool                                                   useAlsoSeedVtx;
//    bool                                                   doHelixFit;
//    bool                                                   removeDuplicates;
//    std::vector< unsigned int >                            allowedDoubleStacks;

//    double mMagneticFieldStrength;


    virtual void beginRun( edm::Run& run, const edm::EventSetup& iSetup );
    virtual void endRun( edm::Run& run, const edm::EventSetup& iSetup );
    virtual void produce( edm::Event& iEvent, const edm::EventSetup& iSetup );

}; 


template< typename T >
L1TkTrackBuilder< T >::L1TkTrackBuilder( const edm::ParameterSet& iConfig )
{
  produces< std::vector< L1TkTrack< T > > >();
  L1TkStubsInputTag = iConfig.getParameter< edm::InputTag >("L1TkStubsBricks");

//  L1TkTrackletInputTag = iConfig.getParameter< edm::InputTag >("L1TkTrackletSeed"); /// The kind of seed
//  useAlsoSeedVtx       = iConfig.getParameter< bool >("UseAlsoSeedVertex");
//  doHelixFit           = iConfig.getParameter< bool >("DoHelixFit");
//  removeDuplicates     = iConfig.getParameter< bool >("RemoveDuplicates");
//  allowedDoubleStacks  = iConfig.getParameter< std::vector< unsigned int > >("SeedDoubleStacks");
}

template< typename T >
L1TkTrackBuilder< T >::~L1TkTrackBuilder() {}

template< typename T >
void L1TkTrackBuilder< T >::beginRun( edm::Run& run, const edm::EventSetup& iSetup )
{
  edm::ESHandle< StackedTrackerGeometry > StackedTrackerGeomHandle;
  iSetup.get< StackedTrackerGeometryRecord >().get( StackedTrackerGeomHandle );
  theStackedTracker = StackedTrackerGeomHandle.product();

  iSetup.get< TrackingAlgorithmRecord >().get( TrackingAlgoHandle );
  std::cout  << "L1TkTrackBuilder<" << templateNameFinder<T>() << "> loaded modules:"
             << "\n\tTrackingAlgorithm:\t" << TrackingAlgoHandle->AlgorithmName()
             << std::endl;

//  edm::ESHandle<MagneticField> magnet;
//  iSetup.get<IdealMagneticFieldRecord>().get(magnet);
//  mMagneticFieldStrength = magnet->inTesla(GlobalPoint(0,0,0)).z();

//  mMagneticFieldStrength = (floor(mMagneticFieldStrength*10.0 + 0.5))/10.0;
}

template< typename T >
void L1TkTrackBuilder< T >::endRun( edm::Run& run, const edm::EventSetup& iSetup ) {}

template< typename T >
void L1TkTrackBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSetup )
{
  std::vector< L1TkTrack< T > > tempTrackCollection;
  tempTrackCollection.clear();
  std::auto_ptr< std::vector< L1TkTrack< T > > > L1TkTracksForOutput( new std::vector< L1TkTrack< T > > );

  edm::Handle< std::vector< L1TkStub< T > > > L1TkStubHandle;
  iEvent.getByLabel( L1TkStubsInputTag, L1TkStubHandle);

  std::vector< L1TkTrack< T > > theseSeeds;
  TrackingAlgoHandle->CreateSeeds( theseSeeds, L1TkStubHandle );










/*
  edm::Handle< L1TkStubCollectionType >     L1TkStubHandleBricks;
  edm::Handle< L1TkTrackletCollectionType > L1TkTrackletHandleSeed;
  iEvent.getByLabel( L1TkStubsInputTag, L1TkStubHandleBricks );
  iEvent.getByLabel( L1TkTrackletInputTag, L1TkTrackletHandleSeed );
  
  L1TkTrackCollectionType tempTrackCollection;
  tempTrackCollection.clear();
  std::auto_ptr< L1TkTrackCollectionType > L1TkTracksForOutput( new L1TkTrackCollectionType );

  L1TkTrackletMapType SeedTracklets;
  for ( unsigned int i = 0; i != L1TkTrackletHandleSeed->size(); ++i )
  {
    StackedTrackerDetId stDetId0( L1TkTrackletHandleSeed->at(i).getStubRef(0)->getDetId() );
    StackedTrackerDetId stDetId1( L1TkTrackletHandleSeed->at(i).getStubRef(1)->getDetId() );
    unsigned int stack0 = stDetId0.iLayer();
    unsigned int stack1 = stDetId1.iLayer();

    unsigned int doubleStack = stack0/2;
    if ( doubleStack != (stack1-1)/2 ) continue; /// Reject bad formed Tracklets
 
    unsigned int ladder0 = stDetId0.iPhi();
    unsigned int ladder1 = stDetId1.iPhi();
    if ( ladder0 != ladder1 ) continue; /// Reject bad formed Tracklets

    bool skip = true;
    for ( unsigned int t = 0; t < allowedDoubleStacks.size(); t++ )
      if ( allowedDoubleStacks.at(t) == doubleStack )
        skip = false;
    if ( allowedDoubleStacks.size() != 0 && skip ) continue;

    SeedTracklets[ doubleStack ].push_back( L1TkTrackletPtrType( L1TkTrackletHandleSeed, i ) );
  }

  L1TkStubMapType BrickStubs;
  for ( unsigned int i = 0; i != L1TkStubHandleBricks->size(); ++i )
  {

    StackedTrackerDetId stDetId( L1TkStubHandleBricks->at(i).getDetId() );

    unsigned int stack = stDetId.iLayer();
    unsigned int doubleStack;
    if ( stack%2 == 0 ) doubleStack = stack/2;
    else doubleStack = (stack-1)/2;

    bool skip = true;
    for ( unsigned int t = 0; t < allowedDoubleStacks.size(); t++ )
      if ( allowedDoubleStacks.at(t) == doubleStack )
        skip = false;
    if ( allowedDoubleStacks.size() != 0 && skip ) continue;

    for ( unsigned int q = 0; q < 5; q++ )
    {
      if ( doubleStack != q) BrickStubs[ q ].push_back( L1TkStubPtrType( L1TkStubHandleBricks , i ) );
    }
  }

  for ( unsigned int j = 0; j < 5; j++ )
  {
    std::vector< L1TkTrackletPtrType > theSeeds  = SeedTracklets[j];
    std::vector< L1TkStubPtrType >     theBricks = BrickStubs[j];

    for ( unsigned int k = 0; k < theSeeds.size(); k++ )
    {
      std::vector< L1TkTrack< T > > allCandTracks;
      allCandTracks.clear();
      allCandTracks = TrackingAlgoHandle->PropagateSeed( theSeeds.at(k), theBricks );

      for ( unsigned int h = 0; h < allCandTracks.size(); h++ )
      {
        if ( iEvent.isRealData() == false )
          allCandTracks.at(h).checkSimTrack();
        allCandTracks.at(h).fitTrack( mMagneticFieldStrength, useAlsoSeedVtx, doHelixFit );
        if ( removeDuplicates )
          tempTrackCollection.push_back( allCandTracks.at(h) );
        else
          L1TkTracksForOutput->push_back( allCandTracks.at(h) );
      } /// End of loop on candidates

    } /// End of loop on seeds
  } /// End of loop on Superlayers

  unsigned int minForDupl = 2;
  unsigned int plusVtx = 0;
  if ( useAlsoSeedVtx ) plusVtx = 1;

  if ( removeDuplicates )
  {
    if ( tempTrackCollection.size() != 0 )
    {
      for ( unsigned int tk = 0; tk < tempTrackCollection.size()-1; tk++ )
      {
        L1TkStubCollectionType tkStubs0 = tempTrackCollection.at(tk).getStubs();
        unsigned int tkNum0 = tkStubs0.size();
        if ( tkNum0 == 0 ) continue;
        unsigned int tkSeed0 = tempTrackCollection.at(tk).getSeedDoubleStack();

        if ( tempTrackCollection.size() == 1 ) continue;
        for ( unsigned int tkk = tk+1; tkk < tempTrackCollection.size(); tkk++ )
        {
          L1TkStubCollectionType tkStubs1 = tempTrackCollection.at(tkk).getStubs();
          unsigned int tkNum1 = tkStubs1.size();
          if ( tkNum1 == 0 ) continue;
          unsigned int tkSeed1 = tempTrackCollection.at(tkk).getSeedDoubleStack();

          unsigned int numShared = 0;
          for ( unsigned int st = 0; st < tkStubs0.size(); st++ )
          {
            if ( numShared >= minForDupl ) continue;
            for ( unsigned int stt = 0; stt < tkStubs1.size(); stt++ )
            {
              if ( numShared >= minForDupl ) continue;
              if ( tkStubs0.at(st).getClusterPtr(0) == tkStubs1.at(stt).getClusterPtr(0) &&
                   tkStubs0.at(st).getClusterPtr(1) == tkStubs1.at(stt).getClusterPtr(1) )
                numShared++;
            }
          } /// End of check if they are shared or not

          if ( numShared < minForDupl ) continue;

          if ( tkSeed1 > tkSeed0 )
            tempTrackCollection.at(tkk) = L1TkTrackType();
          else if ( tkSeed1 < tkSeed0 )
            tempTrackCollection.at(tk) = L1TkTrackType();
          else
          {
            if ( tempTrackCollection.at(tkk).getChi2RPhi() / tkNum1 > tempTrackCollection.at(tk).getChi2RPhi() / tkNum0 )
              tempTrackCollection.at(tkk) = L1TkTrackType();
            else if ( tempTrackCollection.at(tkk).getChi2RPhi() / tkNum1 < tempTrackCollection.at(tk).getChi2RPhi() / tkNum0 )
              tempTrackCollection.at(tk) = L1TkTrackType();
            else
              std::cerr << "*** I CAN'T BELIEVE IT!! ***" << std::endl;
          }
        } /// End of Nested loop
      } /// End of Loop over pairs Candidate L1TkTracks

      for ( unsigned int tk = 0; tk < tempTrackCollection.size(); tk++ )
      {
        if ( tempTrackCollection.at(tk).getStubs().size() != 0 )
          L1TkTracksForOutput->push_back( tempTrackCollection.at(tk) );
      }
    } /// End of if ( tempTrackCollection.size() != 0 ) {
  } /// End of Implement Duplicate Removal
*/

//  if ( doHelixFit && useAlsoSeedVtx )
//    iEvent.put( L1TkTracksForOutput, "Level1TracksHelFitVtxYes" );
//  else if ( useAlsoSeedVtx )
//    iEvent.put( L1TkTracksForOutput, "Level1TracksStdFitVtxYes" );
//  else if ( doHelixFit )
//    iEvent.put( L1TkTracksForOutput, "Level1TracksHelFitVtxNo" );
//  else
//    iEvent.put( L1TkTracksForOutput, "Level1TracksStdFitVtxNo" );

}

#endif