|
|
|
class that does the fitting More...
#include <TtFullHadKinFitter.h>
Public Member Functions | |
| std::list < TtFullHadKinFitter::KinFitResult > | fit (const std::vector< pat::Jet > &jets) |
| do the fitting and return fit result | |
| KinFit (bool useBTagging, unsigned int bTags, std::string bTagAlgo, double minBTagValueBJet, double maxBTagValueNonBJet, std::vector< edm::ParameterSet > udscResolutions, std::vector< edm::ParameterSet > bResolutions, std::vector< double > jetEnergyResolutionScaleFactors, std::vector< double > jetEnergyResolutionEtaBinning, std::string jetCorrectionLevel, int maxNJets, int maxNComb, unsigned int maxNrIter, double maxDeltaS, double maxF, unsigned int jetParam, std::vector< unsigned > constraints, double mW, double mTop) | |
| special constructor | |
| KinFit () | |
| default constructor | |
| void | setBTagging (bool useBTagging, unsigned int bTags, std::string bTagAlgo, double minBTagValueBJet, double maxBTagValueNonBJet) |
| set all parameters for b-tagging | |
| void | setFitter (int maxNJets, unsigned int maxNrIter, double maxDeltaS, double maxF, unsigned int jetParam, std::vector< unsigned > constraints, double mW, double mTop) |
| set parameters for fitter | |
| void | setJEC (std::string jetCorrectionLevel) |
| set jec level | |
| void | setMatch (std::vector< int > match) |
| set match to be used | |
| void | setMatchInvalidity (bool invalidMatch) |
| set the validity of a match | |
| void | setOutput (int maxNComb) |
| set number of combinations of output | |
| void | setResolutions (std::vector< edm::ParameterSet > udscResolutions, std::vector< edm::ParameterSet > bResolutions, std::vector< double > jetEnergyResolutionScaleFactors, std::vector< double > jetEnergyResolutionEtaBinning) |
| set resolutions | |
| void | setUseOnlyMatch (bool useOnlyMatch) |
| set useOnlyMatch | |
| ~KinFit () | |
| default destructor | |
Private Member Functions | |
| TtFullHadKinFitter::Constraint | constraint (unsigned int configParameter) |
| std::vector < TtFullHadKinFitter::Constraint > | constraints (std::vector< unsigned int > &configParameters) |
| pat::Jet | corJet (const pat::Jet &jet, const std::string &quarkType) |
| helper function to construct the proper corrected jet for its corresponding quarkType | |
| bool | doBTagging (const std::vector< pat::Jet > &jets, const unsigned int &bJetCounter, std::vector< int > &combi) |
| TtFullHadKinFitter::Param | param (unsigned int configParameter) |
Private Attributes | |
| std::vector< edm::ParameterSet > | bResolutions_ |
| std::string | bTagAlgo_ |
| input tag for b-tagging algorithm | |
| unsigned int | bTags_ |
| minimal number of b-jets | |
| std::vector< unsigned > | constraints_ |
| numbering of different possible kinematic constraints | |
| TtFullHadKinFitter * | fitter |
| kinematic fit interface | |
| bool | invalidMatch_ |
| match is invalid | |
| std::string | jetCorrectionLevel_ |
| correction level for jets | |
| std::vector< double > | jetEnergyResolutionEtaBinning_ |
| std::vector< double > | jetEnergyResolutionScaleFactors_ |
| scale factors for the jet energy resolution | |
| unsigned int | jetParam_ |
| numbering of different possible jet parametrizations | |
| std::vector< int > | match_ |
| the combination that should be used | |
| double | maxBTagValueNonBJet_ |
| max value of bTag for a non-b-jet | |
| double | maxDeltaS_ |
| maximal chi2 equivalent | |
| double | maxF_ |
| maximal deviation for contstraints | |
| int | maxNComb_ |
| maximal number of combinations to be written to the event | |
| int | maxNJets_ |
| maximal number of jets (-1 possible to indicate 'all') | |
| unsigned int | maxNrIter_ |
| maximal number of iterations to be performed for the fit | |
| double | minBTagValueBJet_ |
| min value of bTag for a b-jet | |
| double | mTop_ |
| top mass value used for constraints | |
| double | mW_ |
| W mass value used for constraints. | |
| std::vector< edm::ParameterSet > | udscResolutions_ |
| store the resolutions for the jets | |
| bool | useBTagging_ |
| bool | useOnlyMatch_ |
| fit or only a certain combination | |
class that does the fitting
Definition at line 133 of file TtFullHadKinFitter.h.
| TtFullHadKinFitter::KinFit::KinFit | ( | ) |
default constructor
Definition at line 298 of file TtFullHadKinFitter.cc.
References constraints_.
: useBTagging_(true), bTags_(2), bTagAlgo_("trackCountingHighPurBJetTags"), minBTagValueBJet_(3.41), maxBTagValueNonBJet_(3.41), udscResolutions_(std::vector<edm::ParameterSet>(0)), bResolutions_(std::vector<edm::ParameterSet>(0)), jetEnergyResolutionScaleFactors_(0), jetEnergyResolutionEtaBinning_(0), jetCorrectionLevel_("L3Absolute"), maxNJets_(-1), maxNComb_(1), maxNrIter_(500), maxDeltaS_(5e-5), maxF_(0.0001), jetParam_(1), mW_(80.4), mTop_(173.), useOnlyMatch_(false), match_(std::vector<int>(0)), invalidMatch_(false) { constraints_.push_back(1); constraints_.push_back(2); constraints_.push_back(5); }
| TtFullHadKinFitter::KinFit::KinFit | ( | bool | useBTagging, |
| unsigned int | bTags, | ||
| std::string | bTagAlgo, | ||
| double | minBTagValueBJet, | ||
| double | maxBTagValueNonBJet, | ||
| std::vector< edm::ParameterSet > | udscResolutions, | ||
| std::vector< edm::ParameterSet > | bResolutions, | ||
| std::vector< double > | jetEnergyResolutionScaleFactors, | ||
| std::vector< double > | jetEnergyResolutionEtaBinning, | ||
| std::string | jetCorrectionLevel, | ||
| int | maxNJets, | ||
| int | maxNComb, | ||
| unsigned int | maxNrIter, | ||
| double | maxDeltaS, | ||
| double | maxF, | ||
| unsigned int | jetParam, | ||
| std::vector< unsigned > | constraints, | ||
| double | mW, | ||
| double | mTop | ||
| ) |
special constructor
Definition at line 327 of file TtFullHadKinFitter.cc.
References bResolutions_, constraints(), constraints_, fitter, jetEnergyResolutionEtaBinning_, jetEnergyResolutionScaleFactors_, jetParam_, maxDeltaS_, maxF_, maxNrIter_, mTop_, mW_, param(), TtFullHadKinFitter::TtFullHadKinFitter(), and udscResolutions_.
: useBTagging_(useBTagging), bTags_(bTags), bTagAlgo_(bTagAlgo), minBTagValueBJet_(minBTagValueBJet), maxBTagValueNonBJet_(maxBTagValueNonBJet), udscResolutions_(udscResolutions), bResolutions_(bResolutions), jetEnergyResolutionScaleFactors_(jetEnergyResolutionScaleFactors), jetEnergyResolutionEtaBinning_(jetEnergyResolutionEtaBinning), jetCorrectionLevel_(jetCorrectionLevel), maxNJets_(maxNJets), maxNComb_(maxNComb), maxNrIter_(maxNrIter), maxDeltaS_(maxDeltaS), maxF_(maxF), jetParam_(jetParam), constraints_(constraints), mW_(mW), mTop_(mTop), useOnlyMatch_(false), invalidMatch_(false) { // define kinematic fit interface fitter = new TtFullHadKinFitter(param(jetParam_), maxNrIter_, maxDeltaS_, maxF_, TtFullHadKinFitter::KinFit::constraints(constraints_), mW_, mTop_, &udscResolutions_, &bResolutions_, &jetEnergyResolutionScaleFactors_, &jetEnergyResolutionEtaBinning_); }
| TtFullHadKinFitter::KinFit::~KinFit | ( | ) |
| TtFullHadKinFitter::Constraint TtFullHadKinFitter::KinFit::constraint | ( | unsigned int | configParameter | ) | [private] |
| std::vector<TtFullHadKinFitter::Constraint> TtFullHadKinFitter::KinFit::constraints | ( | std::vector< unsigned int > & | configParameters | ) | [private] |
Referenced by KinFit(), and setFitter().
| pat::Jet TtFullHadKinFitter::KinFit::corJet | ( | const pat::Jet & | jet, |
| const std::string & | quarkType | ||
| ) | [private] |
helper function to construct the proper corrected jet for its corresponding quarkType
Definition at line 433 of file TtFullHadKinFitter.cc.
References pat::Jet::jecFactor(), metsig::jet, reco::LeafCandidate::p4(), run_regression::ret, and reco::LeafCandidate::setP4().
{
// jetCorrectionLevel was not configured
if(jetCorrectionLevel_.empty())
throw cms::Exception("Configuration")
<< "Unconfigured jetCorrectionLevel. Please use an appropriate, non-empty string.\n";
// quarkType is unknown
if( !(quarkType=="wMix" ||
quarkType=="uds" ||
quarkType=="charm" ||
quarkType=="bottom") )
throw cms::Exception("Configuration")
<< quarkType << " is unknown as a quarkType for the jetCorrectionLevel.\n";
float jecFactor = 1.;
if(quarkType=="wMix") jecFactor = 0.75 * jet.jecFactor(jetCorrectionLevel_, "uds") + 0.25 * jet.jecFactor(jetCorrectionLevel_, "charm");
else jecFactor = jet.jecFactor(jetCorrectionLevel_, quarkType);
pat::Jet ret = jet;
ret.setP4(ret.p4()*jecFactor);
return ret;
}
| bool TtFullHadKinFitter::KinFit::doBTagging | ( | const std::vector< pat::Jet > & | jets, |
| const unsigned int & | bJetCounter, | ||
| std::vector< int > & | combi | ||
| ) | [private] |
Definition at line 366 of file TtFullHadKinFitter.cc.
References TtFullHadEvtPartons::B, TtFullHadEvtPartons::BBar, Exception, TtFullHadEvtPartons::LightP, TtFullHadEvtPartons::LightPBar, TtFullHadEvtPartons::LightQ, and TtFullHadEvtPartons::LightQBar.
{
if( !useBTagging_ ) {
return true;
}
if( bTags_ == 2 &&
jets[combi[TtFullHadEvtPartons::B ]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_ &&
jets[combi[TtFullHadEvtPartons::BBar ]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_ &&
jets[combi[TtFullHadEvtPartons::LightQ ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightQBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightP ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightPBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ ) {
return true;
}
else if( bTags_ == 1 ){
if( bJetCounter == 1 &&
(jets[combi[TtFullHadEvtPartons::B ]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_ ||
jets[combi[TtFullHadEvtPartons::BBar ]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_) &&
jets[combi[TtFullHadEvtPartons::LightQ ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightQBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightP ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightPBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ ) {
return true;
}
else if( bJetCounter > 1 &&
jets[combi[TtFullHadEvtPartons::B ]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_ &&
jets[combi[TtFullHadEvtPartons::BBar ]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_ &&
jets[combi[TtFullHadEvtPartons::LightQ ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightQBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightP ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightPBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ ) {
return true;
}
}
else if( bTags_ == 0 ){
if( bJetCounter == 0){
return true;
}
else if( bJetCounter == 1 &&
(jets[combi[TtFullHadEvtPartons::B ]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_ ||
jets[combi[TtFullHadEvtPartons::BBar ]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_) &&
jets[combi[TtFullHadEvtPartons::LightQ ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightQBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightP ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightPBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ ) {
return true;
}
else if( bJetCounter > 1 &&
jets[combi[TtFullHadEvtPartons::B ]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_ &&
jets[combi[TtFullHadEvtPartons::BBar ]].bDiscriminator(bTagAlgo_) >= minBTagValueBJet_ &&
jets[combi[TtFullHadEvtPartons::LightQ ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightQBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightP ]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ &&
jets[combi[TtFullHadEvtPartons::LightPBar]].bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_ ) {
return true;
}
}
else if( bTags_ > 2 ){
throw cms::Exception("Configuration")
<< "Wrong number of bTags (" << bTags_ << " bTags not supported)!\n";
return true;
}
return false;
}
| std::list< TtFullHadKinFitter::KinFitResult > TtFullHadKinFitter::KinFit::fit | ( | const std::vector< pat::Jet > & | jets | ) |
do the fitting and return fit result
-------------------------------------------------------- skip events with less jets than partons or invalid match --------------------------------------------------------
analyze different jet combinations using the KinFitter (or only a given jet combination if useOnlyMatch=true)
feed out result starting with the JetComb having the smallest chi2
Definition at line 458 of file TtFullHadKinFitter.cc.
References TtFullHadEvtPartons::B, TtFullHadKinFitter::KinFitResult::B, TtFullHadEvtPartons::BBar, TtFullHadKinFitter::KinFitResult::BBar, TtFullHadDaughter::BBar, TtFullHadKinFitter::KinFitResult::Chi2, i, metsig::jet, TtFullHadKinFitter::KinFitResult::JetCombi, TtFullHadDaughter::LightP, TtFullHadKinFitter::KinFitResult::LightP, TtFullHadEvtPartons::LightP, TtFullHadEvtPartons::LightPBar, TtFullHadKinFitter::KinFitResult::LightPBar, TtFullHadDaughter::LightPBar, TtFullHadDaughter::LightQ, TtFullHadKinFitter::KinFitResult::LightQ, TtFullHadEvtPartons::LightQ, TtFullHadDaughter::LightQBar, TtFullHadEvtPartons::LightQBar, TtFullHadKinFitter::KinFitResult::LightQBar, stdcomb::next_combination(), nPartons, TtFullHadKinFitter::KinFitResult::Prob, query::result, TtFullHadKinFitter::KinFitResult::Status, and ntuplemaker::status.
Referenced by TtFullHadKinFitProducer::produce().
{
std::list<TtFullHadKinFitter::KinFitResult> fitResults;
if( jets.size()<nPartons || invalidMatch_ ) {
// indices referring to the jet combination
std::vector<int> invalidCombi;
for(unsigned int i = 0; i < nPartons; ++i) invalidCombi.push_back( -1 );
KinFitResult result;
// status of the fitter
result.Status = -1;
// chi2
result.Chi2 = -1.;
// chi2 probability
result.Prob = -1.;
// the kinFit getters return empty objects here
result.B = fitter->fittedB();
result.BBar = fitter->fittedBBar();
result.LightQ = fitter->fittedLightQ();
result.LightQBar= fitter->fittedLightQBar();
result.LightP = fitter->fittedLightP();
result.LightPBar= fitter->fittedLightPBar();
result.JetCombi = invalidCombi;
// push back fit result
fitResults.push_back( result );
return fitResults;
}
std::vector<int> jetIndices;
if(!useOnlyMatch_) {
for(unsigned int idx=0; idx<jets.size(); ++idx){
if(maxNJets_>=(int)nPartons && maxNJets_==(int)idx) break;
jetIndices.push_back(idx);
}
}
std::vector<int> combi;
for(unsigned int idx=0; idx<nPartons; ++idx) {
useOnlyMatch_?combi.push_back(match_[idx]):combi.push_back(idx);
}
unsigned int bJetCounter = 0;
for(std::vector<pat::Jet>::const_iterator jet = jets.begin(); jet < jets.end(); ++jet){
if(jet->bDiscriminator(bTagAlgo_) >= minBTagValueBJet_) ++bJetCounter;
}
do{
for(int cnt=0; cnt<TMath::Factorial(combi.size()); ++cnt){
// take into account indistinguishability of the two jets from the two W decays,
// and the two decay branches, this reduces the combinatorics by a factor of 2*2*2
if( ((combi[TtFullHadEvtPartons::LightQ] < combi[TtFullHadEvtPartons::LightQBar] &&
combi[TtFullHadEvtPartons::LightP] < combi[TtFullHadEvtPartons::LightPBar] &&
combi[TtFullHadEvtPartons::B] < combi[TtFullHadEvtPartons::BBar] ) ||
useOnlyMatch_) && doBTagging(jets, bJetCounter, combi) ) {
std::vector<pat::Jet> jetCombi;
jetCombi.resize(nPartons);
jetCombi[TtFullHadEvtPartons::LightQ ] = corJet(jets[combi[TtFullHadEvtPartons::LightQ ]], "wMix");
jetCombi[TtFullHadEvtPartons::LightQBar] = corJet(jets[combi[TtFullHadEvtPartons::LightQBar]], "wMix");
jetCombi[TtFullHadEvtPartons::B ] = corJet(jets[combi[TtFullHadEvtPartons::B ]], "bottom");
jetCombi[TtFullHadEvtPartons::BBar ] = corJet(jets[combi[TtFullHadEvtPartons::BBar ]], "bottom");
jetCombi[TtFullHadEvtPartons::LightP ] = corJet(jets[combi[TtFullHadEvtPartons::LightP ]], "wMix");
jetCombi[TtFullHadEvtPartons::LightPBar] = corJet(jets[combi[TtFullHadEvtPartons::LightPBar]], "wMix");
// do the kinematic fit
int status = fitter->fit(jetCombi);
if( status == 0 ) {
// fill struct KinFitResults if converged
TtFullHadKinFitter::KinFitResult result;
result.Status = status;
result.Chi2 = fitter->fitS();
result.Prob = fitter->fitProb();
result.B = fitter->fittedB();
result.BBar = fitter->fittedBBar();
result.LightQ = fitter->fittedLightQ();
result.LightQBar= fitter->fittedLightQBar();
result.LightP = fitter->fittedLightP();
result.LightPBar= fitter->fittedLightPBar();
result.JetCombi = combi;
// push back fit result
fitResults.push_back( result );
}
}
// don't go through combinatorics if useOnlyMatch was chosen
if(useOnlyMatch_){
break;
}
// next permutation
std::next_permutation( combi.begin(), combi.end() );
}
// don't go through combinatorics if useOnlyMatch was chosen
if(useOnlyMatch_){
break;
}
}
while( stdcomb::next_combination( jetIndices.begin(), jetIndices.end(), combi.begin(), combi.end() ) );
// sort results w.r.t. chi2 values
fitResults.sort();
if( (unsigned)fitResults.size() < 1 ) {
// in case no fit results were stored in the list (i.e. when all fits were aborted)
KinFitResult result;
// status of the fitter
result.Status = -1;
// chi2
result.Chi2 = -1.;
// chi2 probability
result.Prob = -1.;
// the kinFit getters return empty objects here
result.B = fitter->fittedB();
result.BBar = fitter->fittedBBar();
result.LightQ = fitter->fittedLightQ();
result.LightQBar= fitter->fittedLightQBar();
result.LightP = fitter->fittedLightP();
result.LightPBar= fitter->fittedLightPBar();
// indices referring to the jet combination
std::vector<int> invalidCombi(nPartons, -1);
result.JetCombi = invalidCombi;
// push back fit result
fitResults.push_back( result );
}
return fitResults;
}
| TtFullHadKinFitter::Param TtFullHadKinFitter::KinFit::param | ( | unsigned int | configParameter | ) | [private] |
Definition at line 605 of file TtFullHadKinFitter.cc.
References Exception, TopKinFitter::kEMom, TopKinFitter::kEtEtaPhi, TopKinFitter::kEtThetaPhi, and query::result.
Referenced by KinFit().
{
TtFullHadKinFitter::Param result;
switch(configParameter){
case TtFullHadKinFitter::kEMom : result=TtFullHadKinFitter::kEMom; break;
case TtFullHadKinFitter::kEtEtaPhi : result=TtFullHadKinFitter::kEtEtaPhi; break;
case TtFullHadKinFitter::kEtThetaPhi : result=TtFullHadKinFitter::kEtThetaPhi; break;
default:
throw cms::Exception("Configuration")
<< "Chosen jet parametrization is not supported: " << configParameter << "\n";
break;
}
return result;
}
| void TtFullHadKinFitter::KinFit::setBTagging | ( | bool | useBTagging, |
| unsigned int | bTags, | ||
| std::string | bTagAlgo, | ||
| double | minBTagValueBJet, | ||
| double | maxBTagValueNonBJet | ||
| ) | [inline] |
set all parameters for b-tagging
Definition at line 148 of file TtFullHadKinFitter.h.
References bTagAlgo_, bTags_, maxBTagValueNonBJet_, minBTagValueBJet_, and useBTagging_.
{
useBTagging_ = useBTagging;
bTags_ = bTags;
bTagAlgo_ = bTagAlgo;
minBTagValueBJet_ = minBTagValueBJet;
maxBTagValueNonBJet_ = maxBTagValueNonBJet;
}
| void TtFullHadKinFitter::KinFit::setFitter | ( | int | maxNJets, |
| unsigned int | maxNrIter, | ||
| double | maxDeltaS, | ||
| double | maxF, | ||
| unsigned int | jetParam, | ||
| std::vector< unsigned > | constraints, | ||
| double | mW, | ||
| double | mTop | ||
| ) | [inline] |
set parameters for fitter
Definition at line 164 of file TtFullHadKinFitter.h.
References constraints(), constraints_, jetParam_, maxDeltaS_, maxF_, maxNJets_, maxNrIter_, mTop_, and mW_.
{
maxNJets_ = maxNJets;
maxNrIter_ = maxNrIter;
maxDeltaS_ = maxDeltaS;
maxF_ = maxF;
jetParam_ = jetParam;
constraints_ = constraints;
mW_ = mW;
mTop_ = mTop;
}
| void TtFullHadKinFitter::KinFit::setJEC | ( | std::string | jetCorrectionLevel | ) | [inline] |
set jec level
Definition at line 176 of file TtFullHadKinFitter.h.
References jetCorrectionLevel_.
{
jetCorrectionLevel_ = jetCorrectionLevel;
}
| void TtFullHadKinFitter::KinFit::setMatch | ( | std::vector< int > | match | ) | [inline] |
set match to be used
Definition at line 184 of file TtFullHadKinFitter.h.
References match(), and match_.
Referenced by TtFullHadKinFitProducer::produce().
| void TtFullHadKinFitter::KinFit::setMatchInvalidity | ( | bool | invalidMatch | ) | [inline] |
set the validity of a match
Definition at line 188 of file TtFullHadKinFitter.h.
References invalidMatch_.
Referenced by TtFullHadKinFitProducer::produce().
{
invalidMatch_ = invalidMatch;
}
| void TtFullHadKinFitter::KinFit::setOutput | ( | int | maxNComb | ) | [inline] |
set number of combinations of output
Definition at line 192 of file TtFullHadKinFitter.h.
References maxNComb_.
{
maxNComb_ = maxNComb;
}
| void TtFullHadKinFitter::KinFit::setResolutions | ( | std::vector< edm::ParameterSet > | udscResolutions, |
| std::vector< edm::ParameterSet > | bResolutions, | ||
| std::vector< double > | jetEnergyResolutionScaleFactors, | ||
| std::vector< double > | jetEnergyResolutionEtaBinning | ||
| ) | [inline] |
set resolutions
Definition at line 156 of file TtFullHadKinFitter.h.
References bResolutions_, jetEnergyResolutionEtaBinning_, jetEnergyResolutionScaleFactors_, and udscResolutions_.
{
udscResolutions_ = udscResolutions;
bResolutions_ = bResolutions;
jetEnergyResolutionScaleFactors_ = jetEnergyResolutionScaleFactors;
jetEnergyResolutionEtaBinning_ = jetEnergyResolutionEtaBinning;
}
| void TtFullHadKinFitter::KinFit::setUseOnlyMatch | ( | bool | useOnlyMatch | ) | [inline] |
set useOnlyMatch
Definition at line 180 of file TtFullHadKinFitter.h.
References useOnlyMatch_.
Referenced by TtFullHadKinFitProducer::produce().
{
useOnlyMatch_ = useOnlyMatch;
}
std::vector<edm::ParameterSet> TtFullHadKinFitter::KinFit::bResolutions_ [private] |
Definition at line 226 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setResolutions().
std::string TtFullHadKinFitter::KinFit::bTagAlgo_ [private] |
input tag for b-tagging algorithm
Definition at line 220 of file TtFullHadKinFitter.h.
Referenced by setBTagging().
unsigned int TtFullHadKinFitter::KinFit::bTags_ [private] |
minimal number of b-jets
Definition at line 218 of file TtFullHadKinFitter.h.
Referenced by setBTagging().
std::vector<unsigned> TtFullHadKinFitter::KinFit::constraints_ [private] |
numbering of different possible kinematic constraints
Definition at line 245 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setFitter().
kinematic fit interface
Definition at line 258 of file TtFullHadKinFitter.h.
Referenced by KinFit().
bool TtFullHadKinFitter::KinFit::invalidMatch_ [private] |
match is invalid
Definition at line 255 of file TtFullHadKinFitter.h.
Referenced by setMatchInvalidity().
std::string TtFullHadKinFitter::KinFit::jetCorrectionLevel_ [private] |
correction level for jets
Definition at line 231 of file TtFullHadKinFitter.h.
Referenced by setJEC().
std::vector<double> TtFullHadKinFitter::KinFit::jetEnergyResolutionEtaBinning_ [private] |
Definition at line 229 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setResolutions().
std::vector<double> TtFullHadKinFitter::KinFit::jetEnergyResolutionScaleFactors_ [private] |
scale factors for the jet energy resolution
Definition at line 228 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setResolutions().
unsigned int TtFullHadKinFitter::KinFit::jetParam_ [private] |
numbering of different possible jet parametrizations
Definition at line 243 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setFitter().
std::vector<int> TtFullHadKinFitter::KinFit::match_ [private] |
the combination that should be used
Definition at line 253 of file TtFullHadKinFitter.h.
Referenced by setMatch().
double TtFullHadKinFitter::KinFit::maxBTagValueNonBJet_ [private] |
max value of bTag for a non-b-jet
Definition at line 224 of file TtFullHadKinFitter.h.
Referenced by setBTagging().
double TtFullHadKinFitter::KinFit::maxDeltaS_ [private] |
maximal chi2 equivalent
Definition at line 239 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setFitter().
double TtFullHadKinFitter::KinFit::maxF_ [private] |
maximal deviation for contstraints
Definition at line 241 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setFitter().
int TtFullHadKinFitter::KinFit::maxNComb_ [private] |
maximal number of combinations to be written to the event
Definition at line 235 of file TtFullHadKinFitter.h.
Referenced by setOutput().
int TtFullHadKinFitter::KinFit::maxNJets_ [private] |
maximal number of jets (-1 possible to indicate 'all')
Definition at line 233 of file TtFullHadKinFitter.h.
Referenced by setFitter().
unsigned int TtFullHadKinFitter::KinFit::maxNrIter_ [private] |
maximal number of iterations to be performed for the fit
Definition at line 237 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setFitter().
double TtFullHadKinFitter::KinFit::minBTagValueBJet_ [private] |
min value of bTag for a b-jet
Definition at line 222 of file TtFullHadKinFitter.h.
Referenced by setBTagging().
double TtFullHadKinFitter::KinFit::mTop_ [private] |
top mass value used for constraints
Definition at line 249 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setFitter().
double TtFullHadKinFitter::KinFit::mW_ [private] |
W mass value used for constraints.
Definition at line 247 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setFitter().
std::vector<edm::ParameterSet> TtFullHadKinFitter::KinFit::udscResolutions_ [private] |
store the resolutions for the jets
Definition at line 226 of file TtFullHadKinFitter.h.
Referenced by KinFit(), and setResolutions().
bool TtFullHadKinFitter::KinFit::useBTagging_ [private] |
switch to tell whether all possible combinations should be used for the switch to tell whether to use b-tagging or not
Definition at line 216 of file TtFullHadKinFitter.h.
Referenced by setBTagging().
bool TtFullHadKinFitter::KinFit::useOnlyMatch_ [private] |
fit or only a certain combination
Definition at line 251 of file TtFullHadKinFitter.h.
Referenced by setUseOnlyMatch().
1.7.3