SFrameAnalysis/src/Cleaner.cxx

#include "../include/Cleaner.h"


Cleaner::Cleaner( BaseCycleContainer* input){

  bcc = input;

}

void Cleaner::JetEnergyResolutionShifter(int syst_shift){

  double met = 0;
  if(bcc->met) met=bcc->met->pt();

  for(unsigned int i=0; i<bcc->jets->size(); ++i){
    Jet jet = bcc->jets->at(i);
    float gen_pt = jet.genjet_pt();
    //ignore unmatched jets (which have zero vector) or jets with very low pt:
    if(gen_pt < 15.0) continue;

    met += jet.pt()*jet.JEC_factor_raw();
    
    float recopt = jet.pt();
    double factor = -10;
    double abseta = fabs(jet.eta());

    //numbers taken from https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution
    if(syst_shift==0){
      if(abseta < 0.5)
        factor = 0.052;
      else if(abseta >= 0.5 && abseta <1.1)
        factor = 0.057;
      else if(abseta >= 1.1 && abseta <1.7)
        factor = 0.096;
      else if(abseta >= 1.7 && abseta <2.3)
        factor = 0.134;
      else if(abseta >= 2.3)
        factor = 0.288;
    }
    else if(syst_shift>0){
      if(abseta < 0.5)
        factor = 0.11;
      else if(abseta >= 0.5 && abseta <1.1)
        factor = 0.12;
      else if(abseta >= 1.1 && abseta <1.7)
        factor = 0.16;
      else if(abseta >= 1.7 && abseta <2.3)
        factor = 0.23;
      else if(abseta >= 2.3)
        factor = 0.49;
    }
    else{
      if(abseta < 0.5)
        factor = -0.01;
      else if(abseta >= 0.5 && abseta <1.1)
        factor = 0.00;
      else if(abseta >= 1.1 && abseta <1.7)
        factor = 0.04;
      else if(abseta >= 1.7 && abseta <2.3)
        factor = 0.03;
      else if(abseta >= 2.3)
        factor = 0.09;
    }

    float deltapt = (recopt - gen_pt) * factor;
    float ptscale = std::max(0.0f, (recopt + deltapt) / recopt);
    jet.set_pt(jet.pt() * ptscale);
    bcc->jets->at(i).set_pt( jet.pt());

    //propagate JER shifts to MET
    met -= jet.pt()*jet.JEC_factor_raw();
  }
  
  //store changed MET, flip phi if new MET is negative
  if(bcc->met){
    if(met>=0){
      bcc->met->set_pt( met);
    }
    else{
      bcc->met->set_pt( -1*met);
      if(bcc->met->phi()<=0)
        bcc->met->set_phi (bcc->met->phi()+PI);
      else
        bcc->met->set_phi (bcc->met->phi()-PI);
    }
  }

  sort(bcc->jets->begin(), bcc->jets->end(), HigherPt());
}


void Cleaner::JetLeptonSubtractor(FactorizedJetCorrector *corrector){

  double met = 0;
  if(bcc->met) met=bcc->met->pt();

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

    LorentzVector jet_v4_raw = bcc->jets->at(i).v4()*bcc->jets->at(i).JEC_factor_raw();

    met-=bcc->jets->at(i).pt();

    //subtract lepton momenta from raw jet momentum
    if(bcc->electrons){
      for(unsigned int j=0; j<bcc->electrons->size(); ++j){
        if(bcc->jets->at(i).deltaR(bcc->electrons->at(j))<0.5){
          jet_v4_raw -= bcc->electrons->at(j).v4();
        }
      }
    }
    if(bcc->muons){
      for(unsigned int j=0; j<bcc->muons->size(); ++j){
        jet_v4_raw -= bcc->muons->at(j).v4();
      }
    }

    //apply jet energy corrections to modified raw momentum
    
    corrector->setJetPt(jet_v4_raw.Pt());
    corrector->setJetEta(jet_v4_raw.Eta());
    corrector->setJetE(jet_v4_raw.E());  
    corrector->setJetA(bcc->jets->at(i).jetArea());
    corrector->setRho(bcc->rho);

    float correctionfactor = corrector->getCorrection();
    LorentzVector jet_v4_corrected = jet_v4_raw *correctionfactor;

    bcc->jets->at(i).set_v4(jet_v4_corrected);
    bcc->jets->at(i).set_JEC_factor_raw(1./correctionfactor);

    met+=bcc->jets->at(i).pt();
    
  }

  //store changed MET, flip phi if new MET is negative
  if(bcc->met){
    if(met>=0){
      bcc->met->set_pt( met);
    }
    else{
      bcc->met->set_pt( -1*met);
      if(bcc->met->phi()<=0)
        bcc->met->set_phi (bcc->met->phi()+PI);
      else
        bcc->met->set_phi (bcc->met->phi()-PI);
    }
  }

}

