CMS 3D CMS Logo
Public Member Functions | Private Member Functions | Private Attributes

TtFullHadKinFitter::KinFit Class Reference

class that does the fitting More...

#include <TtFullHadKinFitter.h>

List of all members.

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, double resolutionSmearFactor, 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, double resolutionSmearFactor=1.)
 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
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.
double resolutionSmearFactor_
 smearing factor for jet energy resolutions
std::vector< edm::ParameterSet > udscResolutions_
 store the resolutions for the jets
bool useBTagging_
bool useOnlyMatch_
 fit or only a certain combination

Detailed Description

class that does the fitting

Definition at line 120 of file TtFullHadKinFitter.h.

Constructor & Destructor Documentation

TtFullHadKinFitter::KinFit::KinFit ( )

default constructor

Definition at line 286 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)),
  resolutionSmearFactor_(1.),
  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,
double  resolutionSmearFactor,
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 314 of file TtFullHadKinFitter.cc.

References constraints(), constraints_, fitter, jetParam_, maxDeltaS_, maxF_, maxNrIter_, mTop_, mW_, param(), and TtFullHadKinFitter::TtFullHadKinFitter().

                                                                                                                                                                          :
  useBTagging_(useBTagging),
  bTags_(bTags),
  bTagAlgo_(bTagAlgo),
  minBTagValueBJet_(minBTagValueBJet),
  maxBTagValueNonBJet_(maxBTagValueNonBJet),
  udscResolutions_(udscResolutions),
  bResolutions_(bResolutions),
  resolutionSmearFactor_(resolutionSmearFactor),
  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_);
}
TtFullHadKinFitter::KinFit::~KinFit ( )

default destructor

Definition at line 344 of file TtFullHadKinFitter.cc.

{
  delete fitter;
}

Member Function Documentation

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 417 of file TtFullHadKinFitter.cc.

References pat::Jet::jecFactor(), metsig::jet, reco::LeafCandidate::p4(), runTheMatrix::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 350 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 442 of file TtFullHadKinFitter.cc.

References TtFullHadKinFitter::KinFitResult::B, TtFullHadEvtPartons::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, TtFullHadKinFitter::KinFitResult::LightQBar, TtFullHadEvtPartons::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, udscResolutions_, bResolutions_, resolutionSmearFactor_);
          
        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( 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 589 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("WrongConfig") 
      << "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 135 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 149 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 161 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 169 of file TtFullHadKinFitter.h.

References match(), and match_.

Referenced by TtFullHadKinFitProducer::produce().

                                       {
      match_ = match;
    }
void TtFullHadKinFitter::KinFit::setMatchInvalidity ( bool  invalidMatch) [inline]

set the validity of a match

Definition at line 173 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 177 of file TtFullHadKinFitter.h.

References maxNComb_.

                                {
      maxNComb_ = maxNComb;
    }
void TtFullHadKinFitter::KinFit::setResolutions ( std::vector< edm::ParameterSet >  udscResolutions,
std::vector< edm::ParameterSet >  bResolutions,
double  resolutionSmearFactor = 1. 
) [inline]

set resolutions

Definition at line 143 of file TtFullHadKinFitter.h.

References bResolutions_, resolutionSmearFactor_, and udscResolutions_.

                                                                                                                                               {
      udscResolutions_       = udscResolutions;
      bResolutions_          = bResolutions;
      resolutionSmearFactor_ = resolutionSmearFactor;
    }
void TtFullHadKinFitter::KinFit::setUseOnlyMatch ( bool  useOnlyMatch) [inline]

set useOnlyMatch

Definition at line 165 of file TtFullHadKinFitter.h.

References useOnlyMatch_.

Referenced by TtFullHadKinFitProducer::produce().

                                           {
      useOnlyMatch_ = useOnlyMatch;
    }

Member Data Documentation

std::vector<edm::ParameterSet> TtFullHadKinFitter::KinFit::bResolutions_ [private]

Definition at line 211 of file TtFullHadKinFitter.h.

Referenced by setResolutions().

std::string TtFullHadKinFitter::KinFit::bTagAlgo_ [private]

input tag for b-tagging algorithm

Definition at line 205 of file TtFullHadKinFitter.h.

Referenced by setBTagging().

unsigned int TtFullHadKinFitter::KinFit::bTags_ [private]

minimal number of b-jets

Definition at line 203 of file TtFullHadKinFitter.h.

Referenced by setBTagging().

std::vector<unsigned> TtFullHadKinFitter::KinFit::constraints_ [private]

numbering of different possible kinematic constraints

Definition at line 229 of file TtFullHadKinFitter.h.

Referenced by KinFit(), and setFitter().

TtFullHadKinFitter* TtFullHadKinFitter::KinFit::fitter [private]

kinematic fit interface

Definition at line 242 of file TtFullHadKinFitter.h.

Referenced by KinFit().

bool TtFullHadKinFitter::KinFit::invalidMatch_ [private]

match is invalid

Definition at line 239 of file TtFullHadKinFitter.h.

Referenced by setMatchInvalidity().

std::string TtFullHadKinFitter::KinFit::jetCorrectionLevel_ [private]

correction level for jets

Definition at line 215 of file TtFullHadKinFitter.h.

Referenced by setJEC().

unsigned int TtFullHadKinFitter::KinFit::jetParam_ [private]

numbering of different possible jet parametrizations

Definition at line 227 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 237 of file TtFullHadKinFitter.h.

Referenced by setMatch().

double TtFullHadKinFitter::KinFit::maxBTagValueNonBJet_ [private]

max value of bTag for a non-b-jet

Definition at line 209 of file TtFullHadKinFitter.h.

Referenced by setBTagging().

double TtFullHadKinFitter::KinFit::maxDeltaS_ [private]

maximal chi2 equivalent

Definition at line 223 of file TtFullHadKinFitter.h.

Referenced by KinFit(), and setFitter().

double TtFullHadKinFitter::KinFit::maxF_ [private]

maximal deviation for contstraints

Definition at line 225 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 219 of file TtFullHadKinFitter.h.

Referenced by setOutput().

int TtFullHadKinFitter::KinFit::maxNJets_ [private]

maximal number of jets (-1 possible to indicate 'all')

Definition at line 217 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 221 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 207 of file TtFullHadKinFitter.h.

Referenced by setBTagging().

double TtFullHadKinFitter::KinFit::mTop_ [private]

top mass value used for constraints

Definition at line 233 of file TtFullHadKinFitter.h.

Referenced by KinFit(), and setFitter().

double TtFullHadKinFitter::KinFit::mW_ [private]

W mass value used for constraints.

Definition at line 231 of file TtFullHadKinFitter.h.

Referenced by KinFit(), and setFitter().

double TtFullHadKinFitter::KinFit::resolutionSmearFactor_ [private]

smearing factor for jet energy resolutions

Definition at line 213 of file TtFullHadKinFitter.h.

Referenced by setResolutions().

std::vector<edm::ParameterSet> TtFullHadKinFitter::KinFit::udscResolutions_ [private]

store the resolutions for the jets

Definition at line 211 of file TtFullHadKinFitter.h.

Referenced by 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 201 of file TtFullHadKinFitter.h.

Referenced by setBTagging().

bool TtFullHadKinFitter::KinFit::useOnlyMatch_ [private]

fit or only a certain combination

Definition at line 235 of file TtFullHadKinFitter.h.

Referenced by setUseOnlyMatch().

Generated for CMSSW Reference Manual by doxygen 1.7.3