WZAnalysis/src/MuonAnalyzer.cc

// -*- C++ -*-
//
// Package:    WZAnalyzer
// Class:      WZAnalyzer
// 
/**\class WZAnalyzer WZAnalyzer.cc Vuko/WZAnalysis/src/WZAnalyzer.cc

 Description: <one line class summary>

 Implementation:
     <Notes on implementation>
*/
//
// Original Author:  Vuko Brigljevic
//         Created:  Fri Nov  9 11:07:27 CET 2007
// $Id: MuonAnalyzer.cc,v 1.8 2008/05/07 12:02:55 senka Exp $
//
//

// system include files
#include <memory>

// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDAnalyzer.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "Vuko/WZAnalysis/interface/MuonAnalyzer.h"
#include "DataFormats/Candidate/interface/OverlapChecker.h"

#include "Vuko/WZAnalysis/interface/ElectronProperties.h"
#include "Vuko/WZAnalysis/interface/MuonProperties.h"

#include "DataFormats/Common/interface/TriggerResults.h"

//--- muon AOD:
#include "DataFormats/JetReco/interface/CaloJetCollection.h"
#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/EgammaCandidates/interface/ElectronFwd.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuIsoDeposit.h"
#include "DataFormats/EgammaReco/interface/BasicCluster.h"
#include "DataFormats/EgammaReco/interface/BasicClusterFwd.h"
#include "DataFormats/EgammaCandidates/interface/PixelMatchGsfElectron.h"

#include "DataFormats/METReco/interface/CaloMET.h"

#include "DataFormats/DTRecHit/interface/DTRecHit1D.h"
#include "DataFormats/CSCRecHit/interface/CSCRecHit2DCollection.h"
#include "DataFormats/RPCRecHit/interface/RPCRecHitCollection.h"

//#include "MuonPOG/RecoMuonTools/SegmentTrackAssociator/interface/SegmentsTrackAssociator.h"

#include "TFile.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TTree.h" 

#include <map>

//
// constants, enums and typedefs
//

//
// static data member definitions
//

//
// constructors and destructor
//
MuonAnalyzer::MuonAnalyzer(const edm::ParameterSet& iConfig)

{

  //now do what ever initialization is needed

  fOutputFileName = iConfig.getUntrackedParameter<string>("HistOutFile"); 
  theMCTruthCollection         = iConfig.getParameter<edm::InputTag>("genParticles");

  //  theMCTruthCollection         = iConfig.getParameter<edm::InputTag>("genParticleCollection");

  theLooseMuonCollection       = iConfig.getParameter<edm::InputTag>("LooseMuons");
  theGoodMuonCollection        = iConfig.getParameter<edm::InputTag>("GoodMuons");
  //  theLooseElectronCollection   = iConfig.getParameter<edm::InputTag>("LooseElectrons");
  //  theGoodElectronCollection    = iConfig.getParameter<edm::InputTag>("GoodElectrons");
  //  theTightLeptonCollection     = iConfig.getParameter<edm::InputTag>("TightLeptons");
  // Z's
  //  theZeeCollection             = iConfig.getParameter<edm::InputTag>("ZtoEE");
  //  theZmumuCollection           = iConfig.getParameter<edm::InputTag>("ZtoMuMu");
  //  theZllCollection             = iConfig.getParameter<edm::InputTag>("ZtoLL");

  theJetCollection             = iConfig.getParameter<edm::InputTag>("Jets");

  theWeightCollection          = iConfig.getParameter<edm::InputTag>("EventWeight");
  alpgenIDTag                  =  iConfig.getParameter<edm::InputTag>("AlpgenIDTag");  

  getAlpgenID = false;
  getAlpgenID                  = iConfig.getParameter<bool>("getAlpgenID");

  getEventWeight = false;
  getEventWeight               = iConfig.getParameter<bool>("getEventWeight");

}


MuonAnalyzer::~MuonAnalyzer()
{
 
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)

}


//
// member functions
//

