Reference Manual

Go to the documentation of this file.
00001 #include "Validation/RecoTrack/interface/MTVHistoProducerAlgoForTracker.h"
00002 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00003 #include "DataFormats/TrackReco/interface/Track.h"
00004 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00005 
00006 #include "DataFormats/TrackReco/interface/DeDxData.h"
00007 #include "DataFormats/Common/interface/ValueMap.h"
00008 #include "DataFormats/Common/interface/Ref.h"
00009 #include <DataFormats/TrackReco/interface/TrackFwd.h>
00010 
00011 #include "DQMServices/ClientConfig/interface/FitSlicesYTool.h"
00012 
00013 #include "TMath.h"
00014 #include <TF1.h>
00015 
00016 using namespace std;
00017 
00018 MTVHistoProducerAlgoForTracker::MTVHistoProducerAlgoForTracker(const edm::ParameterSet& pset): MTVHistoProducerAlgo(pset){
00019   //parameters for _vs_eta plots
00020   minEta  = pset.getParameter<double>("minEta");  
00021   maxEta  = pset.getParameter<double>("maxEta");
00022   nintEta = pset.getParameter<int>("nintEta");
00023   useFabsEta = pset.getParameter<bool>("useFabsEta");
00024 
00025   //parameters for _vs_pt plots
00026   minPt  = pset.getParameter<double>("minPt");
00027   maxPt  = pset.getParameter<double>("maxPt");
00028   nintPt = pset.getParameter<int>("nintPt");
00029   useInvPt = pset.getParameter<bool>("useInvPt");
00030   useLogPt = pset.getUntrackedParameter<bool>("useLogPt",false);
00031 
00032   //parameters for _vs_Hit plots
00033   minHit  = pset.getParameter<double>("minHit");
00034   maxHit  = pset.getParameter<double>("maxHit");
00035   nintHit = pset.getParameter<int>("nintHit");
00036   
00037   //parameters for _vs_phi plots
00038   minPhi  = pset.getParameter<double>("minPhi");
00039   maxPhi  = pset.getParameter<double>("maxPhi");
00040   nintPhi = pset.getParameter<int>("nintPhi");
00041 
00042   //parameters for _vs_Dxy plots
00043   minDxy  = pset.getParameter<double>("minDxy");
00044   maxDxy  = pset.getParameter<double>("maxDxy");
00045   nintDxy = pset.getParameter<int>("nintDxy");
00046     
00047   //parameters for _vs_Dz plots
00048   minDz  = pset.getParameter<double>("minDz");
00049   maxDz  = pset.getParameter<double>("maxDz");
00050   nintDz = pset.getParameter<int>("nintDz");
00051 
00052   //parameters for _vs_ProductionVertexTransvPosition plots
00053   minVertpos  = pset.getParameter<double>("minVertpos");
00054   maxVertpos  = pset.getParameter<double>("maxVertpos");
00055   nintVertpos = pset.getParameter<int>("nintVertpos");
00056 
00057   //parameters for _vs_ProductionVertexZPosition plots
00058   minZpos  = pset.getParameter<double>("minZpos");
00059   maxZpos  = pset.getParameter<double>("maxZpos");
00060   nintZpos = pset.getParameter<int>("nintZpos");
00061 
00062   //parameters for dE/dx plots
00063   minDeDx  = pset.getParameter<double>("minDeDx");
00064   maxDeDx  = pset.getParameter<double>("maxDeDx");
00065   nintDeDx = pset.getParameter<int>("nintDeDx");
00066   
00067   //parameters for resolution plots
00068   ptRes_rangeMin = pset.getParameter<double>("ptRes_rangeMin");
00069   ptRes_rangeMax = pset.getParameter<double>("ptRes_rangeMax");
00070   ptRes_nbin = pset.getParameter<int>("ptRes_nbin");
00071 
00072   phiRes_rangeMin = pset.getParameter<double>("phiRes_rangeMin");
00073   phiRes_rangeMax = pset.getParameter<double>("phiRes_rangeMax");
00074   phiRes_nbin = pset.getParameter<int>("phiRes_nbin");
00075 
00076   cotThetaRes_rangeMin = pset.getParameter<double>("cotThetaRes_rangeMin");
00077   cotThetaRes_rangeMax = pset.getParameter<double>("cotThetaRes_rangeMax");
00078   cotThetaRes_nbin = pset.getParameter<int>("cotThetaRes_nbin");
00079 
00080   dxyRes_rangeMin = pset.getParameter<double>("dxyRes_rangeMin");
00081   dxyRes_rangeMax = pset.getParameter<double>("dxyRes_rangeMax");
00082   dxyRes_nbin = pset.getParameter<int>("dxyRes_nbin");
00083 
00084   dzRes_rangeMin = pset.getParameter<double>("dzRes_rangeMin");
00085   dzRes_rangeMax = pset.getParameter<double>("dzRes_rangeMax");
00086   dzRes_nbin = pset.getParameter<int>("dzRes_nbin");
00087 
00088 
00089   //--- tracking particle selectors for efficiency measurements
00090   using namespace edm;
00091 
00092   ParameterSet generalTpSelectorPSet = pset.getParameter<ParameterSet>("generalTpSelector");
00093   ParameterSet TpSelectorForEfficiencyVsEtaPSet = pset.getParameter<ParameterSet>("TpSelectorForEfficiencyVsEta");
00094   ParameterSet TpSelectorForEfficiencyVsPhiPSet = pset.getParameter<ParameterSet>("TpSelectorForEfficiencyVsPhi");
00095   ParameterSet TpSelectorForEfficiencyVsPtPSet = pset.getParameter<ParameterSet>("TpSelectorForEfficiencyVsPt");
00096   ParameterSet TpSelectorForEfficiencyVsVTXRPSet = pset.getParameter<ParameterSet>("TpSelectorForEfficiencyVsVTXR");
00097   ParameterSet TpSelectorForEfficiencyVsVTXZPSet = pset.getParameter<ParameterSet>("TpSelectorForEfficiencyVsVTXZ");
00098   
00099   using namespace reco::modules;
00100   generalTpSelector             = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(generalTpSelectorPSet));
00101   TpSelectorForEfficiencyVsEta  = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsEtaPSet));
00102   TpSelectorForEfficiencyVsPhi  = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsPhiPSet));
00103   TpSelectorForEfficiencyVsPt   = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsPtPSet));
00104   TpSelectorForEfficiencyVsVTXR = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsVTXRPSet));
00105   TpSelectorForEfficiencyVsVTXZ = new TrackingParticleSelector(ParameterAdapter<TrackingParticleSelector>::make(TpSelectorForEfficiencyVsVTXZPSet));
00106 
00107   // fix for the LogScale by Ryan
00108   if(useLogPt){
00109     maxPt=log10(maxPt);
00110     if(minPt > 0){
00111       minPt=log10(minPt);
00112     }
00113     else{
00114       edm::LogWarning("MultiTrackValidator") 
00115         << "minPt = "
00116         << minPt << " <= 0 out of range while requesting log scale.  Using minPt = 0.1.";
00117       minPt=log10(0.1);
00118     }
00119   }
00120 
00121 }
00122 
00123 MTVHistoProducerAlgoForTracker::~MTVHistoProducerAlgoForTracker(){
00124   delete generalTpSelector;
00125   delete TpSelectorForEfficiencyVsEta;
00126   delete TpSelectorForEfficiencyVsPhi;
00127   delete TpSelectorForEfficiencyVsPt;
00128   delete TpSelectorForEfficiencyVsVTXR;
00129   delete TpSelectorForEfficiencyVsVTXZ;
00130 }
00131 
00132 
00133 void MTVHistoProducerAlgoForTracker::setUpVectors(){
00134   std::vector<double> etaintervalsv;
00135   std::vector<double> phiintervalsv;
00136   std::vector<double> pTintervalsv;
00137   std::vector<double> dxyintervalsv;
00138   std::vector<double> dzintervalsv;
00139   std::vector<double> vertposintervalsv;
00140   std::vector<double> zposintervalsv;
00141   std::vector<int>    totSIMveta,totASSveta,totASS2veta,totRECveta;
00142   std::vector<int>    totSIMvpT,totASSvpT,totASS2vpT,totRECvpT;
00143   std::vector<int>    totSIMv_hit,totASSv_hit,totASS2v_hit,totRECv_hit;
00144   std::vector<int>    totSIMv_phi,totASSv_phi,totASS2v_phi,totRECv_phi;
00145   std::vector<int>    totSIMv_dxy,totASSv_dxy,totASS2v_dxy,totRECv_dxy;
00146   std::vector<int>    totSIMv_dz,totASSv_dz,totASS2v_dz,totRECv_dz;
00147   std::vector<int>    totSIMv_vertpos,totASSv_vertpos,totSIMv_zpos,totASSv_zpos; 
00148 
00149   double step=(maxEta-minEta)/nintEta;
00150   //std::ostringstream title,name; ///BM, what is this?
00151   etaintervalsv.push_back(minEta);
00152   for (int k=1;k<nintEta+1;k++) {
00153     double d=minEta+k*step;
00154     etaintervalsv.push_back(d);
00155     totSIMveta.push_back(0);
00156     totASSveta.push_back(0);
00157     totASS2veta.push_back(0);
00158     totRECveta.push_back(0);
00159   }   
00160   etaintervals.push_back(etaintervalsv);
00161   totSIMeta.push_back(totSIMveta);
00162   totASSeta.push_back(totASSveta);
00163   totASS2eta.push_back(totASS2veta);
00164   totRECeta.push_back(totRECveta);
00165   
00166   double stepPt = (maxPt-minPt)/nintPt;
00167   pTintervalsv.push_back(minPt);
00168   for (int k=1;k<nintPt+1;k++) {
00169     double d=0;
00170     if(useLogPt)d=pow(10,minPt+k*stepPt);
00171     else d=minPt+k*stepPt;
00172     pTintervalsv.push_back(d);
00173     totSIMvpT.push_back(0);
00174     totASSvpT.push_back(0);
00175     totASS2vpT.push_back(0);
00176     totRECvpT.push_back(0);
00177   }
00178   pTintervals.push_back(pTintervalsv);
00179   totSIMpT.push_back(totSIMvpT);
00180   totASSpT.push_back(totASSvpT);
00181   totASS2pT.push_back(totASS2vpT);
00182   totRECpT.push_back(totRECvpT);
00183   
00184   for (int k=1;k<nintHit+1;k++) {
00185     totSIMv_hit.push_back(0);
00186     totASSv_hit.push_back(0);
00187     totASS2v_hit.push_back(0);
00188     totRECv_hit.push_back(0);
00189   }
00190   totSIM_hit.push_back(totSIMv_hit);
00191   totASS_hit.push_back(totASSv_hit);
00192   totASS2_hit.push_back(totASS2v_hit);
00193   totREC_hit.push_back(totRECv_hit);
00194   
00195   double stepPhi = (maxPhi-minPhi)/nintPhi;
00196   phiintervalsv.push_back(minPhi);
00197   for (int k=1;k<nintPhi+1;k++) {
00198     double d=minPhi+k*stepPhi;
00199     phiintervalsv.push_back(d);
00200     totSIMv_phi.push_back(0);
00201     totASSv_phi.push_back(0);
00202     totASS2v_phi.push_back(0);
00203     totRECv_phi.push_back(0);
00204   }
00205   phiintervals.push_back(phiintervalsv);
00206   totSIM_phi.push_back(totSIMv_phi);
00207   totASS_phi.push_back(totASSv_phi);
00208   totASS2_phi.push_back(totASS2v_phi);
00209   totREC_phi.push_back(totRECv_phi);
00210   
00211   double stepDxy = (maxDxy-minDxy)/nintDxy;
00212   dxyintervalsv.push_back(minDxy);
00213   for (int k=1;k<nintDxy+1;k++) {
00214     double d=minDxy+k*stepDxy;
00215     dxyintervalsv.push_back(d);
00216     totSIMv_dxy.push_back(0);
00217     totASSv_dxy.push_back(0);
00218     totASS2v_dxy.push_back(0);
00219     totRECv_dxy.push_back(0);
00220   }
00221   dxyintervals.push_back(dxyintervalsv);
00222   totSIM_dxy.push_back(totSIMv_dxy);
00223   totASS_dxy.push_back(totASSv_dxy);
00224   totASS2_dxy.push_back(totASS2v_dxy);
00225   totREC_dxy.push_back(totRECv_dxy);
00226   
00227   
00228   double stepDz = (maxDz-minDz)/nintDz;
00229   dzintervalsv.push_back(minDz);
00230   for (int k=1;k<nintDz+1;k++) {
00231     double d=minDz+k*stepDz;
00232     dzintervalsv.push_back(d);
00233     totSIMv_dz.push_back(0);
00234     totASSv_dz.push_back(0);
00235     totASS2v_dz.push_back(0);
00236     totRECv_dz.push_back(0);
00237   }
00238   dzintervals.push_back(dzintervalsv);
00239   totSIM_dz.push_back(totSIMv_dz);
00240   totASS_dz.push_back(totASSv_dz);
00241   totASS2_dz.push_back(totASS2v_dz);
00242   totREC_dz.push_back(totRECv_dz);
00243   
00244   double stepVertpos = (maxVertpos-minVertpos)/nintVertpos;
00245   vertposintervalsv.push_back(minVertpos);
00246   for (int k=1;k<nintVertpos+1;k++) {
00247     double d=minVertpos+k*stepVertpos;
00248     vertposintervalsv.push_back(d);
00249     totSIMv_vertpos.push_back(0);
00250     totASSv_vertpos.push_back(0);
00251   }
00252   vertposintervals.push_back(vertposintervalsv);
00253   totSIM_vertpos.push_back(totSIMv_vertpos);
00254   totASS_vertpos.push_back(totASSv_vertpos);
00255     
00256   double stepZpos = (maxZpos-minZpos)/nintZpos;
00257   zposintervalsv.push_back(minZpos);
00258   for (int k=1;k<nintZpos+1;k++) {
00259     double d=minZpos+k*stepZpos;
00260     zposintervalsv.push_back(d);
00261     totSIMv_zpos.push_back(0);
00262     totASSv_zpos.push_back(0);
00263   }
00264   zposintervals.push_back(zposintervalsv);
00265   totSIM_zpos.push_back(totSIMv_zpos);
00266   totASS_zpos.push_back(totASSv_zpos);
00267 }
00268 
00269 void MTVHistoProducerAlgoForTracker::bookSimHistos(){
00270   h_ptSIM.push_back( dbe_->book1D("ptSIM", "generated p_{t}", 5500, 0, 110 ) );
00271   h_etaSIM.push_back( dbe_->book1D("etaSIM", "generated pseudorapidity", 500, -2.5, 2.5 ) );
00272   h_tracksSIM.push_back( dbe_->book1D("tracksSIM","number of simulated tracks",200,-0.5,99.5) );
00273   h_vertposSIM.push_back( dbe_->book1D("vertposSIM","Transverse position of sim vertices",100,0.,120.) );  
00274 }
00275 
00276 
00277 void MTVHistoProducerAlgoForTracker::bookRecoHistos(){
00278   h_tracks.push_back( dbe_->book1D("tracks","number of reconstructed tracks",200,-0.5,19.5) );
00279   h_fakes.push_back( dbe_->book1D("fakes","number of fake reco tracks",20,-0.5,19.5) );
00280   h_charge.push_back( dbe_->book1D("charge","charge",3,-1.5,1.5) );
00281   
00282   h_hits.push_back( dbe_->book1D("hits", "number of hits per track", nintHit,minHit,maxHit ) );
00283   h_losthits.push_back( dbe_->book1D("losthits", "number of lost hits per track", nintHit,minHit,maxHit) );
00284   h_nchi2.push_back( dbe_->book1D("chi2", "normalized #chi^{2}", 200, 0, 20 ) );
00285   h_nchi2_prob.push_back( dbe_->book1D("chi2_prob", "normalized #chi^{2} probability",100,0,1));
00286 
00288   h_recoeta.push_back( dbe_->book1D("num_reco_eta","N of reco track vs eta",nintEta,minEta,maxEta) );
00289   h_assoceta.push_back( dbe_->book1D("num_assoc(simToReco)_eta","N of associated tracks (simToReco) vs eta",nintEta,minEta,maxEta) );
00290   h_assoc2eta.push_back( dbe_->book1D("num_assoc(recoToSim)_eta","N of associated (recoToSim) tracks vs eta",nintEta,minEta,maxEta) );
00291   h_simuleta.push_back( dbe_->book1D("num_simul_eta","N of simulated tracks vs eta",nintEta,minEta,maxEta) );
00292   h_recopT.push_back( dbe_->book1D("num_reco_pT","N of reco track vs pT",nintPt,minPt,maxPt) );
00293   h_assocpT.push_back( dbe_->book1D("num_assoc(simToReco)_pT","N of associated tracks (simToReco) vs pT",nintPt,minPt,maxPt) );
00294   h_assoc2pT.push_back( dbe_->book1D("num_assoc(recoToSim)_pT","N of associated (recoToSim) tracks vs pT",nintPt,minPt,maxPt) );
00295   h_simulpT.push_back( dbe_->book1D("num_simul_pT","N of simulated tracks vs pT",nintPt,minPt,maxPt) );
00296   //
00297   h_recohit.push_back( dbe_->book1D("num_reco_hit","N of reco track vs hit",nintHit,minHit,maxHit) );
00298   h_assochit.push_back( dbe_->book1D("num_assoc(simToReco)_hit","N of associated tracks (simToReco) vs hit",nintHit,minHit,maxHit) );
00299   h_assoc2hit.push_back( dbe_->book1D("num_assoc(recoToSim)_hit","N of associated (recoToSim) tracks vs hit",nintHit,minHit,maxHit) );
00300   h_simulhit.push_back( dbe_->book1D("num_simul_hit","N of simulated tracks vs hit",nintHit,minHit,maxHit) );
00301   //
00302   h_recophi.push_back( dbe_->book1D("num_reco_phi","N of reco track vs phi",nintPhi,minPhi,maxPhi) );
00303   h_assocphi.push_back( dbe_->book1D("num_assoc(simToReco)_phi","N of associated tracks (simToReco) vs phi",nintPhi,minPhi,maxPhi) );
00304   h_assoc2phi.push_back( dbe_->book1D("num_assoc(recoToSim)_phi","N of associated (recoToSim) tracks vs phi",nintPhi,minPhi,maxPhi) );
00305   h_simulphi.push_back( dbe_->book1D("num_simul_phi","N of simulated tracks vs phi",nintPhi,minPhi,maxPhi) );
00306   
00307   h_recodxy.push_back( dbe_->book1D("num_reco_dxy","N of reco track vs dxy",nintDxy,minDxy,maxDxy) );
00308   h_assocdxy.push_back( dbe_->book1D("num_assoc(simToReco)_dxy","N of associated tracks (simToReco) vs dxy",nintDxy,minDxy,maxDxy) );
00309   h_assoc2dxy.push_back( dbe_->book1D("num_assoc(recoToSim)_dxy","N of associated (recoToSim) tracks vs dxy",nintDxy,minDxy,maxDxy) );
00310   h_simuldxy.push_back( dbe_->book1D("num_simul_dxy","N of simulated tracks vs dxy",nintDxy,minDxy,maxDxy) );
00311   
00312   h_recodz.push_back( dbe_->book1D("num_reco_dz","N of reco track vs dz",nintDz,minDz,maxDz) );
00313   h_assocdz.push_back( dbe_->book1D("num_assoc(simToReco)_dz","N of associated tracks (simToReco) vs dz",nintDz,minDz,maxDz) );
00314   h_assoc2dz.push_back( dbe_->book1D("num_assoc(recoToSim)_dz","N of associated (recoToSim) tracks vs dz",nintDz,minDz,maxDz) );
00315   h_simuldz.push_back( dbe_->book1D("num_simul_dz","N of simulated tracks vs dz",nintDz,minDz,maxDz) );
00316   
00317   h_assocvertpos.push_back( dbe_->book1D("num_assoc(simToReco)_vertpos",
00318                                          "N of associated tracks (simToReco) vs transverse vert position",       
00319                                          nintVertpos,minVertpos,maxVertpos) );
00320   h_simulvertpos.push_back( dbe_->book1D("num_simul_vertpos","N of simulated tracks vs transverse vert position",
00321                                          nintVertpos,minVertpos,maxVertpos) );
00322   
00323   h_assoczpos.push_back( dbe_->book1D("num_assoc(simToReco)_zpos","N of associated tracks (simToReco) vs z vert position",
00324                                       nintZpos,minZpos,maxZpos) );
00325   h_simulzpos.push_back( dbe_->book1D("num_simul_zpos","N of simulated tracks vs z vert position",nintZpos,minZpos,maxZpos) );
00326   
00327 
00329   
00330   h_eta.push_back( dbe_->book1D("eta", "pseudorapidity residue", 1000, -0.1, 0.1 ) );
00331   h_pt.push_back( dbe_->book1D("pullPt", "pull of p_{t}", 100, -10, 10 ) );
00332   h_pullTheta.push_back( dbe_->book1D("pullTheta","pull of #theta parameter",250,-25,25) );
00333   h_pullPhi.push_back( dbe_->book1D("pullPhi","pull of #phi parameter",250,-25,25) );
00334   h_pullDxy.push_back( dbe_->book1D("pullDxy","pull of dxy parameter",250,-25,25) );
00335   h_pullDz.push_back( dbe_->book1D("pullDz","pull of dz parameter",250,-25,25) );
00336   h_pullQoverp.push_back( dbe_->book1D("pullQoverp","pull of qoverp parameter",250,-25,25) );
00337   
00338   /* TO BE FIXED -----------
00339   if (associators[ww]=="TrackAssociatorByChi2"){
00340     h_assochi2.push_back( dbe_->book1D("assocChi2","track association #chi^{2}",1000000,0,100000) );
00341     h_assochi2_prob.push_back(dbe_->book1D("assocChi2_prob","probability of association #chi^{2}",100,0,1));
00342   } else if (associators[ww]=="TrackAssociatorByHits"){
00343     h_assocFraction.push_back( dbe_->book1D("assocFraction","fraction of shared hits",200,0,2) );
00344     h_assocSharedHit.push_back(dbe_->book1D("assocSharedHit","number of shared hits",20,0,20));
00345   }
00346   */
00347   h_assocFraction.push_back( dbe_->book1D("assocFraction","fraction of shared hits",200,0,2) );
00348   h_assocSharedHit.push_back(dbe_->book1D("assocSharedHit","number of shared hits",20,0,20));
00349   // ----------------------
00350 
00351   chi2_vs_nhits.push_back( dbe_->book2D("chi2_vs_nhits","#chi^{2} vs nhits",25,0,25,100,0,10) );
00352   
00353   etares_vs_eta.push_back( dbe_->book2D("etares_vs_eta","etaresidue vs eta",nintEta,minEta,maxEta,200,-0.1,0.1) );
00354   nrec_vs_nsim.push_back( dbe_->book2D("nrec_vs_nsim","nrec vs nsim",20,-0.5,19.5,20,-0.5,19.5) );
00355   
00356   chi2_vs_eta.push_back( dbe_->book2D("chi2_vs_eta","chi2_vs_eta",nintEta,minEta,maxEta, 200, 0, 20 ));
00357   chi2_vs_phi.push_back( dbe_->book2D("chi2_vs_phi","#chi^{2} vs #phi",nintPhi,minPhi,maxPhi, 200, 0, 20 ) );
00358   
00359   nhits_vs_eta.push_back( dbe_->book2D("nhits_vs_eta","nhits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00360   nPXBhits_vs_eta.push_back( dbe_->book2D("nPXBhits_vs_eta","# PXB its vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00361   nPXFhits_vs_eta.push_back( dbe_->book2D("nPXFhits_vs_eta","# PXF hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00362   nTIBhits_vs_eta.push_back( dbe_->book2D("nTIBhits_vs_eta","# TIB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00363   nTIDhits_vs_eta.push_back( dbe_->book2D("nTIDhits_vs_eta","# TID hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00364   nTOBhits_vs_eta.push_back( dbe_->book2D("nTOBhits_vs_eta","# TOB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00365   nTEChits_vs_eta.push_back( dbe_->book2D("nTEChits_vs_eta","# TEC hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00366 
00367   nLayersWithMeas_vs_eta.push_back( dbe_->book2D("nLayersWithMeas_vs_eta","# Layers with measurement vs eta",
00368                                                 nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00369   nPXLlayersWithMeas_vs_eta.push_back( dbe_->book2D("nPXLlayersWithMeas_vs_eta","# PXL Layers with measurement vs eta",
00370                                                    nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00371   nSTRIPlayersWithMeas_vs_eta.push_back( dbe_->book2D("nSTRIPlayersWithMeas_vs_eta","# STRIP Layers with measurement vs eta",
00372                                                       nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00373   nSTRIPlayersWith1dMeas_vs_eta.push_back( dbe_->book2D("nSTRIPlayersWith1dMeas_vs_eta","# STRIP Layers with 1D measurement vs eta",
00374                                                         nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00375   nSTRIPlayersWith2dMeas_vs_eta.push_back( dbe_->book2D("nSTRIPlayersWith2dMeas_vs_eta","# STRIP Layers with 2D measurement vs eta",
00376                                                        nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00377   
00378   nhits_vs_phi.push_back( dbe_->book2D("nhits_vs_phi","#hits vs #phi",nintPhi,minPhi,maxPhi,nintHit,minHit,maxHit) );
00379   
00380   nlosthits_vs_eta.push_back( dbe_->book2D("nlosthits_vs_eta","nlosthits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00381   
00382   //resolution of track parameters
00383   //                       dPt/Pt    cotTheta        Phi            TIP            LIP
00384   // log10(pt)<0.5        100,0.1    240,0.08     100,0.015      100,0.1000    150,0.3000
00385   // 0.5<log10(pt)<1.5    100,0.1    120,0.01     100,0.003      100,0.0100    150,0.0500
00386   // >1.5                 100,0.3    100,0.005    100,0.0008     100,0.0060    120,0.0300
00387   
00388   ptres_vs_eta.push_back(dbe_->book2D("ptres_vs_eta","ptres_vs_eta",
00389                                       nintEta,minEta,maxEta, ptRes_nbin, ptRes_rangeMin, ptRes_rangeMax));
00390   
00391   ptres_vs_phi.push_back( dbe_->book2D("ptres_vs_phi","p_{t} res vs #phi",
00392                                        nintPhi,minPhi,maxPhi, ptRes_nbin, ptRes_rangeMin, ptRes_rangeMax));
00393   
00394   ptres_vs_pt.push_back(dbe_->book2D("ptres_vs_pt","ptres_vs_pt",nintPt,minPt,maxPt, ptRes_nbin, ptRes_rangeMin, ptRes_rangeMax));
00395   
00396   cotThetares_vs_eta.push_back(dbe_->book2D("cotThetares_vs_eta","cotThetares_vs_eta",
00397                                             nintEta,minEta,maxEta,cotThetaRes_nbin, cotThetaRes_rangeMin, cotThetaRes_rangeMax));
00398 
00399   
00400   cotThetares_vs_pt.push_back(dbe_->book2D("cotThetares_vs_pt","cotThetares_vs_pt",
00401                                            nintPt,minPt,maxPt, cotThetaRes_nbin, cotThetaRes_rangeMin, cotThetaRes_rangeMax));      
00402 
00403 
00404   phires_vs_eta.push_back(dbe_->book2D("phires_vs_eta","phires_vs_eta",
00405                                        nintEta,minEta,maxEta, phiRes_nbin, phiRes_rangeMin, phiRes_rangeMax));
00406 
00407   phires_vs_pt.push_back(dbe_->book2D("phires_vs_pt","phires_vs_pt",
00408                                       nintPt,minPt,maxPt, phiRes_nbin, phiRes_rangeMin, phiRes_rangeMax));
00409 
00410   phires_vs_phi.push_back(dbe_->book2D("phires_vs_phi","#phi res vs #phi",
00411                                        nintPhi,minPhi,maxPhi,phiRes_nbin, phiRes_rangeMin, phiRes_rangeMax));
00412 
00413   dxyres_vs_eta.push_back(dbe_->book2D("dxyres_vs_eta","dxyres_vs_eta",
00414                                        nintEta,minEta,maxEta,dxyRes_nbin, dxyRes_rangeMin, dxyRes_rangeMax));
00415   
00416   dxyres_vs_pt.push_back( dbe_->book2D("dxyres_vs_pt","dxyres_vs_pt",
00417                                        nintPt,minPt,maxPt,dxyRes_nbin, dxyRes_rangeMin, dxyRes_rangeMax));
00418   
00419   dzres_vs_eta.push_back(dbe_->book2D("dzres_vs_eta","dzres_vs_eta",
00420                                       nintEta,minEta,maxEta,dzRes_nbin, dzRes_rangeMin, dzRes_rangeMax));
00421 
00422   dzres_vs_pt.push_back(dbe_->book2D("dzres_vs_pt","dzres_vs_pt",nintPt,minPt,maxPt,dzRes_nbin, dzRes_rangeMin, dzRes_rangeMax));
00423   
00424   ptmean_vs_eta_phi.push_back(dbe_->bookProfile2D("ptmean_vs_eta_phi","mean p_{t} vs #eta and #phi",
00425                                                   nintPhi,minPhi,maxPhi,nintEta,minEta,maxEta,1000,0,1000));
00426   phimean_vs_eta_phi.push_back(dbe_->bookProfile2D("phimean_vs_eta_phi","mean #phi vs #eta and #phi",
00427                                                    nintPhi,minPhi,maxPhi,nintEta,minEta,maxEta,nintPhi,minPhi,maxPhi));
00428   
00429   //pulls of track params vs eta: to be used with fitslicesytool
00430   dxypull_vs_eta.push_back(dbe_->book2D("dxypull_vs_eta","dxypull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
00431   ptpull_vs_eta.push_back(dbe_->book2D("ptpull_vs_eta","ptpull_vs_eta",nintEta,minEta,maxEta,100,-10,10)); 
00432   dzpull_vs_eta.push_back(dbe_->book2D("dzpull_vs_eta","dzpull_vs_eta",nintEta,minEta,maxEta,100,-10,10)); 
00433   phipull_vs_eta.push_back(dbe_->book2D("phipull_vs_eta","phipull_vs_eta",nintEta,minEta,maxEta,100,-10,10)); 
00434   thetapull_vs_eta.push_back(dbe_->book2D("thetapull_vs_eta","thetapull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
00435   
00436   //      h_ptshiftetamean.push_back( dbe_->book1D("h_ptshifteta_Mean","<#deltapT/pT>[%] vs #eta",nintEta,minEta,maxEta) ); 
00437   
00438 
00439   //pulls of track params vs phi
00440   ptpull_vs_phi.push_back(dbe_->book2D("ptpull_vs_phi","p_{t} pull vs #phi",nintPhi,minPhi,maxPhi,100,-10,10)); 
00441   phipull_vs_phi.push_back(dbe_->book2D("phipull_vs_phi","#phi pull vs #phi",nintPhi,minPhi,maxPhi,100,-10,10)); 
00442   thetapull_vs_phi.push_back(dbe_->book2D("thetapull_vs_phi","#theta pull vs #phi",nintPhi,minPhi,maxPhi,100,-10,10));
00443 
00444   
00445   nrecHit_vs_nsimHit_sim2rec.push_back( dbe_->book2D("nrecHit_vs_nsimHit_sim2rec","nrecHit vs nsimHit (Sim2RecAssoc)",
00446                                                      nintHit,minHit,maxHit, nintHit,minHit,maxHit ));
00447   nrecHit_vs_nsimHit_rec2sim.push_back( dbe_->book2D("nrecHit_vs_nsimHit_rec2sim","nrecHit vs nsimHit (Rec2simAssoc)",
00448                                                      nintHit,minHit,maxHit, nintHit,minHit,maxHit ));
00449 
00450   // dE/dx stuff
00451   // FIXME: it would be nice to have an array
00452   h_dedx_estim1.push_back( dbe_->book1D("h_dedx_estim1","dE/dx estimator 1",nintDeDx,minDeDx,maxDeDx) ); 
00453   h_dedx_estim2.push_back( dbe_->book1D("h_dedx_estim2","dE/dx estimator 2",nintDeDx,minDeDx,maxDeDx) ); 
00454   h_dedx_nom1.push_back( dbe_->book1D("h_dedx_nom1","dE/dx number of measurements",nintHit,minHit,maxHit) ); 
00455   h_dedx_nom2.push_back( dbe_->book1D("h_dedx_nom2","dE/dx number of measurements",nintHit,minHit,maxHit) ); 
00456   h_dedx_sat1.push_back( dbe_->book1D("h_dedx_sat1","dE/dx number of measurements with saturation",nintHit,minHit,maxHit) ); 
00457   h_dedx_sat2.push_back( dbe_->book1D("h_dedx_sat2","dE/dx number of measurements with saturation",nintHit,minHit,maxHit) ); 
00458 
00459 
00460   if(useLogPt){
00461     BinLogX(dzres_vs_pt.back()->getTH2F());
00462     BinLogX(dxyres_vs_pt.back()->getTH2F());
00463     BinLogX(phires_vs_pt.back()->getTH2F());
00464     BinLogX(cotThetares_vs_pt.back()->getTH2F());
00465     BinLogX(ptres_vs_pt.back()->getTH2F());
00466     BinLogX(h_recopT.back()->getTH1F());
00467     BinLogX(h_assocpT.back()->getTH1F());
00468     BinLogX(h_assoc2pT.back()->getTH1F());
00469     BinLogX(h_simulpT.back()->getTH1F());
00470   }  
00471 }
00472 
00473 void MTVHistoProducerAlgoForTracker::bookRecoHistosForStandaloneRunning(){
00474   h_effic.push_back( dbe_->book1D("effic","efficiency vs #eta",nintEta,minEta,maxEta) );
00475   h_efficPt.push_back( dbe_->book1D("efficPt","efficiency vs pT",nintPt,minPt,maxPt) );
00476   h_effic_vs_hit.push_back( dbe_->book1D("effic_vs_hit","effic vs hit",nintHit,minHit,maxHit) );
00477   h_effic_vs_phi.push_back( dbe_->book1D("effic_vs_phi","effic vs phi",nintPhi,minPhi,maxPhi) );
00478   h_effic_vs_dxy.push_back( dbe_->book1D("effic_vs_dxy","effic vs dxy",nintDxy,minDxy,maxDxy) );
00479   h_effic_vs_dz.push_back( dbe_->book1D("effic_vs_dz","effic vs dz",nintDz,minDz,maxDz) );
00480   h_effic_vs_vertpos.push_back( dbe_->book1D("effic_vs_vertpos","effic vs vertpos",nintVertpos,minVertpos,maxVertpos) );
00481   h_effic_vs_zpos.push_back( dbe_->book1D("effic_vs_zpos","effic vs zpos",nintZpos,minZpos,maxZpos) );
00482 
00483   h_fakerate.push_back( dbe_->book1D("fakerate","fake rate vs #eta",nintEta,minEta,maxEta) );
00484   h_fakeratePt.push_back( dbe_->book1D("fakeratePt","fake rate vs pT",nintPt,minPt,maxPt) );
00485   h_fake_vs_hit.push_back( dbe_->book1D("fakerate_vs_hit","fake rate vs hit",nintHit,minHit,maxHit) );
00486   h_fake_vs_phi.push_back( dbe_->book1D("fakerate_vs_phi","fake vs phi",nintPhi,minPhi,maxPhi) );
00487   h_fake_vs_dxy.push_back( dbe_->book1D("fakerate_vs_dxy","fake rate vs dxy",nintDxy,minDxy,maxDxy) );
00488   h_fake_vs_dz.push_back( dbe_->book1D("fakerate_vs_dz","fake vs dz",nintDz,minDz,maxDz) );
00489 
00490   h_chi2meanhitsh.push_back( dbe_->bookProfile("chi2mean_vs_nhits","mean #chi^{2} vs nhits",25,0,25,100,0,10) );
00491   h_chi2meanh.push_back( dbe_->bookProfile("chi2mean","mean #chi^{2} vs #eta",nintEta,minEta,maxEta, 200, 0, 20) );
00492   h_chi2mean_vs_phi.push_back( dbe_->bookProfile("chi2mean_vs_phi","mean of #chi^{2} vs #phi",nintPhi,minPhi,maxPhi, 200, 0, 20) );
00493 
00494   h_hits_eta.push_back( dbe_->bookProfile("hits_eta","mean #hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00495   h_PXBhits_eta.push_back( dbe_->bookProfile("PXBhits_eta","mean # PXB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00496   h_PXFhits_eta.push_back( dbe_->bookProfile("PXFhits_eta","mean # PXF hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00497   h_TIBhits_eta.push_back( dbe_->bookProfile("TIBhits_eta","mean # TIB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00498   h_TIDhits_eta.push_back( dbe_->bookProfile("TIDhits_eta","mean # TID hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00499   h_TOBhits_eta.push_back( dbe_->bookProfile("TOBhits_eta","mean # TOB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00500   h_TEChits_eta.push_back( dbe_->bookProfile("TEChits_eta","mean # TEC hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00501 
00502   h_LayersWithMeas_eta.push_back(dbe_->bookProfile("LayersWithMeas_eta","mean # LayersWithMeas vs eta",
00503                            nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00504   h_PXLlayersWithMeas_eta.push_back(dbe_->bookProfile("PXLlayersWith2dMeas_eta","mean # PXLlayersWithMeas vs eta",
00505                               nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00506   h_STRIPlayersWithMeas_eta.push_back(dbe_->bookProfile("STRIPlayersWithMeas_eta","mean # STRIPlayersWithMeas vs eta",
00507                             nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00508   h_STRIPlayersWith1dMeas_eta.push_back(dbe_->bookProfile("STRIPlayersWith1dMeas_eta","mean # STRIPlayersWith1dMeas vs eta",
00509                               nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00510   h_STRIPlayersWith2dMeas_eta.push_back(dbe_->bookProfile("STRIPlayersWith2dMeas_eta","mean # STRIPlayersWith2dMeas vs eta",
00511                               nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00512   h_hits_phi.push_back( dbe_->bookProfile("hits_phi","mean #hits vs #phi",nintPhi,minPhi,maxPhi, nintHit,minHit,maxHit) );
00513   h_losthits_eta.push_back( dbe_->bookProfile("losthits_eta","losthits_eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit) );
00514 
00515   h_ptrmsh.push_back( dbe_->book1D("ptres_vs_eta_Sigma","#sigma(#deltap_{t}/p_{t}) vs #eta",nintEta,minEta,maxEta) );
00516   h_ptmeanhPhi.push_back( dbe_->book1D("ptres_vs_phi_Mean","mean of p_{t} resolution vs #phi",nintPhi,minPhi,maxPhi));
00517   h_ptrmshPhi.push_back( dbe_->book1D("ptres_vs_phi_Sigma","#sigma(#deltap_{t}/p_{t}) vs #phi",nintPhi,minPhi,maxPhi) );
00518   h_ptmeanhPt.push_back( dbe_->book1D("ptres_vs_pt_Mean","mean of p_{t} resolution vs p_{t}",nintPt,minPt,maxPt));
00519   h_ptrmshPt.push_back( dbe_->book1D("ptres_vs_pt_Sigma","#sigma(#deltap_{t}/p_{t}) vs pT",nintPt,minPt,maxPt) );
00520   h_cotThetameanh.push_back( dbe_->book1D("cotThetares_vs_eta_Mean","#sigma(cot(#theta)) vs #eta Mean",nintEta,minEta,maxEta) );
00521   h_cotThetarmsh.push_back( dbe_->book1D("cotThetares_vs_eta_Sigma","#sigma(cot(#theta)) vs #eta Sigma",nintEta,minEta,maxEta) );
00522   h_cotThetameanhPt.push_back( dbe_->book1D("cotThetares_vs_pt_Mean","#sigma(cot(#theta)) vs pT Mean",nintPt,minPt,maxPt) );
00523   h_cotThetarmshPt.push_back( dbe_->book1D("cotThetares_vs_pt_Sigma","#sigma(cot(#theta)) vs pT Sigma",nintPt,minPt,maxPt) );
00524   h_phimeanh.push_back(dbe_->book1D("phires_vs_eta_Mean","mean of #phi res vs #eta",nintEta,minEta,maxEta));
00525   h_phirmsh.push_back( dbe_->book1D("phires_vs_eta_Sigma","#sigma(#delta#phi) vs #eta",nintEta,minEta,maxEta) );
00526   h_phimeanhPt.push_back(dbe_->book1D("phires_vs_pt_Mean","mean of #phi res vs pT",nintPt,minPt,maxPt));
00527   h_phirmshPt.push_back( dbe_->book1D("phires_vs_pt_Sigma","#sigma(#delta#phi) vs pT",nintPt,minPt,maxPt) );
00528   h_phimeanhPhi.push_back(dbe_->book1D("phires_vs_phi_Mean","mean of #phi res vs #phi",nintPhi,minPhi,maxPhi));
00529   h_phirmshPhi.push_back( dbe_->book1D("phires_vs_phi_Sigma","#sigma(#delta#phi) vs #phi",nintPhi,minPhi,maxPhi) );
00530   h_dxymeanh.push_back( dbe_->book1D("dxyres_vs_eta_Mean","mean of dxyres vs #eta",nintEta,minEta,maxEta) );
00531   h_dxyrmsh.push_back( dbe_->book1D("dxyres_vs_eta_Sigma","#sigma(#deltadxy) vs #eta",nintEta,minEta,maxEta) );
00532   h_dxymeanhPt.push_back( dbe_->book1D("dxyres_vs_pt_Mean","mean of dxyres vs pT",nintPt,minPt,maxPt) );
00533   h_dxyrmshPt.push_back( dbe_->book1D("dxyres_vs_pt_Sigma","#sigmadxy vs pT",nintPt,minPt,maxPt) );
00534   h_dzmeanh.push_back( dbe_->book1D("dzres_vs_eta_Mean","mean of dzres vs #eta",nintEta,minEta,maxEta) );
00535   h_dzrmsh.push_back( dbe_->book1D("dzres_vs_eta_Sigma","#sigma(#deltadz) vs #eta",nintEta,minEta,maxEta) );
00536   h_dzmeanhPt.push_back( dbe_->book1D("dzres_vs_pt_Mean","mean of dzres vs pT",nintPt,minPt,maxPt) );
00537   h_dzrmshPt.push_back( dbe_->book1D("dzres_vs_pt_Sigma","#sigma(#deltadz vs pT",nintPt,minPt,maxPt) );
00538   h_dxypulletamean.push_back( dbe_->book1D("h_dxypulleta_Mean","mean of dxy pull vs #eta",nintEta,minEta,maxEta) ); 
00539   h_ptpulletamean.push_back( dbe_->book1D("h_ptpulleta_Mean","mean of p_{t} pull vs #eta",nintEta,minEta,maxEta) ); 
00540   h_dzpulletamean.push_back( dbe_->book1D("h_dzpulleta_Mean","mean of dz pull vs #eta",nintEta,minEta,maxEta) ); 
00541   h_phipulletamean.push_back( dbe_->book1D("h_phipulleta_Mean","mean of #phi pull vs #eta",nintEta,minEta,maxEta) ); 
00542   h_thetapulletamean.push_back( dbe_->book1D("h_thetapulleta_Mean","mean of #theta pull vs #eta",nintEta,minEta,maxEta) );
00543   h_dxypulleta.push_back( dbe_->book1D("h_dxypulleta_Sigma","#sigma of dxy pull vs #eta",nintEta,minEta,maxEta) ); 
00544   h_ptpulleta.push_back( dbe_->book1D("h_ptpulleta_Sigma","#sigma of p_{t} pull vs #eta",nintEta,minEta,maxEta) ); 
00545   h_dzpulleta.push_back( dbe_->book1D("h_dzpulleta_Sigma","#sigma of dz pull vs #eta",nintEta,minEta,maxEta) ); 
00546   h_phipulleta.push_back( dbe_->book1D("h_phipulleta_Sigma","#sigma of #phi pull vs #eta",nintEta,minEta,maxEta) ); 
00547   h_thetapulleta.push_back( dbe_->book1D("h_thetapulleta_Sigma","#sigma of #theta pull vs #eta",nintEta,minEta,maxEta) );
00548   h_ptshifteta.push_back( dbe_->book1D("ptres_vs_eta_Mean","<#deltapT/pT>[%] vs #eta",nintEta,minEta,maxEta) ); 
00549   h_ptpullphimean.push_back( dbe_->book1D("h_ptpullphi_Mean","mean of p_{t} pull vs #phi",nintPhi,minPhi,maxPhi) ); 
00550   h_phipullphimean.push_back( dbe_->book1D("h_phipullphi_Mean","mean of #phi pull vs #phi",nintPhi,minPhi,maxPhi) );
00551   h_thetapullphimean.push_back( dbe_->book1D("h_thetapullphi_Mean","mean of #theta pull vs #phi",nintPhi,minPhi,maxPhi) );
00552   h_ptpullphi.push_back( dbe_->book1D("h_ptpullphi_Sigma","#sigma of p_{t} pull vs #phi",nintPhi,minPhi,maxPhi) ); 
00553   h_phipullphi.push_back( dbe_->book1D("h_phipullphi_Sigma","#sigma of #phi pull vs #phi",nintPhi,minPhi,maxPhi) );
00554   h_thetapullphi.push_back( dbe_->book1D("h_thetapullphi_Sigma","#sigma of #theta pull vs #phi",nintPhi,minPhi,maxPhi) );
00555   
00556   if(useLogPt){
00557     BinLogX(h_dzmeanhPt.back()->getTH1F());
00558     BinLogX(h_dzrmshPt.back()->getTH1F());
00559     BinLogX(h_dxymeanhPt.back()->getTH1F());
00560     BinLogX(h_dxyrmshPt.back()->getTH1F());
00561     BinLogX(h_phimeanhPt.back()->getTH1F());
00562     BinLogX(h_phirmshPt.back()->getTH1F());
00563     BinLogX(h_cotThetameanhPt.back()->getTH1F());
00564     BinLogX(h_cotThetarmshPt.back()->getTH1F());
00565     BinLogX(h_ptmeanhPt.back()->getTH1F());
00566     BinLogX(h_ptrmshPt.back()->getTH1F());
00567     BinLogX(h_efficPt.back()->getTH1F());
00568     BinLogX(h_fakeratePt.back()->getTH1F());
00569   }    
00570 }
00571 
00572 void MTVHistoProducerAlgoForTracker::fill_generic_simTrack_histos(int count,
00573                                                                   ParticleBase::Vector momentumTP,
00574                                                                   ParticleBase::Point vertexTP){
00575   h_ptSIM[count]->Fill(sqrt(momentumTP.perp2()));
00576   h_etaSIM[count]->Fill(momentumTP.eta());
00577   h_vertposSIM[count]->Fill(sqrt(vertexTP.perp2()));
00578 }
00579 
00580 
00581 
00582 // TO BE FIXED USING PLAIN HISTOGRAMS INSTEAD OF RE-IMPLEMENTATION OF HISTOGRAMS (i.d. vectors<int/double>)
00583 void MTVHistoProducerAlgoForTracker::fill_recoAssociated_simTrack_histos(int count,
00584                                                                          const TrackingParticle& tp,
00585                                                                          ParticleBase::Vector momentumTP,
00586                                                                          ParticleBase::Point vertexTP,
00587                                                                          double dxySim, double dzSim, int nSimHits,
00588                                                                          const reco::Track* track){
00589   bool isMatched = track;
00590 
00591   if((*TpSelectorForEfficiencyVsEta)(tp)){
00592     //effic vs hits
00593     int nSimHitsInBounds = std::min((int)nSimHits,int(maxHit-1));
00594     totSIM_hit[count][nSimHitsInBounds]++;
00595     if(isMatched) {
00596       totASS_hit[count][nSimHitsInBounds]++;
00597       nrecHit_vs_nsimHit_sim2rec[count]->Fill( track->numberOfValidHits(),nSimHits);
00598     }
00599 
00600     //effic vs eta
00601     for (unsigned int f=0; f<etaintervals[count].size()-1; f++){
00602       if (getEta(momentumTP.eta())>etaintervals[count][f]&&
00603           getEta(momentumTP.eta())<etaintervals[count][f+1]) {
00604         totSIMeta[count][f]++;
00605         if (isMatched) {
00606           totASSeta[count][f]++;
00607         }
00608       }
00609     } // END for (unsigned int f=0; f<etaintervals[w].size()-1; f++){
00610   }
00611 
00612   if((*TpSelectorForEfficiencyVsPhi)(tp)){
00613     for (unsigned int f=0; f<phiintervals[count].size()-1; f++){
00614       if (momentumTP.phi() > phiintervals[count][f]&&
00615           momentumTP.phi() <phiintervals[count][f+1]) {
00616         totSIM_phi[count][f]++;
00617         if (isMatched) {
00618           totASS_phi[count][f]++;
00619         }
00620       }
00621     } // END for (unsigned int f=0; f<phiintervals[count].size()-1; f++){
00622   }
00623         
00624   if((*TpSelectorForEfficiencyVsPt)(tp)){
00625     for (unsigned int f=0; f<pTintervals[count].size()-1; f++){
00626       if (getPt(sqrt(momentumTP.perp2()))>pTintervals[count][f]&&
00627           getPt(sqrt(momentumTP.perp2()))<pTintervals[count][f+1]) {
00628         totSIMpT[count][f]++;
00629         if (isMatched) {
00630           totASSpT[count][f]++;
00631         }
00632       }
00633     } // END for (unsigned int f=0; f<pTintervals[count].size()-1; f++){
00634   }     
00635 
00636   if((*TpSelectorForEfficiencyVsVTXR)(tp)){
00637     for (unsigned int f=0; f<dxyintervals[count].size()-1; f++){
00638       if (dxySim>dxyintervals[count][f]&&
00639           dxySim<dxyintervals[count][f+1]) {
00640         totSIM_dxy[count][f]++;
00641         if (isMatched) {
00642           totASS_dxy[count][f]++;
00643         }
00644       }
00645     } // END for (unsigned int f=0; f<dxyintervals[count].size()-1; f++){
00646 
00647     for (unsigned int f=0; f<vertposintervals[count].size()-1; f++){
00648       if (sqrt(vertexTP.perp2())>vertposintervals[count][f]&&
00649           sqrt(vertexTP.perp2())<vertposintervals[count][f+1]) {
00650         totSIM_vertpos[count][f]++;
00651         if (isMatched) {
00652           totASS_vertpos[count][f]++;
00653         }
00654       }
00655     } // END for (unsigned int f=0; f<vertposintervals[count].size()-1; f++){
00656   }
00657 
00658   if((*TpSelectorForEfficiencyVsVTXZ)(tp)){
00659     for (unsigned int f=0; f<dzintervals[count].size()-1; f++){
00660       if (dzSim>dzintervals[count][f]&&
00661           dzSim<dzintervals[count][f+1]) {
00662         totSIM_dz[count][f]++;
00663         if (isMatched) {
00664           totASS_dz[count][f]++;
00665         }
00666       }
00667     } // END for (unsigned int f=0; f<dzintervals[count].size()-1; f++){
00668 
00669   
00670     for (unsigned int f=0; f<zposintervals[count].size()-1; f++){
00671       if (vertexTP.z()>zposintervals[count][f]&&
00672           vertexTP.z()<zposintervals[count][f+1]) {
00673         totSIM_zpos[count][f]++;
00674         if (isMatched) {
00675           totASS_zpos[count][f]++;
00676         }
00677       }
00678     } // END for (unsigned int f=0; f<zposintervals[count].size()-1; f++){
00679   }
00680 
00681 }
00682 
00683 // dE/dx
00684 void MTVHistoProducerAlgoForTracker::fill_dedx_recoTrack_histos(int count, edm::RefToBase<reco::Track>& trackref, std::vector< edm::ValueMap<reco::DeDxData> > v_dEdx) {
00685 //void MTVHistoProducerAlgoForTracker::fill_dedx_recoTrack_histos(reco::TrackRef trackref, std::vector< edm::ValueMap<reco::DeDxData> > v_dEdx) {
00686   double dedx;
00687   int nom;
00688   int sat;
00689   edm::ValueMap<reco::DeDxData> dEdxTrack;
00690   for (unsigned int i=0; i<v_dEdx.size(); i++) {
00691     dEdxTrack = v_dEdx.at(i);
00692     dedx = dEdxTrack[trackref].dEdx(); 
00693     nom  = dEdxTrack[trackref].numberOfMeasurements();
00694     sat  = dEdxTrack[trackref].numberOfSaturatedMeasurements();
00695     if (i==0) {
00696       h_dedx_estim1[count]->Fill(dedx);
00697       h_dedx_nom1[count]->Fill(nom);
00698       h_dedx_sat1[count]->Fill(sat);
00699     } else if (i==1) {
00700       h_dedx_estim2[count]->Fill(dedx);
00701       h_dedx_nom2[count]->Fill(nom);
00702       h_dedx_sat2[count]->Fill(sat);
00703     }
00704   }
00705 }
00706 
00707 
00708 // TO BE FIXED USING PLAIN HISTOGRAMS INSTEAD OF RE-IMPLEMENTATION OF HISTOGRAMS (i.d. vectors<int/double>)
00709 void MTVHistoProducerAlgoForTracker::fill_generic_recoTrack_histos(int count,
00710                                                                    const reco::Track& track,
00711                                                                    math::XYZPoint bsPosition,
00712                                                                    bool isMatched){
00713 
00714   //Compute fake rate vs eta
00715   for (unsigned int f=0; f<etaintervals[count].size()-1; f++){
00716     if (getEta(track.momentum().eta())>etaintervals[count][f]&&
00717         getEta(track.momentum().eta())<etaintervals[count][f+1]) {
00718       totRECeta[count][f]++; 
00719       if (isMatched) {
00720         totASS2eta[count][f]++;
00721       }
00722     }
00723   } // End for (unsigned int f=0; f<etaintervals[count].size()-1; f++){
00724 
00725   for (unsigned int f=0; f<phiintervals[count].size()-1; f++){
00726     if (track.momentum().phi()>phiintervals[count][f]&&
00727         track.momentum().phi()<phiintervals[count][f+1]) {
00728       totREC_phi[count][f]++; 
00729       if (isMatched) {
00730         totASS2_phi[count][f]++;
00731       }         
00732     }
00733   } // End for (unsigned int f=0; f<phiintervals[count].size()-1; f++){
00734 
00735         
00736   for (unsigned int f=0; f<pTintervals[count].size()-1; f++){
00737     if (getPt(sqrt(track.momentum().perp2()))>pTintervals[count][f]&&
00738         getPt(sqrt(track.momentum().perp2()))<pTintervals[count][f+1]) {
00739       totRECpT[count][f]++; 
00740       if (isMatched) {
00741         totASS2pT[count][f]++;
00742       }       
00743     }
00744   } // End for (unsigned int f=0; f<pTintervals[count].size()-1; f++){
00745   
00746   for (unsigned int f=0; f<dxyintervals[count].size()-1; f++){
00747     if (track.dxy(bsPosition)>dxyintervals[count][f]&&
00748         track.dxy(bsPosition)<dxyintervals[count][f+1]) {
00749       totREC_dxy[count][f]++; 
00750       if (isMatched) {
00751         totASS2_dxy[count][f]++;
00752       }       
00753     }
00754   } // End for (unsigned int f=0; f<dxyintervals[count].size()-1; f++){
00755   
00756   for (unsigned int f=0; f<dzintervals[count].size()-1; f++){
00757     if (track.dz(bsPosition)>dzintervals[count][f]&&
00758         track.dz(bsPosition)<dzintervals[count][f+1]) {
00759       totREC_dz[count][f]++; 
00760       if (isMatched) {
00761         totASS2_dz[count][f]++;
00762       }       
00763     }
00764   } // End for (unsigned int f=0; f<dzintervals[count].size()-1; f++){
00765 
00766   int tmp = std::min((int)track.found(),int(maxHit-1));
00767   totREC_hit[count][tmp]++;
00768   if (isMatched) totASS2_hit[count][tmp]++;
00769 
00770 }
00771 
00772 
00773 void MTVHistoProducerAlgoForTracker::fill_simAssociated_recoTrack_histos(int count,
00774                                                                          const reco::Track& track){
00775     //nchi2 and hits global distributions
00776     h_nchi2[count]->Fill(track.normalizedChi2());
00777     h_nchi2_prob[count]->Fill(TMath::Prob(track.chi2(),(int)track.ndof()));
00778     h_hits[count]->Fill(track.numberOfValidHits());
00779     h_losthits[count]->Fill(track.numberOfLostHits());
00780     chi2_vs_nhits[count]->Fill(track.numberOfValidHits(),track.normalizedChi2());
00781     h_charge[count]->Fill( track.charge() );
00782     
00783     //chi2 and #hit vs eta: fill 2D histos
00784     chi2_vs_eta[count]->Fill(getEta(track.eta()),track.normalizedChi2());
00785     nhits_vs_eta[count]->Fill(getEta(track.eta()),track.numberOfValidHits());
00786     nPXBhits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidPixelBarrelHits());
00787     nPXFhits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidPixelEndcapHits());
00788     nTIBhits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidStripTIBHits());
00789     nTIDhits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidStripTIDHits());
00790     nTOBhits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidStripTOBHits());
00791     nTEChits_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().numberOfValidStripTECHits());
00792     nLayersWithMeas_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().trackerLayersWithMeasurement());
00793     nPXLlayersWithMeas_vs_eta[count]->Fill(getEta(track.eta()),track.hitPattern().pixelLayersWithMeasurement());
00794     int LayersAll = track.hitPattern().stripLayersWithMeasurement();
00795     int Layers2D = track.hitPattern().numberOfValidStripLayersWithMonoAndStereo(); 
00796     int Layers1D = LayersAll - Layers2D;        
00797     nSTRIPlayersWithMeas_vs_eta[count]->Fill(getEta(track.eta()),LayersAll);
00798     nSTRIPlayersWith1dMeas_vs_eta[count]->Fill(getEta(track.eta()),Layers1D);
00799     nSTRIPlayersWith2dMeas_vs_eta[count]->Fill(getEta(track.eta()),Layers2D);
00800         
00801     nlosthits_vs_eta[count]->Fill(getEta(track.eta()),track.numberOfLostHits());
00802 }
00803 
00804 
00805 
00806 void MTVHistoProducerAlgoForTracker::fill_ResoAndPull_recoTrack_histos(int count,
00807                                                                        ParticleBase::Vector momentumTP,
00808                                                                        ParticleBase::Point vertexTP,
00809                                                                        int chargeTP,
00810                                                                        const reco::Track& track,
00811                                                                        math::XYZPoint bsPosition){
00812 
00813   // evaluation of TP parameters
00814   double qoverpSim = chargeTP/sqrt(momentumTP.x()*momentumTP.x()+momentumTP.y()*momentumTP.y()+momentumTP.z()*momentumTP.z());
00815   double lambdaSim = M_PI/2-momentumTP.theta();
00816   double phiSim    = momentumTP.phi();
00817   double dxySim    = (-vertexTP.x()*sin(momentumTP.phi())+vertexTP.y()*cos(momentumTP.phi()));
00818   double dzSim     = vertexTP.z() - (vertexTP.x()*momentumTP.x()+vertexTP.y()*momentumTP.y())/sqrt(momentumTP.perp2()) 
00819     * momentumTP.z()/sqrt(momentumTP.perp2());
00820 
00821           
00822   reco::Track::ParameterVector rParameters = track.parameters();
00823   
00824   double qoverpRec(0);
00825   double qoverpErrorRec(0); 
00826   double ptRec(0);
00827   double ptErrorRec(0);
00828   double lambdaRec(0); 
00829   double lambdaErrorRec(0);
00830   double phiRec(0);
00831   double phiErrorRec(0);
00832 
00833   /* TO BE FIXED LATER  -----------
00834   //loop to decide whether to take gsfTrack (utilisation of mode-function) or common track
00835   const GsfTrack* gsfTrack(0);
00836   if(useGsf){
00837     gsfTrack = dynamic_cast<const GsfTrack*>(&(*track));
00838     if (gsfTrack==0) edm::LogInfo("TrackValidator") << "Trying to access mode for a non-GsfTrack";
00839   }
00840   
00841   if (gsfTrack) {
00842     // get values from mode
00843     getRecoMomentum(*gsfTrack, ptRec, ptErrorRec, qoverpRec, qoverpErrorRec, 
00844                     lambdaRec,lambdaErrorRec, phiRec, phiErrorRec); 
00845   }
00846          
00847   else {
00848     // get values from track (without mode) 
00849     getRecoMomentum(*track, ptRec, ptErrorRec, qoverpRec, qoverpErrorRec, 
00850                     lambdaRec,lambdaErrorRec, phiRec, phiErrorRec); 
00851   }
00852   */
00853   getRecoMomentum(track, ptRec, ptErrorRec, qoverpRec, qoverpErrorRec, 
00854                   lambdaRec,lambdaErrorRec, phiRec, phiErrorRec); 
00855   // -------------
00856 
00857   double ptError = ptErrorRec;  
00858   double ptres=ptRec-sqrt(momentumTP.perp2()); 
00859   double etares=track.eta()-momentumTP.Eta();
00860 
00861 
00862   double dxyRec    = track.dxy(bsPosition);
00863   double dzRec     = track.dz(bsPosition);
00864 
00865   // eta residue; pt, k, theta, phi, dxy, dz pulls
00866   double qoverpPull=(qoverpRec-qoverpSim)/qoverpErrorRec;
00867   double thetaPull=(lambdaRec-lambdaSim)/lambdaErrorRec;
00868   double phiPull=(phiRec-phiSim)/phiErrorRec;
00869   double dxyPull=(dxyRec-dxySim)/track.dxyError();
00870   double dzPull=(dzRec-dzSim)/track.dzError();
00871 
00872   double contrib_Qoverp = ((qoverpRec-qoverpSim)/qoverpErrorRec)*
00873     ((qoverpRec-qoverpSim)/qoverpErrorRec)/5;
00874   double contrib_dxy = ((dxyRec-dxySim)/track.dxyError())*((dxyRec-dxySim)/track.dxyError())/5;
00875   double contrib_dz = ((dzRec-dzSim)/track.dzError())*((dzRec-dzSim)/track.dzError())/5;
00876   double contrib_theta = ((lambdaRec-lambdaSim)/lambdaErrorRec)*
00877     ((lambdaRec-lambdaSim)/lambdaErrorRec)/5;
00878   double contrib_phi = ((phiRec-phiSim)/phiErrorRec)*
00879     ((phiRec-phiSim)/phiErrorRec)/5;
00880 
00881   LogTrace("TrackValidatorTEST") 
00882     //<< "assocChi2=" << tp.begin()->second << "\n"
00883     << "" <<  "\n"
00884     << "ptREC=" << ptRec << "\n" << "etaREC=" << track.eta() << "\n" << "qoverpREC=" << qoverpRec << "\n"
00885     << "dxyREC=" << dxyRec << "\n" << "dzREC=" << dzRec << "\n"
00886     << "thetaREC=" << track.theta() << "\n" << "phiREC=" << phiRec << "\n"
00887     << "" <<  "\n"
00888     << "qoverpError()=" << qoverpErrorRec << "\n" << "dxyError()=" << track.dxyError() << "\n"<< "dzError()=" 
00889     << track.dzError() << "\n"
00890     << "thetaError()=" << lambdaErrorRec << "\n" << "phiError()=" << phiErrorRec << "\n"
00891     << "" <<  "\n"
00892     << "ptSIM=" << sqrt(momentumTP.perp2()) << "\n"<< "etaSIM=" << momentumTP.Eta() << "\n"<< "qoverpSIM=" << qoverpSim << "\n"
00893     << "dxySIM=" << dxySim << "\n"<< "dzSIM=" << dzSim << "\n" << "thetaSIM=" << M_PI/2-lambdaSim << "\n" 
00894     << "phiSIM=" << phiSim << "\n"
00895     << "" << "\n"
00896     << "contrib_Qoverp=" << contrib_Qoverp << "\n"<< "contrib_dxy=" << contrib_dxy << "\n"<< "contrib_dz=" << contrib_dz << "\n"
00897     << "contrib_theta=" << contrib_theta << "\n"<< "contrib_phi=" << contrib_phi << "\n"
00898     << "" << "\n"
00899     <<"chi2PULL="<<contrib_Qoverp+contrib_dxy+contrib_dz+contrib_theta+contrib_phi<<"\n";
00900 
00901   h_pullQoverp[count]->Fill(qoverpPull);
00902   h_pullTheta[count]->Fill(thetaPull);
00903   h_pullPhi[count]->Fill(phiPull);
00904   h_pullDxy[count]->Fill(dxyPull);
00905   h_pullDz[count]->Fill(dzPull);
00906 
00907 
00908   h_pt[count]->Fill(ptres/ptError);
00909   h_eta[count]->Fill(etares);
00910   etares_vs_eta[count]->Fill(getEta(track.eta()),etares);
00911   
00912 
00913         
00914   //resolution of track params: fill 2D histos
00915   dxyres_vs_eta[count]->Fill(getEta(track.eta()),dxyRec-dxySim);
00916   ptres_vs_eta[count]->Fill(getEta(track.eta()),(ptRec-sqrt(momentumTP.perp2()))/ptRec);
00917   dzres_vs_eta[count]->Fill(getEta(track.eta()),dzRec-dzSim);
00918   phires_vs_eta[count]->Fill(getEta(track.eta()),phiRec-phiSim);
00919   cotThetares_vs_eta[count]->Fill(getEta(track.eta()),1/tan(M_PI*0.5-lambdaRec)-1/tan(M_PI*0.5-lambdaSim));         
00920   
00921   //same as before but vs pT
00922   dxyres_vs_pt[count]->Fill(getPt(ptRec),dxyRec-dxySim);
00923   ptres_vs_pt[count]->Fill(getPt(ptRec),(ptRec-sqrt(momentumTP.perp2()))/ptRec);
00924   dzres_vs_pt[count]->Fill(getPt(ptRec),dzRec-dzSim);
00925   phires_vs_pt[count]->Fill(getPt(ptRec),phiRec-phiSim);
00926   cotThetares_vs_pt[count]->Fill(getPt(ptRec),1/tan(M_PI*0.5-lambdaRec)-1/tan(M_PI*0.5-lambdaSim));      
00927         
00928   //pulls of track params vs eta: fill 2D histos
00929   dxypull_vs_eta[count]->Fill(getEta(track.eta()),dxyPull);
00930   ptpull_vs_eta[count]->Fill(getEta(track.eta()),ptres/ptError);
00931   dzpull_vs_eta[count]->Fill(getEta(track.eta()),dzPull);
00932   phipull_vs_eta[count]->Fill(getEta(track.eta()),phiPull);
00933   thetapull_vs_eta[count]->Fill(getEta(track.eta()),thetaPull);
00934         
00935   //plots vs phi
00936   nhits_vs_phi[count]->Fill(phiRec,track.numberOfValidHits());
00937   chi2_vs_phi[count]->Fill(phiRec,track.normalizedChi2());
00938   ptmean_vs_eta_phi[count]->Fill(phiRec,getEta(track.eta()),ptRec);
00939   phimean_vs_eta_phi[count]->Fill(phiRec,getEta(track.eta()),phiRec);
00940   ptres_vs_phi[count]->Fill(phiRec,(ptRec-sqrt(momentumTP.perp2()))/ptRec);
00941   phires_vs_phi[count]->Fill(phiRec,phiRec-phiSim); 
00942   ptpull_vs_phi[count]->Fill(phiRec,ptres/ptError);
00943   phipull_vs_phi[count]->Fill(phiRec,phiPull); 
00944   thetapull_vs_phi[count]->Fill(phiRec,thetaPull); 
00945 
00946 
00947 }
00948 
00949 
00950 
00951 void 
00952 MTVHistoProducerAlgoForTracker::getRecoMomentum (const reco::Track& track, double& pt, double& ptError,
00953                                                  double& qoverp, double& qoverpError, double& lambda,double& lambdaError,
00954                                                  double& phi, double& phiError ) const {
00955   pt = track.pt();
00956   ptError = track.ptError();
00957   qoverp = track.qoverp();
00958   qoverpError = track.qoverpError();
00959   lambda = track.lambda();
00960   lambdaError = track.lambdaError(); 
00961   phi = track.phi(); 
00962   phiError = track.phiError();
00963   //   cout <<"test1" << endl; 
00964   
00965 
00966 
00967 }
00968 
00969 void 
00970 MTVHistoProducerAlgoForTracker::getRecoMomentum (const reco::GsfTrack& gsfTrack, double& pt, double& ptError,
00971                                                  double& qoverp, double& qoverpError, double& lambda,double& lambdaError,
00972                                                  double& phi, double& phiError  ) const {
00973 
00974   pt = gsfTrack.ptMode();
00975   ptError = gsfTrack.ptModeError();
00976   qoverp = gsfTrack.qoverpMode();
00977   qoverpError = gsfTrack.qoverpModeError();
00978   lambda = gsfTrack.lambdaMode();
00979   lambdaError = gsfTrack.lambdaModeError(); 
00980   phi = gsfTrack.phiMode(); 
00981   phiError = gsfTrack.phiModeError();
00982   //   cout <<"test2" << endl;
00983 
00984 }
00985 
00986 double 
00987 MTVHistoProducerAlgoForTracker::getEta(double eta) {
00988   if (useFabsEta) return fabs(eta);
00989   else return eta;
00990 }
00991   
00992 double 
00993 MTVHistoProducerAlgoForTracker::getPt(double pt) {
00994   if (useInvPt && pt!=0) return 1/pt;
00995   else return pt;
00996 }
00997 
00998 
00999 void MTVHistoProducerAlgoForTracker::finalHistoFits(int counter){
01000   //resolution of track params: get sigma from 2D histos
01001   FitSlicesYTool fsyt_dxy(dxyres_vs_eta[counter]);
01002   fsyt_dxy.getFittedSigmaWithError(h_dxyrmsh[counter]);
01003   fsyt_dxy.getFittedMeanWithError(h_dxymeanh[counter]);
01004   FitSlicesYTool fsyt_dxyPt(dxyres_vs_pt[counter]);
01005   fsyt_dxyPt.getFittedSigmaWithError(h_dxyrmshPt[counter]);
01006   fsyt_dxyPt.getFittedMeanWithError(h_dxymeanhPt[counter]);
01007   FitSlicesYTool fsyt_pt(ptres_vs_eta[counter]);
01008   fsyt_pt.getFittedSigmaWithError(h_ptrmsh[counter]);
01009   fsyt_pt.getFittedMeanWithError(h_ptshifteta[counter]);      
01010   FitSlicesYTool fsyt_ptPt(ptres_vs_pt[counter]);
01011   fsyt_ptPt.getFittedSigmaWithError(h_ptrmshPt[counter]);
01012   fsyt_ptPt.getFittedMeanWithError(h_ptmeanhPt[counter]);
01013   FitSlicesYTool fsyt_ptPhi(ptres_vs_phi[counter]); 
01014   fsyt_ptPhi.getFittedSigmaWithError(h_ptrmshPhi[counter]);
01015   fsyt_ptPhi.getFittedMeanWithError(h_ptmeanhPhi[counter]);
01016   FitSlicesYTool fsyt_dz(dzres_vs_eta[counter]);
01017   fsyt_dz.getFittedSigmaWithError(h_dzrmsh[counter]);
01018   fsyt_dz.getFittedMeanWithError(h_dzmeanh[counter]);
01019   FitSlicesYTool fsyt_dzPt(dzres_vs_pt[counter]);
01020   fsyt_dzPt.getFittedSigmaWithError(h_dzrmshPt[counter]);
01021   fsyt_dzPt.getFittedMeanWithError(h_dzmeanhPt[counter]);
01022   FitSlicesYTool fsyt_phi(phires_vs_eta[counter]);
01023   fsyt_phi.getFittedSigmaWithError(h_phirmsh[counter]);
01024   fsyt_phi.getFittedMeanWithError(h_phimeanh[counter]);
01025   FitSlicesYTool fsyt_phiPt(phires_vs_pt[counter]);
01026   fsyt_phiPt.getFittedSigmaWithError(h_phirmshPt[counter]);
01027   fsyt_phiPt.getFittedMeanWithError(h_phimeanhPt[counter]);
01028   FitSlicesYTool fsyt_phiPhi(phires_vs_phi[counter]); 
01029   fsyt_phiPhi.getFittedSigmaWithError(h_phirmshPhi[counter]); 
01030   fsyt_phiPhi.getFittedMeanWithError(h_phimeanhPhi[counter]); 
01031   FitSlicesYTool fsyt_cotTheta(cotThetares_vs_eta[counter]);
01032   fsyt_cotTheta.getFittedSigmaWithError(h_cotThetarmsh[counter]);
01033   fsyt_cotTheta.getFittedMeanWithError(h_cotThetameanh[counter]);
01034   FitSlicesYTool fsyt_cotThetaPt(cotThetares_vs_pt[counter]);
01035   fsyt_cotThetaPt.getFittedSigmaWithError(h_cotThetarmshPt[counter]);
01036   fsyt_cotThetaPt.getFittedMeanWithError(h_cotThetameanhPt[counter]);
01037 
01038   //pulls of track params vs eta: get sigma from 2D histos
01039   FitSlicesYTool fsyt_dxyp(dxypull_vs_eta[counter]);
01040   fsyt_dxyp.getFittedSigmaWithError(h_dxypulleta[counter]);
01041   fsyt_dxyp.getFittedMeanWithError(h_dxypulletamean[counter]);
01042   FitSlicesYTool fsyt_ptp(ptpull_vs_eta[counter]);
01043   fsyt_ptp.getFittedSigmaWithError(h_ptpulleta[counter]);
01044   fsyt_ptp.getFittedMeanWithError(h_ptpulletamean[counter]);
01045   FitSlicesYTool fsyt_dzp(dzpull_vs_eta[counter]);
01046   fsyt_dzp.getFittedSigmaWithError(h_dzpulleta[counter]);
01047   fsyt_dzp.getFittedMeanWithError(h_dzpulletamean[counter]);
01048   FitSlicesYTool fsyt_phip(phipull_vs_eta[counter]);
01049   fsyt_phip.getFittedSigmaWithError(h_phipulleta[counter]);
01050   fsyt_phip.getFittedMeanWithError(h_phipulletamean[counter]);
01051   FitSlicesYTool fsyt_thetap(thetapull_vs_eta[counter]);
01052   fsyt_thetap.getFittedSigmaWithError(h_thetapulleta[counter]);
01053   fsyt_thetap.getFittedMeanWithError(h_thetapulletamean[counter]);
01054   //vs phi
01055   FitSlicesYTool fsyt_ptpPhi(ptpull_vs_phi[counter]);
01056   fsyt_ptpPhi.getFittedSigmaWithError(h_ptpullphi[counter]);
01057   fsyt_ptpPhi.getFittedMeanWithError(h_ptpullphimean[counter]);
01058   FitSlicesYTool fsyt_phipPhi(phipull_vs_phi[counter]);
01059   fsyt_phipPhi.getFittedSigmaWithError(h_phipullphi[counter]);
01060   fsyt_phipPhi.getFittedMeanWithError(h_phipullphimean[counter]);
01061   FitSlicesYTool fsyt_thetapPhi(thetapull_vs_phi[counter]);
01062   fsyt_thetapPhi.getFittedSigmaWithError(h_thetapullphi[counter]);
01063   fsyt_thetapPhi.getFittedMeanWithError(h_thetapullphimean[counter]);
01064   
01065   //effic&fake
01066   fillPlotFromVectors(h_effic[counter],totASSeta[counter],totSIMeta[counter],"effic");
01067   fillPlotFromVectors(h_fakerate[counter],totASS2eta[counter],totRECeta[counter],"fakerate");
01068   fillPlotFromVectors(h_efficPt[counter],totASSpT[counter],totSIMpT[counter],"effic");
01069   fillPlotFromVectors(h_fakeratePt[counter],totASS2pT[counter],totRECpT[counter],"fakerate");
01070   fillPlotFromVectors(h_effic_vs_hit[counter],totASS_hit[counter],totSIM_hit[counter],"effic");
01071   fillPlotFromVectors(h_fake_vs_hit[counter],totASS2_hit[counter],totREC_hit[counter],"fakerate");
01072   fillPlotFromVectors(h_effic_vs_phi[counter],totASS_phi[counter],totSIM_phi[counter],"effic");
01073   fillPlotFromVectors(h_fake_vs_phi[counter],totASS2_phi[counter],totREC_phi[counter],"fakerate");
01074   fillPlotFromVectors(h_effic_vs_dxy[counter],totASS_dxy[counter],totSIM_dxy[counter],"effic");
01075   fillPlotFromVectors(h_fake_vs_dxy[counter],totASS2_dxy[counter],totREC_dxy[counter],"fakerate");
01076   fillPlotFromVectors(h_effic_vs_dz[counter],totASS_dz[counter],totSIM_dz[counter],"effic");
01077   fillPlotFromVectors(h_fake_vs_dz[counter],totASS2_dz[counter],totREC_dz[counter],"fakerate");
01078   fillPlotFromVectors(h_effic_vs_vertpos[counter],totASS_vertpos[counter],totSIM_vertpos[counter],"effic");
01079   fillPlotFromVectors(h_effic_vs_zpos[counter],totASS_zpos[counter],totSIM_zpos[counter],"effic");
01080 
01081 }
01082 
01083 
01084 void MTVHistoProducerAlgoForTracker::fillProfileHistosFromVectors(int counter){
01085   //chi2 and #hit vs eta: get mean from 2D histos
01086   doProfileX(chi2_vs_eta[counter],h_chi2meanh[counter]);
01087   doProfileX(nhits_vs_eta[counter],h_hits_eta[counter]);
01088   doProfileX(nPXBhits_vs_eta[counter],h_PXBhits_eta[counter]);
01089   doProfileX(nPXFhits_vs_eta[counter],h_PXFhits_eta[counter]);
01090   doProfileX(nTIBhits_vs_eta[counter],h_TIBhits_eta[counter]);
01091   doProfileX(nTIDhits_vs_eta[counter],h_TIDhits_eta[counter]);
01092   doProfileX(nTOBhits_vs_eta[counter],h_TOBhits_eta[counter]);
01093   doProfileX(nTEChits_vs_eta[counter],h_TEChits_eta[counter]);
01094 
01095   doProfileX(nLayersWithMeas_vs_eta[counter],h_LayersWithMeas_eta[counter]);
01096   doProfileX(nPXLlayersWithMeas_vs_eta[counter],h_PXLlayersWithMeas_eta[counter]);    
01097   doProfileX(nSTRIPlayersWithMeas_vs_eta[counter],h_STRIPlayersWithMeas_eta[counter]);    
01098   doProfileX(nSTRIPlayersWith1dMeas_vs_eta[counter],h_STRIPlayersWith1dMeas_eta[counter]);
01099   doProfileX(nSTRIPlayersWith2dMeas_vs_eta[counter],h_STRIPlayersWith2dMeas_eta[counter]);
01100 
01101 
01102 
01103   doProfileX(nlosthits_vs_eta[counter],h_losthits_eta[counter]);
01104   //vs phi
01105   doProfileX(chi2_vs_nhits[counter],h_chi2meanhitsh[counter]); 
01106   //      doProfileX(ptres_vs_eta[counter],h_ptresmean_vs_eta[counter]);
01107   //      doProfileX(phires_vs_eta[counter],h_phiresmean_vs_eta[counter]);
01108   doProfileX(chi2_vs_phi[counter],h_chi2mean_vs_phi[counter]);
01109   doProfileX(nhits_vs_phi[counter],h_hits_phi[counter]);
01110   //       doProfileX(ptres_vs_phi[counter],h_ptresmean_vs_phi[counter]);
01111   //       doProfileX(phires_vs_phi[counter],h_phiresmean_vs_phi[counter]);
01112 }
01113 
01114 void MTVHistoProducerAlgoForTracker::fillHistosFromVectors(int counter){
01115   fillPlotFromVector(h_recoeta[counter],totRECeta[counter]);
01116   fillPlotFromVector(h_simuleta[counter],totSIMeta[counter]);
01117   fillPlotFromVector(h_assoceta[counter],totASSeta[counter]);
01118   fillPlotFromVector(h_assoc2eta[counter],totASS2eta[counter]);
01119   
01120   fillPlotFromVector(h_recopT[counter],totRECpT[counter]);
01121   fillPlotFromVector(h_simulpT[counter],totSIMpT[counter]);
01122   fillPlotFromVector(h_assocpT[counter],totASSpT[counter]);
01123   fillPlotFromVector(h_assoc2pT[counter],totASS2pT[counter]);
01124   
01125   fillPlotFromVector(h_recohit[counter],totREC_hit[counter]);
01126   fillPlotFromVector(h_simulhit[counter],totSIM_hit[counter]);
01127   fillPlotFromVector(h_assochit[counter],totASS_hit[counter]);
01128   fillPlotFromVector(h_assoc2hit[counter],totASS2_hit[counter]);
01129   
01130   fillPlotFromVector(h_recophi[counter],totREC_phi[counter]);
01131   fillPlotFromVector(h_simulphi[counter],totSIM_phi[counter]);
01132   fillPlotFromVector(h_assocphi[counter],totASS_phi[counter]);
01133   fillPlotFromVector(h_assoc2phi[counter],totASS2_phi[counter]);
01134   
01135   fillPlotFromVector(h_recodxy[counter],totREC_dxy[counter]);
01136   fillPlotFromVector(h_simuldxy[counter],totSIM_dxy[counter]);
01137   fillPlotFromVector(h_assocdxy[counter],totASS_dxy[counter]);
01138   fillPlotFromVector(h_assoc2dxy[counter],totASS2_dxy[counter]);
01139 
01140   fillPlotFromVector(h_recodz[counter],totREC_dz[counter]);
01141   fillPlotFromVector(h_simuldz[counter],totSIM_dz[counter]);
01142   fillPlotFromVector(h_assocdz[counter],totASS_dz[counter]);
01143   fillPlotFromVector(h_assoc2dz[counter],totASS2_dz[counter]);
01144   
01145   fillPlotFromVector(h_simulvertpos[counter],totSIM_vertpos[counter]);
01146   fillPlotFromVector(h_assocvertpos[counter],totASS_vertpos[counter]);
01147   
01148   fillPlotFromVector(h_simulzpos[counter],totSIM_zpos[counter]);
01149   fillPlotFromVector(h_assoczpos[counter],totASS_zpos[counter]);  
01150 }
/data/refman/pasoursint/CMSSW_4_1_8_patch13/src/Validation/RecoTrack/src/MTVHistoProducerAlgoForTracker.cc
