MuonSpectrometer.h

Go to the documentation of this file.

#ifndef ATLFAST_MUONSPECTROMETER_H
#define ATLFAST_MUONSPECTROMETER_H

#include <map>

#include "AtlfastAlgs/XMLHelpers.h"
#include "CLHEP/Vector/LorentzVector.h"

namespace Atlfast{
  
  // ============================================

  class EtaBin{
  public:
    EtaBin(double deltaponp, int bin);    
    void setEtaStuff(double etaFirst, double deltaEta);
    void combine(EtaBin& otherEtaBin, double thispt, double nextpt);
    double calculateResolution(const HepLorentzVector& avec);
    void dump(std::string indent);
    double getEtaMin(){return m_etamin;}
    double getEtaMax(){return m_etamax;}
  private:
    int m_etabin;
    double m_etamin;
    double m_etamax;
    double m_etavalue;
    double m_deltaponp;
    double m_constterm;
    double m_ptterm;
  };
  
  // ============================================

  class PhiBin{
  public:
    PhiBin(DOMNode* boundaries, DOMNode* phi);
    ~PhiBin();
    void setPhiStuff(double sectorPhimin, double sectorPhimax, double deltaPhi, int phipoints);
    void combine(PhiBin &otherPhiBin, double thispt, double nextpt);
    double calculateResolution(const HepLorentzVector& avec);
    void dump(std::string indent);
    double getPhiMin(){return m_phimin;}
    double getPhiMax(){return m_phimax;}
  private:
    int m_phibin;
    double m_phimin;
    double m_phimax;
    double m_phivalue;
    std::vector<EtaBin> m_etas;
  };
  
  // ============================================
  
  class Sector{
  public:
    Sector(DOMNode* boundaries, DOMNode* sector);
    ~Sector();
    void combine(Sector& otherSec, double thispt, double nextpt);
    double calculateResolution(const HepLorentzVector& avec);
    void dump(std::string indent);
    std::string getSectorType(){return m_sectorType;}
  private:
    std::string  m_sectorType;
    double m_phimin;
    double m_phimax;
    std::vector<PhiBin> m_phis;
  };
  
  // ============================================
  
  class MuonSpectrometer{
  public:
    MuonSpectrometer(double ptmin, double ptmax, std::vector<Sector> sectors);
    double calculateResolution(const HepLorentzVector& avec);
    void dump(std::string indent);
    void setSectorMap(std::map<int,std::string> sectortypes);
    double getPtMin(){return m_ptmin;}
    double getPtMax(){return m_ptmax;}
  private:
    double m_ptmin;
    double m_ptmax;
    double m_sectorsize;
    std::vector<Sector> m_sectors;
    std::map<int,std::string> m_sectortypes;
  };

  // ============================================ 
  
  class ProtoSpectrometer{
  public:
    // find the ptbin number in the constructor
    ProtoSpectrometer(DOMNode* boundaries, DOMNode* ptbinres, bool lowestpT, bool highestpT);
    ~ProtoSpectrometer();
    double getPtValue() const {return m_ptvalue;}
    MuonSpectrometer combine(ProtoSpectrometer& otherPS);
    void dump(std::string indent);
  private:
    std::vector<Sector> m_sectors;
    int m_ptbin;
    double m_ptvalue;
    bool m_lowestpT;
    bool m_highestpT;
  };

  // ============================================

  class MuonResolutionCalculator{
  public:
    MuonResolutionCalculator(const char* filename);
    ~MuonResolutionCalculator(){};
    double calculateResolution(const HepLorentzVector& avec);
    void dump(std::string indent);
  private:
    std::map<int,std::string> makeSectorMap(DOMNode* boundaries);
    std::vector<ProtoSpectrometer> m_protoSpectrometers;
    std::vector<MuonSpectrometer> m_muonSpectrometers;
  };
  
  // ============================================

  class IsCorrectEtaBin{
  public:
    IsCorrectEtaBin(double eta);
    bool operator()(EtaBin&);
  private:
    double m_eta;
  };  

  // ============================================

  class IsCorrectPhiBin{
  public:
    IsCorrectPhiBin(double phi);
    bool operator()(PhiBin&);
  private:
    double m_phi;
  };  

  // ============================================

  class IsCorrectSector{
  public:
    IsCorrectSector(std::string sectortype);
    bool operator()(Sector&);
  private:
    std::string m_sectortype;
  };  

  // ============================================

  class IsCorrectMuonSpectrometer{
  public:
    IsCorrectMuonSpectrometer(double pT);
    bool operator()(MuonSpectrometer&);
  private:
    double m_pT;
  };  

  // ============================================

  class AddToDump{
  public:
    AddToDump(std::string indent):m_indent(indent){}
    template<class T>
      void operator()(T t){
      t.dump(m_indent);
    }
  private:
    std::string m_indent;
  };
  
  // ============================================
  
  class AddToMap{
  public:
    AddToMap():m_sectorcount(0){}
    void operator()(DOMNode* sectorTypeNode){
      char* s = getText(sectorTypeNode);
      std::string sectortype(s);
      XMLString::release(&s);
      ++m_sectorcount;
      m_map[m_sectorcount] = sectortype;
    }
    std::map<int,std::string> getMap(){return m_map;}
  private:
    std::map<int,std::string> m_map;
    int m_sectorcount;
  };
  
  // ===========================================
  
  template <class T>
    class SpectrometerComponentInstantiator{
    public:
    SpectrometerComponentInstantiator(DOMNode* boundaries):
      m_boundaries(boundaries){}
    
    void operator()(DOMNode* node){
      m_objs.push_back(T(m_boundaries, node));
    }
    std::vector<T> objects() const{
      return m_objs;}
    private:
    DOMNode* m_boundaries;
    std::vector<T> m_objs;
  };
  
  // ===========================================
  
  template <class T>
    class SpectrometerComponentBinInstantiator{
    public:
    SpectrometerComponentBinInstantiator(DOMNode* boundaries):
      m_boundaries(boundaries), m_bin(0){}
    
    void operator()(double resolution){
      m_objs.push_back(T(resolution, m_bin++));
    }
    std::vector<T> objects() const{return m_objs;}
    private:
    DOMNode* m_boundaries;
    int m_bin;
    std::vector<T> m_objs;
  };
  
  // ============================================
  
} // namespace Atlfast

#endif

---