bool TopPairEMuReferenceSelection::isLooseElectron(const ElectronPointer electron) const {
bool passesEtAndEta = electron->et() > 20. && fabs(electron->eta()) < 2.5;
bool passesID(electron->passesElectronID(ElectronID::MVAIDTrigger));
bool passesIso = electron->pfRelativeIsolationRhoCorrected() < 0.15;
return passesEtAndEta && passesIso && passesID;
}
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;
}
bool TopPairEMuReferenceSelection::isGoodElectron(const ElectronPointer electron) const {
bool passesEtAndEta = electron->et() > 20 && fabs(electron->eta()) < 2.5;
bool passesD0 = fabs(electron->d0()) < 0.04; //cm
bool passesID(electron->passesElectronID(ElectronID::MVAIDTrigger));
bool passesIsolation = isIsolatedElectron(electron);
bool passesConvVeto = electron->passConversionVeto();
return passesEtAndEta && passesD0 && passesID && passesIsolation && passesConvVeto;
}
bool TopPairMuPlusJetsReferenceSelection2011::isLooseElectron(const ElectronPointer electron) const {
bool passesEtAndEta = electron->et() > 15. && fabs(electron->eta()) < 2.5 && !electron->isInCrack();
// bool passesID(electron->passesElectronID(ElectronID::MVAIDTrigger));
bool passesIso = electron->pfRelativeIsolationRhoCorrected() < 0.2;
return passesEtAndEta && passesIso;
}
ElectronPointer TestObjectFactory::goodIsolatedElectron2() {
ElectronPointer electron = TestObjectFactory::goodIsolatedElectron();
ElectronPointer electron2 = TestObjectFactory::goodIsolatedElectron();
FourVector vec = electron->getFourVector();
vec.SetPx(vec.Px() - 20);
vec.SetPy(-vec.Py());
vec.SetPz(-vec.Pz());
electron2->setFourVector(vec);
//Z mass requirement
assert(electron->invariantMass(electron2) > 80);
assert(electron->invariantMass(electron2) < 100);
assert(electron2->relativeIsolation() < 0.1);
return electron2;
}
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;
}
ElectronPointer TestObjectFactory::goodIsolatedElectron() {
ElectronPointer electron = TestObjectFactory::goodCaloElectron();
electron->setTrackerIsolation(0.4);
electron->setEcalIsolation(0.3);
electron->setHcalIsolation(0.5);
assert(electron->isIsolated());
assert(electron->isGood());
assert(electron->isFromConversion() == false);
assert(electron->isTaggedAsConversion(0.02,0.02) == false);
return electron;
}
bool TopPairCandidateTutorial::isolatedElectronNotTaggedAsFromConversion() const {
bool passConversion = false;
ElectronPointer electron;
if (Event::usePFIsolation) {
if (goodPFIsolatedElectrons.size() > 0)
electron = goodPFIsolatedElectrons.front();
} else {
if (goodIsolatedElectrons.size() > 0)
electron = goodIsolatedElectrons.front();
}
if (electron != 0) {
if (useCustomConversionTagger) {
conversionTagger->calculateConversionVariables(electron, tracks, 3.8, 0.45);
passConversion = conversionTagger->isFromConversion(0.02, 0.02) == false;
} else {
passConversion = electron->isTaggedAsConversion(0.02, 0.02) == false;
}
}
return passConversion;
}
bool QCDBCToESelection::isGoodElectron(const ElectronPointer electron) const {
bool passesEtAndEta = electron->et() > 30 && fabs(electron->eta()) < 2.5 && !electron->isInCrack();
bool passesD0 = fabs(electron->d0()) > 0.02; //cm, inverted cut for non-prompt electrons
bool passesHOverE = electron->HadOverEm() < 0.05; // same for EE and EB
bool passesID(electron->passesElectronID(ElectronID::MVAIDTrigger));
return passesEtAndEta && passesD0 && passesHOverE && passesID;
}
bool TopPairMuPlusJetsReferenceSelection2011::isGoodElectron(const ElectronPointer electron) const {
bool passesEtAndEta = electron->et() > 30 && fabs(electron->eta()) < 2.5 && !electron->isInCrack();
bool passesD0 = fabs(electron->d0()) < 0.02; //cm
bool passesHOverE = electron->HadOverEm() < 0.05; // same for EE and EB
bool passesID(electron->passesElectronID(ElectronID::MVAIDTrigger));
return passesEtAndEta && passesD0 &&
// passesDistanceToPV &&
passesHOverE && passesID;
}
bool HLTriggerQCDAnalyser::passesTriggerAnalysisSelection(const EventPtr event) const {
const ElectronCollection electrons(event->Electrons());
const JetCollection jets(event->Jets());
if (electrons.size() == 0 || jets.size() < 3)
return false;
unsigned int nElectrons(0);
for (unsigned int index = 0; index < electrons.size(); ++index) {
const ElectronPointer electron(electrons.at(index));
if (fabs(electron->eta()) < 2.5 && electron->pt() > 20)
++nElectrons;
//if more than 2 electrons passing the selection of > 20GeV, reject event
}
const ElectronPointer mostEnergeticElectron(electrons.front());
//clean jets against electron
JetCollection cleanedJets;
for (unsigned int index = 0; index < jets.size(); ++index) {
const JetPointer jet(jets.at(index));
if (!jet->isWithinDeltaR(0.3, mostEnergeticElectron))
cleanedJets.push_back(jet);
}
unsigned int nCleanedJetsAbove30GeV(0), nCleanedJetsAbove45GeV(0);
for (unsigned int index = 0; index < cleanedJets.size(); ++index) {
const JetPointer jet(cleanedJets.at(index));
if (jet->pt() > 45.)
++nCleanedJetsAbove45GeV;
if (jet->pt() > 30.)
++nCleanedJetsAbove30GeV;
}
return nElectrons == 1
&& (nCleanedJetsAbove45GeV >= 3
|| (nCleanedJetsAbove45GeV >= 2 && nCleanedJetsAbove30GeV >= 3 && event->runnumber() >= 194270));
}
extern void printElectron(const ElectronPointer electron) {
printParticle(electron);
cout << "Electron Information" << endl;
cout << setw(30) << "isTight" << setw(30) << "isNonIso" << setw(30) << "isConv" << endl;
cout << setw(30) << electron->isTightElectron() << setw(30) << electron->isTightNonIsoElectron() << setw(30) << electron->isTightConversionElectron() << endl;
cout << setw(30) << "sigma_{ieta ieta}" << setw(30) << "|Delta phi_{in}|" << setw(30) << "|Delta eta_{in}|" << setw(30) << "HadOverEm" << endl;
cout << setw(30) << electron->sigmaIEtaIEta() << setw(30) << fabs(electron->dPhiIn()) << setw(30) << fabs(electron->dEtaIn()) << setw(30) << electron->HadOverEm() << endl;
cout << setw(30) << "Isolation" << setw(30) << "superClusterEta" << endl;
cout << setw(30) << electron->PFRelIso03DeltaBeta() << setw(30) << electron->superClusterEta() << endl;
}
void Event::selectElectronsByQuality() {
goodElectrons.clear();
goodIsolatedElectrons.clear();
goodPFIsolatedElectrons.clear();
for (unsigned int index = 0; index < allElectrons.size(); ++index) {
ElectronPointer electron = allElectrons.at(index);
if (electron->isGood())
goodElectrons.push_back(electron);
if(electron->isGood(20))
qcdElectrons.push_back(electron);
if (electron->isGood() && electron->isIsolated())
goodIsolatedElectrons.push_back(electron);
if(electron->algorithm() == ElectronAlgorithm::ParticleFlow){
if(electron->isGood() && electron->isPFIsolated())
goodPFIsolatedElectrons.push_back(electron);
}
if (electron->isLoose())
looseElectrons.push_back(electron);
}
}
void DiElectronAnalyser::analyse(const EventPtr event) {
histMan_->setCurrentHistogramFolder(histogramFolder_);
ElectronCollection electrons = event->Electrons();
weight_ = event->weight() * prescale_ * scale_;
if (electrons.size() == 2) {
ElectronPointer leadingElectron = electrons.front();
ElectronPointer secondElectron = electrons.at(1);
histMan_->H1D_BJetBinned("diElectronMass")->Fill(leadingElectron->invariantMass(secondElectron), weight_);
}
ElectronCollection isolatedElectrons;
for (unsigned int index = 0; index < electrons.size(); ++index) {
const ElectronPointer electron(electrons.at(index));
if (electron->pfRelativeIsolation(0.3) < 0.1)
isolatedElectrons.push_back(electron);
}
if (isolatedElectrons.size() == 2) {
ElectronPointer leadingElectron = isolatedElectrons.front();
ElectronPointer secondElectron = isolatedElectrons.at(1);
histMan_->H1D_BJetBinned("diElectronMass_iso")->Fill(leadingElectron->invariantMass(secondElectron), weight_);
}
}
ElectronPointer TestObjectFactory::goodCaloElectron() {
ElectronPointer electron = ElectronPointer(new Electron(100., 99., 13., 5.));
electron->setUsedAlgorithm(ElectronAlgorithm::Calo);
electron->setSuperClusterEta(0);
electron->setD0_wrtBeamSpot(0);
electron->setD0(0);
VertexPointer pv = TestObjectFactory::goodVertex();
electron->setZDistanceToPrimaryVertex(0);
electron->setDEtaIn(0);
electron->setDPhiIn(0);
electron->setHadOverEm(0);
electron->setSigmaIEtaIEta(0);
electron->setNumberOfMissingInnerLayerHits(0);
electron->setDCotThetaToNextTrack(0.5);
electron->setDistToNextTrack(0.5);
assert(electron->relativeIsolation() > 0.1);
return electron;
}
void ElectronAnalyser::analyseElectron(const ElectronPointer electron, double weight) {
histMan_->setCurrentHistogramFolder(histogramFolder_);
weight_ = weight * prescale_ * scale_;
if (!singleElectronOnly_)
return;
histMan_->H1D("electron_eta")->Fill(electron->eta(), weight_);
histMan_->H1D("electron_AbsEta")->Fill(fabs(electron->eta()), weight_);
histMan_->H1D("electron_pfIsolation_03_deltaBeta")->Fill(electron->PFRelIso03DeltaBeta(), weight_);
if (!ttbarPlusMETAnalysisSetup_) {
histMan_->H1D("electron_pT")->Fill(electron->pt(), weight_);
histMan_->H1D("electron_phi")->Fill(electron->phi(), weight_);
histMan_->H1D("electron_sigma_ietaieta")->Fill(electron->sigmaIEtaIEta(), weight_);
histMan_->H1D("electron_dPhi_in")->Fill(electron->dPhiIn(), weight_);
histMan_->H1D("electron_dEta_in")->Fill(electron->dEtaIn(), weight_);
histMan_->H1D("electron_HadOverEM")->Fill(electron->HadOverEm(), weight_);
histMan_->H1D("electron_mvaTrigV0")->Fill(electron->mvaTrigV0(), weight_);
histMan_->H1D("electron_mvaNonTrigV0")->Fill(electron->mvaNonTrigV0(), weight_);
histMan_->H1D("electron_dB")->Fill(electron->d0(), weight_);
}
treeMan_->setCurrentFolder(histogramFolder_);
treeMan_->Fill("EventWeight", weight_ );
treeMan_->Fill("pt", electron->pt() );
treeMan_->Fill("eta", electron->eta() );
treeMan_->Fill("etaSC", electron->superClusterEta() );
treeMan_->Fill("relIso_03_deltaBeta", electron->PFRelIso03DeltaBeta() );
double efficiencyCorrection = electron->getEfficiencyCorrection( 0 );
treeMan_->Fill("ElectronEfficiencyCorrection", efficiencyCorrection);
}
ElectronPointer TestObjectFactory::goodIsolatedElectron() {
ElectronPointer electron = TestObjectFactory::goodCaloElectron();
electron->setTrackerIsolation(0.4);
electron->setEcalIsolation(0.3);
electron->setHcalIsolation(0.5);
electron->setPFChargedHadronIsolation(0.4);
electron->setPFGammaIsolation(0.3);
electron->setPFNeutralHadronIsolation(0.5);
electron->setUsedAlgorithm(ElectronAlgorithm::ParticleFlow);
electron->setPFPUChargedHadronIsolation(0.2);
electron->setPFRelativeIsolationRho(0.05);
assert(electron->relativeIsolation() < 0.1);
assert(electron->pfRelativeIsolationRhoCorrected() < 0.1);
return electron;
}
bool TopPairEMuReferenceSelection::isGoodPhoton(const PhotonPointer photon, const EventPtr event) const {
bool passesEtAndEta = photon->et() > 25 && fabs(photon->eta()) < 1.4442 && !photon->isInCrack();
bool passesSafeElectronVeto = photon->ConversionSafeElectronVeto();
bool passesHOverE = photon->SingleTowerHoE() < 0.05; // same for EE and EB
// bool passesShowerShape = false;
// bool passesPFChargedIso = false;
bool passesPFNeutralIso = false;
bool passesPFPhotonIso = false;
bool passesphoSCChIso = false;
// bool passesphoSCNuIso = false;
// bool passesphoSCPhIso = false;
if (photon->isInBarrelRegion()) {
// passesShowerShape = photon->sigmaIEtaIEta() < 0.012;
// passesPFChargedIso = photon->RhoCorrectedPFChargedHadronIso(event->rho()) < 2.6;
passesPFNeutralIso = photon->RhoCorrectedPFNeutralHadronIso(event->rho()) < 7.5 + 0.04 * photon->pt(); //3.5
passesPFPhotonIso = photon->RhoCorrectedPFPhotonIso(event->rho()) < 5 + 0.005 * photon->pt(); //1.3
passesphoSCChIso = photon->RhoCorrectedSCChIso(event->rho()) < 5;
// passesphoSCNuIso = photon->RhoCorrectedSCNuIso(event->rho()) < 3.5 + 0.04 * photon->pt();
// passesphoSCPhIso = photon->RhoCorrectedSCPhIso(event->rho()) < 1.3 + 0.005 * photon->pt();
} else if (photon->isInEndCapRegion()) {
// passesShowerShape = photon->sigmaIEtaIEta() < 0.034;
// passesPFChargedIso = photon->RhoCorrectedPFChargedHadronIso(event->rho()) < 2.3;
passesPFNeutralIso = photon->RhoCorrectedPFNeutralHadronIso(event->rho()) < 2.9 + 0.04 * photon->pt();
passesPFPhotonIso = photon->RhoCorrectedPFPhotonIso(event->rho()) < 1.5 + 0.005 * photon->pt();
passesphoSCChIso = photon->RhoCorrectedSCChIso(event->rho()) < 2.3;
// passesphoSCNuIso = photon->RhoCorrectedSCNuIso(event->rho()) < 2.9 + 0.04 * photon->pt();
// passesphoSCPhIso = photon->RhoCorrectedSCPhIso(event->rho()) < 1.5 + 0.005 * photon->pt();
}
const ElectronCollection electrons(goodElectrons(event));
const MuonCollection muons(goodMuons(event));
const JetCollection jets(event->Jets());;
bool passesDeltaRgammaMuons = false;
for (unsigned int index = 0; index < muons.size(); ++index) {
const MuonPointer muon(muons.at(index));
passesDeltaRgammaMuons = photon->deltaR(muon) > 0.3;
if(photon->deltaR(muon) < 0.3)
break;
}
bool passesDeltaRgammaElectrons = false;
for (unsigned int index = 0; index < electrons.size(); ++index) {
const ElectronPointer electron(electrons.at(index));
passesDeltaRgammaElectrons = photon->deltaR(electron) > 0.3;
if(photon->deltaR(electron) < 0.3)
break;
}
bool passesDeltaRgammaJets = false;
for (unsigned int index = 0; index < jets.size(); ++index) {
const JetPointer jet(jets.at(index));
passesDeltaRgammaJets = photon->deltaR(jet) > 0.3;
}
bool passesDeltaRjetsElectrons = false;
for (unsigned int index = 0; index < electrons.size(); ++index) {
const ElectronPointer electron(electrons.at(index));
for(unsigned int jindex = 0; jindex<jets.size(); ++jindex){
const JetPointer jet(jets[jindex]);
passesDeltaRjetsElectrons = electron->deltaR(jet) > 0.3;
}
}
bool passesDeltaRjetsMuons = false;
for (unsigned int index = 0; index < muons.size(); ++index) {
const MuonPointer muon(muons.at(index));
for(unsigned int jindex = 0; jindex<jets.size(); ++jindex){
const JetPointer jet(jets[jindex]);
passesDeltaRjetsMuons = muon->deltaR(jet) > 0.3;
}
}
return passesEtAndEta && passesSafeElectronVeto && passesHOverE /*&& passesShowerShape*/ && passesPFNeutralIso && passesPFPhotonIso && passesphoSCChIso && passesDeltaRgammaElectrons &&
passesDeltaRgammaMuons && passesDeltaRgammaJets && passesDeltaRjetsMuons && passesDeltaRjetsElectrons;
}
void ElectronAnalyser::analyse(const EventPtr event) {
histMan_->setCurrentHistogramFolder(histogramFolder_);
weight_ = event->weight() * prescale_ * scale_;
const ElectronCollection electrons = event->Electrons();
if (singleElectronOnly_)
return;
histMan_->H1D("Number_Of_Electrons")->Fill(electrons.size(), weight_);
for (unsigned int index = 0; index < electrons.size(); ++index) {
const ElectronPointer electron(electrons.at(index));
histMan_->H1D("All_Electron_Pt")->Fill(electron->pt(), weight_);
histMan_->H1D("All_Electron_Eta")->Fill(electron->eta(), weight_);
histMan_->H1D("All_Electron_AbsEta")->Fill(fabs(electron->eta()), weight_);
histMan_->H1D("All_Electron_Phi")->Fill(electron->phi(), weight_);
histMan_->H1D("All_Electron_pfIsolation_03_deltaBeta")->Fill(electron->PFRelIso03DeltaBeta(), weight_);
histMan_->H1D("All_Electron_sigma_ietaieta")->Fill(electron->sigmaIEtaIEta(), weight_);
histMan_->H1D("All_Electron_dPhi_in")->Fill(electron->dPhiIn(), weight_);
histMan_->H1D("All_Electron_dEta_in")->Fill(electron->dEtaIn(), weight_);
histMan_->H1D("All_Electron_HadOverEM")->Fill(electron->HadOverEm(), weight_);
histMan_->H1D("All_Electron_mvaTrigV0")->Fill(electron->mvaTrigV0(), weight_);
histMan_->H1D("All_Electron_mvaNonTrigV0")->Fill(electron->mvaNonTrigV0(), weight_);
histMan_->H1D("All_Electron_dB")->Fill(electron->d0(), weight_);
}
}
bool TopPairEMuReferenceSelection::isNminusOnePhoton(const PhotonPointer photon, const EventPtr event, TString cut) const {
const ElectronCollection electrons(goodElectrons(event));
const MuonCollection muons(goodMuons(event));
const JetCollection jets(event->Jets());
bool passesEtAndEta = photon->et() > 25 && fabs(photon->eta()) < 2.5 && !photon->isInCrack();
bool passesSafeElectronVeto = photon->ConversionSafeElectronVeto();
bool passesHOverE = photon->SingleTowerHoE() < 0.05; // same for EE and EB
bool passesShowerShape = false;
// bool passesPFChargedIso = false;
bool passesPFNeutralIso = false;
bool passesPFPhotonIso = false;
bool passesphoSCChIso = false;
bool backgroundShape = false;
if (photon->isInBarrelRegion()) {
passesShowerShape = photon->sigmaIEtaIEta() < 0.012;
// passesPFChargedIso = photon->RhoCorrectedPFChargedHadronIso(event->rho()) < 2.6;
passesPFNeutralIso = photon->RhoCorrectedPFNeutralHadronIso(event->rho()) < 3.5 + 0.04 * photon->pt();
passesPFPhotonIso = photon->RhoCorrectedPFPhotonIso(event->rho()) < 1.3 + 0.005 * photon->pt();
passesphoSCChIso = photon->RhoCorrectedSCChIso(event->rho()) < 20;
backgroundShape = photon->sigmaIEtaIEta() > 0.012 && photon->sigmaIEtaIEta() < 0.029;
} else if (photon->isInEndCapRegion()) {
passesShowerShape = photon->sigmaIEtaIEta() < 0.034;
// passesPFChargedIso = photon->RhoCorrectedPFChargedHadronIso(event->rho()) < 2.3;
passesPFNeutralIso = photon->RhoCorrectedPFNeutralHadronIso(event->rho()) < 2.9 + 0.04 * photon->pt();
passesPFPhotonIso = photon->RhoCorrectedPFPhotonIso(event->rho()) < 1.5 + 0.005 * photon->pt();
passesphoSCChIso = photon->RhoCorrectedSCChIso(event->rho()) < 20;
backgroundShape = photon->sigmaIEtaIEta() > 0.012 && photon->sigmaIEtaIEta() < 0.029;
}
bool passesDeltaRgammaMuons = false;
for (unsigned int index = 0; index < muons.size(); ++index) {
const MuonPointer muon(muons.at(index));
passesDeltaRgammaMuons = photon->deltaR(muon) > 0.5;
if(photon->deltaR(muon) < 0.5)
break;
}
bool passesDeltaRgammaElectrons = false;
for (unsigned int index = 0; index < electrons.size(); ++index) {
const ElectronPointer electron(electrons.at(index));
passesDeltaRgammaElectrons = photon->deltaR(electron) > 0.7;
if(photon->deltaR(electron) < 0.7)
break;
}
bool passesDeltaRgammaJets = false;
for (unsigned int index = 0; index < jets.size(); ++index) {
const JetPointer jet(jets.at(index));
passesDeltaRgammaJets = photon->deltaR(jet) > 0.7;
}
bool passesDeltaRjetsElectrons = false;
for (unsigned int index = 0; index < electrons.size(); ++index) {
const ElectronPointer electron(electrons.at(index));
for(unsigned int jindex = 0; jindex<jets.size(); ++jindex){
const JetPointer jet(jets[jindex]);
passesDeltaRjetsElectrons = electron->deltaR(jet) > 0.5;
}
}
bool passesDeltaRjetsMuons = false;
for (unsigned int index = 0; index < muons.size(); ++index) {
const MuonPointer muon(muons.at(index));
for(unsigned int jindex = 0; jindex<jets.size(); ++jindex){
const JetPointer jet(jets[jindex]);
passesDeltaRjetsMuons = muon->deltaR(jet) > 0.5;
}
}
if(cut == "passesEtAndEta")
return passesSafeElectronVeto && passesHOverE && passesShowerShape && passesPFNeutralIso && passesPFPhotonIso && passesDeltaRgammaElectrons &&
passesDeltaRgammaMuons && passesDeltaRgammaJets && passesDeltaRjetsMuons && passesDeltaRjetsElectrons && passesphoSCChIso;
else if(cut == "passesHOverE")
return passesEtAndEta && passesSafeElectronVeto && passesShowerShape && passesPFNeutralIso && passesPFPhotonIso && passesDeltaRgammaElectrons &&
passesDeltaRgammaMuons && passesDeltaRgammaJets && passesDeltaRjetsMuons && passesDeltaRjetsElectrons && passesphoSCChIso;
else if(cut == "passesShowerShape")
return passesEtAndEta && passesSafeElectronVeto && passesHOverE && passesPFNeutralIso && passesPFPhotonIso && passesDeltaRgammaElectrons &&
passesDeltaRgammaMuons && passesDeltaRgammaJets && passesDeltaRjetsMuons && passesDeltaRjetsElectrons && passesphoSCChIso;
else if(cut == "passesPFNeutralIso")
return passesEtAndEta && passesSafeElectronVeto && passesHOverE && passesShowerShape && passesPFPhotonIso && passesDeltaRgammaElectrons &&
passesDeltaRgammaMuons && passesDeltaRgammaJets && passesDeltaRjetsMuons && passesDeltaRjetsElectrons && passesphoSCChIso;
else if(cut == "passesPFPhotonIso")
return passesEtAndEta && passesSafeElectronVeto && passesHOverE && passesShowerShape && passesPFNeutralIso && passesDeltaRgammaElectrons &&
passesDeltaRgammaMuons && passesDeltaRgammaJets && passesDeltaRjetsMuons && passesDeltaRjetsElectrons && passesphoSCChIso;
else if(cut == "passesphoSCChIso")
return passesEtAndEta && passesSafeElectronVeto && passesHOverE && backgroundShape && passesPFNeutralIso && passesPFPhotonIso &&
passesDeltaRgammaElectrons && passesDeltaRgammaMuons && passesDeltaRgammaJets && passesDeltaRjetsMuons && passesDeltaRjetsElectrons;
else if(cut == "passesDeltaRgammaMuons" && cut == "passesDeltaRgammaElectrons")
return passesEtAndEta && passesSafeElectronVeto && passesHOverE && passesShowerShape && passesPFNeutralIso && passesPFPhotonIso &&
passesDeltaRgammaJets && passesDeltaRjetsMuons && passesDeltaRjetsElectrons && passesphoSCChIso;
else if(cut == "passesDeltaRjetsElectrons" && cut == "passesDeltaRjetsMuons")
return passesEtAndEta && passesSafeElectronVeto && passesHOverE && passesShowerShape && passesPFNeutralIso && passesPFPhotonIso &&
passesDeltaRgammaJets && passesDeltaRgammaMuons && passesDeltaRgammaElectrons && passesphoSCChIso;
else if(cut == "passesDeltaRgammaJets")
return passesEtAndEta && passesSafeElectronVeto && passesHOverE && passesShowerShape && passesPFNeutralIso && passesPFPhotonIso &&
passesDeltaRgammaElectrons && passesDeltaRgammaMuons && passesDeltaRjetsMuons && passesDeltaRjetsElectrons && passesphoSCChIso;
else if(cut == "backgroundShape")
return passesEtAndEta && passesSafeElectronVeto && passesHOverE && passesPFNeutralIso && passesPFPhotonIso && passesDeltaRgammaElectrons &&
passesDeltaRgammaMuons && passesDeltaRjetsMuons && passesDeltaRjetsElectrons && passesphoSCChIso && passesDeltaRgammaJets && backgroundShape;
else
return passesEtAndEta && passesSafeElectronVeto && passesHOverE && passesShowerShape && passesPFNeutralIso && passesPFPhotonIso && passesDeltaRgammaElectrons && passesDeltaRgammaMuons &&
passesDeltaRgammaJets && passesDeltaRjetsMuons && passesDeltaRjetsElectrons && passesphoSCChIso;
}
ElectronPointer TestObjectFactory::goodCaloElectron() {
ElectronPointer electron = ElectronPointer(new Electron(100., 99., 13., 5.));
electron->setUsedAlgorithm(ElectronAlgorithm::Calo);
electron->setSuperClusterEta(0);
electron->setD0_wrtBeamSpot(0);
VertexPointer pv = TestObjectFactory::goodVertex();
electron->setZDistanceToPrimaryVertex(0);
electron->setDEtaIn(0);
electron->setDPhiIn(0);
electron->setHadOverEm(0);
electron->setSigmaIEtaIEta(0);
electron->setNumberOfMissingInnerLayerHits(0);
electron->setDCotThetaToNextTrack(0.5);
electron->setDistToNextTrack(0.5);
if (electron->isGood() == false) {
cout << "Et " << electron->et() << endl;
cout << "Eta " << electron->eta() << endl;
cout << "VBTF 70 " << electron->VBTF_W70_ElectronID() << endl;
cout << "d0 " << electron->d0_wrtBeamSpot() << endl;
cout << "Et " << electron->et() << endl;
}
assert(electron->isGood());
assert(electron->isFromConversion() == false);
assert(electron->isIsolated() == false);
return electron;
}
void DiElectronAnalyser::analyse(const EventPtr event, const ElectronCollection electrons) {
histMan_->setCurrentHistogramFolder(histogramFolder_);
weight_ = event->weight() * prescale_ * scale_;
if (electrons.size() == 2) {
ElectronPointer leadingElectron = electrons.front();
ElectronPointer secondElectron = electrons.at(1);
//both
histMan_->H1D_BJetBinned("diLepton_Mass")->Fill(leadingElectron->invariantMass(secondElectron), weight_);
histMan_->H1D_BJetBinned("diLepton_DeltaR")->Fill(leadingElectron->deltaR(secondElectron), weight_);
//lead
histMan_->H1D_BJetBinned("LeadLepton_Pt")->Fill(leadingElectron->pt(), weight_);
histMan_->H1D_BJetBinned("LeadLepton_Eta")->Fill(leadingElectron->eta(), weight_);
histMan_->H1D_BJetBinned("LeadLepton_AbsEta")->Fill(abs(leadingElectron->eta()), weight_);
histMan_->H1D_BJetBinned("LeadLepton_Phi")->Fill(leadingElectron->phi(), weight_);
histMan_->H1D_BJetBinned("LeadLepton_RelIso")->Fill(leadingElectron->pfRelativeIsolationRhoCorrected(), weight_);
histMan_->H1D_BJetBinned("LeadLepton_HadOverEM")->Fill(leadingElectron->HadOverEm(), weight_);
histMan_->H1D_BJetBinned("LeadLepton_dB")->Fill(leadingElectron->d0_wrtBeamSpot(), weight_);
//second
histMan_->H1D_BJetBinned("SecondLepton_Pt")->Fill(secondElectron->pt(), weight_);
histMan_->H1D_BJetBinned("SecondLepton_Eta")->Fill(secondElectron->eta(), weight_);
histMan_->H1D_BJetBinned("SecondLepton_AbsEta")->Fill(abs(secondElectron->eta()), weight_);
histMan_->H1D_BJetBinned("SecondLepton_Phi")->Fill(secondElectron->phi(), weight_);
histMan_->H1D_BJetBinned("SecondLepton_RelIso")->Fill(secondElectron->pfRelativeIsolationRhoCorrected(), weight_);
histMan_->H1D_BJetBinned("SecondLepton_HadOverEM")->Fill(secondElectron->HadOverEm(), weight_);
histMan_->H1D_BJetBinned("SecondLepton_dB")->Fill(secondElectron->d0_wrtBeamSpot(), weight_);
}
}