//tight ele ID from https://twiki.cern.ch/twiki/bin/view/CMS/EgammaCutBasedIdentification
bool Cleaner::eleID(Electron ele){

  bool pass=false;
  
  if(fabs(ele.supercluster_eta())<1.4442){
    if(ele.dEtaIn()<0.004 && ele.dPhiIn()<0.03 && ele.sigmaIEtaIEta()<0.01 && ele.HoverE()<0.12 && fabs(1./ele.EcalEnergy()-1./ele.v4().P())<0.05) pass=true; 
  }
  else if( fabs(ele.supercluster_eta())>1.5660){
    if(ele.dEtaIn()<0.005 && ele.dPhiIn()<0.02 && ele.sigmaIEtaIEta()<0.03 && ele.HoverE()<0.10 && fabs(1./ele.EcalEnergy()-1./ele.v4().P())<0.05) pass=true; 
  }

  return pass;

}

//pf ID has already been applied when using goodPatJets
bool Cleaner::pfID(Jet jet){

  if(jet.numberOfDaughters()>1 
     && jet.neutralHadronEnergyFraction()<0.99
     && jet.neutralEmEnergyFraction()<0.99){
    
    if(fabs(jet.eta())>=2.4)
      return true;
    
    if(jet.chargedEmEnergyFraction()<0.99
       && jet.chargedHadronEnergyFraction()>0
       && jet.chargedMultiplicity()>0)
      return true;

  }
  return false;
     
}


void Cleaner::ElectronCleaner_noIso(double ptmin, double etamax){

  std::vector<Electron> good_eles;
  for(unsigned int i=0; i<bcc->electrons->size(); ++i){
    Electron ele = bcc->electrons->at(i);
    if(ele.pt()>ptmin){
      if(fabs(ele.eta())<etamax){
        if(fabs(ele.supercluster_eta())<1.4442 || fabs(ele.supercluster_eta())>1.5660){
          if(bcc->pvs->size()>0){
            if(ele.gsfTrack_dxy_vertex(bcc->pvs->at(0).x(), bcc->pvs->at(0).y())<0.02){
              if(ele.passconversionveto()){
                //if(ele.mvaTrigV0>0.0){
                if(eleID(ele)){
                    good_eles.push_back(ele);
                }
                //}
              }
            }
          }
        }
      }
    }
  }

  bcc->electrons->clear();

  for(unsigned int i=0; i<good_eles.size(); ++i){
    bcc->electrons->push_back(good_eles[i]);
  }
  sort(bcc->electrons->begin(), bcc->electrons->end(), HigherPt());
}

void Cleaner::ElectronCleaner(double ptmin, double etamax, double relisomax){

  ElectronCleaner_noIso(ptmin, etamax);
  std::vector<Electron> good_eles;
  for(unsigned int i=0; i<bcc->electrons->size(); ++i){
    Electron ele = bcc->electrons->at(i);
    if(ele.relIso()<relisomax){
      good_eles.push_back(ele);
    }
  }
  bcc->electrons->clear();

  for(unsigned int i=0; i<good_eles.size(); ++i){
    bcc->electrons->push_back(good_eles[i]);
  }
  sort(bcc->electrons->begin(), bcc->electrons->end(), HigherPt());

}


