#include <MuonTrackValidatorBase.h>

Inheritance diagram for MuonTrackValidatorBase:

Public Member Functions
void	BinLogX (TH1 *h)
virtual void	doProfileX (TH2 th2, MonitorElement me)
virtual void	doProfileX (MonitorElement th2m, MonitorElement me)
void	fillPlotFromVector (MonitorElement *h, std::vector< int > &vec)
void	fillPlotFromVectors (MonitorElement *h, std::vector< int > &numerator, std::vector< int > &denominator, std::string type)
virtual double	getEta (double eta)
virtual double	getPt (double pt)
	MuonTrackValidatorBase (const edm::ParameterSet &pset)
	Constructor.
void	setUpVectors ()
virtual	~MuonTrackValidatorBase ()
	Destructor.
Protected Attributes
std::vector< const TrackAssociatorBase * >	associator
std::vector< std::string >	associators
edm::InputTag	bsSrc
int	cotThetaRes_nbin
double	cotThetaRes_rangeMax
double	cotThetaRes_rangeMin
DQMStore *	dbe_
std::vector< std::vector < double > >	dxyintervals
int	dxyRes_nbin
double	dxyRes_rangeMax
double	dxyRes_rangeMin
std::vector< std::vector < double > >	dzintervals
int	dzRes_nbin
double	dzRes_rangeMax
double	dzRes_rangeMin
std::vector< std::vector < double > >	etaintervals
std::vector< MonitorElement * >	h_assoc2dxy
std::vector< MonitorElement * >	h_assoc2dz
std::vector< MonitorElement * >	h_assoc2eta
std::vector< MonitorElement * >	h_assoc2hit
std::vector< MonitorElement * >	h_assoc2phi
std::vector< MonitorElement * >	h_assoc2pT
std::vector< MonitorElement * >	h_assocdxy
std::vector< MonitorElement * >	h_assocdz
std::vector< MonitorElement * >	h_assoceta
std::vector< MonitorElement * >	h_assoceta_Quality05
std::vector< MonitorElement * >	h_assoceta_Quality075
std::vector< MonitorElement * >	h_assocFraction
std::vector< MonitorElement * >	h_assochit
std::vector< MonitorElement * >	h_assocphi
std::vector< MonitorElement * >	h_assocphi_Quality05
std::vector< MonitorElement * >	h_assocphi_Quality075
std::vector< MonitorElement * >	h_assocpT
std::vector< MonitorElement * >	h_assocpT_Quality05
std::vector< MonitorElement * >	h_assocpT_Quality075
std::vector< MonitorElement * >	h_assocSharedHit
std::vector< MonitorElement * >	h_assocvertpos
std::vector< MonitorElement * >	h_assoczpos
std::vector< MonitorElement * >	h_charge
std::vector< MonitorElement * >	h_CSChits_eta
std::vector< MonitorElement * >	h_DThits_eta
std::vector< MonitorElement * >	h_eta
std::vector< MonitorElement * >	h_etaSIM
std::vector< MonitorElement * >	h_fakes
std::vector< MonitorElement * >	h_hits
std::vector< MonitorElement * >	h_hits_eta
std::vector< MonitorElement * >	h_pt
std::vector< MonitorElement * >	h_ptSIM
std::vector< MonitorElement * >	h_pullDxy
std::vector< MonitorElement * >	h_pullDz
std::vector< MonitorElement * >	h_pullPhi
std::vector< MonitorElement * >	h_pullQoverp
std::vector< MonitorElement * >	h_pullTheta
std::vector< MonitorElement * >	h_PurityVsQuality
std::vector< MonitorElement * >	h_recodxy
std::vector< MonitorElement * >	h_recodz
std::vector< MonitorElement * >	h_recoeta
std::vector< MonitorElement * >	h_recohit
std::vector< MonitorElement * >	h_recophi
std::vector< MonitorElement * >	h_recopT
std::vector< MonitorElement * >	h_RPChits_eta
std::vector< MonitorElement * >	h_simuldxy
std::vector< MonitorElement * >	h_simuldz
std::vector< MonitorElement * >	h_simuleta
std::vector< MonitorElement * >	h_simulhit
std::vector< MonitorElement * >	h_simulphi
std::vector< MonitorElement * >	h_simulpT
std::vector< MonitorElement * >	h_simulvertpos
std::vector< MonitorElement * >	h_simulzpos
std::vector< MonitorElement * >	h_tracks
std::vector< MonitorElement * >	h_tracksSIM
std::vector< MonitorElement * >	h_vertposSIM
bool	ignoremissingtkcollection_
std::vector< edm::InputTag >	label
edm::InputTag	label_tp_effic
edm::InputTag	label_tp_fake
double	max
double	maxDxy
double	maxDz
double	maxHit
double	maxPhi
double	maxpT
double	maxVertpos
double	maxZpos
double	min
double	minDxy
double	minDz
double	minHit
double	minPhi
double	minpT
double	minVertpos
double	minZpos
std::vector< MonitorElement * >	nCSChits_vs_eta
std::vector< MonitorElement * >	nDThits_vs_eta
std::vector< MonitorElement * >	nhits_vs_eta
int	nint
int	nintDxy
int	nintDz
int	nintHit
int	nintPhi
int	nintpT
int	nintVertpos
int	nintZpos
std::vector< MonitorElement * >	nrec_vs_nsim
std::vector< MonitorElement * >	nrecHit_vs_nsimHit_rec2sim
std::vector< MonitorElement * >	nrecHit_vs_nsimHit_sim2rec
std::vector< MonitorElement * >	nRPChits_vs_eta
std::string	out
std::string	parametersDefiner
std::vector< std::vector < double > >	phiintervals
int	phiRes_nbin
double	phiRes_rangeMax
double	phiRes_rangeMin
std::vector< std::vector < double > >	pTintervals
int	ptRes_nbin
double	ptRes_rangeMax
double	ptRes_rangeMin
edm::ESHandle< MagneticField >	theMF
std::vector< std::vector< int > >	totASS2_dxy
std::vector< std::vector< int > >	totASS2_dz
std::vector< std::vector< int > >	totASS2_hit
std::vector< std::vector< int > >	totASS2_phi
std::vector< std::vector< int > >	totASS2eta
std::vector< std::vector< int > >	totASS2pT
std::vector< std::vector< int > >	totASS_dxy
std::vector< std::vector< int > >	totASS_dz
std::vector< std::vector< int > >	totASS_hit
std::vector< std::vector< int > >	totASS_phi
std::vector< std::vector< int > >	totASS_phi_Quality05
std::vector< std::vector< int > >	totASS_phi_Quality075
std::vector< std::vector< int > >	totASS_vertpos
std::vector< std::vector< int > >	totASS_zpos
std::vector< std::vector< int > >	totASSeta
std::vector< std::vector< int > >	totASSeta_Quality05
std::vector< std::vector< int > >	totASSeta_Quality075
std::vector< std::vector< int > >	totASSpT
std::vector< std::vector< int > >	totASSpT_Quality05
std::vector< std::vector< int > >	totASSpT_Quality075
std::vector< std::vector< int > >	totREC_dxy
std::vector< std::vector< int > >	totREC_dz
std::vector< std::vector< int > >	totREC_hit
std::vector< std::vector< int > >	totREC_phi
std::vector< std::vector< int > >	totRECeta
std::vector< std::vector< int > >	totRECpT
std::vector< std::vector< int > >	totSIM_dxy
std::vector< std::vector< int > >	totSIM_dz
std::vector< std::vector< int > >	totSIM_hit
std::vector< std::vector< int > >	totSIM_phi
std::vector< std::vector< int > >	totSIM_vertpos
std::vector< std::vector< int > >	totSIM_zpos
std::vector< std::vector< int > >	totSIMeta
std::vector< std::vector< int > >	totSIMpT
bool	useFabs
bool	useInvPt
bool	useLogPt
bool	usemuon
bool	usetracker
std::vector< std::vector < double > >	vertposintervals
std::vector< std::vector < double > >	zposintervals

