void METAnalyser::analyseTransverseMass(const EventPtr event, const ParticlePointer particle) {
histMan_->setCurrentHistogramFolder(histogramFolder_);
weight_ = event->weight() * prescale_ * scale_;
for (unsigned index = 0; index < METAlgorithm::NUMBER_OF_METALGORITHMS; ++index) {
std::string prefix = METAlgorithm::prefixes.at(index);
METAlgorithm::value metType = (METAlgorithm::value) index;
if (!MET::isAvailableInNTupleVersion(Globals::NTupleVersion, index))
continue;
if (MET::isMCOnlyMETType(index) && event->isRealData())
continue; //skip MC only METs for real data
const METPointer met(event->MET(metType));
histMan_->setCurrentHistogramFolder(histogramFolder_ + "/" + prefix);
double MT = Event::MT(particle, met);
double angle = met->angle(particle);
double delPhi = met->deltaPhi(particle);
histMan_->H1D("Transverse_Mass")->Fill(MT, weight_);
histMan_->H1D("Angle_lepton_MET")->Fill(angle, weight_);
histMan_->H1D("DeltaPhi_lepton_MET")->Fill(delPhi, weight_);
if (met->et() < 20)
histMan_->H1D("Transverse_Mass_MET20")->Fill(MT, weight_);
histMan_->H2D("MET_vs_leptonPt")->Fill(particle->pt(), met->et(), weight_);
histMan_->H1D("MET_plus_leptonPt")->Fill(particle->pt() + met->et(), weight_);
histMan_->H2D("MET_vs_leptonEta")->Fill(particle->eta(), met->et(), weight_);
}
}
bool PseudoTopAnalyser::passesEventSelection( const MCParticlePointer pseudoLepton, const ParticlePointer pseudoNeutrino, const JetCollection pseudoJets, const MCParticleCollection pseudoBs, const ParticleCollection allPseudoLeptons, const ParticlePointer pseudoMET ) {
// Event selection taken from here : https://twiki.cern.ch/twiki/bin/view/LHCPhysics/ParticleLevelTopDefinitions
unsigned int numberGoodLeptons = 0;
unsigned int numberVetoLeptons = 0;
ParticlePointer leadingLepton;
for ( unsigned int leptonIndex = 0; leptonIndex < allPseudoLeptons.size(); ++ leptonIndex ) {
const ParticlePointer lepton = allPseudoLeptons.at(leptonIndex);
// Check if this is a good signal type lepton
if ( lepton->pt() > minLeptonPt_ && fabs(lepton->eta()) < maxLeptonAbsEta_ ) {
++numberGoodLeptons;
if ( leadingLepton == 0 ) leadingLepton = lepton;
}
// Check if this is a veto lepton
if ( lepton->pt() > minVetoLeptonPt_ && fabs(lepton->eta()) < maxVetoLeptonAbsEta_ ) {
++numberVetoLeptons;
}
}
// Neutrino pt sum
bool passesNeutrinoSumPt = false;
if ( pseudoMET != 0 ) {
if ( pseudoMET->pt() > minNeutrinoSumPt_ ) passesNeutrinoSumPt = true;
}
// W MT
bool passesWMT = false;
if ( leadingLepton != 0 && pseudoMET != 0 ) {
double genMT = sqrt( 2 * leadingLepton->pt() * pseudoMET->pt() * ( 1 - cos(leadingLepton->phi() - pseudoMET->phi() ) ) );
if (genMT > minWMt_) passesWMT = true;
}
// Jets
unsigned int numberGoodJets = 0;
unsigned int numberGoodBJets = 0;
for ( unsigned int jetIndex = 0; jetIndex < pseudoJets.size(); ++ jetIndex ) {
const JetPointer jet = pseudoJets.at(jetIndex);
// Check if this is a good jet
if ( jet->pt() > minJetPt_ && fabs(jet->eta()) < maxJetAbsEta_ ) {
++numberGoodJets;
// Check if this is also a good b jet
if ( fabs( jet->partonFlavour() ) == 5 ) {
++numberGoodBJets;
}
}
}
if ( numberGoodLeptons == 1 && numberVetoLeptons <= 1 && passesNeutrinoSumPt && passesWMT && numberGoodJets >= minNJets_ && numberGoodBJets >= minNBJets_ ) {
return true;
}
else return false;
}
TtbarHypothesis::TtbarHypothesis(const LeptonPointer& elec, const ParticlePointer& neut, const JetPointer& lepBJet,
const JetPointer& hadBJet, const JetPointer& hadWJet1, const JetPointer& hadWJet2) :
totalChi2(99999.), leptonicChi2(99999.), hadronicChi2(99999.), globalChi2(99999.), hadronicTop(), leptonicTop(), leptonicW(
new Particle(*elec + *neut)), hadronicW(new Particle(*hadWJet1 + *hadWJet2)), resonance(), neutrinoFromW(
neut), leptonicBjet(lepBJet), hadronicBJet(hadBJet), jet1FromW(hadWJet1), jet2FromW(hadWJet2), leptonFromW(
elec), met(new MET(neut->px(), neut->py())) {
}
double Event::MT(const ParticlePointer particle, const METPointer met) {
double energySquared = pow(particle->et() + met->et(), 2);
double momentumSquared = pow(particle->px() + met->px(), 2) + pow(particle->py() + met->py(), 2);
double MTSquared = energySquared - momentumSquared;
if (MTSquared > 0)
return sqrt(MTSquared);
else
return -1;
}
void METAnalyser::analyse_ST(const EventPtr event, const ParticlePointer particle, const JetCollection jets) {
histMan_->setCurrentHistogramFolder(histogramFolder_);
weight_ = event->weight() * prescale_ * scale_;
for (unsigned index = 0; index < METAlgorithm::NUMBER_OF_METALGORITHMS; ++index) {
std::string prefix = METAlgorithm::prefixes.at(index);
METAlgorithm::value metType = (METAlgorithm::value) index;
if (!MET::isAvailableInNTupleVersion(Globals::NTupleVersion, index))
continue;
bool isMCOnlyMET = MET::isMCOnlyMETType(index);
if (isMCOnlyMET && event->isRealData()) //these METs are MC only (Jet resolution systematics)
continue;
const METPointer met(event->MET(metType));
float ST = Event::ST(jets, particle, met);
float WPT = Event::WPT(particle, met);
float MT = Event::MT(particle, met);
histMan_->setCurrentHistogramFolder(histogramFolder_ + "/" + prefix);
histMan_->H1D("ST")->Fill(ST, weight_);
histMan_->H1D("WPT")->Fill(WPT, weight_);
histMan_->H1D("MT")->Fill(MT, weight_);
treeMan_->setCurrentFolder(histogramFolder_);
treeMan_->Fill("ST",ST);
treeMan_->Fill("WPT",WPT);
treeMan_->Fill("MT",MT);
histMan_->H2D("HT_vs_MET_plus_leptonPt")->Fill(particle->pt() + met->et(), Event::HT(jets), weight_);
}
}
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;
}
bool TopPairEMuReferenceSelection::passesDiLeptonSelection(const EventPtr event) const {
const ElectronCollection electrons(signalElectrons(event));
const MuonCollection muons(signalMuons(event));
double mass = 0;
if(electrons.size() > 0 && muons.size() > 0){
ElectronPointer electron = electrons.front();
MuonPointer muon = muons.front();
ParticlePointer dilepton;
dilepton = ParticlePointer(new Particle(*electron + *muon));
mass = dilepton->mass();
}
return mass > 20;
}
TtbarHypothesis::TtbarHypothesis(const LeptonPointer& elec,
const ParticlePointer& neut, const JetPointer& lepBJet,
const JetPointer& hadBJet, const JetPointer& hadWJet1,
const JetPointer& hadWJet2) :
totalChi2(99999.), //
leptonicChi2(99999.), //
hadronicChi2(99999.), //
globalChi2(99999.), //
discriminator(999999), //
hadronicTop(), //
leptonicTop(), //
leptonicW(new Particle(*elec + *neut)), //
hadronicW(new Particle(*hadWJet1 + *hadWJet2)), //
resonance(), //
neutrinoFromW(neut), //
leptonicBjet(lepBJet), //
hadronicBJet(hadBJet), //
jet1FromW(hadWJet1), //
jet2FromW(hadWJet2), //
leptonFromW(elec), //
met(new MET(neut->px(), neut->py())), //
decayChannel(Decay::unknown) {
}
extern void printParticle(const ParticlePointer particle) {
cout << particle->toString() << endl;
}
void PseudoTopAnalyser::analyse(const EventPtr event) {
weight_ = event->weight();
treeMan_->setCurrentFolder(histogramFolder_);
// Store gen selection criteria
treeMan_->Fill("isSemiLeptonicElectron", event->isSemiLeptonicElectron());
treeMan_->Fill("isSemiLeptonicMuon", event->isSemiLeptonicMuon());
const PseudoTopParticlesPointer pseudoTopParticles = event->PseudoTopParticles();
const MCParticleCollection pseudoTops = pseudoTopParticles->getPseudoTops();
const MCParticlePointer pseudoLeptonicW = pseudoTopParticles->getPseudoLeptonicW();
const MCParticlePointer pseudoLepton = pseudoTopParticles->getPseudoLepton();
const ParticleCollection allPseudoLeptons = pseudoTopParticles->getAllPseudoLeptons();
const MCParticleCollection pseudoBs = pseudoTopParticles->getPseudoBs();
const ParticlePointer pseudoMET = pseudoTopParticles->getPseudoMET();
const ParticlePointer pseudoNeutrino = pseudoTopParticles->getPseudoNeutrino();
const JetCollection pseudoJets = pseudoTopParticles->getPseudoJets();
ParticleCollection pseudoTopsForTTbar;
// // Only consider events with two pseudo tops
// if ( pseudoTops.size() != 2 ) return;
// // Also only consider events that are semi leptonic at the pseudo top level
// if ( !pseudoTopParticles->isSemiLeptonic() ) return;
// Check if event passes event selection (at pseudo top level)
if ( passesEventSelection( pseudoLepton, pseudoNeutrino, pseudoJets, pseudoBs, allPseudoLeptons, pseudoMET ) ) {
treeMan_->Fill("passesGenEventSelection",1);
}
else {
treeMan_->Fill("passesGenEventSelection",0);
}
//
// TOP VARIABLES
// Top reco at particle level performed
//
// Store info on top
for ( unsigned int ptIndex = 0; ptIndex < pseudoTops.size(); ++ ptIndex ) {
// cout << "Getting pseudo top number : " << ptIndex << endl;
const ParticlePointer pseudoTop = pseudoTops[ptIndex];
pseudoTopsForTTbar.push_back( pseudoTop );
treeMan_->Fill("pseudoTop_pT", pseudoTop->pt() );
treeMan_->Fill("pseudoTop_y", pseudoTop->rapidity() );
}
if( pseudoTopsForTTbar.size() == 2 ) {
// Store info on ttbar
ParticlePointer pseudoTTbar( new Particle( *pseudoTopsForTTbar[0] + *pseudoTopsForTTbar[1] ) );
treeMan_->Fill("pseudoTTbar_pT", pseudoTTbar->pt() );
treeMan_->Fill("pseudoTTbar_y", pseudoTTbar->rapidity() );
treeMan_->Fill("pseudoTTbar_m", pseudoTTbar->mass() );
}
// Store info on Bs
if ( pseudoBs.size() == 2 ) {
unsigned int leadingPsuedoBIndex = 0;
if ( pseudoBs[1]->pt() > pseudoBs[0]->pt() ) {
leadingPsuedoBIndex = 1;
}
unsigned int subleadingPsuedoBIndex = ( leadingPsuedoBIndex == 0 ) ? 1 : 0;
treeMan_->Fill("pseudoB_pT", pseudoBs[leadingPsuedoBIndex]->pt() );
treeMan_->Fill("pseudoB_eta", pseudoBs[leadingPsuedoBIndex]->eta() );
treeMan_->Fill("pseudoB_pT", pseudoBs[subleadingPsuedoBIndex]->pt() );
treeMan_->Fill("pseudoB_eta", pseudoBs[subleadingPsuedoBIndex]->eta() );
// for ( unsigned int pbIndex = 0; pbIndex < pseudoBs.size(); ++pbIndex ) {
// treeMan_->Fill("pseudoB_pT", pseudoBs[pbIndex]->pt() );
// treeMan_->Fill("pseudoB_eta", pseudoBs[pbIndex]->eta() );
// }
}
//
// GLOBAL VARIABLES
// No top reco at particle level
//
if ( allPseudoLeptons.size() > 0 ) {
// Store info on lepton
treeMan_->Fill("pseudoLepton_pT", allPseudoLeptons[0]->pt() );
treeMan_->Fill("pseudoLepton_eta", allPseudoLeptons[0]->eta() );
}
// Store pseudo MET
if ( pseudoMET != 0 ) {
treeMan_->Fill("pseudoMET", pseudoMET->et() );
METAlgorithm::value metType = (METAlgorithm::value) 0;
const METPointer met(event->MET(metType));
if ( pseudoMET->et() <= 0 && met->et() > 0 ) {
}
treeMan_->Fill("pseudoMET_mass", pseudoMET->mass() );
}
// Store pseudo HT
treeMan_->Fill("pseudoHT", event->HT( pseudoJets ) );
// Store pseudo ST
if ( allPseudoLeptons.size() > 0 ) {
treeMan_->Fill("pseudoST", event->ST( pseudoJets, allPseudoLeptons[0], METPointer( new MET( pseudoMET->px(), pseudoMET->py() )) ) );
}
// Store pseudo MT and WPT
// These are from the W reconstructed from the pseudo particles
// i.e. use the neutrino assocaited with the W rather than the more "global" MET
if ( pseudoLeptonicW != 0 ) {
treeMan_->Fill("pseudoWPT_reco", pseudoLeptonicW->pt() );
}
if ( pseudoMET != 0 && allPseudoLeptons.size() > 0 ) {
double WPT = event->WPT( allPseudoLeptons[0], METPointer( new MET( pseudoMET->px(), pseudoMET->py() )) );
treeMan_->Fill("pseudoWPT", WPT );
double MT = event->MT( allPseudoLeptons[0], METPointer( new MET( pseudoMET->px(), pseudoMET->py() )) );
treeMan_->Fill("pseudoMT", MT );
}
}
double Particle::deltaR(const ParticlePointer other) const {
return fourvector.DeltaR(other->getFourVector());
}
double Event::ST(const JetCollection jets, const ParticlePointer lepton, const METPointer met) {
// ST = HT + MET + lepton pt
double ht = Event::HT(jets);
return ht + met->et() + lepton->pt();
}
double Particle::angle(const ParticlePointer otherParticle) const {
return fourvector.Angle(otherParticle->getFourVector().Vect());
}
double Particle::relativePtTo(const ParticlePointer otherParticle) const {
double relativePt = fourvector.Perp(otherParticle->getFourVector().Vect());
return fabs(relativePt);
}
double Particle::invariantMass(const ParticlePointer otherParticle) const {
TLorentzVector combinedParticle(fourvector + otherParticle->getFourVector());
return combinedParticle.M();
}
void TTbar_plus_X_analyser::fillCommonTrees(const EventPtr event, const unsigned int selectionCriteria, std::string folder ) {
SelectionCriteria::selection selection = SelectionCriteria::selection(selectionCriteria);
// Jets
const JetCollection jets(event->CleanedJets());
// B Jets
unsigned int numberOfBjets = event->getNBJets( selection );
const JetCollection bJets(event->CleanedBJets());
// Lepton
const LeptonPointer signalLepton = event->getSignalLepton( selection );
// MET
const METPointer MET_original(event->MET((METAlgorithm::value) 0));
treeMan_->setCurrentFolder(folder);
treeMan_->Fill("EventWeight", event->weight());
treeMan_->Fill("PUWeight", event->PileUpWeight());
treeMan_->Fill("PUWeight_up", event->PileUpWeight(1));
treeMan_->Fill("PUWeight_down", event->PileUpWeight(-1));
treeMan_->Fill("lepton_eta",signalLepton->eta());
treeMan_->Fill("lepton_pt",signalLepton->pt());
treeMan_->Fill("lepton_charge",signalLepton->charge());
if (selection == SelectionCriteria::selection(SelectionCriteria::ElectronPlusJetsReference) ||
selection == SelectionCriteria::selection(SelectionCriteria::ElectronPlusJetsQCDNonIsolated) ||
selection == SelectionCriteria::selection(SelectionCriteria::ElectronPlusJetsQCDConversion)){
treeMan_->Fill("lepton_isolation", signalLepton->PFRelIsoWithEA());
treeMan_->Fill("lepton_hltECALisolation", signalLepton->hltECALIso());
treeMan_->Fill("lepton_hltHCALisolation", signalLepton->hltHCALIso());
treeMan_->Fill("lepton_hltTrackerisolation", signalLepton->hltTrackerIso());
if ( signalLepton->pt() > 0 ) {
treeMan_->Fill("lepton_hltTrackerisolation_overPt", signalLepton->hltTrackerIso() / signalLepton->pt() );
}
}
else if (selection == SelectionCriteria::selection(SelectionCriteria::MuonPlusJetsReference) ||
selection == SelectionCriteria::selection(SelectionCriteria::MuonPlusJetsQCDNonIsolated1p5to3) ||
selection == SelectionCriteria::selection(SelectionCriteria::MuonPlusJetsQCDNonIsolated3toInf)){
treeMan_->Fill("lepton_isolation", signalLepton->PFRelIso04DeltaBeta());
}
treeMan_->Fill("M3",Event::M3(jets));
if ( numberOfBjets > 0 ) {
treeMan_->Fill("M_bl",Event::M_bl(bJets, signalLepton));
treeMan_->Fill("angle_bl",Event::angle_bl(bJets, signalLepton));
// if ( numberOfBjets >= 2 ) {
// unsigned int highestCSVJetIndex = 0;
// unsigned int secondHighestCSVJetIndex = 0;
// Event::getTopTwoCSVJets( bJets, highestCSVJetIndex, secondHighestCSVJetIndex );
// JetPointer highestCSVJet(bJets.at(highestCSVJetIndex));
// JetPointer secondHighestCSVJet(bJets.at(secondHighestCSVJetIndex));
// treeMan_->Fill("deltaPhi_bb", fabs( Event::deltaPhi_bb(highestCSVJet, secondHighestCSVJet) ) ) ;
// treeMan_->Fill("deltaEta_bb", fabs( Event::deltaEta_bb(highestCSVJet, secondHighestCSVJet) ) ) ;
// treeMan_->Fill("angle_bb", Event::angle_bb(highestCSVJet, secondHighestCSVJet));
// }
}
for (unsigned int index = 0; index < jets.size(); ++index) {
treeMan_->Fill("jet_pt", jets.at(index)->pt() );
treeMan_->Fill("jet_eta", jets.at(index)->eta() );
treeMan_->Fill("jet_csv", jets.at(index)->getBTagDiscriminator(BtagAlgorithm::CombinedSecondaryVertexV2) );
}
treeMan_->Fill("HT",Event::HT(jets));
treeMan_->Fill("MET",MET_original->et());
treeMan_->Fill("MET_phi",MET_original->phi());
treeMan_->Fill("ST",Event::ST(jets, signalLepton, MET_original));
treeMan_->Fill("WPT",Event::WPT(signalLepton, MET_original));
treeMan_->Fill("MT",Event::MT(signalLepton, MET_original));
treeMan_->Fill("NJets",Event::NJets(jets));
treeMan_->Fill("NBJets",Event::NJets(bJets));
treeMan_->Fill("NVertices", event->Vertices().size());
treeMan_->Fill("BJetWeight",event->BJetWeight());
treeMan_->Fill("BJetEfficiencyCorrectionWeight",event->BJetEfficiencyCorrectionWeight());
treeMan_->Fill("BJetAlternativeWeight",event->BJetAlternativeWeight());
treeMan_->Fill("BJetUpWeight",event->BJetUpWeight());
treeMan_->Fill("BJetDownWeight",event->BJetDownWeight());
treeMan_->Fill("LightJetUpWeight",event->LightJetUpWeight());
treeMan_->Fill("LightJetDownWeight",event->LightJetDownWeight());
treeMan_->Fill("tau1", event->getTau1());
treeMan_->Fill("tau2", event->getTau2());
treeMan_->Fill("tau3", event->getTau3());
treeMan_->Fill("tau4", event->getTau4());
treeMan_->Fill("tau5", event->getTau5());
treeMan_->Fill("tau6", event->getTau6());
// MET Uncertainties
for ( unsigned int unc_i = 0; unc_i < MET_original->getAllMETUncertainties().size(); ++unc_i ) {
METPointer METForUnc_i = MET_original->getMETForUncertainty( unc_i );
treeMan_->Fill("MET_METUncertainties",METForUnc_i->et());
treeMan_->Fill("ST_METUncertainties",Event::ST(jets, signalLepton, METForUnc_i));
treeMan_->Fill("WPT_METUncertainties",Event::WPT(signalLepton, METForUnc_i));
}
double topPtWeight = 1.;
if ( ( event->isSemiLeptonicElectron() || event->isSemiLeptonicMuon() ) ) {
const TTGenInfoPointer ttGen( event->TTGenInfo() );
const ParticlePointer leptonicTop = ttGen->getLeptonicTop();
const ParticlePointer hadronicTop = ttGen->getHadronicTop();
if ( leptonicTop != 0 && hadronicTop != 0 ) {
// Store info on leptonic top
treeMan_->Fill("lepTopPt_parton", leptonicTop->pt() );
treeMan_->Fill("hadTopPt_parton", hadronicTop->pt() );
topPtWeight = exp( 0.0615 - 0.0005 * leptonicTop->pt() ) * exp( 0.0615 - 0.0005 * hadronicTop->pt() );
}
}
treeMan_->Fill("topPtWeight",topPtWeight);
fillLeptonEfficiencyCorrectionBranches( event, selectionCriteria, signalLepton );
wAnalyser_->analyseHadronicW( event, jets, bJets, folder );
}
double Particle::deltaEta(const ParticlePointer other) const {
return eta() - other->eta();
}
