VHbbAnalysisCode/src/VHbbCandidateVariables.cpp

#include "TrkUpgradeAnalysis/VHbb/interface/VHbbCandidateVariables.h"

#include <sstream>
#include <stdexcept>
#include "VHbbAnalysis/VHbbDataFormats/interface/VHbbCandidate.h"
#include "TrkUpgradeAnalysis/VHbb/interface/tools.h" // required for trkupgradeanalysis::tools::NTupleRow

// Required to work out deltaPhi
#include "DataFormats/GeometryVector/interface/VectorUtil.h"


trkupgradeanalysis::variables::VHbbCandidateVariable::VHbbCandidateVariable( const std::string& name, size_t suggestedNumberOfBins, double suggestedLowerEdge, double suggestedUpperEdge ) :
        name_(name), suggestedNumberOfBins_(suggestedNumberOfBins), suggestedLowerEdge_(suggestedLowerEdge), suggestedUpperEdge_(suggestedUpperEdge)
{
        // No operation besides the initialiser list
}

trkupgradeanalysis::variables::VHbbCandidateVariable::~VHbbCandidateVariable()
{
        // No operation
}

std::string trkupgradeanalysis::variables::VHbbCandidateVariable::variableName() const
{
        return name_;
}

double trkupgradeanalysis::variables::VHbbCandidateVariable::histogrammableValue() const
{
        return value_;
}

size_t trkupgradeanalysis::variables::VHbbCandidateVariable::suggestedNumberOfBins() const
{
        return suggestedNumberOfBins_;
}

double trkupgradeanalysis::variables::VHbbCandidateVariable::suggestedLowerEdge() const
{
        return suggestedLowerEdge_;
}

double trkupgradeanalysis::variables::VHbbCandidateVariable::suggestedUpperEdge() const
{
        return suggestedUpperEdge_;
}

void trkupgradeanalysis::variables::VHbbCandidateVariable::set( const trkupgradeanalysis::tools::NTupleRow& ntupleRow )
{
        // The default implementation assumes the variable was saved with a branch name of the variable name
        value_=ntupleRow.getDouble(name_);
}


trkupgradeanalysis::variables::NumberOfAdditionalJets::NumberOfAdditionalJets( bool applyCleaning ) :
        VHbbCandidateVariable("NumberOfAdditionalJets",91,-0.5,90.5), applyCleaning_(applyCleaning)
{
        // No operation besides the initialiser list
}

void trkupgradeanalysis::variables::NumberOfAdditionalJets::set( const VHbbCandidate& vhbbCandidate )
{
        if( !applyCleaning_ ) value_=vhbbCandidate.additionalJets.size();
        else
        {
                value_=0;
                for( std::vector<VHbbEvent::SimpleJet>::const_iterator iJet=vhbbCandidate.additionalJets.begin(); iJet!=vhbbCandidate.additionalJets.end(); ++iJet )
                {
                        if( jetId( *iJet )==true && fabs(iJet->p4.Eta()) < 2.5 && iJet->p4.Pt() > 20 ) ++value_;
                }
        }

}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::NumberOfAdditionalJets::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::NumberOfAdditionalJets(*this) );
}

bool trkupgradeanalysis::variables::NumberOfAdditionalJets::jetId( const VHbbEvent::SimpleJet& jet ) const
{
        if( jet.neutralHadronEFraction > 0.99 ) return false;
        if( jet.neutralEmEFraction > 0.99 ) return false;
        if( jet.nConstituents <= 1 ) return false;
        if( fabs(jet.p4.Eta()) < 2.5 )
        {
                if( jet.chargedEmEFraction > 0.99 ) return false;
                if( jet.chargedHadronEFraction == 0 ) return false;
                if( jet.ntracks== 0 ) return false;
        }

        return true;
}


trkupgradeanalysis::variables::DiJetMass::DiJetMass() :
        VHbbCandidateVariable("DiJetMass",60,0,250)
{
        // No operation besides the initialiser list
}

void trkupgradeanalysis::variables::DiJetMass::set( const VHbbCandidate& vhbbCandidate )
{
        value_=vhbbCandidate.H.p4.M();
}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::DiJetMass::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::DiJetMass(*this) );
}


trkupgradeanalysis::variables::HighestCSV::HighestCSV( size_t maximumJetNumber ) :
        VHbbCandidateVariable("HighestCSV",60,-1,1.5), maximumJetNumber_(maximumJetNumber)
{
        // Overwrite the name with more information
        std::stringstream nameStream;
        nameStream << "HighestCSVOf";

        if( maximumJetNumber_==0 ) nameStream << "AllJets";
        else nameStream << "First" << maximumJetNumber_ << "Jets";

        name_=nameStream.str();
}