Detailed Description

Base class for analyzers that produces histograms to validate Muon Track Reconstruction performances

Date:: 2011/02/07 11:02:26

Revision:: 1.5

Definition at line 36 of file MuonTrackValidatorBase.h.

Constructor & Destructor Documentation

MuonTrackValidatorBase::MuonTrackValidatorBase ( const edm::ParameterSet & pset ) [inline]

Constructor.

Definition at line 39 of file MuonTrackValidatorBase.h.

References dbe_, maxpT, minpT, cmsCodeRules::cppFunctionSkipper::operator, and useLogPt.

                                                     :
    label(pset.getParameter< std::vector<edm::InputTag> >("label")),
    usetracker(pset.getParameter<bool>("usetracker")),
    usemuon(pset.getParameter<bool>("usemuon")),
    bsSrc(pset.getParameter< edm::InputTag >("beamSpot")),
    label_tp_effic(pset.getParameter< edm::InputTag >("label_tp_effic")),
    label_tp_fake(pset.getParameter< edm::InputTag >("label_tp_fake")),
    associators(pset.getParameter< std::vector<std::string> >("associators")),
    out(pset.getParameter<std::string>("outputFile")),   
    parametersDefiner(pset.getParameter<std::string>("parametersDefiner")),
    min(pset.getParameter<double>("min")),
    max(pset.getParameter<double>("max")),
    nint(pset.getParameter<int>("nint")),
    useFabs(pset.getParameter<bool>("useFabsEta")),
    minpT(pset.getParameter<double>("minpT")),
    maxpT(pset.getParameter<double>("maxpT")),
    nintpT(pset.getParameter<int>("nintpT")),
    minHit(pset.getParameter<double>("minHit")),
    maxHit(pset.getParameter<double>("maxHit")),
    nintHit(pset.getParameter<int>("nintHit")),
    minPhi(pset.getParameter<double>("minPhi")),
    maxPhi(pset.getParameter<double>("maxPhi")),
    nintPhi(pset.getParameter<int>("nintPhi")),
    minDxy(pset.getParameter<double>("minDxy")),
    maxDxy(pset.getParameter<double>("maxDxy")),
    nintDxy(pset.getParameter<int>("nintDxy")),
    minDz(pset.getParameter<double>("minDz")),
    maxDz(pset.getParameter<double>("maxDz")),
    nintDz(pset.getParameter<int>("nintDz")),
    minVertpos(pset.getParameter<double>("minVertpos")),
    maxVertpos(pset.getParameter<double>("maxVertpos")),
    nintVertpos(pset.getParameter<int>("nintVertpos")),
    minZpos(pset.getParameter<double>("minZpos")),
    maxZpos(pset.getParameter<double>("maxZpos")),
    nintZpos(pset.getParameter<int>("nintZpos")),
    useInvPt(pset.getParameter<bool>("useInvPt")),
    //
    ptRes_rangeMin(pset.getParameter<double>("ptRes_rangeMin")),
    ptRes_rangeMax(pset.getParameter<double>("ptRes_rangeMax")),
    phiRes_rangeMin(pset.getParameter<double>("phiRes_rangeMin")),
    phiRes_rangeMax(pset.getParameter<double>("phiRes_rangeMax")),
    cotThetaRes_rangeMin(pset.getParameter<double>("cotThetaRes_rangeMin")),
    cotThetaRes_rangeMax(pset.getParameter<double>("cotThetaRes_rangeMax")),
    dxyRes_rangeMin(pset.getParameter<double>("dxyRes_rangeMin")),
    dxyRes_rangeMax(pset.getParameter<double>("dxyRes_rangeMax")),
    dzRes_rangeMin(pset.getParameter<double>("dzRes_rangeMin")),
    dzRes_rangeMax(pset.getParameter<double>("dzRes_rangeMax")),
    ptRes_nbin(pset.getParameter<int>("ptRes_nbin")),
    cotThetaRes_nbin(pset.getParameter<int>("cotThetaRes_nbin")),
    phiRes_nbin(pset.getParameter<int>("phiRes_nbin")),
    dxyRes_nbin(pset.getParameter<int>("dxyRes_nbin")),
    dzRes_nbin(pset.getParameter<int>("dzRes_nbin")),
    ignoremissingtkcollection_(pset.getUntrackedParameter<bool>("ignoremissingtrackcollection",false)),
    useLogPt(pset.getUntrackedParameter<bool>("useLogPt",false))
    //
    {
      dbe_ = edm::Service<DQMStore>().operator->();
      if(useLogPt){
        maxpT=log10(maxpT);
        minpT=log10(minpT);
      }
    }

