MuonSeedBuilder.h

Go to the documentation of this file.

#ifndef RecoMuon_MuonSeedBuilder_H
#define RecoMuon_MuonSeedBuilder_H

#include <FWCore/ParameterSet/interface/ParameterSet.h>
#include <RecoMuon/MeasurementDet/interface/MuonDetLayerMeasurements.h>
#include <DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h>
#include "FWCore/Framework/interface/ConsumesCollector.h"

//muon service
#include <RecoMuon/TrackingTools/interface/MuonServiceProxy.h>

#include<vector>

class DetLayer; 
class MuonDetLayerGeometry;
class MagneticField;
class MuonSeedCreator;
class MuonSeedCleaner;

typedef std::vector<TrajectorySeed> SeedContainer;

class MuonSeedBuilder
{

 public:

  typedef MuonTransientTrackingRecHit::MuonRecHitContainer SegmentContainer;
  typedef std::deque<bool> BoolContainer;

  explicit MuonSeedBuilder(const edm::ParameterSet&, edm::ConsumesCollector& );
  
  ~MuonSeedBuilder();
  
  // Operations

  void setGeometry( const MuonDetLayerGeometry* lgeom ) {muonLayers = lgeom;}

  void setBField( const MagneticField* theField ) {BField = theField;}

  int build( edm::Event& event, const edm::EventSetup& eventSetup, TrajectorySeedCollection& seeds );

  std::vector<int> badSeedLayer;


 private:

  bool foundMatchingSegment( int type, SegmentContainer& protoTrack, SegmentContainer& segments,
       BoolContainer& usedSeg, float& eta_temp, float& phi_temp, int& lastLayer, bool& showeringBefore );

  std::vector<TrajectorySeed> seedCleaner(const edm::EventSetup& eventSetup, std::vector<TrajectorySeed>& seeds );   

  double etaError(const GlobalPoint gp, double rErr);

  bool IdentifyShowering( SegmentContainer& segs, BoolContainer& usedSeg, float& eta_last, float& phi_last, int layer, int& NShoweringSegments  );

  
  //std::vector<SeedContainer> GroupSeeds( std::vector<TrajectorySeed>& seeds );
  //TrajectorySeed BetterDirection( std::vector<TrajectorySeed>& seeds ) ;
  //TrajectorySeed BetterChi2( std::vector<TrajectorySeed>& seeds );
  //bool MomentumFilter(std::vector<TrajectorySeed>& seeds );


  //SeedContainer LengthFilter(std::vector<TrajectorySeed>& seeds );
  //SeedContainer SeedCandidates( std::vector<TrajectorySeed>& seeds, bool good );
  //unsigned int OverlapSegments( TrajectorySeed seed1, TrajectorySeed seed2 );

  //int NRecHitsFromSegment( const TrackingRecHit& rhit );
  //int NRecHitsFromSegment( MuonTransientTrackingRecHit *rhit );
  //int NRecHitsFromSegment( const MuonTransientTrackingRecHit& rhit );
  //double NChi2OfSegment( const TrackingRecHit& rhit );

  //GlobalPoint SeedPosition( TrajectorySeed seed );
  //GlobalVector SeedMomentum( TrajectorySeed seed );

  // This Producer private debug flag
  bool debug;

  // Enable the DT measurement
  bool enableDTMeasurement;

  // Enable the CSC measurement
  bool enableCSCMeasurement;

  // Minimum # of hits to consider a CSC Segment;
  int minCSCHitsPerSegment;

  // Minimum # of hits to consider a DT Segment;
  int minDTHitsPerSegment;

  // Maximum distance from initial segment
  float maxDeltaEtaCSC;
  float maxDeltaPhiCSC;
  float maxDeltaEtaOverlap;
  float maxDeltaPhiOverlap;
  float maxDeltaEtaDT;
  float maxDeltaPhiDT;

  // Number of Segments from a shower
  int NShowerSeg;
  SegmentContainer ShoweringSegments;   
  std::vector<int> ShoweringLayers; 
  edm::InputTag theDTSegmentLabel;

  edm::InputTag theCSCSegmentLabel;

  MuonSeedCreator* muonSeedCreate_;
  MuonSeedCleaner* muonSeedClean_;

  // Cache geometry for current event
  const MuonDetLayerGeometry* muonLayers;

  // Cache Magnetic Field for current event
  const MagneticField* BField;
 
  // muon service
  MuonServiceProxy* theService;

  // Minimum separation when we can distinguish between 2 muon seeds
  // (to suppress combinatorics)
  float maxEtaResolutionDT;
  float maxEtaResolutionCSC;
  float maxPhiResolutionDT;
  float maxPhiResolutionCSC;
  float theMinMomentum;

  MuonDetLayerMeasurements * muonMeasurements;

};
#endif