void trkupgradeanalysis::variables::HighestCSV::set( const VHbbCandidate& vhbbCandidate )
{
        unsigned int numberOfJetsToCheck=maximumJetNumber_;
        if( maximumJetNumber_==0 || numberOfJetsToCheck>vhbbCandidate.H.jets.size() ) numberOfJetsToCheck=vhbbCandidate.H.jets.size();

        value_=-1; // Start off with a nonsensical default so I know if things go wrong
        for( unsigned int a=0; a<numberOfJetsToCheck; ++a )
        {
                if( vhbbCandidate.H.jets.at(a).csv > value_ ) value_=vhbbCandidate.H.jets.at(a).csv;
        }

}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::HighestCSV::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::HighestCSV(*this) );
}


trkupgradeanalysis::variables::LowestCSV::LowestCSV( size_t maximumJetNumber ) :
        VHbbCandidateVariable("LowestCSV",60,-1,1.5), maximumJetNumber_(maximumJetNumber)
{
        // Overwrite the name with more information
        std::stringstream nameStream;
        nameStream << "LowestCSVOf";

        if( maximumJetNumber_==0 ) nameStream << "AllJets";
        else nameStream << "First" << maximumJetNumber_ << "Jets";

        name_=nameStream.str();
}

void trkupgradeanalysis::variables::LowestCSV::set( const VHbbCandidate& vhbbCandidate )
{
        unsigned int numberOfJetsToCheck=maximumJetNumber_;
        if( maximumJetNumber_==0 || numberOfJetsToCheck>vhbbCandidate.H.jets.size() ) numberOfJetsToCheck=vhbbCandidate.H.jets.size();

        value_=-1; // Start off with a nonsensical default so I know if things go wrong
        for( unsigned int a=0; a<numberOfJetsToCheck; ++a )
        {
                if( (vhbbCandidate.H.jets.at(a).csv<value_) || value_==-1 ) value_=vhbbCandidate.H.jets.at(a).csv;
        }

}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::LowestCSV::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::LowestCSV(*this) );
}


trkupgradeanalysis::variables::NumberOfJets::NumberOfJets() :
        VHbbCandidateVariable("NumberOfJets",6,-0.5,5.5)
{
        // No operation besides the initialiser list
}

void trkupgradeanalysis::variables::NumberOfJets::set( const VHbbCandidate& vhbbCandidate )
{
        value_=vhbbCandidate.H.jets.size();
}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::NumberOfJets::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::NumberOfJets(*this) );
}


trkupgradeanalysis::variables::MuonPixelHits::MuonPixelHits( bool checkFirstMuon ) :
        VHbbCandidateVariable("MuonPixelHits",7,-1.5,5.5), checkFirstMuon_(checkFirstMuon), throwExceptions_(false)
{
        // Need to add which muon I'm checking to the name
        if( checkFirstMuon_ ) name_="MuonPixelHitsOfFirstMuon";
        else name_="MuonPixelHitsOfSecondMuon";
}

// TODO - Get rid of this once fully debugged.
#include <iostream>
void trkupgradeanalysis::variables::MuonPixelHits::set( const VHbbCandidate& vhbbCandidate )
{
        value_=-1; // Set to an invalid value in case of error

        if( vhbbCandidate.V.muons.size()<2 )
        {
                if( throwExceptions_ ) throw std::runtime_error( "trkupgradeanalysis::variables::MuonPixelHits::set(..) - There are fewer than 2 muons");
                else
                {
//                      std::cerr << "trkupgradeanalysis::variables::MuonPixelHits::set(..) - There are fewer than 2 muons" << std::endl;
                        return;
                }
        }

        if( checkFirstMuon_ )
        {
                value_=vhbbCandidate.V.muons[0].nPixelHits;
//              if( vhbbCandidate.V.firstLepton<vhbbCandidate.V.muons.size() ) value_=vhbbCandidate.V.muons[vhbbCandidate.V.firstLepton].nPixelHits;
//              else std::cerr << "trkupgradeanalysis::variables::MuonPixelHits::set(..) - vhbbCandidate.V.firstLepton=" << vhbbCandidate.V.firstLepton
//                              << " (candidateType=" << vhbbCandidate.candidateType << ")"
//                              << "[" << vhbbCandidate.V.muons.size() << "," << vhbbCandidate.V.firstLepton << "," << vhbbCandidate.V.secondLepton << "]" << std::endl;
        }
        else
        {
                value_=vhbbCandidate.V.muons[1].nPixelHits;
//              if( vhbbCandidate.V.secondLepton<vhbbCandidate.V.muons.size() ) value_=vhbbCandidate.V.muons[vhbbCandidate.V.secondLepton].nPixelHits;
//              else std::cerr << "trkupgradeanalysis::variables::MuonPixelHits::set(..) - vhbbCandidate.V.secondLepton=" << vhbbCandidate.V.secondLepton
//                              << " (candidateType=" << vhbbCandidate.candidateType << ")"
//                              << "[" << vhbbCandidate.V.muons.size() << "," << vhbbCandidate.V.firstLepton << "," << vhbbCandidate.V.secondLepton << "]" << std::endl;
        }
}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::MuonPixelHits::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::MuonPixelHits(*this) );
}


