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

Go to the documentation of this file.

#ifndef CLUSTER_BUILDER_H
#define CLUSTER_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/ClusteringAlgorithm.h"
#include "SLHCUpgradeSimulations/L1TrackTrigger/interface/ClusteringAlgorithmRecord.h"
#include "Geometry/TrackerGeometryBuilder/interface/StackedTrackerDetUnit.h"
#include <memory>
#include <map>
#include <vector>

template< typename T >
class L1TkClusterBuilder : public edm::EDProducer
{
  public:
    explicit L1TkClusterBuilder( const edm::ParameterSet& iConfig );

    ~L1TkClusterBuilder();

  private:
    const StackedTrackerGeometry              *theStackedTrackers;
    edm::ESHandle< ClusteringAlgorithm< T > > ClusteringAlgoHandle; // Handles are needed in ::produce()
    edm::Handle< edm::DetSetVector< PixelDigiSimLink > >   PixelDigiSimLinkHandle;
    edm::Handle< edm::SimTrackContainer >                  SimTrackHandle;
    std::vector< edm::InputTag >                           rawHitInputTags;
    edm::InputTag                                          simTrackInputTag;
    unsigned int                                           ADCThreshold;  

    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 );

    void RetrieveRawHits( std::map< DetId, std::vector< T > > &mRawHits, const edm::Event& iEvent );

}; 



template< typename T >
L1TkClusterBuilder< T >::L1TkClusterBuilder( const edm::ParameterSet& iConfig )
{
  rawHitInputTags  = iConfig.getParameter< std::vector< edm::InputTag > >("rawHits");
  simTrackInputTag = iConfig.getParameter< edm::InputTag >("simTrackHits");
  ADCThreshold     = iConfig.getParameter< unsigned int >("ADCThreshold");
  produces< std::vector< L1TkCluster< T > > >();
}

template<>
L1TkClusterBuilder< Ref_PSimHit_ >::L1TkClusterBuilder( const edm::ParameterSet& iConfig )
{
  rawHitInputTags  = iConfig.getParameter< std::vector< edm::InputTag > >("rawHits");
  simTrackInputTag = iConfig.getParameter< edm::InputTag >("simTrackHits");
  produces< std::vector< L1TkCluster< Ref_PSimHit_ > > >();
}

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

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

  iSetup.get< ClusteringAlgorithmRecord >().get( ClusteringAlgoHandle );

  std::cout << std::endl;
  std::cout << "L1TkClusterBuilder<" << templateNameFinder<T>() << "> loaded modules:"
            << "\n\tClusteringAlgorithm:\t" << ClusteringAlgoHandle->AlgorithmName()
            << std::endl;
  std::cout << std::endl;
}

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

template< typename T >
void L1TkClusterBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSetup )
{
  std::auto_ptr< std::vector< L1TkCluster< T > > > ClustersForOutput( new std::vector< L1TkCluster< T > > );

  iEvent.getByLabel( "simSiPixelDigis", PixelDigiSimLinkHandle );

  iEvent.getByLabel( simTrackInputTag, SimTrackHandle );

  std::map< DetId, std::vector< T > > rawHits; 


  this->RetrieveRawHits( rawHits, iEvent );

  StackedTrackerGeometry::StackContainerIterator StackedTrackerIterator;
  for ( StackedTrackerIterator = theStackedTrackers->stacks().begin();
        StackedTrackerIterator != theStackedTrackers->stacks().end();
        ++StackedTrackerIterator )
  {
    StackedTrackerDetUnit* Unit = *StackedTrackerIterator;
    StackedTrackerDetId Id = Unit->Id();
    assert(Unit == theStackedTrackers->idToStack(Id));

    std::vector< std::vector< T > > innerHits, outerHits;

    typename std::map< DetId, std::vector< T > >::const_iterator innerHitFind = rawHits.find( Unit->stackMember(0) );
    typename std::map< DetId, std::vector< T > >::const_iterator outerHitFind = rawHits.find( Unit->stackMember(1) );

    if ( innerHitFind != rawHits.end() ) ClusteringAlgoHandle->Cluster( innerHits, innerHitFind->second );
    if ( outerHitFind != rawHits.end() ) ClusteringAlgoHandle->Cluster( outerHits, outerHitFind->second );

    for ( unsigned int i = 0; i < innerHits.size(); i++ )
    {
      L1TkCluster< T > temp( innerHits.at(i), Id, 0 );
      if ( iEvent.isRealData() == false )
        theStackedTrackers->checkSimTrack(&temp, PixelDigiSimLinkHandle, SimTrackHandle ); 

      ClustersForOutput->push_back( temp );
    }
    for ( unsigned int i = 0; i < outerHits.size(); i++ )
    {
      L1TkCluster< T > temp( outerHits.at(i), Id, 1 );
      if ( iEvent.isRealData() == false )
        theStackedTrackers->checkSimTrack( &temp, PixelDigiSimLinkHandle, SimTrackHandle ); 

      ClustersForOutput->push_back( temp );
    }

  } 

  iEvent.put( ClustersForOutput );
}

template<>
void L1TkClusterBuilder< Ref_PixelDigi_ >::RetrieveRawHits( std::map< DetId, std::vector< Ref_PixelDigi_ > > &mRawHits,
                                                                         const edm::Event& iEvent )
{
  mRawHits.clear();
  std::vector< edm::InputTag >::iterator it;
  for ( it = rawHitInputTags.begin();
        it != rawHitInputTags.end();
        ++it )
  {
    edm::Handle< edm::DetSetVector< PixelDigi > > HitHandle;
    iEvent.getByLabel( *it, HitHandle );

    edm::DetSetVector<PixelDigi>::const_iterator detsIter;
    edm::DetSet<PixelDigi>::const_iterator       hitsIter;

    for ( detsIter = HitHandle->begin();
          detsIter != HitHandle->end();
          detsIter++ )
    {
      DetId id = detsIter->id;

      if ( id.subdetId()==1 || id.subdetId()==2 )
      {
        for ( hitsIter = detsIter->data.begin();
              hitsIter != detsIter->data.end();
              hitsIter++ )
        {
          if ( hitsIter->adc() >= ADCThreshold )
          {
            mRawHits[id].push_back( makeRefTo( HitHandle, id , hitsIter ) );
          } 
        } 
      } 
    } 
  } 
}

template<>
void L1TkClusterBuilder< Ref_PSimHit_ >::RetrieveRawHits( std::map< DetId, std::vector< Ref_PSimHit_ > > &mRawHits,
                                                                       const edm::Event& iEvent )
{
  mRawHits.clear();
  for ( std::vector<edm::InputTag>::iterator it = rawHitInputTags.begin();
        it != rawHitInputTags.end();
        ++it )
  {
    edm::Handle< edm::PSimHitContainer > HitHandle;
    iEvent.getByLabel( *it, HitHandle );

    for ( unsigned int i=0 ; i != HitHandle->size() ; ++i )
    {
      DetId id = DetId(HitHandle->at(i).detUnitId());
      if ( id.subdetId()==1 || id.subdetId()==2 )
        mRawHits[id].push_back( edm::Ref<edm::PSimHitContainer>( HitHandle, i ) );
    } 
  } 
}

#endif