virtual MuonTrackValidatorBase::~MuonTrackValidatorBase ( ) [inline, virtual]

Destructor.

Definition at line 103 of file MuonTrackValidatorBase.h.

{ }

Member Function Documentation

void MuonTrackValidatorBase::BinLogX ( TH1 * h ) [inline]

Definition at line 154 of file MuonTrackValidatorBase.h.

References Capri::details::from(), i, and tablePrinter::width.

  {
    
    TAxis *axis = h->GetXaxis();
    int bins = axis->GetNbins();
    
    float from = axis->GetXmin();
    float to = axis->GetXmax();
    float width = (to - from) / bins;
    float *new_bins = new float[bins + 1];
    
    for (int i = 0; i <= bins; i++) {
      new_bins[i] = TMath::Power(10, from + i * width);
      
    }
    axis->Set(bins, new_bins);
    delete[] new_bins;
  }

virtual void MuonTrackValidatorBase::doProfileX	(	MonitorElement *	th2m,
		MonitorElement *	me
	)		`[inline, virtual]`

Definition at line 115 of file MuonTrackValidatorBase.h.

References doProfileX(), and MonitorElement::getTH2F().

                                                                     {
    doProfileX(th2m->getTH2F(), me);
  }

virtual void MuonTrackValidatorBase::doProfileX	(	TH2 *	th2,
		MonitorElement *	me
	)		`[inline, virtual]`