trkupgradeanalysis::variables::HighestMuonPixelHits::HighestMuonPixelHits() :
        VHbbCandidateVariable("HighestMuonPixelHits",7,-1.5,5.5), throwExceptions_(false)
{
        // No operation besides the initialiser list
}

void trkupgradeanalysis::variables::HighestMuonPixelHits::set( const VHbbCandidate& vhbbCandidate )
{
        value_=-1; // Set to an invalid value in case of error

        if( vhbbCandidate.V.muons.size()<2 || vhbbCandidate.V.firstLepton>vhbbCandidate.V.muons.size() || vhbbCandidate.V.secondLepton>vhbbCandidate.V.muons.size() )
        {
                if( throwExceptions_ ) throw std::runtime_error( "trkupgradeanalysis::variables::HighestMuonPixelHits::set(..) - There are not enough muons");
                else
                {
//                      std::cerr << "trkupgradeanalysis::variables::HighestMuonPixelHits::set(..) - There are fewer than 2 muons" << std::endl;
                        return;
                }
        }

        int firstMuon=vhbbCandidate.V.muons[vhbbCandidate.V.firstLepton].nPixelHits;
        int secondMuon=vhbbCandidate.V.muons[vhbbCandidate.V.secondLepton].nPixelHits;
        firstMuon > secondMuon ? value_=firstMuon : value_=secondMuon;
}


void trkupgradeanalysis::variables::HighestMuonPixelHits::set( const trkupgradeanalysis::tools::NTupleRow& ntupleRow )
{
        try // Try the default behaviour, if that doesn't work check for MuonPixelHitsOfFirstMuon and MuonPixelHitsOfSecondMuon
        {
                value_=ntupleRow.getDouble(name_);
        }
        catch( std::exception& error )
        {
                double firstMuon=ntupleRow.getDouble("MuonPixelHitsOfFirstMuon");
                double secondMuon=ntupleRow.getDouble("MuonPixelHitsOfSecondMuon");
                firstMuon > secondMuon ? value_=firstMuon : value_=secondMuon;
        }
}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::HighestMuonPixelHits::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::HighestMuonPixelHits(*this) );
}


trkupgradeanalysis::variables::LowestMuonPixelHits::LowestMuonPixelHits() :
        VHbbCandidateVariable("LowestMuonPixelHits",7,-1.5,5.5), throwExceptions_(false)
{
        // No operation besides the initialiser list
}

void trkupgradeanalysis::variables::LowestMuonPixelHits::set( const VHbbCandidate& vhbbCandidate )
{
        value_=-1; // Set to an invalid value in case of error

        if( vhbbCandidate.V.muons.size()<2 || vhbbCandidate.V.firstLepton>vhbbCandidate.V.muons.size() || vhbbCandidate.V.secondLepton>vhbbCandidate.V.muons.size() )
        {
                if( throwExceptions_ ) throw std::runtime_error( "trkupgradeanalysis::variables::LowestMuonPixelHits::set(..) - There are not enough muons");
                else
                {
//                      std::cerr << "trkupgradeanalysis::variables::LowestMuonPixelHits::set(..) - There are fewer than 2 muons" << std::endl;
                        return;
                }
        }

        int firstMuon=vhbbCandidate.V.muons[vhbbCandidate.V.firstLepton].nPixelHits;
        int secondMuon=vhbbCandidate.V.muons[vhbbCandidate.V.secondLepton].nPixelHits;
        firstMuon < secondMuon ? value_=firstMuon : value_=secondMuon;
}