// ------------ method called to for each event  ------------
void
MuonAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
{

  cout <<" ulazi u analyze metodu" << endl;
   using namespace edm;
   using namespace reco;
   using namespace std;

   ///////////////////////////////////////
   //
   /// EVENT INITIALISATION
   ///

   //read run number and event ID number
   RunNumber = iEvent.id().run();
   EventID   = iEvent.id().event();

   ////////////////////////////////////////
   // Get lists

   // loose muons
   Handle<CandidateCollection> looseMuonCands;
   iEvent.getByLabel( theLooseMuonCollection , looseMuonCands);

   // good muons
   Handle<CandidateCollection> goodMuonCands;
   iEvent.getByLabel( theGoodMuonCollection , goodMuonCands);

   // tight leptons
   //   Handle<CandidateCollection> tightLeptonCands;
   //   iEvent.getByLabel( theTightLeptonCollection , tightLeptonCands);

   // jets

   Handle<CaloJetCollection> jetCands;
   iEvent.getByLabel( theJetCollection , jetCands);


   // event weights (CSA07 soups...)   
   eventWeight = -1;

   Handle< double> weightHandle;
   Handle<int> genProcessID;
   Handle<int> alpgenProcessID;
   Handle<double> genEventScale;

   if (getEventWeight) {

     iEvent.getByLabel (theWeightCollection, weightHandle);
     if (weightHandle.isValid()) {
       eventWeight = * weightHandle;
     }

     iEvent.getByLabel( "genEventProcID", genProcessID );
       if (genProcessID.isValid()) {
         processID = *genProcessID;
     }

     if (processID==4 && getAlpgenID) {
             iEvent.getByLabel( alpgenIDTag , alpgenProcessID );
             if (alpgenProcessID.isValid()) {
                 alpgenID = *alpgenProcessID;
             }
     } else alpgenID=0;


     iEvent.getByLabel( "genEventScale", genEventScale );
       if (genEventScale.isValid()) {
         eventScale = *genEventScale;
     }
   }
 
   // selected muons

//    cout << "\t # loose mu : " <<  looseMuonCands->size() 
//      << "\t # tight mu : " <<  goodMuonCands->size() 
//      << "\t # loose e : " <<   looseElectronCands->size() 
//      << "\t # tight e : " <<   goodElectronCands->size() 
//      << "\t # tight l : " <<   tightLeptonCands->size() 
//      << "\t # Z->mumu : " <<  zmumuCands->size() 
//      << "\t # Z->ee : " <<  zeeCands->size() 
//      << "\t # Z->ll : " <<  zllCands->size() 
//      << endl;

   N_looseMuons=0;
   N_looseElectrons=0;
   N_goodMuonCands=0;
   N_looseMuons = looseMuonCands->size();
   N_goodMuonCands=goodMuonCands->size();
  
  //  Handle <reco::GenParticleCandidateCollection> mccands;
  Handle<CandidateCollection> mccands;
  iEvent.getByLabel( theMCTruthCollection,mccands );
  
  collectMCsummary(mccands);
  

  // matching:

  matching(iEvent,looseMuonCands, 13);

  getMother(&(*mccands)[1]);

  //  dodatak za muon fake rate:
  matching_JetsWithMuons(iEvent, looseMuonCands, jetCands);
  matching_JetsWithB(iEvent, jetCands);
  matching_JetsWithC(iEvent, jetCands);

//   for(CaloJetCollection::const_iterator jet = jetCands->begin();
//       jet != jetCands->end(); jet++) {

  nb_jet=0;
  nb_jet_eta_cut=0;
  nb_jet_eta_and_pt_cut=0;
  for (unsigned int i=0;i<jetCands->size();i++){
    nb_jet++;
    if (fabs((*jetCands)[i].eta())<2.5 ){
      nb_jet_eta_cut++;
      if ((*jetCands)[i].pt()<10){
        nb_jet_eta_and_pt_cut++;
      }
    }
  }

  nb_muon=0;
  for (unsigned int i=0;i<looseMuonCands->size();i++){
    if (fabs((*looseMuonCands)[i].eta())<2.5 ){
      nb_muon++;
    }
  }

  for (unsigned int i=0;i<jetCands->size();i++){

    //  cout <<" # jets ="<<jetCands->size() <<endl;
    JetmatchedMuon=0;
    JetmatchedB=0;
    JetmatchedC=0;
    MuonmatchedGenMuon=0;
    dr_muon=0.;
    dr_B=0.;
    dr_C=0.;
    //    cout <<"       dr na pocetku="<<dr << endl;
    Jet_E=-10.;
    Jet_Et=-10.;
    Jet_eta=-10.;
    Jet_theta=-10.;
    Jet_phi=-10.;
    Jet_P=-10.;
    Jet_Pt=-10.;
    Jet_Py=-10.;

    Jet_maxEInEmTowers=-10.;
    Jet_maxEInHadTowers=-10.;
    Jet_energyFractionHadronic=-10.;
    Jet_emEnergyFraction=-10.;
    Jet_hadEnergyInHB=-10.;
    Jet_hadEnergyInHO=-10.;
    Jet_hadEnergyInHE=-10.;
    Jet_hadEnergyInHF=-10.;
    Jet_emEnergyInEB=-10.;
    Jet_emEnergyInEE=-10.;
    Jet_emEnergyInHF=-10.;
    Jet_towersArea=-10.;
    Jet_n90=-10.;
    Jet_n60=-10.;

    muon_Et=-10.;
    muon_eta=-10.;
    muon_theta=-10.;
    muon_P=-10.;
    muon_Pt=-10.;
    muon_Pt_jet=-10.;
    muon_Py=-10.;
    B_Et=-10.;
    B_eta=-10.;
    B_Pt=-10.;
    C_Et=-10.;
    C_eta=-10.;
    C_Pt=-10.;
    gen_muon_Et=-10.;
    gen_muon_eta=-10.;
    gen_muon_P=-10.;
    gen_muon_Pt=-10.;
    muon_mother=0;
    muon_mother_id=0;
    W_mother_id=0;

    muon_global=0;

    muon_global_chi2=-10.; 
    muon_global_p=-10.; 
    muon_global_pt=-10.; 
    muon_global_outerP=-10.;  
    muon_global_outerPt=-10.;
    muon_global_ndof=-10.;
    muon_global_normalizedChi2=-10.;
    muon_global_recHitsSize=1000;
    muon_global_numberOfLostHits=-10;
    muon_global_numberOfValidHits=-10;
    muon_global_innerPosition_x=-10.;
    muon_global_innerPosition_y=-10.;
    muon_global_innerPosition_z=-10.;
    muon_global_outerPosition_x=-10.;
    muon_global_outerPosition_y=-10.;
    muon_global_outerPosition_z=-10.;
    muon_global_outerPosition_layerId=-10.;
    muon_global_outerPosition_superlayerId=-10.;
    muon_global_outerPosition_chamberId=-10.;
    muon_global_dz=-10.;
    muon_global_dz_error=-10.;
    muon_global_lasthit_x=-10.;
    muon_global_lasthit_y=-10.;
    muon_global_lasthit_z=-10.;

    muon_STA=0;
    
    muon_STA_chi2=-10.; 
    muon_STA_p=-10.; 
    muon_STA_pt=-10.; 
    muon_STA_outerP=-10.;  
    muon_STA_outerPt=-10.;
    muon_STA_ndof=-10.;
    muon_STA_normalizedChi2=-10.;
    muon_STA_recHitsSize=1000;
    muon_STA_numberOfLostHits=-10;
    muon_STA_numberOfValidHits=-10;
    muon_STA_innerPosition_x=-10.;
    muon_STA_innerPosition_y=-10.;
    muon_STA_innerPosition_z=-10.;
    muon_STA_outerPosition_x=-10.;
    muon_STA_outerPosition_y=-10.;
    muon_STA_outerPosition_z=-10.;
    muon_STA_outerPosition_layerId=-10.;
    muon_STA_outerPosition_superlayerId=-10.;
    muon_STA_outerPosition_chamberId=-10.;
    muon_STA_dz=-10.;
    muon_STA_dz_error=-10.;

    
    muon_track=0; 

    muon_track_chi2=-10.; 
    muon_track_p=-10.; 
    muon_track_pt=-10.; 
    muon_track_outerP=-10.;  
    muon_track_outerPt=-10.;
    muon_track_ndof=-10.;
    muon_track_normalizedChi2=-10.;
    muon_track_recHitsSize=1000;
    muon_track_numberOfLostHits=-10;
    muon_track_numberOfValidHits=-10;
    muon_track_innerPosition_x=-10.;
    muon_track_innerPosition_y=-10.;
    muon_track_innerPosition_z=-10.;
    muon_track_outerPosition_x=-10.;
    muon_track_outerPosition_y=-10.;
    muon_track_outerPosition_z=-10.;
    muon_track_outerPosition_layerId=-10.;
    muon_track_outerPosition_superlayerId=-10.;
    muon_track_outerPosition_chamberId=-10.;
    muon_track_dz=-10.;
    muon_track_dz_error=-10.;

    DT=0;
    DT_wheel = -10;
    DT_sector = -10;
    DT_station = -10;
    DT_superlayer = -10;
    DT_layer = -10;
    CSC=0;
    CSC_ring = -10;
    CSC_station = -10;
    CSC_endcap = -10;
    CSC_chamber = -10;
    CSC_layer = -10;
    RPC=0;
    RPC_layer=-10;
    RPC_region=-10;
    RPC_ring=-10;
    RPC_sector=-10;
    RPC_station=-10;
    RPC_subsector=-10;
    
    
      Jet_E=(*jetCands)[i].energy();
      Jet_Et=(*jetCands)[i].et();
      Jet_eta=(*jetCands)[i].eta();
      //      cout<<"" <<endl;
      //      cout<<"Jet_eta="<<Jet_eta<<endl;
      Jet_theta=(*jetCands)[i].theta();
      //      cout<<"Jet_theta="<<Jet_theta<<endl;
      Jet_phi=(*jetCands)[i].phi();
      Jet_P=(*jetCands)[i].p();
      Jet_Pt=(*jetCands)[i].pt();
      Jet_Py=(*jetCands)[i].py();
      //      cout<<"Jet_Py="<<Jet_Py<<endl;
      
      Jet_maxEInEmTowers=(*jetCands)[i].maxEInEmTowers();
      Jet_maxEInHadTowers=(*jetCands)[i].maxEInHadTowers();
      Jet_energyFractionHadronic=(*jetCands)[i].energyFractionHadronic();
      Jet_emEnergyFraction=(*jetCands)[i].emEnergyFraction();
      Jet_hadEnergyInHB=(*jetCands)[i].hadEnergyInHB();
      Jet_hadEnergyInHO=(*jetCands)[i].hadEnergyInHO();
      Jet_hadEnergyInHE=(*jetCands)[i].hadEnergyInHE();
      Jet_hadEnergyInHF=(*jetCands)[i].hadEnergyInHF();
      Jet_emEnergyInEB=(*jetCands)[i].emEnergyInEB();
      Jet_emEnergyInEE=(*jetCands)[i].emEnergyInEE();
      Jet_emEnergyInHF=(*jetCands)[i].emEnergyInHF();
      Jet_towersArea=(*jetCands)[i].towersArea();
      Jet_n90=(*jetCands)[i].n90();
      Jet_n60=(*jetCands)[i].n60();


    const reco::Candidate * matchedmuon=MatchedMuonWithJet(&(*jetCands)[i]);
    
    if (MatchedMuonWithJet(&(*jetCands)[i])) {
      //      cout <<" jet IMA matched muon !!!!!!!!!!!!!!" <<endl;
      JetmatchedMuon=1; 
      dr_muon=dR_Muon_Jet(&(*jetCands)[i]);
      //      cout <<"       dr="<< dr_muon << "  dR_Muon_Jet(&(*jetCands)[i])="<<dR_Muon_Jet(&(*jetCands)[i])<< endl;
      //        muon_Et=MatchedMuonWithJet(&(*jetCands)[i])->et();
      //        muon_eta=MatchedMuonWithJet(&(*jetCands)[i])->eta();
      //        muon_Pt=MatchedMuonWithJet(&(*jetCands)[i])->pt();
      //        muon_STA_chi2=MatchedMuonWithJet(&(*jetCands)[i])->standAloneMuon()->chi2();
      muon_Et = matchedmuon->et();
      muon_theta = matchedmuon->theta();
      //      cout<<"" <<endl;
      //      cout << "muon_theta="<<muon_theta<< endl;
      muon_eta = matchedmuon->eta();
      //      cout << "muon_eta="<<muon_eta<< endl;
      muon_Pt = matchedmuon->pt();
      muon_Py = matchedmuon->py();
      //      cout << "muon_Py="<<muon_Py<< endl;
      muon_P = matchedmuon->p();

      
      if((muon_Py>0 && Jet_Py>0) || (muon_Py<0 && Jet_Py<0)) theta=abs(muon_theta-Jet_theta);
      else if((muon_Py>0 && Jet_Py<0) || (muon_Py<0 && Jet_Py>0)) theta=abs(muon_theta+Jet_theta);
      else if(muon_Py==0) theta=abs(Jet_theta);
      else if(Jet_Py==0) theta=abs(muon_theta);
      else theta=0;
      //      else theta=-10;
      //      cout <<"  theta="<<theta << endl;
      if (theta!=0) muon_Pt_jet=abs(muon_P*TMath::Sin(theta));
      else muon_Pt_jet=-10;
//       cout <<"  muon_P="<< muon_P << endl;
//       cout <<"  muon_Pt_jet="<<muon_Pt_jet << endl;
//       cout <<""<< endl;
      const reco::Muon* matchedmuon_recoMuon = dynamic_cast<const reco::Muon *> (matchedmuon); // conversion of matchedmuon from reco::Candidate to reco::Muon
//       reco::TrackRef combined_muon = new reco::Track::Track();
//       combined_muon = matchedmuon_recoMuon->combinedMuon();
      
      if (&(matchedmuon_recoMuon->combinedMuon())!=0){
      //      if (combined_muon==0){
        muon_global=1;
        muon_global_chi2 = matchedmuon_recoMuon->combinedMuon()->chi2();
        muon_global_p = matchedmuon_recoMuon->combinedMuon()->p();
        muon_global_pt = matchedmuon_recoMuon->combinedMuon()->pt();
        muon_global_outerP = matchedmuon_recoMuon->combinedMuon()->outerP();
        muon_global_outerPt = matchedmuon_recoMuon->combinedMuon()->outerPt();
        muon_global_ndof = matchedmuon_recoMuon->combinedMuon()->ndof();
        muon_global_normalizedChi2 = matchedmuon_recoMuon->combinedMuon()->normalizedChi2();
        muon_global_recHitsSize = matchedmuon_recoMuon->combinedMuon()->recHitsSize();
        muon_global_numberOfLostHits = matchedmuon_recoMuon->combinedMuon()->numberOfLostHits();
        muon_global_numberOfValidHits = matchedmuon_recoMuon->combinedMuon()->numberOfValidHits();
        muon_global_innerPosition_x = matchedmuon_recoMuon->combinedMuon()->innerPosition().x();
        muon_global_innerPosition_y = matchedmuon_recoMuon->combinedMuon()->innerPosition().y();
        muon_global_innerPosition_z = matchedmuon_recoMuon->combinedMuon()->innerPosition().z();
        muon_global_outerPosition_x = matchedmuon_recoMuon->combinedMuon()->outerPosition().x();
        muon_global_outerPosition_y = matchedmuon_recoMuon->combinedMuon()->outerPosition().y();
        muon_global_outerPosition_z = matchedmuon_recoMuon->combinedMuon()->outerPosition().z();
        muon_global_dz=matchedmuon_recoMuon->combinedMuon()->dz();
        muon_global_dz_error=matchedmuon_recoMuon->combinedMuon()->dzError();

        ////////////////////////////////////////////////
        //      chamber, layer, superlayer

        //      cout <<"prije rechit"<<endl;
        int recHit_size= matchedmuon_recoMuon->combinedMuon()-> recHitsSize();
        //      trackingRecHit_iterator recHit = matchedmuon_recoMuon->combinedMuon()->recHitsEnd();
        TrackingRecHitRef recHit_last= matchedmuon_recoMuon->combinedMuon()->recHit(recHit_size-1);
        double last_hit_distance=sqrt(recHit_last->localPosition().x()*recHit_last->localPosition().x()+
                                      recHit_last->localPosition().y()*recHit_last->localPosition().y()+
                                      recHit_last->localPosition().z()*recHit_last->localPosition().z());
        //      cout <<"last hit distance="<<last_hit_distance <<endl;

        trackingRecHit_iterator rhbegin =  matchedmuon_recoMuon->combinedMuon()->recHitsBegin();
        trackingRecHit_iterator rhend =  matchedmuon_recoMuon->combinedMuon()->recHitsEnd();
        double distance,distance_r,max;
        int max_i=0;
        int i=0;
        int j=0;
        
        //loop over recHit
        // trazim zadnji hit (najveca udaljenost od IP)

//      for(trackingRecHit_iterator recHit = rhbegin; recHit != rhend; ++recHit){ 

//        distance=sqrt(((*recHit)->localPosition().x())*((*recHit)->localPosition().x())
//                             +((*recHit)->localPosition().y())*((*recHit)->localPosition().y())
//                             +((*recHit)->localPosition().z())*((*recHit)->localPosition().z()));
//        distance_r=sqrt(((*recHit)->localPosition().x())*((*recHit)->localPosition().x())
//                             +((*recHit)->localPosition().y())*((*recHit)->localPosition().y()));
//        if (recHit==rhbegin) {
//          max=distance;
//        }
//        if (distance>max) {
//          max=distance;
//          max_i=i;
//        }
// //     cout<< "i="<< i<< endl;
// //     cout <<"hit distance="<< distance << endl;
// //     cout <<"hit distance_x="<< (*recHit)->localPosition().x() << endl;
// //     cout <<"hit distance_r="<< distance_r << endl;
// //     cout <<"hit valid="<< (*recHit)->isValid() << endl;
//        i++;
//      }
        //      cout << "max="<< max<< endl;
        //      cout << "i of max="<< max_i<<endl;

//      DT_station=0;
//      DT_superlayer=0;
//      DT_layer=0;

//      for(trackingRecHit_iterator recHit = rhbegin; recHit != rhend; ++recHit){
//        j++;
//        cout << "j="<< j<< endl;
          //      if (j-1!=max_i) continue;      // kada uzimam onaj najdalji (PAZI: lokalne varijable su u pitanju!)
          //      if (j!=recHit_size) continue;  // kada uzimam zadnji po redu recHit

        //      TrackingRecHitRef recHit=recHit_last;
//        cout <<" last hit !!!!" <<endl;
//        cout << "j="<<j <<endl;


          // NAPOMENA: kada imam iterator preko svih recHitova onda (*recHit)->localPosition(), a kada imam lastHit onda (recHit_last)->localPosition()


//        muon_global_lasthit_r=sqrt(((*recHit)->localPosition().x())*((*recHit)->localPosition().x())
//                                   +((*recHit)->localPosition().y())*((*recHit)->localPosition().y()));
//        muon_global_lasthit_distance=sqrt(((*recHit)->localPosition().x())*((*recHit)->localPosition().x())
//                                          +((*recHit)->localPosition().y())*((*recHit)->localPosition().y())
//                                          +((*recHit)->localPosition().z())*((*recHit)->localPosition().z()));
          muon_global_lasthit_x=(recHit_last)->localPosition().x();
          cout <<"hit x="<<muon_global_lasthit_x <<endl;
          muon_global_lasthit_y=(recHit_last)->localPosition().y();
          muon_global_lasthit_z=(recHit_last)->localPosition().z();
          
          cout <<" distance="<<sqrt(((recHit_last)->localPosition().x())*((recHit_last)->localPosition().x())
                                    +((recHit_last)->localPosition().y())*((recHit_last)->localPosition().y())
                                    +((recHit_last)->localPosition().z())*((recHit_last)->localPosition().z())) <<endl;
          //      cout <<"rechit"<<endl;
          DetId IdRivHit = (recHit_last)->geographicalId(); 
          //      cout <<"IdRivHit"<<endl;

          if (IdRivHit.det() == DetId::Muon) {
            cout <<" is in muon detector" <<endl;
            
            //if the recHit belong to a DT
            if (IdRivHit.subdetId() == MuonSubdetId::DT ) {
              cout <<"  is in DT" <<endl;
              //LogTrace(metname) <<"The recHit belong to a DT";
              // get the chamber Id
              cout <<"cudno="<<IdRivHit.rawId() <<endl;
              DTChamberId chamberId(IdRivHit.rawId()); 
              cout <<"   DTChamberId" << endl;
              
              DTWireId ch_id(IdRivHit.rawId()); 
              cout <<"     DTWireId" << endl;
              cout <<"     proba!" << endl;
              DT=1;
              //              if(DT_station>ch_id.station()) continue;
              DT_station = ch_id.station();
              //              if(DT_superlayer>ch_id.superlayer()) continue;
              DT_superlayer = ch_id.superlayer();
              cout <<"     proba 2!" << endl;
              //              if(DT_layer>ch_id.layer()) continue;
              DT_layer = ch_id.layer();
              DT_wheel= ch_id.wheel();
              DT_sector= ch_id.sector();

              cout <<"       wheel="<< DT_wheel << endl;
              cout <<"       station="<< DT_station << endl;
              cout <<"       layer="<< DT_layer << endl;
              cout <<"       super="<< DT_superlayer << endl;
              cout <<"       sector="<< DT_sector << endl;
              
              
              //          DTWireId  = dynamic_cast<TrackingRecHit *> (&rechit); // ne radi
              
            //    }
              
            }
            
            if (IdRivHit.subdetId() == MuonSubdetId::CSC ) {
              cout <<"  is in CSC" <<endl;
              CSC=1;
              CSCDetId  tempchamberId(IdRivHit.rawId());
              CSC_ring = tempchamberId.ring();
              CSC_station = tempchamberId.station();
              CSC_endcap = tempchamberId.endcap();
              CSC_chamber = tempchamberId.chamber();
              CSC_layer = tempchamberId.layer();

              cout <<"    CSC   ring="<< CSC_ring << endl;
              cout <<"    CSC   station="<< CSC_station << endl;
              cout <<"    CSC   layer="<< CSC_layer << endl;

              cout <<"    CSC   endcap="<< CSC_endcap << endl;

              cout <<"    CSC   chamber="<< CSC_chamber << endl;
            }

            if (IdRivHit.subdetId() == MuonSubdetId::RPC ) {
              cout <<"  is in RPC" <<endl;
              RPCDetId  tempRPCId(IdRivHit.rawId());
              RPC=1;
              RPC_layer=tempRPCId.layer();
              RPC_region=tempRPCId.region();
              RPC_ring=tempRPCId.ring();
              RPC_sector=tempRPCId.sector();
              RPC_station=tempRPCId.station();
              RPC_subsector=tempRPCId.subsector();

              cout <<"    RPC   ring="<< RPC_ring << endl;
              cout <<"    RPC   station="<< RPC_station << endl;
              cout <<"    RPC   layer="<< RPC_layer << endl;
              cout <<"    RPC   region="<< RPC_region << endl;
              cout <<"    RPC   sector="<< RPC_sector << endl;
              cout <<"    RPC   subsector="<< RPC_subsector << endl;
            }
          }
          else cout <<" is not in muon det" << endl;
          //    }

        //      TrackingRecHitRef *recHit= matchedmuon_recoMuon->combinedMuon()->recHit(recHit_size-1);
        cout <<"last hit function" << endl;
        cout <<" distance="<<sqrt(((recHit_last)->localPosition().x())*((recHit_last)->localPosition().x())
                               +((recHit_last)->localPosition().y())*((recHit_last)->localPosition().y())
                               +((recHit_last)->localPosition().z())*((recHit_last)->localPosition().z())) << endl;
//      for(CandidateCollection::const_iterator z1 = zllCands->begin(); 
//          z1 != zllCands->end(); ++ z1 ) {
//      }

//      TrackingRecHitRef rechit = matchedmuon_recoMuon->combinedMuon()->recHit(3); // radi!!
// //   trackingRecHit_iterator rechit = matchedmuon_recoMuon->combinedMuon()->recHitsEnd(); // radi!!
//      //      TrackingRecHit * rechit_noref = dynamic_cast<TrackingRecHit *> (&rechit); // ne radi
//      //      DTRecHit1D * rechit_1d = dynamic_cast<DTRecHit1D *> (&rechit); // ne radi
//      //      DTRecHit1D * rechit_1d = dynamic_cast<DTRecHit1D *> (&rechit); // ne radi
//      //      DTRecHit1D * rechit_1d;
//      //      rechit_1d = (&rechit); 
//      muon_global_outerPosition_layerId=0;


//////////////////////////////////////

//      for (pa_sim = simHits->begin(); pa_sim != simHits->end(); ++pa_sim ) {
//      trackingRecHit_iterator pa_sim;
//      for (trackingRecHit_iterator pa_sim = matchedmuon_recoMuon->combinedMuon()->recHitsBegin(); pa_sim != matchedmuon_recoMuon->combinedMuon()->recHitsEnd(); ++pa_sim ) {
        for (unsigned int i=1;i<matchedmuon_recoMuon->combinedMuon()->recHitsSize()+1;i++){
          //TrackingRecHit pa_sim = matchedmuon_recoMuon->combinedMuon()->recHitsBegin(); pa_sim != matchedmuon_recoMuon->combinedMuon()->recHitsEnd(); ++pa_sim ) {

          //      cout <<" --------------------- analiza?:"<<endl;

          if (i!=matchedmuon_recoMuon->combinedMuon()->recHitsSize()) continue;

          //      cout <<" --------------------- rec hits analiza:"<<endl;
        }

///////////////////////////////////////

      }

      if (&(matchedmuon_recoMuon->standAloneMuon())!=0){
        muon_STA=1;
        muon_STA_chi2 = matchedmuon_recoMuon->standAloneMuon()->chi2();
        muon_STA_p = matchedmuon_recoMuon->standAloneMuon()->p();
        muon_STA_pt = matchedmuon_recoMuon->standAloneMuon()->pt();
        muon_STA_outerP = matchedmuon_recoMuon->standAloneMuon()->outerP();
        muon_STA_outerPt = matchedmuon_recoMuon->standAloneMuon()->outerPt();
        muon_STA_ndof = matchedmuon_recoMuon->standAloneMuon()->ndof();
        muon_STA_normalizedChi2 = matchedmuon_recoMuon->standAloneMuon()->normalizedChi2();
        muon_STA_recHitsSize = matchedmuon_recoMuon->standAloneMuon()->recHitsSize();
        muon_STA_numberOfLostHits = matchedmuon_recoMuon->standAloneMuon()->numberOfLostHits();
        muon_STA_numberOfValidHits = matchedmuon_recoMuon->standAloneMuon()->numberOfValidHits();
        muon_STA_innerPosition_x = matchedmuon_recoMuon->standAloneMuon()->innerPosition().x();
        muon_STA_innerPosition_y = matchedmuon_recoMuon->standAloneMuon()->innerPosition().y();
        muon_STA_innerPosition_z = matchedmuon_recoMuon->standAloneMuon()->innerPosition().z();
        muon_STA_outerPosition_x = matchedmuon_recoMuon->standAloneMuon()->outerPosition().x();
        muon_STA_outerPosition_y = matchedmuon_recoMuon->standAloneMuon()->outerPosition().y();
        muon_STA_outerPosition_z = matchedmuon_recoMuon->standAloneMuon()->outerPosition().z();
        muon_STA_dz=matchedmuon_recoMuon->standAloneMuon()->dz();
        muon_STA_dz_error=matchedmuon_recoMuon->standAloneMuon()->dzError();
      }

      if (&(matchedmuon_recoMuon->track())!=0){
        muon_track=1;
        muon_track_chi2 = matchedmuon_recoMuon->track()->chi2();
        muon_track_p = matchedmuon_recoMuon->track()->p();
        muon_track_pt = matchedmuon_recoMuon->track()->pt();
        muon_track_outerP = matchedmuon_recoMuon->track()->outerP();
        muon_track_outerPt = matchedmuon_recoMuon->track()->outerPt();
        muon_track_ndof = matchedmuon_recoMuon->track()->ndof();
        muon_track_normalizedChi2 = matchedmuon_recoMuon->track()->normalizedChi2();
        muon_track_recHitsSize = matchedmuon_recoMuon->track()->recHitsSize();
        muon_track_numberOfLostHits = matchedmuon_recoMuon->track()->numberOfLostHits();
        muon_track_numberOfValidHits = matchedmuon_recoMuon->track()->numberOfValidHits();
        muon_track_innerPosition_x = matchedmuon_recoMuon->track()->innerPosition().x();
        muon_track_innerPosition_y = matchedmuon_recoMuon->track()->innerPosition().y();
        muon_track_innerPosition_z = matchedmuon_recoMuon->track()->innerPosition().z();
        muon_track_outerPosition_x = matchedmuon_recoMuon->track()->outerPosition().x();
        muon_track_outerPosition_y = matchedmuon_recoMuon->track()->outerPosition().y();
        muon_track_outerPosition_z = matchedmuon_recoMuon->track()->outerPosition().z();
        muon_track_dz=matchedmuon_recoMuon->track()->dz();
        muon_track_dz_error=matchedmuon_recoMuon->track()->dzError();
      }
      //        if (fabs(MatchedMuonWithJet(&(*jetCands)[i])->eta())<2.5) {
      //          cout <<"   muon prolazi eta cut" <<endl;
      
      for (map< int, 
               std::vector<  matchedParticles >   > ::iterator iter = leptonMatching.begin();
           iter!=leptonMatching.end();   iter++) // entire map
        {
          //        for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
          //          const reco::Candidate * nesto=iter->second[j].pair.second;
          
          if ((iter->first)==13)
            cout <<"IDE PO CIJELOJ MAPI 13" << endl;
            cout <<"-----------------------------------------------------" << endl;
          //        }
        }
      
      // ako muon (matched with jet) ima matched gen_muon

      if (MatchedGenParticle(matchedmuon)){
        //      cout <<" muon has matched gen muon !!!!!!!!!!" <<endl;
        MuonmatchedGenMuon=1;
        gen_muon_Et=MatchedGenParticle(matchedmuon)->et();
        gen_muon_eta=MatchedGenParticle(matchedmuon)->eta();
        gen_muon_P=MatchedGenParticle(matchedmuon)->p();
        gen_muon_Pt=MatchedGenParticle(matchedmuon)->pt();
        MuonAnalyzer::LeptonOrigin origin = getMother(MatchedGenParticle(matchedmuon));
        
        if (origin == MuonAnalyzer::wboson ){
          muon_mother=1;
          //      cout << "MatchedGenFromW=true" <<endl;
          W_mother_id = getMother_Id(getMother_particle(MatchedGenParticle(matchedmuon)));
          }
        else if (origin == MuonAnalyzer::zboson ){
          muon_mother=2;
          //      cout << "MatchedGenFromZ=true" <<endl;
        }
        else if (origin == MuonAnalyzer::bdecay )    {            
          muon_mother = 3;
          //        cout << "MatchedGenFromB=true" <<endl;
        }
        else if (origin == MuonAnalyzer::cdecay )    {            
          muon_mother = 4;
          //      cout << "MatchedGenFromC=true" <<endl;
        }
        else if (origin == MuonAnalyzer::tdecay )    {            
          muon_mother = 5;
          //      cout << "MatchedGenFromT=true" <<endl;
        }
        muon_mother_id=getMother_Id(MatchedGenParticle(matchedmuon));
        
        
          //      }
      }
      //      }
      //      cout <<" jet nema matched muon" <<endl;   
    }
    
    if (MatchedBhadronWithJet(&(*jetCands)[i])) {
      //        cout <<" ima matched B hadron !!!!!!!!" << endl;
        /////////////////

        JetmatchedB=1;  
        dr_B=dR_B_Jet(&(*jetCands)[i]);
        //      cout <<"       dr="<< dr_B << "  dR_B_Jet(&(*jetCands)[i])="<<dR_B_Jet(&(*jetCands)[i])<< endl;
        B_Et=MatchedBhadronWithJet(&(*jetCands)[i])->et();
        B_eta=MatchedBhadronWithJet(&(*jetCands)[i])->eta();
        B_Pt=MatchedBhadronWithJet(&(*jetCands)[i])->pt();

    }

      if (MatchedChadronWithJet(&(*jetCands)[i])) {
        //      cout <<" ima matched C hadron !!!!!!!!" << endl;
        /////////////////
        
        JetmatchedC=1;  
        dr_C=dR_C_Jet(&(*jetCands)[i]);
        //      cout <<"       dr="<< dr_C << "  dR_C_Jet(&(*jetCands)[i])="<<dR_C_Jet(&(*jetCands)[i])<< endl;
        C_Et=MatchedChadronWithJet(&(*jetCands)[i])->et();
        C_eta=MatchedChadronWithJet(&(*jetCands)[i])->eta();
        C_Pt=MatchedChadronWithJet(&(*jetCands)[i])->pt();
       
      }

//       Jet_E=(*jetCands)[i].energy();
//       Jet_Et=(*jetCands)[i].et();
//       Jet_eta=(*jetCands)[i].eta();
//       cout<<"" <<endl;
//       cout<<"Jet_eta="<<Jet_eta<<endl;
//       Jet_theta=(*jetCands)[i].theta();
//       cout<<"Jet_theta="<<Jet_theta<<endl;
//       Jet_phi=(*jetCands)[i].phi();
//       Jet_P=(*jetCands)[i].p();
//       Jet_Pt=(*jetCands)[i].pt();
//       Jet_Py=(*jetCands)[i].py();
//       cout<<"Jet_Py="<<Jet_Py<<endl;
      
//       Jet_maxEInEmTowers=(*jetCands)[i].maxEInEmTowers();
//       Jet_maxEInHadTowers=(*jetCands)[i].maxEInHadTowers();
//       Jet_energyFractionHadronic=(*jetCands)[i].energyFractionHadronic();
//       Jet_emEnergyFraction=(*jetCands)[i].emEnergyFraction();
//       Jet_hadEnergyInHB=(*jetCands)[i].hadEnergyInHB();
//       Jet_hadEnergyInHO=(*jetCands)[i].hadEnergyInHO();
//       Jet_hadEnergyInHE=(*jetCands)[i].hadEnergyInHE();
//       Jet_hadEnergyInHF=(*jetCands)[i].hadEnergyInHF();
//       Jet_emEnergyInEB=(*jetCands)[i].emEnergyInEB();
//       Jet_emEnergyInEE=(*jetCands)[i].emEnergyInEE();
//       Jet_emEnergyInHF=(*jetCands)[i].emEnergyInHF();
//       Jet_towersArea=(*jetCands)[i].towersArea();
//       Jet_n90=(*jetCands)[i].n90();
//       Jet_n60=(*jetCands)[i].n60();
      
      //      cout <<" muon mother="<< muon_mother <<endl;
      
      muonTree->Fill();
  }
  
  //   for (int i=0;i<N_looseMuons; i++){
//     if (MatchedGenParticle(&(*looseMuonCands)[i])==0) matchedMuon=0;
//     else matchedMuon=1;
//     // (&(*looseMuonCands)[0])   
//     muonTree->Fill();    
//   } 

  JetMuTree->Fill();


}


