Esempio n. 1
0
const ElectronCollection TopPairEMuReferenceSelection::signalElectrons(const EventPtr event) const {

	const MuonCollection muons(goodMuons(event));
	const ElectronCollection electrons(goodElectrons(event));
	ElectronCollection signalElectrons;


	double ptMax = 0;
	int storeIndexA = -1;

//	    cout << "loop for max pt, muons: " << muons.size() << "electrons: " << electrons.size() << endl;
	if(electrons.size() >= 1 && muons.size() >= 1){
		for (unsigned int indexA = 0; indexA < electrons.size(); ++indexA) {
		const ElectronPointer electron(electrons.at(indexA));
				for (unsigned int indexB = 0; indexB < muons.size(); ++indexB) {
					const MuonPointer muon(muons.at(indexB));
					if((electron->charge()*muon->charge() < 0) && ((electron->pt()+muon->pt())>ptMax)){
						ptMax = electron->pt()+muon->pt();
						storeIndexA = indexA;
					}
				}
	}
	
	if(storeIndexA != -1)
    		signalElectrons.push_back(electrons.at(storeIndexA));

	}

	return signalElectrons;

}
Esempio n. 2
0
bool TopPairEMuReferenceSelection::isGoodMuon(const MuonPointer muon) const {
	bool passesEtAndEta = muon->pt() > 20 && fabs(muon->eta()) < 2.4;
	bool passesID = (muon->isGlobal() || muon->isTracker()) && muon->isPFMuon();
    bool passesIsolation  = isIsolatedMuon(muon);

	return passesEtAndEta && passesID && passesIsolation;
}
bool TopPairMuPlusJetsReferenceSelection2011::isLooseMuon(const MuonPointer muon) const {
	bool passesPt = muon->pt() > 10;
	bool passesEta = fabs(muon->eta()) < 2.5;
	bool isGlobalOrTracker = muon->isGlobal() || muon->isTracker();
	bool isLooselyIsolated = muon->pfRelativeIsolation(0.4) < 0.2;

	return passesPt && passesEta && isGlobalOrTracker && isLooselyIsolated;
}
Esempio n. 4
0
bool TopPairEMuReferenceSelection::passesZmassVeto(const EventPtr event) const {

	const ElectronCollection electrons(signalElectrons(event));
	const MuonCollection muons(signalMuons(event));
	ElectronCollection electronColl;
	MuonCollection muonColl;

	
	double ptMax = 0;
	int storeIndexA = -1;
	int storeIndexB = -1;
	if(electrons.size() >= 1 && muons.size() >= 1){
		for (unsigned int indexA = 0; indexA < electrons.size(); ++indexA) {
		const ElectronPointer electron(electrons.at(indexA));
				for (unsigned int indexB = 0; indexB < muons.size(); ++indexB) {
					const MuonPointer muon(muons.at(indexB));
					if((electron->charge() == -muon->charge()) && ((electron->pt()+muon->pt())>ptMax)){
						ptMax = electron->pt()+muon->pt();
						storeIndexA = indexA;
						storeIndexB = indexB;
					}
				}

		if(storeIndexA != storeIndexB){
		
			electronColl.push_back(electrons.at(storeIndexA));
			muonColl.push_back(muons.at(storeIndexB));	
		}

		}
	}
	
	ElectronPointer electron = electronColl.front();
	MuonPointer muon = muonColl.front();
	
	double mass = 0;

 	ParticlePointer dilepton;
 	dilepton = ParticlePointer(new Particle(*electron + *muon));
 	mass = dilepton->mass();
	

	return mass < 76 || mass > 106;

}
Esempio n. 5
0
bool TopPairEMuReferenceSelection::isLooseMuon(const MuonPointer muon) const {
	bool passesPt = muon->pt() > 10;
	bool passesEta = fabs(muon->eta()) < 2.5;
	bool isPFMuon = muon->isPFMuon();
	bool isGlobalOrTracker = muon->isGlobal() || muon->isTracker();
	bool isLooselyIsolated = muon->pfRelativeIsolation(0.4, true) < 0.2;

	return isPFMuon && passesPt && passesEta && isGlobalOrTracker && isLooselyIsolated;
}
bool TopPairMuPlusJetsReferenceSelection2011::isGoodMuon(const MuonPointer muon) const {
	bool passesEtAndEta = muon->pt() > 26 && fabs(muon->eta()) < 2.1;
	bool passesD0 = fabs(muon->d0()) < 0.02; //cm
	bool passesDistanceToPV = fabs(muon->ZDistanceToPrimaryVertex()) < 1;
	bool passesID(muon->isTracker() && muon->isGlobal());

	bool passesMuonQuality_1(muon->normChi2() < 10 && muon->trackerLayersWithMeasurement() > 8);
	bool passesMuonQuality_2(muon->numberOfValidMuonHits() > 0 && muon->pixelLayersWithMeasurement() > 0);
	bool passesMuonQuality_3(muon->numberOfMatchedStations() > 1);
	bool passesMuonQuality = passesMuonQuality_1 && passesMuonQuality_2 && passesMuonQuality_3;

	return passesEtAndEta && passesD0 && passesDistanceToPV && passesID && passesMuonQuality;
}
Esempio n. 7
0
void MuonAnalyser::analyseMuon(const MuonPointer muon, double weight) {
	histMan_->setCurrentHistogramFolder(histogramFolder_);
	weight_ = weight * prescale_ * scale_;

	histMan_->H1D("muon_eta")->Fill(muon->eta(), weight_);
	histMan_->H1D("muon_AbsEta")->Fill(fabs(muon->eta()), weight_);
	histMan_->H1D("muon_pfIsolation_03_DeltaBeta")->Fill(muon->PFRelIso03DeltaBeta(), weight_);
	histMan_->H1D("muon_pfIsolation_04_DeltaBeta")->Fill(muon->PFRelIso04DeltaBeta(), weight_);

	if (!ttbarPlusMETAnalysisSetup_) {
		histMan_->H1D("muon_pT")->Fill(muon->pt(), weight_);
		histMan_->H1D("muon_phi")->Fill(muon->phi(), weight_);

		histMan_->H1D("muon_dB")->Fill(muon->d0(), weight_);
	}

	treeMan_->setCurrentFolder(histogramFolder_);
	treeMan_->Fill("EventWeight", weight_ );
	treeMan_->Fill("pt", muon->pt() );
	treeMan_->Fill("eta", muon->eta() );	
	treeMan_->Fill("relIso_04_deltaBeta", muon->PFRelIso04DeltaBeta() );	
}
Esempio n. 8
0
void MuonAnalyser::analyse(const EventPtr event) {
	if (singleMuonOnly_)
		return;
	histMan_->setCurrentHistogramFolder(histogramFolder_);
	weight_ = event->weight() * prescale_ * scale_;
	const MuonCollection muons = event->Muons();

	histMan_->H1D("Number_Of_Muons")->Fill(muons.size(), weight_);
	for (unsigned int index = 0; index < muons.size(); ++index) {
		const MuonPointer muon(muons.at(index));

		histMan_->H1D("All_Muon_Pt")->Fill(muon->pt(), weight_);
		histMan_->H1D("All_Muon_Eta")->Fill(muon->eta(), weight_);
		histMan_->H1D("All_Muon_AbsEta")->Fill(fabs(muon->eta()), weight_);
		histMan_->H1D("All_Muon_Phi")->Fill(muon->phi(), weight_);
		histMan_->H1D("All_Muon_pfIsolation_03")->Fill(muon->PFRelIso03(), weight_);
		histMan_->H1D("All_Muon_pfIsolation_04")->Fill(muon->PFRelIso04(), weight_);

		histMan_->H1D("All_Muon_dB")->Fill(muon->d0(), weight_);
	}
}