void trkupgradeanalysis::variables::LowestMuonPixelHits::set( const trkupgradeanalysis::tools::NTupleRow& ntupleRow )
{
        try // Try the default behaviour, if that doesn't work check for MuonPixelHitsOfFirstMuon and MuonPixelHitsOfSecondMuon
        {
                value_=ntupleRow.getDouble(name_);
        }
        catch( std::exception& error )
        {
                double firstMuon=ntupleRow.getDouble("MuonPixelHitsOfFirstMuon");
                double secondMuon=ntupleRow.getDouble("MuonPixelHitsOfSecondMuon");
                firstMuon < secondMuon ? value_=firstMuon : value_=secondMuon;
        }
}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::LowestMuonPixelHits::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::LowestMuonPixelHits(*this) );
}


trkupgradeanalysis::variables::CandidateType::CandidateType() :
        VHbbCandidateVariable("CandidateType",6,-0.5,5.5)
{
        // No operation besides the initialiser list
}

void trkupgradeanalysis::variables::CandidateType::set( const VHbbCandidate& vhbbCandidate )
{
        value_=vhbbCandidate.candidateType;
}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::CandidateType::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::CandidateType(*this) );
}


trkupgradeanalysis::variables::DiLeptonMass::DiLeptonMass() :
        VHbbCandidateVariable("DiLeptonMass",60,0,250)
{
        // No operation besides the initialiser list
}

void trkupgradeanalysis::variables::DiLeptonMass::set( const VHbbCandidate& vhbbCandidate )
{
        value_=vhbbCandidate.V.p4.M();
}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::DiLeptonMass::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::DiLeptonMass(*this) );
}


trkupgradeanalysis::variables::HiggsCandidatePt::HiggsCandidatePt() :
        VHbbCandidateVariable("HiggsCandidatePt",60,0,250)
{
        // No operation besides the initialiser list
}

void trkupgradeanalysis::variables::HiggsCandidatePt::set( const VHbbCandidate& vhbbCandidate )
{
        value_=vhbbCandidate.H.p4.Pt();;
}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::HiggsCandidatePt::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::HiggsCandidatePt(*this) );
}


trkupgradeanalysis::variables::VectorBosonCandidatePt::VectorBosonCandidatePt() :
        VHbbCandidateVariable("VectorBosonCandidatePt",60,0,250)
{
        // No operation besides the initialiser list
}

void trkupgradeanalysis::variables::VectorBosonCandidatePt::set( const VHbbCandidate& vhbbCandidate )
{
        value_=vhbbCandidate.V.p4.Pt();
}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::VectorBosonCandidatePt::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::VectorBosonCandidatePt(*this) );
}


trkupgradeanalysis::variables::DeltaPhiVH::DeltaPhiVH() :
        VHbbCandidateVariable("DeltaPhiVH",60,0,M_PI)
{
        // No operation besides the initialiser list
}

void trkupgradeanalysis::variables::DeltaPhiVH::set( const VHbbCandidate& vhbbCandidate )
{
        value_=TMath::Abs( Geom::deltaPhi( vhbbCandidate.H.p4.Phi(), vhbbCandidate.V.p4.Phi() ) );
}