// ------------ method called once each job just before starting event loop  ------------
void 
MuonAnalyzer::beginJob(const edm::EventSetup&)
{

  using namespace wzana;

  //  theFile   = new TFile( "wz.root", "RECREATE" ) ;
  theFile   = new TFile( fOutputFileName.c_str(), "RECREATE" ) ;

  muonTree = new TTree("JetMuon_Tree","muon informations for fake rate");
  JetMuTree = new TTree("JetMuEvent_Tree","event info");

  initialiseTree();

}

// ------------ method called once each job just after ending the event loop  ------------
void 
MuonAnalyzer::endJob() {

  theFile->Write();
  theFile->Close();

}


void MuonAnalyzer::initialiseTree() {

  // muon properties for fake rate

  muonTree->Branch("weight",    &eventWeight,  "weight/F");
  muonTree->Branch("processID", &processID, "processID/I");
  muonTree->Branch("alpgenID", &alpgenID, "alpgenID/I");
  muonTree->Branch("genEventScale",    &eventScale,  "genEventScale/F");
  muonTree->Branch("RunNumber", &RunNumber, "RunNumber/I");
  muonTree->Branch("EventID", &EventID, "EventID/I");

  muonTree->Branch("N_looseMuons",&N_looseMuons,"N_looseMuons/I");
  muonTree->Branch("N_goodMuonCands",&N_goodMuonCands,"N_goodMuonCands/I");
  muonTree->Branch("matchedMuon",&matchedMuon,"matchedMuon/I");

  muonTree->Branch("nb_jet",&nb_jet,"nb_jet/I");
  muonTree->Branch("nb_jet_eta_cut",&nb_jet_eta_cut,"nb_jet_eta_cut/I");
  muonTree->Branch("nb_jet_eta_and_pt_cut",&nb_jet_eta_and_pt_cut,"nb_jet_eta_and_pt_cut/I");

  muonTree->Branch("nb_muon",&nb_muon,"nb_muon/I");
  
  //  muonTree->Branch("NbJets",&,"/I");
  muonTree->Branch("JetmatchedMuon",&JetmatchedMuon,"JetmatchedMuon/I");
  muonTree->Branch("JetmatchedB",&JetmatchedB,"JetmatchedB/I");
  muonTree->Branch("JetmatchedC",&JetmatchedC,"JetmatchedC/I");
  muonTree->Branch("MuonmatchedGenMuon",&MuonmatchedGenMuon,"MuonmatchedGenMuon/I");

  muonTree->Branch("Jet_E",&Jet_E,"Jet_E/F");
  muonTree->Branch("Jet_Et",&Jet_Et,"Jet_Et/F");
  muonTree->Branch("Jet_eta",&Jet_eta,"Jet_eta/F");  
  muonTree->Branch("Jet_theta",&Jet_theta,"Jet_theta/F");  
  muonTree->Branch("Jet_P",&Jet_P,"Jet_P/F");
  muonTree->Branch("Jet_Pt",&Jet_Pt,"Jet_Pt/F");
  muonTree->Branch("Jet_Py",&Jet_Py,"Jet_Py/F");
  muonTree->Branch("Jet_maxEInEmTowers",&Jet_maxEInEmTowers,"Jet_maxEInEmTowers/F");
  muonTree->Branch("Jet_maxEInHadTowers",&Jet_maxEInHadTowers,"Jet_maxEInHadTowers/F");
  muonTree->Branch("Jet_energyFractionHadronic",&Jet_energyFractionHadronic,"Jet_energyFractionHadronic/F");
  muonTree->Branch("Jet_emEnergyFraction",&Jet_emEnergyFraction,"Jet_emEnergyFraction/F");
  muonTree->Branch("Jet_hadEnergyInHB",&Jet_hadEnergyInHB,"Jet_hadEnergyInHB/F");
  muonTree->Branch("Jet_hadEnergyInHO",&Jet_hadEnergyInHO,"Jet_hadEnergyInHO/F");
  muonTree->Branch("Jet_hadEnergyInHE",&Jet_hadEnergyInHE,"Jet_hadEnergyInHE/F");
  muonTree->Branch("Jet_hadEnergyInHF",&Jet_hadEnergyInHF,"Jet_hadEnergyInHF/F");
  muonTree->Branch("Jet_emEnergyInEB",&Jet_emEnergyInEB,"Jet_emEnergyInEB/F");
  muonTree->Branch("Jet_emEnergyInEE",&Jet_emEnergyInEE,"Jet_emEnergyInEE/F");
  muonTree->Branch("Jet_emEnergyInHF",&Jet_emEnergyInHF,"Jet_emEnergyInHF/F");
  muonTree->Branch("Jet_towersArea",&Jet_towersArea,"Jet_towersArea/F");
  muonTree->Branch("Jet_n90",&Jet_n90,"Jet_n90/F");
  muonTree->Branch("Jet_n60",&Jet_n60,"Jet_n60/F");

  muonTree->Branch("muon_Et",&muon_Et,"muon_Et/F");
  muonTree->Branch("muon_eta",&muon_eta,"muon_eta/F");
  muonTree->Branch("muon_theta",&muon_theta,"muon_theta/F");
  muonTree->Branch("muon_P",&muon_P,"muon_P/F");
  muonTree->Branch("muon_Pt",&muon_Pt,"muon_Pt/F");  
  muonTree->Branch("muon_Pt_jet",&muon_Pt_jet,"muon_Pt_jet/F");
  muonTree->Branch("muon_Py",&muon_Py,"muon_Py/F");

  muonTree->Branch("B_Et",&B_Et,"B_Et/F");
  muonTree->Branch("B_eta",&B_eta,"B_eta/F");
  muonTree->Branch("B_Pt",&B_Pt,"B_Pt/F");

  muonTree->Branch("C_Et",&C_Et,"C_Et/F");
  muonTree->Branch("C_eta",&C_eta,"C_eta/F");
  muonTree->Branch("C_Pt",&C_Pt,"C_Pt/F");

  muonTree->Branch("gen_muon_Et",&gen_muon_Et,"gen_muon_Et/F");
  muonTree->Branch("gen_muon_eta",&gen_muon_eta,"gen_muon_eta/F");
  muonTree->Branch("gen_muon_P",&gen_muon_P,"gen_muon_P/F");
  muonTree->Branch("gen_muon_Pt",&gen_muon_Pt,"gen_muon_Pt/F");

  muonTree->Branch("dr_muon",&dr_muon,"dr_muon/F");
  muonTree->Branch("dr_B",&dr_B,"dr_B/F");
  muonTree->Branch("dr_C",&dr_C,"dr_C/F");

  muonTree->Branch("muon_mother",&muon_mother,"muon_mother/I");
  muonTree->Branch("muon_mother_id",&muon_mother_id,"muon_mother_id/I");

  muonTree->Branch("W_mother_id",&W_mother_id,"W_mother_id/I");

  muonTree->Branch("DT", &DT , "DT/I"); 
  muonTree->Branch("DT_wheel", &DT_wheel , "DT_wheel/I"); 
  muonTree->Branch("DT_sector", &DT_sector , "DT_sector/I"); 
  muonTree->Branch("DT_station", &DT_station , "DT_station/I"); 
  muonTree->Branch("DT_layer", &DT_layer , "DT_layer/I"); 
  muonTree->Branch("DT_superlayer",&DT_superlayer," DT_superlayer/I"); 
  muonTree->Branch("CSC", &CSC , "CSC/I"); 
  muonTree->Branch("CSC_ring",& CSC_ring,"CSC_ring/I");
  muonTree->Branch("CSC_station",& CSC_station,"CSC_station/I");
  muonTree->Branch("CSC_endcap",& CSC_endcap,"CSC_endcap/I");
  muonTree->Branch("CSC_chamber" ,& CSC_chamber,"CSC_chamber/I");
  muonTree->Branch("SC_layer",& CSC_layer,"CSC_layer/I");
  muonTree->Branch("RPC", &RPC , "RPC/I"); 
  muonTree->Branch("RPC_layer",&RPC_layer,"RPC_layer/I");
  muonTree->Branch("RPC_region",&RPC_region,"RPC_region/I");
  muonTree->Branch("RPC_ring",&RPC_ring,"RPC_ring/I");
  muonTree->Branch("RPC_sector",&RPC_sector,"RPC_sector/I");
  muonTree->Branch("RPC_station",&RPC_station,"RPC_station/I");
  muonTree->Branch("RPC_subsector",&RPC_subsector,"RPC_subsector/I");
  
  muonTree->Branch("muon_global", &muon_global , "muon_global/I"); 
  muonTree->Branch("muon_global_chi2", &muon_global_chi2 , "muon_global_chi2/D"); 
  muonTree->Branch("muon_global_p",&muon_global_p," muon_global_p/D"); 
  muonTree->Branch("muon_global_pt",&muon_global_pt,  "muon_global_pt/D"); 
  muonTree->Branch("muon_global_outerP",& muon_global_outerP,"muon_global_outerP/D");  
  muonTree->Branch("muon_global_outerPt",& muon_global_outerPt,"muon_global_outerPt/D");
  muonTree->Branch("muon_global_ndof",&muon_global_ndof,"muon_global_ndof/D");
  muonTree->Branch("muon_global_normalizedChi2",& muon_global_normalizedChi2,"muon_global_normalizedChi2/D");
  muonTree->Branch("muon_global_recHitsSize",&muon_global_recHitsSize,"muon_global_recHitsSize/I");
  muonTree->Branch("muon_global_numberOfLostHits",& muon_global_numberOfLostHits,"muon_global_numberOfLostHits/I");
  muonTree->Branch("muon_global_numberOfValidHits",&muon_global_numberOfValidHits,"muon_global_numberOfValidHits/I");
  muonTree->Branch("muon_global_innerPosition_x",& muon_global_innerPosition_x,"muon_global_innerPosition_x/D");
  muonTree->Branch("muon_global_innerPosition_y",& muon_global_innerPosition_y,"muon_global_innerPosition_y/D");
  muonTree->Branch("muon_global_innerPosition_z",& muon_global_innerPosition_z,"muon_global_innerPosition_z/D");
  muonTree->Branch("muon_global_outerPosition_x",& muon_global_outerPosition_x,"muon_global_outerPosition_x/D");
  muonTree->Branch("muon_global_outerPosition_y",& muon_global_outerPosition_y,"muon_global_outerPosition_y/D");
  muonTree->Branch("muon_global_outerPosition_z",& muon_global_outerPosition_z,"muon_global_outerPosition_z/D");
  muonTree->Branch("muon_global_dz",&muon_global_dz,"muon_global_dz/D");
  muonTree->Branch("muon_global_dz_error",&muon_global_dz_error,"muon_global_dz_error/D");
  muonTree->Branch("muon_global_lasthit_x",&muon_global_lasthit_x,"muon_global_lasthit_x/D");
  muonTree->Branch("muon_global_lasthit_y",&muon_global_lasthit_y,"muon_global_lasthit_y/D");
  muonTree->Branch("muon_global_lasthit_z",&muon_global_lasthit_z,"muon_global_lasthit_z/D");

  muonTree->Branch("muon_STA", &muon_STA , "muon_STA/I"); 
  muonTree->Branch("muon_STA_chi2", &muon_STA_chi2 , "muon_STA_chi2/D"); 
  muonTree->Branch("muon_STA_p",&muon_STA_p," muon_STA_p/D"); 
  muonTree->Branch("muon_STA_pt",&muon_STA_pt,  "muon_STA_pt/D"); 
  muonTree->Branch("muon_STA_outerP",& muon_STA_outerP,"muon_STA_outerP/D");  
  muonTree->Branch("muon_STA_outerPt",& muon_STA_outerPt,"muon_STA_outerPt/D");
  muonTree->Branch("muon_STA_ndof",&muon_STA_ndof,"muon_STA_ndof/D");
  muonTree->Branch("muon_STA_normalizedChi2",& muon_STA_normalizedChi2,"muon_STA_normalizedChi2/D");
  muonTree->Branch("muon_STA_recHitsSize",&muon_STA_recHitsSize,"muon_STA_recHitsSize/I");
  muonTree->Branch("muon_STA_numberOfLostHits",& muon_STA_numberOfLostHits,"muon_STA_numberOfLostHits/I");
  muonTree->Branch("muon_STA_numberOfValidHits",&muon_STA_numberOfValidHits,"muon_STA_numberOfValidHits/I");
  muonTree->Branch("muon_STA_innerPosition_x",& muon_STA_innerPosition_x,"muon_STA_innerPosition_x/D");
  muonTree->Branch("muon_STA_innerPosition_y",& muon_STA_innerPosition_y,"muon_STA_innerPosition_y/D");
  muonTree->Branch("muon_STA_innerPosition_z",& muon_STA_innerPosition_z,"muon_STA_innerPosition_z/D");
  muonTree->Branch("muon_STA_outerPosition_x",& muon_STA_outerPosition_x,"muon_STA_outerPosition_x/D");
  muonTree->Branch("muon_STA_outerPosition_y",& muon_STA_outerPosition_y,"muon_STA_outerPosition_y/D");
  muonTree->Branch("muon_STA_outerPosition_z",& muon_STA_outerPosition_z,"muon_STA_outerPosition_z/D");
  muonTree->Branch("muon_STA_dz",&muon_STA_dz,"muon_STA_dz/D");
  muonTree->Branch("muon_STA_dz_error",&muon_STA_dz_error,"muon_STA_dz_error/D");

  muonTree->Branch("muon_track", &muon_track , "muon_track/I"); 
  muonTree->Branch("muon_track_chi2", &muon_track_chi2 , "muon_track_chi2/D"); 
  muonTree->Branch("muon_track_p",&muon_track_p," muon_track_p/D"); 
  muonTree->Branch("muon_track_pt",&muon_track_pt,  "muon_track_pt/D"); 
  muonTree->Branch("muon_track_outerP",& muon_track_outerP,"muon_track_outerP/D");  
  muonTree->Branch("muon_track_outerPt",& muon_track_outerPt,"muon_track_outerPt/D");
  muonTree->Branch("muon_track_ndof",&muon_track_ndof,"muon_track_ndof/D");
  muonTree->Branch("muon_track_normalizedChi2",& muon_track_normalizedChi2,"muon_track_normalizedChi2/D");
  muonTree->Branch("muon_track_recHitsSize",&muon_track_recHitsSize,"muon_track_recHitsSize/I");
  muonTree->Branch("muon_track_numberOfLostHits",& muon_track_numberOfLostHits,"muon_track_numberOfLostHits/I");
  muonTree->Branch("muon_track_numberOfValidHits",&muon_track_numberOfValidHits,"muon_track_numberOfValidHits/I");
  muonTree->Branch("muon_track_innerPosition_x",& muon_track_innerPosition_x,"muon_track_innerPosition_x/D");
  muonTree->Branch("muon_track_innerPosition_y",& muon_track_innerPosition_y,"muon_track_innerPosition_y/D");
  muonTree->Branch("muon_track_innerPosition_z",& muon_track_innerPosition_z,"muon_track_innerPosition_z/D");
  muonTree->Branch("muon_track_outerPosition_x",& muon_track_outerPosition_x,"muon_track_outerPosition_x/D");
  muonTree->Branch("muon_track_outerPosition_y",& muon_track_outerPosition_y,"muon_track_outerPosition_y/D");
  muonTree->Branch("muon_track_outerPosition_z",& muon_track_outerPosition_z,"muon_track_outerPosition_z/D");
  muonTree->Branch("muon_track_dz",&muon_track_dz,"muon_track_dz/D");
  muonTree->Branch("muon_track_dz_error",&muon_track_dz_error,"muon_track_dz_error/D");

 
  JetMuTree->Branch("nb_jet",&nb_jet,"nb_jet/I");
  JetMuTree->Branch("nb_jet_eta_cut",&nb_jet_eta_cut,"nb_jet_eta_cut/I");
  JetMuTree->Branch("nb_jet_eta_and_pt_cut",&nb_jet_eta_and_pt_cut,"nb_jet_eta_and_pt_cut/I");

  JetMuTree->Branch("nb_muon",&nb_muon,"nb_muon/I");

  JetMuTree->Branch("weight",    &eventWeight,  "weight/F");
  JetMuTree->Branch("processID", &processID, "processID/I");
  JetMuTree->Branch("alpgenID", &alpgenID, "alpgenID/I");
  JetMuTree->Branch("genEventScale",    &eventScale,  "genEventScale/F");
  JetMuTree->Branch("RunNumber", &RunNumber, "RunNumber/I");
  JetMuTree->Branch("EventID", &EventID, "EventID/I");

}


