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
#	User	Rev	Content
1	grimes	1.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			}