std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::DeltaPhiVH::copy() const
{
        return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::DeltaPhiVH(*this) );
}
Revision:	1.1
Committed:	Wed Aug 15 22:37:47 2012 UTC (12 years, 8 months ago) by grimes
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	Long overdue commit with several new files
#	Content
1	#include "TrkUpgradeAnalysis/VHbb/interface/VHbbCandidateVariables.h"
2
3	#include <sstream>
4	#include <stdexcept>
5	#include "VHbbAnalysis/VHbbDataFormats/interface/VHbbCandidate.h"
6	#include "TrkUpgradeAnalysis/VHbb/interface/tools.h" // required for trkupgradeanalysis::tools::NTupleRow
7
8	// Required to work out deltaPhi
9	#include "DataFormats/GeometryVector/interface/VectorUtil.h"
10
11
12	trkupgradeanalysis::variables::VHbbCandidateVariable::VHbbCandidateVariable( const std::string& name, size_t suggestedNumberOfBins, double suggestedLowerEdge, double suggestedUpperEdge ) :
13	name_(name), suggestedNumberOfBins_(suggestedNumberOfBins), suggestedLowerEdge_(suggestedLowerEdge), suggestedUpperEdge_(suggestedUpperEdge)
14	{
15	// No operation besides the initialiser list
16	}
17
18	trkupgradeanalysis::variables::VHbbCandidateVariable::~VHbbCandidateVariable()
19	{
20	// No operation
21	}
22
23	std::string trkupgradeanalysis::variables::VHbbCandidateVariable::variableName() const
24	{
25	return name_;
26	}
27
28	double trkupgradeanalysis::variables::VHbbCandidateVariable::histogrammableValue() const
29	{
30	return value_;
31	}
32
33	size_t trkupgradeanalysis::variables::VHbbCandidateVariable::suggestedNumberOfBins() const
34	{
35	return suggestedNumberOfBins_;
36	}
37
38	double trkupgradeanalysis::variables::VHbbCandidateVariable::suggestedLowerEdge() const
39	{
40	return suggestedLowerEdge_;
41	}
42
43	double trkupgradeanalysis::variables::VHbbCandidateVariable::suggestedUpperEdge() const
44	{
45	return suggestedUpperEdge_;
46	}
47
48	void trkupgradeanalysis::variables::VHbbCandidateVariable::set( const trkupgradeanalysis::tools::NTupleRow& ntupleRow )
49	{
50	// The default implementation assumes the variable was saved with a branch name of the variable name
51	value_=ntupleRow.getDouble(name_);
52	}
53
54
55
56
57
58	trkupgradeanalysis::variables::NumberOfAdditionalJets::NumberOfAdditionalJets( bool applyCleaning ) :
59	VHbbCandidateVariable("NumberOfAdditionalJets",91,-0.5,90.5), applyCleaning_(applyCleaning)
60	{
61	// No operation besides the initialiser list
62	}
63
64	void trkupgradeanalysis::variables::NumberOfAdditionalJets::set( const VHbbCandidate& vhbbCandidate )
65	{
66	if( !applyCleaning_ ) value_=vhbbCandidate.additionalJets.size();
67	else
68	{
69	value_=0;
70	for( std::vector<VHbbEvent::SimpleJet>::const_iterator iJet=vhbbCandidate.additionalJets.begin(); iJet!=vhbbCandidate.additionalJets.end(); ++iJet )
71	{
72	if( jetId( *iJet )==true && fabs(iJet->p4.Eta()) < 2.5 && iJet->p4.Pt() > 20 ) ++value_;
73	}
74	}
75
76	}
77
78	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::NumberOfAdditionalJets::copy() const
79	{
80	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::NumberOfAdditionalJets(*this) );
81	}
82
83	bool trkupgradeanalysis::variables::NumberOfAdditionalJets::jetId( const VHbbEvent::SimpleJet& jet ) const
84	{
85	if( jet.neutralHadronEFraction > 0.99 ) return false;
86	if( jet.neutralEmEFraction > 0.99 ) return false;
87	if( jet.nConstituents <= 1 ) return false;
88	if( fabs(jet.p4.Eta()) < 2.5 )
89	{
90	if( jet.chargedEmEFraction > 0.99 ) return false;
91	if( jet.chargedHadronEFraction == 0 ) return false;
92	if( jet.ntracks== 0 ) return false;
93	}
94
95	return true;
96	}
97
98
99
100
101
102
103
104	trkupgradeanalysis::variables::DiJetMass::DiJetMass() :
105	VHbbCandidateVariable("DiJetMass",60,0,250)
106	{
107	// No operation besides the initialiser list
108	}
109
110	void trkupgradeanalysis::variables::DiJetMass::set( const VHbbCandidate& vhbbCandidate )
111	{
112	value_=vhbbCandidate.H.p4.M();
113	}
114
115	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::DiJetMass::copy() const
116	{
117	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::DiJetMass(*this) );
118	}
119
120
121
122
123
124
125
126	trkupgradeanalysis::variables::HighestCSV::HighestCSV( size_t maximumJetNumber ) :
127	VHbbCandidateVariable("HighestCSV",60,-1,1.5), maximumJetNumber_(maximumJetNumber)
128	{
129	// Overwrite the name with more information
130	std::stringstream nameStream;
131	nameStream << "HighestCSVOf";
132
133	if( maximumJetNumber_==0 ) nameStream << "AllJets";
134	else nameStream << "First" << maximumJetNumber_ << "Jets";
135
136	name_=nameStream.str();
137	}
138
139	void trkupgradeanalysis::variables::HighestCSV::set( const VHbbCandidate& vhbbCandidate )
140	{
141	unsigned int numberOfJetsToCheck=maximumJetNumber_;
142	if( maximumJetNumber_==0 \|\| numberOfJetsToCheck>vhbbCandidate.H.jets.size() ) numberOfJetsToCheck=vhbbCandidate.H.jets.size();
143
144	value_=-1; // Start off with a nonsensical default so I know if things go wrong
145	for( unsigned int a=0; a<numberOfJetsToCheck; ++a )
146	{
147	if( vhbbCandidate.H.jets.at(a).csv > value_ ) value_=vhbbCandidate.H.jets.at(a).csv;
148	}
149
150	}
151
152	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::HighestCSV::copy() const
153	{
154	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::HighestCSV(*this) );
155	}
156
157
158
159
160
161
162
163	trkupgradeanalysis::variables::LowestCSV::LowestCSV( size_t maximumJetNumber ) :
164	VHbbCandidateVariable("LowestCSV",60,-1,1.5), maximumJetNumber_(maximumJetNumber)
165	{
166	// Overwrite the name with more information
167	std::stringstream nameStream;
168	nameStream << "LowestCSVOf";
169
170	if( maximumJetNumber_==0 ) nameStream << "AllJets";
171	else nameStream << "First" << maximumJetNumber_ << "Jets";
172
173	name_=nameStream.str();
174	}
175
176	void trkupgradeanalysis::variables::LowestCSV::set( const VHbbCandidate& vhbbCandidate )
177	{
178	unsigned int numberOfJetsToCheck=maximumJetNumber_;
179	if( maximumJetNumber_==0 \|\| numberOfJetsToCheck>vhbbCandidate.H.jets.size() ) numberOfJetsToCheck=vhbbCandidate.H.jets.size();
180
181	value_=-1; // Start off with a nonsensical default so I know if things go wrong
182	for( unsigned int a=0; a<numberOfJetsToCheck; ++a )
183	{
184	if( (vhbbCandidate.H.jets.at(a).csv<value_) \|\| value_==-1 ) value_=vhbbCandidate.H.jets.at(a).csv;
185	}
186
187	}
188
189	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::LowestCSV::copy() const
190	{
191	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::LowestCSV(*this) );
192	}
193
194
195
196
197
198
199
200	trkupgradeanalysis::variables::NumberOfJets::NumberOfJets() :
201	VHbbCandidateVariable("NumberOfJets",6,-0.5,5.5)
202	{
203	// No operation besides the initialiser list
204	}
205
206	void trkupgradeanalysis::variables::NumberOfJets::set( const VHbbCandidate& vhbbCandidate )
207	{
208	value_=vhbbCandidate.H.jets.size();
209	}
210
211	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::NumberOfJets::copy() const
212	{
213	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::NumberOfJets(*this) );
214	}
215
216
217
218
219
220
221
222	trkupgradeanalysis::variables::MuonPixelHits::MuonPixelHits( bool checkFirstMuon ) :
223	VHbbCandidateVariable("MuonPixelHits",7,-1.5,5.5), checkFirstMuon_(checkFirstMuon), throwExceptions_(false)
224	{
225	// Need to add which muon I'm checking to the name
226	if( checkFirstMuon_ ) name_="MuonPixelHitsOfFirstMuon";
227	else name_="MuonPixelHitsOfSecondMuon";
228	}
229
230	// TODO - Get rid of this once fully debugged.
231	#include <iostream>
232	void trkupgradeanalysis::variables::MuonPixelHits::set( const VHbbCandidate& vhbbCandidate )
233	{
234	value_=-1; // Set to an invalid value in case of error
235
236	if( vhbbCandidate.V.muons.size()<2 )
237	{
238	if( throwExceptions_ ) throw std::runtime_error( "trkupgradeanalysis::variables::MuonPixelHits::set(..) - There are fewer than 2 muons");
239	else
240	{
241	// std::cerr << "trkupgradeanalysis::variables::MuonPixelHits::set(..) - There are fewer than 2 muons" << std::endl;
242	return;
243	}
244	}
245
246	if( checkFirstMuon_ )
247	{
248	value_=vhbbCandidate.V.muons[0].nPixelHits;
249	// if( vhbbCandidate.V.firstLepton<vhbbCandidate.V.muons.size() ) value_=vhbbCandidate.V.muons[vhbbCandidate.V.firstLepton].nPixelHits;
250	// else std::cerr << "trkupgradeanalysis::variables::MuonPixelHits::set(..) - vhbbCandidate.V.firstLepton=" << vhbbCandidate.V.firstLepton
251	// << " (candidateType=" << vhbbCandidate.candidateType << ")"
252	// << "[" << vhbbCandidate.V.muons.size() << "," << vhbbCandidate.V.firstLepton << "," << vhbbCandidate.V.secondLepton << "]" << std::endl;
253	}
254	else
255	{
256	value_=vhbbCandidate.V.muons[1].nPixelHits;
257	// if( vhbbCandidate.V.secondLepton<vhbbCandidate.V.muons.size() ) value_=vhbbCandidate.V.muons[vhbbCandidate.V.secondLepton].nPixelHits;
258	// else std::cerr << "trkupgradeanalysis::variables::MuonPixelHits::set(..) - vhbbCandidate.V.secondLepton=" << vhbbCandidate.V.secondLepton
259	// << " (candidateType=" << vhbbCandidate.candidateType << ")"
260	// << "[" << vhbbCandidate.V.muons.size() << "," << vhbbCandidate.V.firstLepton << "," << vhbbCandidate.V.secondLepton << "]" << std::endl;
261	}
262	}
263
264	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::MuonPixelHits::copy() const
265	{
266	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::MuonPixelHits(*this) );
267	}
268
269
270
271
272
273
274	trkupgradeanalysis::variables::HighestMuonPixelHits::HighestMuonPixelHits() :
275	VHbbCandidateVariable("HighestMuonPixelHits",7,-1.5,5.5), throwExceptions_(false)
276	{
277	// No operation besides the initialiser list
278	}
279
280	void trkupgradeanalysis::variables::HighestMuonPixelHits::set( const VHbbCandidate& vhbbCandidate )
281	{
282	value_=-1; // Set to an invalid value in case of error
283
284	if( vhbbCandidate.V.muons.size()<2 \|\| vhbbCandidate.V.firstLepton>vhbbCandidate.V.muons.size() \|\| vhbbCandidate.V.secondLepton>vhbbCandidate.V.muons.size() )
285	{
286	if( throwExceptions_ ) throw std::runtime_error( "trkupgradeanalysis::variables::HighestMuonPixelHits::set(..) - There are not enough muons");
287	else
288	{
289	// std::cerr << "trkupgradeanalysis::variables::HighestMuonPixelHits::set(..) - There are fewer than 2 muons" << std::endl;
290	return;
291	}
292	}
293
294	int firstMuon=vhbbCandidate.V.muons[vhbbCandidate.V.firstLepton].nPixelHits;
295	int secondMuon=vhbbCandidate.V.muons[vhbbCandidate.V.secondLepton].nPixelHits;
296	firstMuon > secondMuon ? value_=firstMuon : value_=secondMuon;
297	}
298
299
300	void trkupgradeanalysis::variables::HighestMuonPixelHits::set( const trkupgradeanalysis::tools::NTupleRow& ntupleRow )
301	{
302	try // Try the default behaviour, if that doesn't work check for MuonPixelHitsOfFirstMuon and MuonPixelHitsOfSecondMuon
303	{
304	value_=ntupleRow.getDouble(name_);
305	}
306	catch( std::exception& error )
307	{
308	double firstMuon=ntupleRow.getDouble("MuonPixelHitsOfFirstMuon");
309	double secondMuon=ntupleRow.getDouble("MuonPixelHitsOfSecondMuon");
310	firstMuon > secondMuon ? value_=firstMuon : value_=secondMuon;
311	}
312	}
313
314	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::HighestMuonPixelHits::copy() const
315	{
316	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::HighestMuonPixelHits(*this) );
317	}
318
319
320
321
322
323
324	trkupgradeanalysis::variables::LowestMuonPixelHits::LowestMuonPixelHits() :
325	VHbbCandidateVariable("LowestMuonPixelHits",7,-1.5,5.5), throwExceptions_(false)
326	{
327	// No operation besides the initialiser list
328	}
329
330	void trkupgradeanalysis::variables::LowestMuonPixelHits::set( const VHbbCandidate& vhbbCandidate )
331	{
332	value_=-1; // Set to an invalid value in case of error
333
334	if( vhbbCandidate.V.muons.size()<2 \|\| vhbbCandidate.V.firstLepton>vhbbCandidate.V.muons.size() \|\| vhbbCandidate.V.secondLepton>vhbbCandidate.V.muons.size() )
335	{
336	if( throwExceptions_ ) throw std::runtime_error( "trkupgradeanalysis::variables::LowestMuonPixelHits::set(..) - There are not enough muons");
337	else
338	{
339	// std::cerr << "trkupgradeanalysis::variables::LowestMuonPixelHits::set(..) - There are fewer than 2 muons" << std::endl;
340	return;
341	}
342	}
343
344	int firstMuon=vhbbCandidate.V.muons[vhbbCandidate.V.firstLepton].nPixelHits;
345	int secondMuon=vhbbCandidate.V.muons[vhbbCandidate.V.secondLepton].nPixelHits;
346	firstMuon < secondMuon ? value_=firstMuon : value_=secondMuon;
347	}
348
349
350	void trkupgradeanalysis::variables::LowestMuonPixelHits::set( const trkupgradeanalysis::tools::NTupleRow& ntupleRow )
351	{
352	try // Try the default behaviour, if that doesn't work check for MuonPixelHitsOfFirstMuon and MuonPixelHitsOfSecondMuon
353	{
354	value_=ntupleRow.getDouble(name_);
355	}
356	catch( std::exception& error )
357	{
358	double firstMuon=ntupleRow.getDouble("MuonPixelHitsOfFirstMuon");
359	double secondMuon=ntupleRow.getDouble("MuonPixelHitsOfSecondMuon");
360	firstMuon < secondMuon ? value_=firstMuon : value_=secondMuon;
361	}
362	}
363
364	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::LowestMuonPixelHits::copy() const
365	{
366	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::LowestMuonPixelHits(*this) );
367	}
368
369
370
371
372
373
374
375	trkupgradeanalysis::variables::CandidateType::CandidateType() :
376	VHbbCandidateVariable("CandidateType",6,-0.5,5.5)
377	{
378	// No operation besides the initialiser list
379	}
380
381	void trkupgradeanalysis::variables::CandidateType::set( const VHbbCandidate& vhbbCandidate )
382	{
383	value_=vhbbCandidate.candidateType;
384	}
385
386	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::CandidateType::copy() const
387	{
388	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::CandidateType(*this) );
389	}
390
391
392
393
394
395
396
397	trkupgradeanalysis::variables::DiLeptonMass::DiLeptonMass() :
398	VHbbCandidateVariable("DiLeptonMass",60,0,250)
399	{
400	// No operation besides the initialiser list
401	}
402
403	void trkupgradeanalysis::variables::DiLeptonMass::set( const VHbbCandidate& vhbbCandidate )
404	{
405	value_=vhbbCandidate.V.p4.M();
406	}
407
408	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::DiLeptonMass::copy() const
409	{
410	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::DiLeptonMass(*this) );
411	}
412
413
414
415
416
417
418
419	trkupgradeanalysis::variables::HiggsCandidatePt::HiggsCandidatePt() :
420	VHbbCandidateVariable("HiggsCandidatePt",60,0,250)
421	{
422	// No operation besides the initialiser list
423	}
424
425	void trkupgradeanalysis::variables::HiggsCandidatePt::set( const VHbbCandidate& vhbbCandidate )
426	{
427	value_=vhbbCandidate.H.p4.Pt();;
428	}
429
430	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::HiggsCandidatePt::copy() const
431	{
432	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::HiggsCandidatePt(*this) );
433	}
434
435
436
437
438
439
440
441	trkupgradeanalysis::variables::VectorBosonCandidatePt::VectorBosonCandidatePt() :
442	VHbbCandidateVariable("VectorBosonCandidatePt",60,0,250)
443	{
444	// No operation besides the initialiser list
445	}
446
447	void trkupgradeanalysis::variables::VectorBosonCandidatePt::set( const VHbbCandidate& vhbbCandidate )
448	{
449	value_=vhbbCandidate.V.p4.Pt();
450	}
451
452	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::VectorBosonCandidatePt::copy() const
453	{
454	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::VectorBosonCandidatePt(*this) );
455	}
456
457
458
459
460
461
462
463	trkupgradeanalysis::variables::DeltaPhiVH::DeltaPhiVH() :
464	VHbbCandidateVariable("DeltaPhiVH",60,0,M_PI)
465	{
466	// No operation besides the initialiser list
467	}
468
469	void trkupgradeanalysis::variables::DeltaPhiVH::set( const VHbbCandidate& vhbbCandidate )
470	{
471	value_=TMath::Abs( Geom::deltaPhi( vhbbCandidate.H.p4.Phi(), vhbbCandidate.V.p4.Phi() ) );
472	}
473
474	std::auto_ptr<trkupgradeanalysis::variables::VHbbCandidateVariable> trkupgradeanalysis::variables::DeltaPhiVH::copy() const
475	{
476	return std::auto_ptr<VHbbCandidateVariable>( new trkupgradeanalysis::variables::DeltaPhiVH(*this) );
477	}