////////////////////////
// matching
//

class MatchingInfo {
public:

  MatchingInfo(float dr, int gen, int reco) : deltaR(dr), genMuon(gen),recoMuon(reco) {}
  
  bool operator<(const MatchingInfo m) { return deltaR < m.deltaR;}
  
  float deltaR;
  int   genMuon;
  int   recoMuon;
  
};


bool betterMatch2(MatchingInfo m1, MatchingInfo m2) 
{ return m1.deltaR < m2.deltaR;}


// method that gives the vector<MatchingInfo> matching_Infos containing (dR,i,j); i=genParticle index, j=ParticleCollection index:

void MuonAnalyzer::matching(const edm::Event& iEvent, Handle<reco::CandidateCollection> cands, int pdgid){

  using namespace edm;
  using namespace reco;
  using namespace std;

  //-------------------------
  Handle<CandidateCollection> mccands;
  iEvent.getByLabel( theMCTruthCollection,mccands );
  
  vector <GenParticleCandidate*> genparticles;
  
  for(CandidateCollection::const_iterator p = mccands->begin();
      p != mccands->end(); p++) {
    
    //  reco::Candidate* p_tmp = &(*p);
    reco::GenParticleCandidate* ptr = (reco::GenParticleCandidate*) &(*p);
    
    if ( (ptr)->status() == 1
         /*&& (ptr)->momentum().perp() > 2.*/ ) { // stable particles with pt>2 only
      if ( abs((ptr)->pdgId()) == pdgid ) {
        genparticles.push_back((ptr));
        //cout << "electron MCT\n";
      }
    }
  }
  

  int n1=0; 
  vector<MatchingInfo> matching_Infos;
  for ( unsigned int i=0; i<genparticles.size(); i++ ) // po svim MC muonima
    {
      
      for (unsigned int j = 0; j < cands->size(); j++)// po svim reco muonima
        {
          
          double d_eta2=(*cands)[j].eta()-(genparticles)[i]->eta();
          double d_phi=fabs((*cands)[j].phi()-(genparticles)[i]->phi());
          double dR_byhand= sqrt(d_eta2*d_eta2+d_phi*d_phi);
          double dR=dR_byhand;
          
          if (dR<0.15){
            n1++;
            matching_Infos.push_back(MatchingInfo(dR,i,j));
          }
          
        }
    } 
  
  sort(matching_Infos.begin(),matching_Infos.end(),betterMatch2);  // sorting (dR,i,j)   
  
  if (genparticles.size()!=0 && cands->size()!=0){
    // Now exclude combinations using same gen or rec muons
    for (std::vector<MatchingInfo>::iterator it=matching_Infos.begin();
         it != matching_Infos.end(); it++) {
      for (std::vector<MatchingInfo>::iterator it2=matching_Infos.begin();
           it2!=it; it2++) {
        if ( (it->genMuon == it2->genMuon) || (it->recoMuon == it2->recoMuon) ) {
          matching_Infos.erase(it);
          it=matching_Infos.begin();
          break;
        }
      }
    }
  }
  
   // Now put result in vector of pairs

   leptonMatching[pdgid].clear();
   
   for (vector<MatchingInfo>::iterator match=matching_Infos.begin();
        match !=matching_Infos.end(); match++) { // po tablici dr,i,j

     pair<const GenParticleCandidate*, const reco::Candidate *> pair;
     //     vector<pair,float > matchedParticles;
     pair.first = genparticles[match->genMuon];
     pair.second = & (*cands)[match->recoMuon];

     matchedParticles cestice(genparticles[match->genMuon] ,& (*cands)[match->recoMuon] , match->deltaR);

     leptonMatching[pdgid].push_back(cestice);

   }
  
}