void Cleaner::MuonCleaner_noIso(double ptmin, double etamax){

  std::vector<Muon> good_mus;
  for(unsigned int i=0; i<bcc->muons->size(); ++i){
    Muon mu = bcc->muons->at(i);
    if(mu.pt()>ptmin){
      if(fabs(mu.eta())<etamax){
        if(mu.isGlobalMuon()){
          if(mu.globalTrack_chi2()/mu.globalTrack_ndof()<10){
            if(mu.innerTrack_trackerLayersWithMeasurement()>8){
              if(mu.dB()<0.02){
                if(fabs(mu.vertex_z()-bcc->pvs->at(0).z())<1){
                  if(mu.innerTrack_numberOfValidPixelHits()>0){
                    if(mu.numberOfMatchedStations()>1){
                      good_mus.push_back(mu);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  bcc->muons->clear();

  for(unsigned int i=0; i<good_mus.size(); ++i){
    bcc->muons->push_back(good_mus[i]);
  }
  sort(bcc->muons->begin(), bcc->muons->end(), HigherPt());
}

void Cleaner::MuonCleaner(double ptmin, double etamax, double relisomax){

  MuonCleaner_noIso(ptmin, etamax);

  std::vector<Muon> good_mus;
  for(unsigned int i=0; i<bcc->muons->size(); ++i){
    Muon mu = bcc->muons->at(i);
    if(mu.relIso()<relisomax){
      good_mus.push_back(mu);
    }
  }
  bcc->muons->clear();

  for(unsigned int i=0; i<good_mus.size(); ++i){
    bcc->muons->push_back(good_mus[i]);
  }
  sort(bcc->muons->begin(), bcc->muons->end(), HigherPt());
}

void Cleaner::TauCleaner(double ptmin, double etamax){

  std::vector<Tau> good_taus;
  for(unsigned int i=0; i<bcc->taus->size(); ++i){
    Tau tau = bcc->taus->at(i);
    if(tau.pt()>ptmin){
      if(fabs(tau.eta())<etamax){
        if(bcc->taus->at(i).decayModeFinding()){
          if(bcc->taus->at(i).byMediumCombinedIsolationDeltaBetaCorr()){
            if(bcc->taus->at(i).againstElectronTight()){
              if(bcc->taus->at(i).againstMuonTight()){
                good_taus.push_back(tau);
              }
            }
          }
        }
      }
    }
  }
  
  bcc->taus->clear();

  for(unsigned int i=0; i<good_taus.size(); ++i){
    bcc->taus->push_back(good_taus[i]);
  }
  sort(bcc->taus->begin(), bcc->taus->end(), HigherPt());
}


void Cleaner::JetCleaner(double ptmin, double etamax, bool doPFID){

  std::vector<Jet> good_jets;
  for(unsigned int i=0; i<bcc->jets->size(); ++i){
    Jet jet = bcc->jets->at(i);
    if(jet.pt()>ptmin){
      if(fabs(jet.eta())<etamax){
        if(!doPFID || pfID(jet)){
          good_jets.push_back(jet);
        }
      }
    }
  }

  bcc->jets->clear();

  for(unsigned int i=0; i<good_jets.size(); ++i){
    bcc->jets->push_back(good_jets[i]);
  }
  sort(bcc->jets->begin(), bcc->jets->end(), HigherPt());
}

void Cleaner::TopJetCleaner(double ptmin, double etamax, bool doPFID){

  std::vector<TopJet> good_topjets;
  for(unsigned int i=0; i<bcc->topjets->size(); ++i){
    TopJet topjet = bcc->topjets->at(i);
    if(topjet.pt()>ptmin){
      if(fabs(topjet.eta())<etamax){
        if(!doPFID || pfID(topjet)){
          good_topjets.push_back(topjet);
        }
      }
    }
  }
  bcc->topjets->clear();

  for(unsigned int i=0; i<good_topjets.size(); ++i){
    bcc->topjets->push_back(good_topjets[i]);
  }
  sort(bcc->topjets->begin(), bcc->topjets->end(), HigherPt());
}


void Cleaner::PrimaryVertexCleaner(int ndofmax, double zmax, double rhomax){

  std::vector<PrimaryVertex> good_pvs;
  for(unsigned int i=0; i<bcc->pvs->size(); ++i){
    PrimaryVertex pv = bcc->pvs->at(i);
    if(pv.ndof()>=ndofmax && fabs(pv.z())<zmax && pv.rho()<=rhomax){
      good_pvs.push_back(pv);
    } 
  }
  bcc->pvs->clear();

  for(unsigned int i=0; i<good_pvs.size(); ++i){
    bcc->pvs->push_back(good_pvs[i]);
  }

}
Revision:	1.7
Committed:	Wed May 30 09:41:12 2012 UTC (12 years, 11 months ago) by peiffer
Content type:	text/plain
Branch:	MAIN
Changes since 1.6:	+124 -13 lines
Log Message:	modules for Zprime pre-selection
#	User	Rev	Content
1	peiffer	1.1	#include "../include/Cleaner.h"
2
3
4	peiffer	1.7	Cleaner::Cleaner( BaseCycleContainer* input){
5	peiffer	1.1
6	peiffer	1.7	bcc = input;
7	peiffer	1.1
8			}
9
10	peiffer	1.2	void Cleaner::JetEnergyResolutionShifter(int syst_shift){
11
12	peiffer	1.6	double met = 0;
13			if(bcc->met) met=bcc->met->pt();
14	peiffer	1.2
15			for(unsigned int i=0; i<bcc->jets->size(); ++i){
16			Jet jet = bcc->jets->at(i);
17	peiffer	1.5	float gen_pt = jet.genjet_pt();
18	peiffer	1.2	//ignore unmatched jets (which have zero vector) or jets with very low pt:
19			if(gen_pt < 15.0) continue;
20
21	peiffer	1.5	met += jet.pt()*jet.JEC_factor_raw();
22	peiffer	1.2
23	peiffer	1.5	float recopt = jet.pt();
24	peiffer	1.2	double factor = -10;
25	peiffer	1.5	double abseta = fabs(jet.eta());
26	peiffer	1.2
27			//numbers taken from https://twiki.cern.ch/twiki/bin/view/CMS/JetResolution
28			if(syst_shift==0){
29			if(abseta < 0.5)
30			factor = 0.052;
31			else if(abseta >= 0.5 && abseta <1.1)
32			factor = 0.057;
33			else if(abseta >= 1.1 && abseta <1.7)
34			factor = 0.096;
35			else if(abseta >= 1.7 && abseta <2.3)
36			factor = 0.134;
37			else if(abseta >= 2.3)
38			factor = 0.288;
39			}
40			else if(syst_shift>0){
41			if(abseta < 0.5)
42			factor = 0.11;
43			else if(abseta >= 0.5 && abseta <1.1)
44			factor = 0.12;
45			else if(abseta >= 1.1 && abseta <1.7)
46			factor = 0.16;
47			else if(abseta >= 1.7 && abseta <2.3)
48			factor = 0.23;
49			else if(abseta >= 2.3)
50			factor = 0.49;
51			}
52			else{
53			if(abseta < 0.5)
54			factor = -0.01;
55			else if(abseta >= 0.5 && abseta <1.1)
56			factor = 0.00;
57			else if(abseta >= 1.1 && abseta <1.7)
58			factor = 0.04;
59			else if(abseta >= 1.7 && abseta <2.3)
60			factor = 0.03;
61			else if(abseta >= 2.3)
62			factor = 0.09;
63			}
64
65			float deltapt = (recopt - gen_pt) * factor;
66			float ptscale = std::max(0.0f, (recopt + deltapt) / recopt);
67	peiffer	1.5	jet.set_pt(jet.pt() * ptscale);
68			bcc->jets->at(i).set_pt( jet.pt());
69	peiffer	1.2
70			//propagate JER shifts to MET
71	peiffer	1.5	met -= jet.pt()*jet.JEC_factor_raw();
72	peiffer	1.2	}
73
74			//store changed MET, flip phi if new MET is negative
75	peiffer	1.6	if(bcc->met){
76			if(met>=0){
77			bcc->met->set_pt( met);
78			}
79			else{
80			bcc->met->set_pt( -1*met);
81			if(bcc->met->phi()<=0)
82			bcc->met->set_phi (bcc->met->phi()+PI);
83			else
84	peiffer	1.7	bcc->met->set_phi (bcc->met->phi()-PI);
85	peiffer	1.6	}
86	peiffer	1.2	}
87	peiffer	1.6
88	peiffer	1.5	sort(bcc->jets->begin(), bcc->jets->end(), HigherPt());
89	peiffer	1.2	}
90
91	peiffer	1.1
92	peiffer	1.7	void Cleaner::JetLeptonSubtractor(FactorizedJetCorrector *corrector){
93
94			double met = 0;
95			if(bcc->met) met=bcc->met->pt();
96
97			for(unsigned int i=0; i<bcc->jets->size(); ++i){
98
99			LorentzVector jet_v4_raw = bcc->jets->at(i).v4()*bcc->jets->at(i).JEC_factor_raw();
100
101			met-=bcc->jets->at(i).pt();
102
103			//subtract lepton momenta from raw jet momentum
104			if(bcc->electrons){
105			for(unsigned int j=0; j<bcc->electrons->size(); ++j){
106			if(bcc->jets->at(i).deltaR(bcc->electrons->at(j))<0.5){
107			jet_v4_raw -= bcc->electrons->at(j).v4();
108			}
109			}
110			}
111			if(bcc->muons){
112			for(unsigned int j=0; j<bcc->muons->size(); ++j){
113			jet_v4_raw -= bcc->muons->at(j).v4();
114			}
115			}
116
117			//apply jet energy corrections to modified raw momentum
118
119			corrector->setJetPt(jet_v4_raw.Pt());
120			corrector->setJetEta(jet_v4_raw.Eta());
121			corrector->setJetE(jet_v4_raw.E());
122			corrector->setJetA(bcc->jets->at(i).jetArea());
123			corrector->setRho(bcc->rho);
124
125			float correctionfactor = corrector->getCorrection();
126			LorentzVector jet_v4_corrected = jet_v4_raw *correctionfactor;
127
128			bcc->jets->at(i).set_v4(jet_v4_corrected);
129			bcc->jets->at(i).set_JEC_factor_raw(1./correctionfactor);
130
131			met+=bcc->jets->at(i).pt();
132
133			}
134
135			//store changed MET, flip phi if new MET is negative
136			if(bcc->met){
137			if(met>=0){
138			bcc->met->set_pt( met);
139			}
140			else{
141			bcc->met->set_pt( -1*met);
142			if(bcc->met->phi()<=0)
143			bcc->met->set_phi (bcc->met->phi()+PI);
144			else
145			bcc->met->set_phi (bcc->met->phi()-PI);
146			}
147			}
148
149			}
150
151	peiffer	1.1	//tight ele ID from https://twiki.cern.ch/twiki/bin/view/CMS/EgammaCutBasedIdentification
152			bool Cleaner::eleID(Electron ele){
153
154			bool pass=false;
155
156	peiffer	1.5	if(fabs(ele.supercluster_eta())<1.4442){
157			if(ele.dEtaIn()<0.004 && ele.dPhiIn()<0.03 && ele.sigmaIEtaIEta()<0.01 && ele.HoverE()<0.12 && fabs(1./ele.EcalEnergy()-1./ele.v4().P())<0.05) pass=true;
158	peiffer	1.1	}
159	peiffer	1.5	else if( fabs(ele.supercluster_eta())>1.5660){
160			if(ele.dEtaIn()<0.005 && ele.dPhiIn()<0.02 && ele.sigmaIEtaIEta()<0.03 && ele.HoverE()<0.10 && fabs(1./ele.EcalEnergy()-1./ele.v4().P())<0.05) pass=true;
161	peiffer	1.1	}
162
163			return pass;
164
165			}
166
167	peiffer	1.2	//pf ID has already been applied when using goodPatJets
168			bool Cleaner::pfID(Jet jet){
169
170	peiffer	1.5	if(jet.numberOfDaughters()>1
171			&& jet.neutralHadronEnergyFraction()<0.99
172			&& jet.neutralEmEnergyFraction()<0.99){
173	peiffer	1.2
174	peiffer	1.5	if(fabs(jet.eta())>=2.4)
175	peiffer	1.2	return true;
176
177	peiffer	1.5	if(jet.chargedEmEnergyFraction()<0.99
178			&& jet.chargedHadronEnergyFraction()>0
179			&& jet.chargedMultiplicity()>0)
180	peiffer	1.2	return true;
181
182			}
183			return false;
184
185			}
186
187	peiffer	1.1
188	peiffer	1.7	void Cleaner::ElectronCleaner_noIso(double ptmin, double etamax){
189	peiffer	1.1
190	peiffer	1.3	std::vector<Electron> good_eles;
191	peiffer	1.1	for(unsigned int i=0; i<bcc->electrons->size(); ++i){
192			Electron ele = bcc->electrons->at(i);
193	peiffer	1.5	if(ele.pt()>ptmin){
194			if(fabs(ele.eta())<etamax){
195			if(fabs(ele.supercluster_eta())<1.4442 \|\| fabs(ele.supercluster_eta())>1.5660){
196	peiffer	1.1	if(bcc->pvs->size()>0){
197	peiffer	1.5	if(ele.gsfTrack_dxy_vertex(bcc->pvs->at(0).x(), bcc->pvs->at(0).y())<0.02){
198			if(ele.passconversionveto()){
199	peiffer	1.1	//if(ele.mvaTrigV0>0.0){
200			if(eleID(ele)){
201	peiffer	1.3	good_eles.push_back(ele);
202	peiffer	1.1	}
203			//}
204			}
205			}
206			}
207			}
208			}
209			}
210			}
211
212	peiffer	1.3	bcc->electrons->clear();
213
214			for(unsigned int i=0; i<good_eles.size(); ++i){
215			bcc->electrons->push_back(good_eles[i]);
216			}
217	peiffer	1.5	sort(bcc->electrons->begin(), bcc->electrons->end(), HigherPt());
218	peiffer	1.1	}
219
220	peiffer	1.7	void Cleaner::ElectronCleaner(double ptmin, double etamax, double relisomax){
221	peiffer	1.1
222	peiffer	1.7	ElectronCleaner_noIso(ptmin, etamax);
223			std::vector<Electron> good_eles;
224			for(unsigned int i=0; i<bcc->electrons->size(); ++i){
225			Electron ele = bcc->electrons->at(i);
226			if(ele.relIso()<relisomax){
227			good_eles.push_back(ele);
228			}
229			}
230			bcc->electrons->clear();
231
232			for(unsigned int i=0; i<good_eles.size(); ++i){
233			bcc->electrons->push_back(good_eles[i]);
234			}
235			sort(bcc->electrons->begin(), bcc->electrons->end(), HigherPt());
236
237			}
238
239
240			void Cleaner::MuonCleaner_noIso(double ptmin, double etamax){
241	peiffer	1.3
242			std::vector<Muon> good_mus;
243	peiffer	1.1	for(unsigned int i=0; i<bcc->muons->size(); ++i){
244			Muon mu = bcc->muons->at(i);
245	peiffer	1.5	if(mu.pt()>ptmin){
246			if(fabs(mu.eta())<etamax){
247			if(mu.isGlobalMuon()){
248			if(mu.globalTrack_chi2()/mu.globalTrack_ndof()<10){
249			if(mu.innerTrack_trackerLayersWithMeasurement()>8){
250			if(mu.dB()<0.02){
251	peiffer	1.7	if(fabs(mu.vertex_z()-bcc->pvs->at(0).z())<1){
252			if(mu.innerTrack_numberOfValidPixelHits()>0){
253			if(mu.numberOfMatchedStations()>1){
254			good_mus.push_back(mu);
255	peiffer	1.1	}
256			}
257			}
258			}
259			}
260			}
261			}
262			}
263			}
264			}
265	peiffer	1.3	bcc->muons->clear();
266
267			for(unsigned int i=0; i<good_mus.size(); ++i){
268			bcc->muons->push_back(good_mus[i]);
269			}
270	peiffer	1.5	sort(bcc->muons->begin(), bcc->muons->end(), HigherPt());
271	peiffer	1.1	}
272	peiffer	1.2
273	peiffer	1.7	void Cleaner::MuonCleaner(double ptmin, double etamax, double relisomax){
274
275			MuonCleaner_noIso(ptmin, etamax);
276
277			std::vector<Muon> good_mus;
278			for(unsigned int i=0; i<bcc->muons->size(); ++i){
279			Muon mu = bcc->muons->at(i);
280			if(mu.relIso()<relisomax){
281			good_mus.push_back(mu);
282			}
283			}
284			bcc->muons->clear();
285
286			for(unsigned int i=0; i<good_mus.size(); ++i){
287			bcc->muons->push_back(good_mus[i]);
288			}
289			sort(bcc->muons->begin(), bcc->muons->end(), HigherPt());
290			}
291
292	peiffer	1.4	void Cleaner::TauCleaner(double ptmin, double etamax){
293
294			std::vector<Tau> good_taus;
295			for(unsigned int i=0; i<bcc->taus->size(); ++i){
296			Tau tau = bcc->taus->at(i);
297	peiffer	1.5	if(tau.pt()>ptmin){
298			if(fabs(tau.eta())<etamax){
299			if(bcc->taus->at(i).decayModeFinding()){
300			if(bcc->taus->at(i).byMediumCombinedIsolationDeltaBetaCorr()){
301			if(bcc->taus->at(i).againstElectronTight()){
302			if(bcc->taus->at(i).againstMuonTight()){
303	peiffer	1.4	good_taus.push_back(tau);
304			}
305			}
306			}
307			}
308			}
309			}
310			}
311
312			bcc->taus->clear();
313
314			for(unsigned int i=0; i<good_taus.size(); ++i){
315			bcc->taus->push_back(good_taus[i]);
316			}
317	peiffer	1.5	sort(bcc->taus->begin(), bcc->taus->end(), HigherPt());
318	peiffer	1.4	}
319
320	peiffer	1.2
321	peiffer	1.3	void Cleaner::JetCleaner(double ptmin, double etamax, bool doPFID){
322
323			std::vector<Jet> good_jets;
324	peiffer	1.2	for(unsigned int i=0; i<bcc->jets->size(); ++i){
325			Jet jet = bcc->jets->at(i);
326	peiffer	1.5	if(jet.pt()>ptmin){
327			if(fabs(jet.eta())<etamax){
328	peiffer	1.2	if(!doPFID \|\| pfID(jet)){
329	peiffer	1.3	good_jets.push_back(jet);
330	peiffer	1.2	}
331			}
332			}
333			}
334
335	peiffer	1.3	bcc->jets->clear();
336
337			for(unsigned int i=0; i<good_jets.size(); ++i){
338			bcc->jets->push_back(good_jets[i]);
339			}
340	peiffer	1.5	sort(bcc->jets->begin(), bcc->jets->end(), HigherPt());
341	peiffer	1.2	}
342
343	peiffer	1.3	void Cleaner::TopJetCleaner(double ptmin, double etamax, bool doPFID){
344	peiffer	1.2
345	peiffer	1.3	std::vector<TopJet> good_topjets;
346	peiffer	1.2	for(unsigned int i=0; i<bcc->topjets->size(); ++i){
347			TopJet topjet = bcc->topjets->at(i);
348	peiffer	1.5	if(topjet.pt()>ptmin){
349			if(fabs(topjet.eta())<etamax){
350	peiffer	1.2	if(!doPFID \|\| pfID(topjet)){
351	peiffer	1.3	good_topjets.push_back(topjet);
352	peiffer	1.2	}
353			}
354			}
355			}
356	peiffer	1.3	bcc->topjets->clear();
357	peiffer	1.2
358	peiffer	1.3	for(unsigned int i=0; i<good_topjets.size(); ++i){
359			bcc->topjets->push_back(good_topjets[i]);
360			}
361	peiffer	1.5	sort(bcc->topjets->begin(), bcc->topjets->end(), HigherPt());
362	peiffer	1.2	}
363	peiffer	1.7
364
365			void Cleaner::PrimaryVertexCleaner(int ndofmax, double zmax, double rhomax){
366
367			std::vector<PrimaryVertex> good_pvs;
368			for(unsigned int i=0; i<bcc->pvs->size(); ++i){
369			PrimaryVertex pv = bcc->pvs->at(i);
370			if(pv.ndof()>=ndofmax && fabs(pv.z())<zmax && pv.rho()<=rhomax){
371			good_pvs.push_back(pv);
372			}
373			}
374			bcc->pvs->clear();
375
376			for(unsigned int i=0; i<good_pvs.size(); ++i){
377			bcc->pvs->push_back(good_pvs[i]);
378			}
379
380			}