/data/refman/pasoursint/CMSSW_5_3_3/src/DataFormats/METReco/interface/PhiWedge.h

Go to the documentation of this file.

#ifndef DATAFORMATS_METRECO_PHIWEDGE_H
#define DATAFORMATS_METRECO_PHIWEDGE_H
/*
  [class]:  PhiWedge
  [authors]: R. Remington, The University of Florida
  [description]: Simple class analogous to CaloTower but in z-direction.  Stores basic information related to Hcal and Ecal rechits within constant 5-degree phi windows.  The idea will be to match these reconstructed phi-wedges with csc tracks for BeamHalo identification.
  [date]: October 15, 2009
*/
#include "TMath.h"
#include <vector>
namespace reco{
  
  class PhiWedge {
    
  public:
    // Constructors
    PhiWedge();
    PhiWedge(float E, int iphi, int constituents);
    PhiWedge(float E, int iphi, int constituents, float min_time , float max_time);
    PhiWedge(const PhiWedge&);
    // Destructors
    
    ~PhiWedge(){}
    
    // Energy sum of all rechits above threshold in this 5-degree window
    float Energy() const {return energy_;}
    
    // Number of rechits above threshold in this 5-degree window
    int NumberOfConstituents() const  {return constituents_;}
    
    // iPhi value of this 5-degree window
    int iPhi() const {return iphi_;}
    
    // Global phi lower bound of this 5-degree window (between 0 and 2Pi)
    float PhiLow() const {return 2.*TMath::Pi()*(float)((iphi_ * 5)-(5.));}
    
    // Global phi upper bound of this 5-degree window (between 0 and 2Pi
    float PhiHigh() const {return 2.*TMath::Pi()*(float)((iphi_* 5));}

    // Get Min/Max Time
    float MinTime()const{return min_time_;}
    float MaxTime()const{return max_time_;}
    
    // Get halo direction confidence based on time ordering of the rechits ( must be within range of -1 to + 1 )
    // Direction is calculated by counting the number of pair-wise time-ascending rechits from -Z to +Z and then normalizing this count by number of pair-wise combinations
    // If all pair-wise combinations are consistent with a common z-direction, then this value will be plus or minus 1 exactly.  Otherwise it will be somewhere in between.
    float ZDirectionConfidence() const { return (1. - PlusZOriginConfidence_)*2. -1. ;}
    float PlusZDirectionConfidence() const { return 1.-PlusZOriginConfidence_;}
    float MinusZDirectionConfidence() const { return PlusZOriginConfidence_ ;}
    
    // Get halo origin confidence based on time ordering of the rechits
    float PlusZOriginConfidence() const { return PlusZOriginConfidence_ ;} 
    float MinusZOriginConfidence() const { return 1.- PlusZOriginConfidence_;}
    
    // To be filled later or removed
    int OverlappingCSCTracks() const {return OverlappingCSCTracks_;}
    int OverlappingCSCSegments()const {return OverlappingCSCSegments_;}
    int OverlappingCSCRecHits() const {return OverlappingCSCRecHits_;}
    int OverlappingCSCHaloTriggers() const {return OverlappingCSCHaloTriggers_;}
    
    // Setters
    void SetOverlappingCSCTracks(int x) { OverlappingCSCTracks_ = x;}
    void SetOverlappingCSCSegments(int x) { OverlappingCSCSegments_ =x;}
    void SetOverlappingCSCRecHits(int x){ OverlappingCSCRecHits_ =x ;}
    void SetOverlappingCSCHaloTriggers(int x){ OverlappingCSCHaloTriggers_ = x ;}
    void SetMinMaxTime(float min, float max ){ min_time_ = min; max_time_ = max;}
    void SetPlusZOriginConfidence( float x ) { PlusZOriginConfidence_ = x ;}
    


  private:
    float energy_;
    int iphi_;
    int constituents_;
    float  min_time_;
    float max_time_;
    float PlusZOriginConfidence_;
    int OverlappingCSCTracks_;
    int OverlappingCSCSegments_;
    int OverlappingCSCRecHits_;
    int OverlappingCSCHaloTriggers_;
    
  };
  typedef std::vector<PhiWedge> PhiWedgeCollection;
}
#endif