/////////////////////////////////////////////////////////////////////
//   made for muon fake rate
// method that gives the vector<MatchingInfo> matching_Infos containing (dR,i,j); i=genParticle index, j=ParticleCollection index:

void MuonAnalyzer::matching_JetsWithMuons(const edm::Event& iEvent, Handle<reco::CandidateCollection> cands, Handle<reco::CaloJetCollection> jets){

  using namespace edm;
  using namespace reco;
  using namespace std;

  //  cout <<" ulazi u matching_JetsWithMuons" <<endl;
  
  int n1=0; 
  vector<MatchingInfo> matching_Infos;
  //  cout <<"# jets="<<jets->size()<< "  # muons="<<cands->size() << endl;
  for ( unsigned int i=0; i<jets->size(); i++ ) // po svim jetovima
    {
      //      cout <<"    next jet" <<endl;    
      for (unsigned int j = 0; j < cands->size(); j++)// po svim reco muonima
        {
          //      cout <<"    next muon" <<endl;          
          double d_eta2=(*cands)[j].eta()-(*jets)[i].eta();
          double d_phi=fabs((*cands)[j].phi()-(*jets)[i].phi());
          double dR_byhand= sqrt(d_eta2*d_eta2+d_phi*d_phi);
          double dR=dR_byhand;
          //      cout <<"dR="<< dR <<endl;       
          //      if (dR<0.15){
            n1++;
            matching_Infos.push_back(MatchingInfo(dR,i,j));
            //    }
          
        }
    } 
  
  sort(matching_Infos.begin(),matching_Infos.end(),betterMatch2);  // sorting (dR,i,j)   
  
  if (jets->size()!=0 && cands->size()!=0){
    // Now exclude combinations using same gen or rec muons
    for (std::vector<MatchingInfo>::iterator it=matching_Infos.begin();
         it != matching_Infos.end(); it++) {
      for (std::vector<MatchingInfo>::iterator it2=matching_Infos.begin();
           it2!=it; it2++) {
        if ( (it->genMuon == it2->genMuon) || (it->recoMuon == it2->recoMuon) ) {
          matching_Infos.erase(it);
          it=matching_Infos.begin();
          break;
        }
      }
    }
  }
  
   // Now t in vector of pairs

   Muon_Jet_Matching[1].clear();
   
   for (vector<MatchingInfo>::iterator match=matching_Infos.begin();
        match !=matching_Infos.end(); match++) { // po tablici dr,i,j

     pair<const CaloJet*, const reco::Candidate *> pair;
     //     vector<pair,float > matchedParticles;
     pair.first = &(*jets)[match->genMuon];
     pair.second = & (*cands)[match->recoMuon];

     matchedJets_and_Muons cestice(&(*jets)[match->genMuon] ,& (*cands)[match->recoMuon] , match->deltaR);

     Muon_Jet_Matching[1].push_back(cestice);

   }

   //   cout <<" nakon pisanja u Muon_Jet_Matching[1]" << endl;
   for (vector<MatchingInfo>::iterator match=matching_Infos.begin();
        match !=matching_Infos.end(); match++) { // po tablici dr,i,j
     //    cout <<" nakon pisanja u Muon_Jet_Matching[1]" << endl;
     for (map< int, 
            std::vector< matchedJets_and_Muons >   > ::iterator iter = Muon_Jet_Matching.begin();
          iter!=Muon_Jet_Matching.end();   iter++) // entire map
       {
         for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
           const reco::Candidate * nesto=iter->second[j].pair.second;
           //      ::OverlapChecker overlap;
           //      if (overlap(*nesto,*daughter)){
           //      cout <<"*****dr="<< iter->second[j].delta_R<<endl;
             //      cout <<"*****dr="<< iter->second[j].delta_R<<endl;
             //    }
         }
         
         
         }
     
     
     }
  
}

