TTStubAlgorithm_official.h

Go to the documentation of this file.

#ifndef L1_TRACK_TRIGGER_STUB_ALGO_official_H
#define L1_TRACK_TRIGGER_STUB_ALGO_official_H

#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/ModuleFactory.h"
#include "FWCore/Framework/interface/ESProducer.h"

#include "L1Trigger/TrackTrigger/interface/TTStubAlgorithm.h"
#include "L1Trigger/TrackTrigger/interface/TTStubAlgorithmRecord.h"

#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h"
#include "Geometry/CommonTopologies/interface/Topology.h"
#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h"
#include "Geometry/CommonTopologies/interface/PixelTopology.h"

#include <memory>
#include <string>
#include <map>
#include <typeinfo>

template< typename T >
class TTStubAlgorithm_official : public TTStubAlgorithm< T >
{
  private:
    bool        mPerformZMatchingPS;
    bool        mPerformZMatching2S;
    bool        m_tilted;
    std::string className_;

    std::vector< double >                barrelCut;
    std::vector< std::vector< double > > ringCut;
    std::vector< std::vector< double > > tiltedCut;
    std::vector< double >                barrelNTilt;

  public:
    TTStubAlgorithm_official( const TrackerGeometry* const theTrackerGeom, const TrackerTopology* const theTrackerTopo,
                             std::vector< double > setBarrelCut,
                             std::vector< std::vector< double > > setRingCut,
                             std::vector< std::vector< double > > setTiltedCut,
                             std::vector< double > setBarrelNTilt,
                  bool aPerformZMatchingPS, bool aPerformZMatching2S )
      : TTStubAlgorithm< T >( theTrackerGeom, theTrackerTopo, __func__ )
    {
      barrelCut = setBarrelCut;
      ringCut = setRingCut;
      tiltedCut = setTiltedCut;
      barrelNTilt = setBarrelNTilt;
      mPerformZMatchingPS = aPerformZMatchingPS;
      mPerformZMatching2S = aPerformZMatching2S;
    }

    ~TTStubAlgorithm_official(){}

    void PatternHitCorrelation( bool &aConfirmation,
                                int &aDisplacement,
                                int &anOffset,
                                const TTStub< T > &aTTStub ) const;

}; 

template< >
void TTStubAlgorithm_official< Ref_Phase2TrackerDigi_ >::PatternHitCorrelation( bool &aConfirmation,
                                                                       int &aDisplacement,
                                                                       int &anOffset,
                                                                       const TTStub< Ref_Phase2TrackerDigi_ > &aTTStub ) const;

template< typename T >
class ES_TTStubAlgorithm_official : public edm::ESProducer
{
  private:
    std::shared_ptr< TTStubAlgorithm< T > > _theAlgo;

    std::vector< double >                setBarrelCut;
    std::vector< std::vector< double > > setRingCut;
    std::vector< std::vector< double > > setTiltedCut;

    std::vector< double >                   setBarrelNTilt;

    bool  mPerformZMatchingPS;
    bool  mPerformZMatching2S;

  public:
    ES_TTStubAlgorithm_official( const edm::ParameterSet & p )
    {
      mPerformZMatchingPS =  p.getParameter< bool >("zMatchingPS");
      mPerformZMatching2S =  p.getParameter< bool >("zMatching2S");
      setBarrelCut = p.getParameter< std::vector< double > >("BarrelCut");
      setBarrelNTilt = p.getParameter< std::vector< double > >("NTiltedRings");

      std::vector< edm::ParameterSet > vPSet  = p.getParameter< std::vector< edm::ParameterSet > >("EndcapCutSet");
      std::vector< edm::ParameterSet > vPSet2 = p.getParameter< std::vector< edm::ParameterSet > >("TiltedBarrelCutSet");

      std::vector< edm::ParameterSet >::const_iterator iPSet;
      for ( iPSet = vPSet.begin(); iPSet != vPSet.end(); iPSet++ )
      {
        setRingCut.push_back( iPSet->getParameter< std::vector< double > >("EndcapCut") );
      }

      for ( iPSet = vPSet2.begin(); iPSet != vPSet2.end(); iPSet++ )
      {
        setTiltedCut.push_back( iPSet->getParameter< std::vector< double > >("TiltedCut") );
      }


      setWhatProduced( this );
    }

    virtual ~ES_TTStubAlgorithm_official(){}

    std::shared_ptr< TTStubAlgorithm< T > > produce( const TTStubAlgorithmRecord & record )
    { 
      edm::ESHandle< TrackerGeometry > tGeomHandle;
      record.getRecord< TrackerDigiGeometryRecord >().get( tGeomHandle );
      const TrackerGeometry* const theTrackerGeom = tGeomHandle.product();
      edm::ESHandle<TrackerTopology> tTopoHandle;
      record.getRecord< TrackerTopologyRcd >().get(tTopoHandle);
      const TrackerTopology* const theTrackerTopo = tTopoHandle.product();

      TTStubAlgorithm< T >* TTStubAlgo = new TTStubAlgorithm_official< T >( theTrackerGeom, theTrackerTopo, 
                                        setBarrelCut, setRingCut, setTiltedCut, setBarrelNTilt,
                                        mPerformZMatchingPS, mPerformZMatching2S);

      _theAlgo = std::shared_ptr< TTStubAlgorithm< T > >( TTStubAlgo );
      return _theAlgo;
    } 

};

#endif