Definition at line 105 of file MuonTrackValidatorBase.h.

References Exception, MonitorElement::getNbinsX(), MonitorElement::getTProfile(), and p1.

Referenced by doProfileX().

                                                        {
    if (th2->GetNbinsX()==me->getNbinsX()){
      TProfile * p1 = (TProfile*) th2->ProfileX();
      p1->Copy(*me->getTProfile());
      delete p1;
    } else {
      throw cms::Exception("MuonTrackValidator") << "Different number of bins!";
    }
  }

void MuonTrackValidatorBase::fillPlotFromVector	(	MonitorElement *	h,
		std::vector< int > &	vec
	)		`[inline]`

Definition at line 129 of file MuonTrackValidatorBase.h.

References j, and MonitorElement::setBinContent().

                                                                  {
    for (unsigned int j=0; j<vec.size(); j++){
      h->setBinContent(j+1, vec[j]);
    }
  }

void MuonTrackValidatorBase::fillPlotFromVectors	(	MonitorElement *	h,
		std::vector< int > &	numerator,
		std::vector< int > &	denominator,
		std::string	type
	)		`[inline]`

Definition at line 135 of file MuonTrackValidatorBase.h.

References j, MonitorElement::setBinContent(), MonitorElement::setBinError(), mathSSE::sqrt(), and relativeConstraints::value.

                                                                                                                    {
    double value,err;
    for (unsigned int j=0; j<numerator.size(); j++){
      if (denominator[j]!=0){
        if (type=="effic")
          value = ((double) numerator[j])/((double) denominator[j]);
        else if (type=="fakerate")
          value = 1-((double) numerator[j])/((double) denominator[j]);
        else return;
        err = sqrt( value*(1-value)/(double) denominator[j] );
        h->setBinContent(j+1, value);
        h->setBinError(j+1,err);
      }
      else {
        h->setBinContent(j+1, 0);
      }
    }
  }

virtual double MuonTrackValidatorBase::getEta ( double eta ) [inline, virtual]

Definition at line 119 of file MuonTrackValidatorBase.h.

References eta(), and useFabs.

                                    {
    if (useFabs) return fabs(eta);
    else return eta;
  }

virtual double MuonTrackValidatorBase::getPt ( double pt ) [inline, virtual]

Definition at line 124 of file MuonTrackValidatorBase.h.

References useInvPt.

                                  {
    if (useInvPt && pt!=0) return 1/pt;
    else return pt;
  }

void MuonTrackValidatorBase::setUpVectors ( ) [inline]

Definition at line 173 of file MuonTrackValidatorBase.h.