/////////////////////////////////////////////////////////////////////
//   made for muon fake rate
// method that gives the vector<MatchingInfo> matching_Infos containing (dR,i,j); i=genParticle index, j=ParticleCollection index:

void MuonAnalyzer::matching_JetsWithB(const edm::Event& iEvent, Handle<reco::CaloJetCollection> jets){

  //  cout <<" ulazi u matching_JetsWithB" <<endl;

  using namespace edm;
  using namespace reco;
  using namespace std;

  Handle<CandidateCollection> mccands;
  iEvent.getByLabel( theMCTruthCollection,mccands );

  vector <GenParticleCandidate*> genBparticles;  // vector u kojem su svi B hadroni cija majka nije B hadron (b kvark)
  //  vector <GenParticleCandidate*> genCparticles;  // vector u kojem su svi D hadroni cija majka nije D niti B hadron (c kvark)
  

  for(CandidateCollection::const_iterator p = mccands->begin();
      p != mccands->end(); p++) {

    reco::GenParticleCandidate* ptr = (reco::GenParticleCandidate*) &(*p); 

    ///////////////////////////////////////////////////////
    if ((((abs(ptr->pdgId()))/100)%10 ==5)||(((abs(ptr->pdgId()))/1000)%10 ==5  )) {  // b
      if ((((abs(ptr->mother()->pdgId()))/100)%10 !=5)&&(((abs(ptr->mother()->pdgId()))/1000)%10 !=5  )) genBparticles.push_back(ptr); // mother is not b
    }
    
    ///////////////////////////////////////////////////////

  
//     int pdg_id=ptr->pdgId();
//     //  cout << "particle id : " << pdg_id << endl;
    
//     while ( ptr ->mother()!=0 )  {  //izvrsava se sve dok ne dodje do nule tj. dok ne trazi majku od protona
//       //    cout << "Going up: ";
//       //    cout << "Mother id : " << genParticle->pdgId() << endl;
//       ptr= (reco::GenParticleCandidate*) ptr->mother();

//       if (abs(ptr->pdgId())!=abs(pdg_id)) {
//      //      cout<< " good mother " <<endl;

//      if ((((abs(ptr->pdgId()))/100)%10 ==5)||(((abs(ptr->pdgId()))/1000)%10 ==5  )) {  // mother is b
//        //      while (ptr = const_cast<reco::GenParticleCandidate *>(dynamic_cast<const reco::GenParticleCandidate *>(ptr->mother()))) {
//        while (ptr ->mother()!=0) {
            
//          //      ptr= (reco::GenParticleCandidate*) ptr->mother();
//          //      if ((((abs(ptr->pdgId()))/100)%10 !=5)||(((abs(ptr->pdgId()))/1000)%10 !=5  )){ // ako majka nije b
//          if ((((abs(ptr ->mother()->pdgId()))/100)%10 !=5)||(((abs(ptr ->mother()->pdgId()))/1000)%10 !=5  )){ // ako majka nije b
//            genBparticles.push_back(ptr);
//            break;
//          }
//          ptr= (reco::GenParticleCandidate*) ptr->mother();
//        }
          
//      }          
        
//       }
      
//     }

  }
  
  int n1=0; 
  vector<MatchingInfo> matching_Infos;
  //  cout <<"# jets="<<jets->size()<< "  # B hadrons="<<genBparticles.size() << endl;
  for ( unsigned int i=0; i<genBparticles.size(); i++ ) // po svim MC B hadronima 
    {
      //      cout <<"    next B hadron" <<endl;    
      for (unsigned int j = 0; j < jets->size(); j++)// po svim jetovima
        {
          //      cout <<"    next jet" <<endl;           
          double d_eta2=(*jets)[j].eta()-(genBparticles)[i]->eta();
          double d_phi=fabs((*jets)[j].phi()-(genBparticles)[i]->phi());
          double dR_byhand= sqrt(d_eta2*d_eta2+d_phi*d_phi);
          double dR=dR_byhand;
          //      cout <<"dR="<< dR <<endl;       
          //      if (dR<0.15){
            n1++;
            matching_Infos.push_back(MatchingInfo(dR,i,j));
            //    }
          
        }
    } 
  
  sort(matching_Infos.begin(),matching_Infos.end(),betterMatch2);  // sorting (dR,i,j)   
  
  if (jets->size()!=0 && genBparticles.size()!=0){
    // Now exclude combinations using same gen or rec muons
    for (std::vector<MatchingInfo>::iterator it=matching_Infos.begin();
         it != matching_Infos.end(); it++) {
      for (std::vector<MatchingInfo>::iterator it2=matching_Infos.begin();
           it2!=it; it2++) {
        if ( (it->genMuon == it2->genMuon) || (it->recoMuon == it2->recoMuon) ) {
          matching_Infos.erase(it);
          it=matching_Infos.begin();
          break;
        }
      }
    }
  }
  
   // Now t in vector of pairs

   B_Jet_Matching[1].clear();
   
   for (vector<MatchingInfo>::iterator match=matching_Infos.begin();
        match !=matching_Infos.end(); match++) { // po tablici dr,i,j

     pair<const GenParticleCandidate*, const CaloJet*> pair;
     //     vector<pair,float > matchedParticles;
     pair.first = genBparticles[match->genMuon];
     pair.second = &(*jets)[match->recoMuon];

     matchedJets_and_B cestice(genBparticles[match->genMuon],&(*jets)[match->recoMuon] , match->deltaR);

     B_Jet_Matching[1].push_back(cestice);

   }
   
   //   cout <<" nakon pisanja u B_Jet_Matching[1]" << endl;
   for (vector<MatchingInfo>::iterator match=matching_Infos.begin();
        match !=matching_Infos.end(); match++) { // po tablici dr,i,j
     //    int j=0;
     for (map< int, 
            std::vector< matchedJets_and_B >   > ::iterator iter = B_Jet_Matching.begin();
          iter!=B_Jet_Matching.end();   iter++) // entire map
       {
         for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
           const reco::Candidate * nesto=iter->second[j].pair.second;
           //      ::OverlapChecker overlap;
           //      if (overlap(*nesto,*daughter)){
           //      cout <<"*****dr="<< iter->second[j].delta_R<<endl;
           //        cout <<"*****dr="<< iter->second[j].delta_R<<endl;
           //      }
         }
 
       }
    
   }
   
}

