MuonAcceptor.h

Go to the documentation of this file.

// MuonAcceptor class
//
// Implements acceptance for muons
//
// Namespace Atlfast::
//
//--------------------------------------------------------------
//
// Authors: S. Hassani, S. Dean
//

#ifndef ATLFAST_MUONACCEPTOR_H
#define ATLFAST_MUONACCEPTOR_H

#include <sstream>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iterator>
#include <list>
#include <vector>
#include <map>
#include <string>
#include <utility>

#include "GaudiKernel/MsgStream.h"

#include "AtlfastAlgs/IAcceptor.h"

#include "CLHEP/Random/RandomEngine.h"

namespace Atlfast {

  using std::vector;
  using std::pair;
  

  class muEffdata{
    
  public:
    muEffdata();
    virtual ~muEffdata();
    muEffdata(double &pt,double &etamin,double &etamax,
              vector<pair<int,int> > &VecPaire);
    
  public:
    
    void Print(std::ostream* out);
    
    void SetPt (double pt);
    void SetEtaMin (double etamin);
    void SetEtaMax (double etamax);
    void SetPtEtaNum(vector<int> ptEtaNum);
    void SetPtEtaNumeDeno(vector<pair<int,int> > VecPaire);
    
    double GetPt();
    double GetEtaMin();
    double GetEtaMax();
    int    GetPtEtaNum(vector<int> &ptEtaNum);
    void   GetPtEtaNumeDeno(double &pt,double &etamin,double &etamax,
                            vector<pair<int,int> > &VecPaire);
    
  private:
    
    double m_pt;
    double m_etamin;
    double m_etamax;
    vector<int> m_ptEtaNum;
    vector<pair<int,int> > m_VecPaire;
  };
  
  class MuonAcceptor : virtual public IAcceptor{
  public:
    
    MuonAcceptor( int muSmearKey, MsgStream& log);
    virtual ~MuonAcceptor() { };
    
    //--------------------------------------------------------------------------
    // the only thing we actually need to provide is the accept() method
    //--------------------------------------------------------------------------
    virtual bool accept( const ReconstructedParticle &particle, MsgStream &log );
    
    int  muReadEff(std::ifstream& InputFile,vector<muEffdata>& VectorOfmuEffdata);
    
    vector<pair<int,int> > muEffGetPaire(double pt,double etamin,double etamax);
    pair<double,double>    muGetPtLowHigh(double pt);
    int muGetPaireNumeDenoPosi(double pt,double etamin,double etamax);
    
    pair<double,double> muEfficiency(double ptIn,double etaIn, double phi);
    pair<double,double> muEff(double ptIn,double etaIn, double phi);
    
    int muGetEtaBin(double etaIn);
    int muGetPhiBin(double phi);
    int muGetPhiBin1(double phi);
    
    pair<double,double> muPhiEff(double pt,double etamin,double etamax,
                                 double phimin,double phimax);
    pair<double,double> getPhiEff(double pt,double effin,double phig,
                                  double etamin,double etamax);

    void muPhiEfficiency(double pt,double etaIn,double phi,
                         double &eff,double &eeff);
    
    //
  private:
    vector<muEffdata>   m_muEffdataObject;
    vector<double>      m_ptValues;
    vector<double>      m_etaminValues;
    vector<double>      m_etamaxValues; 
    MsgStream&          m_log;
    HepRandomEngine*    m_randomEngine;
  };
  
  
} // end of namespace bracket

#endif

---