References dxyintervals, dzintervals, etaintervals, gen::k, max, maxDxy, maxDz, maxPhi, maxpT, maxVertpos, maxZpos, min, minDxy, minDz, minPhi, minpT, minVertpos, minZpos, mergeVDriftHistosByStation::name, nint, nintDxy, nintDz, nintHit, nintPhi, nintpT, nintVertpos, nintZpos, phiintervals, funct::pow(), pTintervals, launcher::step, indexGen::title, totASS2_dxy, totASS2_dz, totASS2_hit, totASS2_phi, totASS2eta, totASS2pT, totASS_dxy, totASS_dz, totASS_hit, totASS_phi, totASS_phi_Quality05, totASS_phi_Quality075, totASS_vertpos, totASS_zpos, totASSeta, totASSeta_Quality05, totASSeta_Quality075, totASSpT, totASSpT_Quality05, totASSpT_Quality075, totREC_dxy, totREC_dz, totREC_hit, totREC_phi, totRECeta, totRECpT, totSIM_dxy, totSIM_dz, totSIM_hit, totSIM_phi, totSIM_vertpos, totSIM_zpos, totSIMeta, totSIMpT, useLogPt, vertposintervals, and zposintervals.

                      {
    std::vector<double> etaintervalsv;
    std::vector<double> phiintervalsv;
    std::vector<double> pTintervalsv;
    std::vector<double> dxyintervalsv;
    std::vector<double> dzintervalsv;
    std::vector<double> vertposintervalsv;
    std::vector<double> zposintervalsv;
    std::vector<int>    totSIMveta,totASSveta,totASS2veta,totRECveta;
    std::vector<int>    totSIMvpT,totASSvpT,totASS2vpT,totRECvpT;
    std::vector<int>    totSIMv_hit,totASSv_hit,totASS2v_hit,totRECv_hit;
    std::vector<int>    totSIMv_phi,totASSv_phi,totASS2v_phi,totRECv_phi;
    std::vector<int>    totSIMv_dxy,totASSv_dxy,totASS2v_dxy,totRECv_dxy;
    std::vector<int>    totSIMv_dz,totASSv_dz,totASS2v_dz,totRECv_dz;
    std::vector<int>    totSIMv_vertpos,totASSv_vertpos,totSIMv_zpos,totASSv_zpos; 

    // for muon Validation
    std::vector<int>    totASSveta_Quality05, totASSveta_Quality075;
    std::vector<int>    totASSvpT_Quality05, totASSvpT_Quality075;
    std::vector<int>    totASSv_phi_Quality05, totASSv_phi_Quality075;

    double step=(max-min)/nint;
    std::ostringstream title,name;
    etaintervalsv.push_back(min);
    for (int k=1;k<nint+1;k++) {
      double d=min+k*step;
      etaintervalsv.push_back(d);
      totSIMveta.push_back(0);
      totASSveta.push_back(0);
      totASS2veta.push_back(0);
      totRECveta.push_back(0);
      //
      totASSveta_Quality05.push_back(0);
      totASSveta_Quality075.push_back(0);
    }   
    etaintervals.push_back(etaintervalsv);
    totSIMeta.push_back(totSIMveta);
    totASSeta.push_back(totASSveta);
    totASS2eta.push_back(totASS2veta);
    totRECeta.push_back(totRECveta);
    //
    totASSeta_Quality05.push_back(totASSveta_Quality05);
    totASSeta_Quality075.push_back(totASSveta_Quality075);
  
    double steppT = (maxpT-minpT)/nintpT;
    pTintervalsv.push_back(minpT);
    for (int k=1;k<nintpT+1;k++) {
      double d=0;
      if(useLogPt)d=pow(10,minpT+k*steppT);
      else d=minpT+k*steppT;
      pTintervalsv.push_back(d);
      totSIMvpT.push_back(0);
      totASSvpT.push_back(0);
      totASS2vpT.push_back(0);
      totRECvpT.push_back(0);
      //
      totASSvpT_Quality05.push_back(0);
      totASSvpT_Quality075.push_back(0);
    }
    pTintervals.push_back(pTintervalsv);
    totSIMpT.push_back(totSIMvpT);
    totASSpT.push_back(totASSvpT);
    totASS2pT.push_back(totASS2vpT);
    totRECpT.push_back(totRECvpT);
    //
    totASSpT_Quality05.push_back(totASSvpT_Quality05); 
    totASSpT_Quality075.push_back(totASSvpT_Quality075);

    for (int k=1;k<nintHit+1;k++) {
      totSIMv_hit.push_back(0);
      totASSv_hit.push_back(0);
      totASS2v_hit.push_back(0);
      totRECv_hit.push_back(0);
    }
    totSIM_hit.push_back(totSIMv_hit);
    totASS_hit.push_back(totASSv_hit);
    totASS2_hit.push_back(totASS2v_hit);
    totREC_hit.push_back(totRECv_hit);

    double stepPhi = (maxPhi-minPhi)/nintPhi;
    phiintervalsv.push_back(minPhi);
    for (int k=1;k<nintPhi+1;k++) {
      double d=minPhi+k*stepPhi;
      phiintervalsv.push_back(d);
      totSIMv_phi.push_back(0);
      totASSv_phi.push_back(0);
      totASS2v_phi.push_back(0);
      totRECv_phi.push_back(0);
      //
      totASSv_phi_Quality05.push_back(0);
      totASSv_phi_Quality075.push_back(0);
    }
    phiintervals.push_back(phiintervalsv);
    totSIM_phi.push_back(totSIMv_phi);
    totASS_phi.push_back(totASSv_phi);
    totASS2_phi.push_back(totASS2v_phi);
    totREC_phi.push_back(totRECv_phi);
    //
    totASS_phi_Quality05.push_back(totASSv_phi_Quality05);
    totASS_phi_Quality075.push_back(totASSv_phi_Quality075);

    double stepDxy = (maxDxy-minDxy)/nintDxy;
    dxyintervalsv.push_back(minDxy);
    for (int k=1;k<nintDxy+1;k++) {
      double d=minDxy+k*stepDxy;
      dxyintervalsv.push_back(d);
      totSIMv_dxy.push_back(0);
      totASSv_dxy.push_back(0);
      totASS2v_dxy.push_back(0);
      totRECv_dxy.push_back(0);
    }
    dxyintervals.push_back(dxyintervalsv);
    totSIM_dxy.push_back(totSIMv_dxy);
    totASS_dxy.push_back(totASSv_dxy);
    totASS2_dxy.push_back(totASS2v_dxy);
    totREC_dxy.push_back(totRECv_dxy);


    double stepDz = (maxDz-minDz)/nintDz;
    dzintervalsv.push_back(minDz);
    for (int k=1;k<nintDz+1;k++) {
      double d=minDz+k*stepDz;
      dzintervalsv.push_back(d);
      totSIMv_dz.push_back(0);
      totASSv_dz.push_back(0);
      totASS2v_dz.push_back(0);
      totRECv_dz.push_back(0);
    }
    dzintervals.push_back(dzintervalsv);
    totSIM_dz.push_back(totSIMv_dz);
    totASS_dz.push_back(totASSv_dz);
    totASS2_dz.push_back(totASS2v_dz);
    totREC_dz.push_back(totRECv_dz);

    double stepVertpos = (maxVertpos-minVertpos)/nintVertpos;
    vertposintervalsv.push_back(minVertpos);
    for (int k=1;k<nintVertpos+1;k++) {
      double d=minVertpos+k*stepVertpos;
      vertposintervalsv.push_back(d);
      totSIMv_vertpos.push_back(0);
      totASSv_vertpos.push_back(0);
    }
    vertposintervals.push_back(vertposintervalsv);
    totSIM_vertpos.push_back(totSIMv_vertpos);
    totASS_vertpos.push_back(totASSv_vertpos);
      
    double stepZpos = (maxZpos-minZpos)/nintZpos;
    zposintervalsv.push_back(minZpos);
    for (int k=1;k<nintZpos+1;k++) {
      double d=minZpos+k*stepZpos;
      zposintervalsv.push_back(d);
      totSIMv_zpos.push_back(0);
      totASSv_zpos.push_back(0);
    }
    zposintervals.push_back(zposintervalsv);
    totSIM_zpos.push_back(totSIMv_zpos);
    totASS_zpos.push_back(totASSv_zpos);

  }