/////////////////////////////////////////////////////////////////////
//   made for muon fake rate
// method that gives the vector<MatchingInfo> matching_Infos containing (dR,i,j); i=genParticle index, j=ParticleCollection index:

void MuonAnalyzer::matching_JetsWithC(const edm::Event& iEvent, Handle<reco::CaloJetCollection> jets){

  //  cout <<" ulazi u matching_JetsWithC" <<endl;

  using namespace edm;
  using namespace reco;
  using namespace std;

  Handle<CandidateCollection> mccands;
  iEvent.getByLabel( theMCTruthCollection,mccands );

  vector <GenParticleCandidate*> genCparticles;  // vector u kojem su svi D hadroni cija majka nije D niti B hadron (c kvark)
  
  for(CandidateCollection::const_iterator p = mccands->begin();
      p != mccands->end(); p++) {

    reco::GenParticleCandidate* ptr = (reco::GenParticleCandidate*) &(*p);   

    if ((((abs(ptr->pdgId()))/100)%10 ==4)||(((abs(ptr->pdgId()))/1000)%10 ==4  )) {  // c
      if ((((abs(ptr->mother()->pdgId()))/100)%10 !=4)&&(((abs(ptr->mother()->pdgId()))/1000)%10 !=4  )
          && (((abs(ptr->mother()->pdgId()))/100)%10 !=5)&&(((abs(ptr->mother()->pdgId()))/1000)%10 !=5  )) 
        genCparticles.push_back(ptr);  // mother is not b or c
    }
    
//     int pdg_id=ptr->pdgId();
//     //  cout << "particle id : " << pdg_id << endl;
    
//     while (ptr->mother()!=0) {  //izvrsava se sve dok ne dodje do nule tj. dok ne trazi majku od protona
//       //    cout << "Going up: ";
//       //    cout << "Mother id : " << genParticle->pdgId() << endl;
//       ptr= (reco::GenParticleCandidate*) ptr->mother();
//       if (abs(ptr->pdgId())!=abs(pdg_id)) {
//      //      cout<< " good mother " <<endl;

           
//      if ((((abs(ptr->pdgId()))/100)%10 ==4)||(((abs(ptr->pdgId()))/1000)%10 ==4  )) {  // mother is c
//        while (ptr->mother()!=0) {
//          //      ptr= (reco::GenParticleCandidate*) ptr->mother();       
//          if (((((abs(ptr->mother()->pdgId()))/100)%10 !=4)||(((abs(ptr->mother()->pdgId()))/1000)%10 !=4  )) && 
//              ((((abs(ptr->mother()->pdgId()))/100)%10 !=5)||(((abs(ptr->mother()->pdgId()))/1000)%10 !=5  ))){ // ako majka nije c niti b
//            genCparticles.push_back(ptr);
//            break;
//          }
//          ptr= (reco::GenParticleCandidate*) ptr->mother();    
//        }
//      }
        

//       }
//     }
    
  }
  
  int n1=0; 
  vector<MatchingInfo> matching_Infos;
  //  cout <<"# jets="<<jets->size()<< "  # C hadrons="<<genCparticles.size() << endl;
  for ( unsigned int i=0; i<genCparticles.size(); i++ ) // po svim MC B hadronima 
    {
      //      cout <<"    next B hadron" <<endl;    
      for (unsigned int j = 0; j < jets->size(); j++)// po svim jetovima
        {
          //      cout <<"    next jet" <<endl;           
          double d_eta2=(*jets)[j].eta()-(genCparticles)[i]->eta();
          double d_phi=fabs((*jets)[j].phi()-(genCparticles)[i]->phi());
          double dR_byhand= sqrt(d_eta2*d_eta2+d_phi*d_phi);
          double dR=dR_byhand;
          //      cout <<"dR="<< dR <<endl;       
          //      if (dR<0.15){
            n1++;
            matching_Infos.push_back(MatchingInfo(dR,i,j));
            //    }
          
        }
    } 
  
  sort(matching_Infos.begin(),matching_Infos.end(),betterMatch2);  // sorting (dR,i,j)   
  
  if (jets->size()!=0 && genCparticles.size()!=0){
    // Now exclude combinations using same gen or rec muons
    for (std::vector<MatchingInfo>::iterator it=matching_Infos.begin();
         it != matching_Infos.end(); it++) {
      for (std::vector<MatchingInfo>::iterator it2=matching_Infos.begin();
           it2!=it; it2++) {
        if ( (it->genMuon == it2->genMuon) || (it->recoMuon == it2->recoMuon) ) {
          matching_Infos.erase(it);
          it=matching_Infos.begin();
          break;
        }
      }
    }
  }
  
   // Now t in vector of pairs

   C_Jet_Matching[1].clear();
   
   for (vector<MatchingInfo>::iterator match=matching_Infos.begin();
        match !=matching_Infos.end(); match++) { // po tablici dr,i,j

     pair<const GenParticleCandidate*, const CaloJet*> pair;
     //     vector<pair,float > matchedParticles;
     pair.first = genCparticles[match->genMuon];
     pair.second = &(*jets)[match->recoMuon];

     matchedJets_and_C cestice(genCparticles[match->genMuon],&(*jets)[match->recoMuon] , match->deltaR);

     C_Jet_Matching[1].push_back(cestice);

   }

   //   cout <<" nakon pisanja u C_Jet_Matching[1]" << endl;
   for (vector<MatchingInfo>::iterator match=matching_Infos.begin();
        match !=matching_Infos.end(); match++) { // po tablici dr,i,j
     for (map< int, 
            std::vector< matchedJets_and_B >   > ::iterator iter = B_Jet_Matching.begin();
          iter!=B_Jet_Matching.end();   iter++) // entire map
       {
         for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
           const reco::Candidate * nesto=iter->second[j].pair.second;
           //      ::OverlapChecker overlap;
           //      if (overlap(*nesto,*daughter)){
           //      cout <<"*****dr="<< iter->second[j].delta_R<<endl;
             //      cout <<"*****dr="<< iter->second[j].delta_R<<endl;
             //    }
         }
                 
       }
     
     
   }
   
}


//---------------------------------------------------


// get mother of particle 
// returns mother = 1 if mother is Z boson
// returns mother = 2 if mother is W boson
// returns mother = 4 if mother is b
// returns mother = 0 else 

MuonAnalyzer::LeptonOrigin MuonAnalyzer::getMother(const reco::Candidate* genParticle){

  int pdg_id=genParticle->pdgId();
  //  cout << "particle id : " << pdg_id << endl;

  while (genParticle = genParticle->mother() ) {  //izvrsava se sve dok ne dodje do nule tj. dok ne trazi majku od protona
    //    cout << "Going up: ";
    //    cout << "Mother id : " << genParticle->pdgId() << endl;
    if (abs(genParticle->pdgId())!=abs(pdg_id)) {
      //      cout<< " good mother " <<endl;
      if (abs(genParticle->pdgId())==23){ // mother is Z
        return zboson;
      } 
      if (abs(genParticle->pdgId())==24) { // mother is W
        return wboson;
      }
      //       if (abs(genParticle->pdgId())==23 || abs(genParticle->pdgId())==24) { // mother is W or Z
      //        WZ_matched=1; 
      //        mother=3;
      //       } 
      if ((((abs(genParticle->pdgId()))/100)%10 ==5)||(((abs(genParticle->pdgId()))/1000)%10 ==5  )) {  // mother is b
        return bdecay;
      }    
      if ((((abs(genParticle->pdgId()))/100)%10 ==4)||(((abs(genParticle->pdgId()))/1000)%10 ==4  )) {  // mother is c
        return cdecay;
      }    
      if (abs(genParticle->pdgId()==6)) {  // mother is t
        return tdecay;
      }    
      return other;
    }
  }

  return other; 
}

const reco::Candidate * MuonAnalyzer::getMother_particle(const reco::Candidate* genParticle){

  int pdg_id=genParticle->pdgId();
  //  cout << "particle id : " << pdg_id << endl;

  while (genParticle = genParticle->mother() ) {  //izvrsava se sve dok ne dodje do nule tj. dok ne trazi majku od protona
    //    cout << "Going up: ";
    //    cout << "Mother id : " << genParticle->pdgId() << endl;
    if (abs(genParticle->pdgId())!=abs(pdg_id)) {
      //      cout<< " good mother " <<endl;
      return genParticle->mother();
    }
  }

  return 0;
}


///////////////////
int MuonAnalyzer::getMother_Id(const reco::Candidate* genParticle){

  int mother_id=0;

  int pdg_id=genParticle->pdgId();
  //  cout << "particle id : " << pdg_id << endl;

  while (genParticle = genParticle->mother() ) {  //izvrsava se sve dok ne dodje do nule tj. dok ne trazi majku od protona
    if (abs(genParticle->pdgId())!=abs(pdg_id)) {
      mother_id=genParticle->pdgId();
      return mother_id; 
    }
  }
  
  return mother_id; 
}

/////////////////


const reco::Candidate * MuonAnalyzer::MatchedGenParticle(const reco::Candidate * daughter){
  ::OverlapChecker overlap;
  matched_genParticle=0;

  for (map< int, 
         std::vector<  matchedParticles >   > ::iterator iter = leptonMatching.begin();
       iter!=leptonMatching.end();   iter++) // entire map
    {
      for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
        const reco::Candidate * nesto=iter->second[j].pair.second;
        if (overlap(*nesto,*daughter)){
          matched_genParticle=iter->second[j].pair.first;
        }
      }
    }
  return matched_genParticle;
}

/////////////////////////////////////////
// for muon fake rate

const reco::Candidate * MuonAnalyzer::MatchedMuonWithJet(const reco::CaloJet * daughter){
  ::OverlapChecker overlap;
  matched_Muon=0;

  for (map< int, 
         std::vector< matchedJets_and_Muons >   > ::iterator iter = Muon_Jet_Matching.begin();
       iter!=Muon_Jet_Matching.end();   iter++) // entire map
    {
      //      cout <<" ide preko cijele mape za jet" <<endl;
      for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
        const  reco::CaloJet * nesto=iter->second[j].pair.first;
        if (overlap(*nesto,*daughter)){
          matched_Muon=iter->second[j].pair.second;  /// tu je bila greska
        }
      }
    }
  return matched_Muon;
}


