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

Go to the documentation of this file.

#ifndef L1TK_STUB_BUILDER_H
#define L1TK_STUB_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/L1TrackTrigger/interface/HitMatchingAlgorithm.h"
#include "SLHCUpgradeSimulations/L1TrackTrigger/interface/HitMatchingAlgorithmRecord.h"
#include "classNameFinder.h"

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

template<  typename T  >
class L1TkStubBuilder : public edm::EDProducer
{
  public:
    typedef std::pair< StackedTrackerDetId, unsigned int >                      ClusterKey;     
    typedef std::map< ClusterKey, std::vector< edm::Ptr< L1TkCluster< T > > > > L1TkClusterMap; 

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

    ~L1TkStubBuilder();

  private:
    const StackedTrackerGeometry               *theStackedTracker;
    edm::ESHandle< HitMatchingAlgorithm< T > > MatchingAlgoHandle;
    edm::InputTag                                           L1TkClustersInputTag;

    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 >
L1TkStubBuilder< T >::L1TkStubBuilder( const edm::ParameterSet& iConfig )
{
  produces< std::vector< L1TkStub< T > > >( "StubsPass" );
  produces< std::vector< L1TkStub< T > > >( "StubsFail" );
  L1TkClustersInputTag = iConfig.getParameter< edm::InputTag >("L1TkClusters");
}

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

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

  iSetup.get< HitMatchingAlgorithmRecord >().get( MatchingAlgoHandle );

  std::cout << std::endl;
  std::cout << "L1TkStubBuilder<" << templateNameFinder<T>() << "> loaded modules:"
            << "\n\tHitMatchingAlgorithm:\t" << MatchingAlgoHandle->AlgorithmName()
            << std::endl;
  std::cout << std::endl;
  std::cout << "W A R N I N G! this producer produces two categories of stubs: accepted and rejected!" << std::endl;
  std::cout << "               ONLY the accepted ones are correctly filled with MC truth etc" << std::endl;
  std::cout << "               the rejected ones have only the clusters correctly filled in data members!" << std::endl;
  std::cout << std::endl;

}

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

template< typename T >
void L1TkStubBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSetup )
{  
  std::auto_ptr< std::vector< L1TkStub< T > > > L1TkStubsForOutputAccepted( new std::vector< L1TkStub< T > > );
  std::auto_ptr< std::vector< L1TkStub< T > > > L1TkStubsForOutputRejected( new std::vector< L1TkStub< T > > );

  edm::Handle< std::vector< L1TkCluster< T > > > L1TkClusterHandle;
  iEvent.getByLabel( L1TkClustersInputTag, L1TkClusterHandle);   

  L1TkClusterMap clusterMap;
  clusterMap.clear();
  typename std::vector< L1TkCluster< T > >::const_iterator inputIter;
  unsigned int j = 0; 

  for ( inputIter = L1TkClusterHandle->begin();
        inputIter != L1TkClusterHandle->end();
        ++inputIter )
  {
    edm::Ptr< L1TkCluster< T > > tempCluPtr( L1TkClusterHandle, j++ );
    ClusterKey mapkey = std::make_pair( StackedTrackerDetId( inputIter->getDetId() ), inputIter->getStackMember() );

    if ( clusterMap.find( mapkey ) == clusterMap.end() )
    {
      std::vector< edm::Ptr< L1TkCluster< T > > > tempCluVec;
      tempCluVec.clear();
      tempCluVec.push_back( tempCluPtr );
      clusterMap.insert( std::pair< ClusterKey, std::vector< edm::Ptr< L1TkCluster< T > > > > ( mapkey, tempCluVec ) );
    }
    else
    {
      clusterMap[mapkey].push_back( tempCluPtr );   
    }
  }

  StackedTrackerGeometry::StackContainerIterator StackedTrackerIterator;
  for ( StackedTrackerIterator = theStackedTracker->stacks().begin();
        StackedTrackerIterator != theStackedTracker->stacks().end();
        ++StackedTrackerIterator )
  {
    StackedTrackerDetUnit* Unit = *StackedTrackerIterator;
    StackedTrackerDetId Id = Unit->Id();
    assert(Unit == theStackedTracker->idToStack(Id));
    
    ClusterKey inmapkey  = std::make_pair(Id, 0);
    ClusterKey outmapkey = std::make_pair(Id, 1);

    typename L1TkClusterMap::const_iterator innerIter = clusterMap.find(inmapkey);
    typename L1TkClusterMap::const_iterator outerIter = clusterMap.find(outmapkey);

    if ( innerIter == clusterMap.end() || outerIter == clusterMap.end() ) continue;

    std::vector< edm::Ptr< L1TkCluster< T > > > innerClusters = innerIter->second;
    std::vector< edm::Ptr< L1TkCluster< T > > > outerClusters = outerIter->second;

    typename std::vector< edm::Ptr< L1TkCluster< T > > >::iterator innerClusterIter, outerClusterIter;

    if ( innerClusters.size() && outerClusters.size() )
    {
      for ( innerClusterIter = innerClusters.begin();
            innerClusterIter != innerClusters.end();
            ++innerClusterIter )
      {
        for ( outerClusterIter = outerClusters.begin();
              outerClusterIter != outerClusters.end();
              ++outerClusterIter )
        {
          L1TkStub< T > tempL1TkStub( Id );
          tempL1TkStub.addClusterPtr( *innerClusterIter ); 
          tempL1TkStub.addClusterPtr( *outerClusterIter );

          bool thisConfirmation = false;
          int thisDisplacement = 999999;
          int thisOffset = 0; 

          MatchingAlgoHandle->CheckTwoMemberHitsForCompatibility( thisConfirmation, thisDisplacement, thisOffset, tempL1TkStub );

          if ( thisConfirmation )
          {
            if ( iEvent.isRealData() == false )
              tempL1TkStub.checkSimTrack();

            tempL1TkStub.setTriggerDisplacement( thisDisplacement );
            tempL1TkStub.setTriggerOffset( thisOffset );

            L1TkStubsForOutputAccepted->push_back( tempL1TkStub );

          } 
          else
            L1TkStubsForOutputRejected->push_back( tempL1TkStub );

        } 
      } 
    } 
  } 

  iEvent.put( L1TkStubsForOutputAccepted, "StubsPass" );
  iEvent.put( L1TkStubsForOutputRejected, "StubsFail" );
}

#endif