/////////////////////////////
// Jet and B hadron matching

const reco::Candidate * MuonAnalyzer::MatchedBhadronWithJet(const reco::CaloJet * daughter){
  ::OverlapChecker overlap;
  matched_B=0;

  for (map< int, 
         std::vector< matchedJets_and_B >   > ::iterator iter = B_Jet_Matching.begin();
       iter!=B_Jet_Matching.end();   iter++) // entire map
    {
      //      cout <<" ide preko cijele mape za jet" <<endl;
      for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
        const  reco::CaloJet * nesto=iter->second[j].pair.second;
        if (overlap(*nesto,*daughter)){
          matched_B=iter->second[j].pair.first;  /// tu je bila greska
        }
      }
    }
  return matched_B;
}

/////////////////////////////
// Jet and C hadron matching

const reco::Candidate * MuonAnalyzer::MatchedChadronWithJet(const reco::CaloJet * daughter){
  ::OverlapChecker overlap;
  matched_C=0;

  for (map< int, 
         std::vector< matchedJets_and_C >   > ::iterator iter = C_Jet_Matching.begin();
       iter!=C_Jet_Matching.end();   iter++) // entire map
    {
      //      cout <<" ide preko cijele mape za jet" <<endl;
      for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
        const  reco::CaloJet * nesto=iter->second[j].pair.second;
        if (overlap(*nesto,*daughter)){
          matched_C=iter->second[j].pair.first;  /// tu je bila greska
        }
      }
    }
  return matched_C;
}


float MuonAnalyzer::dR(const reco::Candidate * daughter){

  ::OverlapChecker overlap;

  float delta_r = -10;
  for (map< int, 
         std::vector<  matchedParticles >   > ::iterator iter = leptonMatching.begin();
       iter!=leptonMatching.end();   iter++) // entire map
    {
      for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
        const reco::Candidate * nesto=iter->second[j].pair.second;
        if (overlap(*nesto,*daughter)){
          delta_r=iter->second[j].delta_R;
        }
      }
    }
  return delta_r;
}

float MuonAnalyzer::dR_Muon_Jet(const reco::CaloJet * daughter){

  ::OverlapChecker overlap;

  float delta_r = -10;
  for (map< int, 
         std::vector<matchedJets_and_Muons > > ::iterator iter = Muon_Jet_Matching.begin();
       iter!=Muon_Jet_Matching.end();   iter++) // entire map
    {
      for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
        const reco::CaloJet * nesto=iter->second[j].pair.first;
        if (overlap(*nesto,*daughter)){
          delta_r=iter->second[j].delta_R;
        }
      }
    }
  return delta_r;
}

float MuonAnalyzer::dR_B_Jet(const reco::CaloJet * daughter){

  ::OverlapChecker overlap;

  float delta_r = -10;
  for (map< int, 
         std::vector<matchedJets_and_B > > ::iterator iter = B_Jet_Matching.begin();
       iter!=B_Jet_Matching.end();   iter++) // entire map
    {
      for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
        const reco::CaloJet * nesto=iter->second[j].pair.second;
        if (overlap(*nesto,*daughter)){
          delta_r=iter->second[j].delta_R;
        }
      }
    }
  return delta_r;
}

float MuonAnalyzer::dR_C_Jet(const reco::CaloJet * daughter){

  ::OverlapChecker overlap;

  float delta_r = -10;
  for (map< int, 
         std::vector<matchedJets_and_C > > ::iterator iter = C_Jet_Matching.begin();
       iter!=C_Jet_Matching.end();   iter++) // entire map
    {
      for (unsigned int j=0; j<iter->second.size(); j++){ // entire vector<class<>>
        const reco::CaloJet * nesto=iter->second[j].pair.second;
        if (overlap(*nesto,*daughter)){
          delta_r=iter->second[j].delta_R;
        }
      }
    }
  return delta_r;
}


void MuonAnalyzer::collectMCsummary(Handle <reco::CandidateCollection> mccands) {
 
  using namespace reco;

  //collections

  MCleptZ1_pdgid = -1;
  MCleptZ2_pdgid = -1;
  MCleptW_pdgid = -1;

  MCleptZ1_pt = -1;
  MCleptZ2_pt = -1;
  MCleptW_pt = -1;
  
  MCleptZ1_eta = -1;
  MCleptZ2_eta = -1;
  MCleptW_eta = -1;
  
  MCleptZ1_phi = -1;
  MCleptZ2_phi = -1;
  MCleptW_phi = -1;
   
  vector<reco::GenParticleCandidate*> Tau;
  vector<reco::GenParticleCandidate*> StableMuons;
  vector<reco::GenParticleCandidate*> StableElectrons;

  
  for(CandidateCollection::const_iterator p = mccands->begin();
      p != mccands->end(); p++) {

    //  reco::Candidate* p_tmp = &(*p);
    reco::GenParticleCandidate* ptr = (reco::GenParticleCandidate*) &(*p);
  
        if ( (ptr)->status() == 1
                /*&& (ptr)->momentum().perp() > 2.*/ ) { // stable particles with pt>2 only
                if ( abs((ptr)->pdgId()) == 11 ) {

                        StableElectrons.push_back((ptr));
                        //cout << "electron MCT\n";
                }
                else if ( abs((ptr)->pdgId()) == 13 ) {

                        StableMuons.push_back((ptr)) ;
                        //cout << "muon MCT\n";
                }
        }
        else if ((ptr)->status() == 2) {
                if ( abs((ptr)->pdgId()) == 15 ) {//tau
                        Tau.push_back((ptr));
                }
        }
  }

//   std::cout << "# Electrons : " << StableElectrons.size()
//          << "# Muons     : " << StableMuons.size() << std::endl
//          << "# Tau     : " << Tau.size() << std::endl;


  vector<reco::GenParticleCandidate*> * StableLeptons[3] = {&StableElectrons, &StableMuons, &Tau};

  vector<reco::GenParticleCandidate*> TauChildLeptons;

  
   //erase electrons and muons from tau from GenparticleCandidate Vector and put to Tau Vector
   for (int i=1; i>=0; i--) {
       for (   vector<reco::GenParticleCandidate*>::iterator lepton = StableLeptons[i]->begin();
               lepton != StableLeptons[i]->end();lepton++) {

                reco::GenParticleCandidate* mcParticleRef = *lepton;

               int parentItr=0;
                 while ( mcParticleRef->mother()!=0 && parentItr<2) {

                         parentItr++;

                         mcParticleRef = (reco::GenParticleCandidate*) mcParticleRef->mother();
                         if (mcParticleRef==0) break;

                         //if tau
                         if (abs((mcParticleRef)->pdgId())==15 ) {
                               //put into collection
                               TauChildLeptons.push_back(*lepton);
                               StableLeptons[i]->erase(lepton);
                               lepton--;
                               break;
                         }
               }
       }
   }


  bool firstZlept = true;
  int MC_tauDecayTypeZ1 = 0;
  int MC_tauDecayTypeZ2 = 0;
  int MC_tauDecayTypeW  = 0;


  for (int i=2; i>=0; i--) {
        while (StableLeptons[i]->size() > 0) {
                float maxPt = 0;
                vector<reco::GenParticleCandidate*>::iterator  index = StableLeptons[i]->end();

                for (   vector<reco::GenParticleCandidate*>::iterator lepton = StableLeptons[i]->begin();
                        lepton != StableLeptons[i]->end(); lepton++ ) {

                        if ((*lepton)->pt() > maxPt) {
                                maxPt = (*lepton)->pt();
                                index = lepton;
                        }
                }
                bool Zchild = false;
                bool Wchild = false;
                bool isTau = false;

        
                reco::GenParticleCandidate* mcParticleRef = *index;

                if (abs((*index)->pdgId()) == 15) isTau = true;

                //find W/Z mother
                int parentItr=0;
                while ( mcParticleRef->mother()!=0 && parentItr<2) {

                        if (parentItr>=2) break;
                        parentItr++;
                        mcParticleRef = (reco::GenParticleCandidate*) mcParticleRef->mother();
                        if (mcParticleRef==0) break;

                        if (abs((mcParticleRef)->pdgId())==23  ) {
                                Zchild=true;
                                break;
                        }
                        if (abs((mcParticleRef)->pdgId())==24  ) {
                                Wchild=true;
                                break;
                        }
                }
        
                
                if (maxPt >0) {
                        int * MCtauDecayTypePtr = 0;
        
                        if (Wchild) {
                                MCleptW_pdgid=(*index)->pdgId();
                                MCleptW_pt=(float)(*index)->pt();
                                MCleptW_eta=(float)(*index)->eta();
                                MCleptW_phi=(float)(*index)->phi();
                               if (isTau) {
                                       MCtauDecayTypePtr = &MC_tauDecayTypeW;
                                       MC_tauDecayTypeW =3;//default to hadronic decay
                               }

                        }
                        if (Zchild) {
                                if (firstZlept) {
                                        firstZlept=false;
                                        MCleptZ1_pdgid=(*index)->pdgId();
                                        MCleptZ1_pt=(float)(*index)->pt();
                                        MCleptZ1_eta=(float)(*index)->eta();
                                        MCleptZ1_phi=(float)(*index)->phi();
                                        if (isTau) {
                                                MCtauDecayTypePtr = &MC_tauDecayTypeZ1;
                                                MC_tauDecayTypeZ1 =3;
                                        }

                                }
                                else  {
                                        MCleptZ2_pdgid=(*index)->pdgId();
                                        MCleptZ2_pt=(float)(*index)->pt();
                                        MCleptZ2_eta=(float)(*index)->eta();
                                        MCleptZ2_phi=(float)(*index)->phi();
                                       if (isTau) {
                                               MCtauDecayTypePtr = &MC_tauDecayTypeZ2;
                                               MC_tauDecayTypeZ2 =3;
                                       }

                                }
                        }
                       //check type of tau decay
                       if (MCtauDecayTypePtr) {
                               for( vector<reco::GenParticleCandidate*>::iterator p = TauChildLeptons.begin();p != TauChildLeptons.end(); p++) {
                                       int pitr = 0;
                                       reco::GenParticleCandidate* mcParticleRef = *p;
                                       while (mcParticleRef->mother() && pitr<2) {
                                               pitr++;
                                               mcParticleRef =(reco::GenParticleCandidate*) mcParticleRef->mother();
                                               if (mcParticleRef==0) break;
                                               if (mcParticleRef == *index) {
                                                       if (abs((*p)->pdgId()) == 11) *MCtauDecayTypePtr = 1;
                                                       if (abs((*p)->pdgId()) == 13) *MCtauDecayTypePtr = 2;
                                               }
                                       }
                                }
                        }
                }
                StableLeptons[i]->erase(index);
        }
  }
}
//define this as a plug-in
// DEFINE_FWK_MODULE(WZAnalyzer);

Revision:	1.9
Committed:	Fri Jul 4 18:52:23 2008 UTC (16 years, 9 months ago) by ymaravin
Content type:	text/plain
Branch:	MAIN
CVS Tags:	keti_Aug25_01, keti-Aug5-2008-01, keti-Aug4-2008-01, ym-1-6-12-01, HEAD
Changes since 1.8:	+6 -6 lines
Log Message:	Updates for 1_6_12 release