#include <TtFullHadKinFitter.h>

Inheritance diagram for TtFullHadKinFitter:

Classes
class	KinFit
	class that does the fitting More...
struct	KinFitResult
	struct for fit results More...
Public Types
enum	Constraint { kWPlusMass = 1, kWMinusMass, kTopMass, kTopBarMass, kEqualTopMasses }
	supported constraints More...
Public Member Functions
TtHadEvtSolution	addKinFitInfo (TtHadEvtSolution *asol)
	add kin fit information to the old event solution (in for legacy reasons)
int	fit (const std::vector< pat::Jet > &jets)
	kinematic fit interface
const pat::Particle	fittedB () const
	return fitted b quark candidate
const pat::Particle	fittedBBar () const
	return fitted b quark candidate
const pat::Particle	fittedLightP () const
	return fitted light quark candidate
const pat::Particle	fittedLightPBar () const
	return fitted light quark candidate
const pat::Particle	fittedLightQ () const
	return fitted light quark candidate
const pat::Particle	fittedLightQBar () const
	return fitted light quark candidate
std::vector < TtFullHadKinFitter::Constraint >	intToConstraint (std::vector< unsigned int > constraints)
	used to convert vector of int's to vector of constraints (just used in TtFullHadKinFitter(int, int, double, double, std::vector<unsigned int>))
	TtFullHadKinFitter ()
	default constructor
	TtFullHadKinFitter (Param jetParam, int maxNrIter, double maxDeltaS, double maxF, std::vector< Constraint > constraints, double mW=80.4, double mTop=173., const std::vector< edm::ParameterSet > udscResolutions=0, const std::vector< edm::ParameterSet > bResolutions=0, const std::vector< double > jetEnergyResolutionScaleFactors=0, const std::vector< double > jetEnergyResolutionEtaBinning=0)
	constructor initialized with built-in types and class enum's custom parameters
	TtFullHadKinFitter (int jetParam, int maxNrIter, double maxDeltaS, double maxF, std::vector< unsigned int > constraints, double mW=80.4, double mTop=173., const std::vector< edm::ParameterSet > udscResolutions=0, const std::vector< edm::ParameterSet > bResolutions=0, const std::vector< double > jetEnergyResolutionScaleFactors=0, const std::vector< double > jetEnergyResolutionEtaBinning=0)
	constructor initialized with build-in types as custom parameters (only included to keep TtHadEvtSolutionMaker.cc running)
	~TtFullHadKinFitter ()
	default destructor
Private Member Functions
void	printSetup () const
	print fitter setup
void	setupConstraints ()
	initialize constraints
void	setupFitter ()
	setup fitter
void	setupJets ()
	initialize jet inputs
Private Attributes
TAbsFitParticle *	b_
	input particles
TAbsFitParticle *	bBar_
const std::vector < edm::ParameterSet > *	bResolutions_
std::vector< Constraint >	constraints_
	vector of constraints to be used
CovarianceMatrix *	covM_
	get object resolutions and put them into a matrix
pat::Particle	fittedB_
	output particles
pat::Particle	fittedBBar_
pat::Particle	fittedLightP_
pat::Particle	fittedLightPBar_
pat::Particle	fittedLightQ_
pat::Particle	fittedLightQBar_
const std::vector< double > *	jetEnergyResolutionEtaBinning_
const std::vector< double > *	jetEnergyResolutionScaleFactors_
	scale factors for the jet energy resolution
Param	jetParam_
	jet parametrization
TAbsFitParticle *	lightP_
TAbsFitParticle *	lightPBar_
TAbsFitParticle *	lightQ_
TAbsFitParticle *	lightQBar_
std::map< Constraint, TFitConstraintM * >	massConstr_
	supported constraints
const std::vector < edm::ParameterSet > *	udscResolutions_
	resolutions

Detailed Description

Definition at line 29 of file TtFullHadKinFitter.h.

Member Enumeration Documentation

enum TtFullHadKinFitter::Constraint

supported constraints

Enumerator:

kWPlusMass
kWMinusMass
kTopMass
kTopBarMass
kEqualTopMasses

Definition at line 33 of file TtFullHadKinFitter.h.

{ kWPlusMass=1, kWMinusMass, kTopMass, kTopBarMass, kEqualTopMasses };

Constructor & Destructor Documentation

TtFullHadKinFitter::TtFullHadKinFitter ( )

default constructor

Definition at line 16 of file TtFullHadKinFitter.cc.

References setupFitter().

Referenced by TtFullHadKinFitter::KinFit::KinFit().

                                      :
  TopKinFitter(),
  b_(0), bBar_(0), lightQ_(0), lightQBar_(0), lightP_(0), lightPBar_(0),
  udscResolutions_(0), bResolutions_(0),
  jetEnergyResolutionScaleFactors_(0), jetEnergyResolutionEtaBinning_(0),
  jetParam_(kEMom)
{
  setupFitter();
}

TtFullHadKinFitter::TtFullHadKinFitter	(	int	jetParam,
		int	maxNrIter,
		double	maxDeltaS,
		double	maxF,
		std::vector< unsigned int >	constraints,
		double	mW = `80.4`,
		double	mTop = `173.`,
		const std::vector< edm::ParameterSet > *	udscResolutions = `0`,
		const std::vector< edm::ParameterSet > *	bResolutions = `0`,
		const std::vector< double > *	jetEnergyResolutionScaleFactors = `0`,
		const std::vector< double > *	jetEnergyResolutionEtaBinning = `0`
	)

constructor initialized with build-in types as custom parameters (only included to keep TtHadEvtSolutionMaker.cc running)

Definition at line 40 of file TtFullHadKinFitter.cc.

References setupFitter().

                                                                                              :
  TopKinFitter(maxNrIter, maxDeltaS, maxF, mW, mTop),
  b_(0), bBar_(0), lightQ_(0), lightQBar_(0), lightP_(0), lightPBar_(0),
  udscResolutions_(udscResolutions), bResolutions_(bResolutions),
  jetEnergyResolutionScaleFactors_(jetEnergyResolutionScaleFactors),
  jetEnergyResolutionEtaBinning_(jetEnergyResolutionEtaBinning),
  jetParam_((Param)jetParam), constraints_(intToConstraint(constraints))
{
  setupFitter();
}

TtFullHadKinFitter::TtFullHadKinFitter	(	Param	jetParam,
		int	maxNrIter,
		double	maxDeltaS,
		double	maxF,
		std::vector< Constraint >	constraints,
		double	mW = `80.4`,
		double	mTop = `173.`,
		const std::vector< edm::ParameterSet > *	udscResolutions = `0`,
		const std::vector< edm::ParameterSet > *	bResolutions = `0`,
		const std::vector< double > *	jetEnergyResolutionScaleFactors = `0`,
		const std::vector< double > *	jetEnergyResolutionEtaBinning = `0`
	)

constructor initialized with built-in types and class enum's custom parameters

constructor initialized with build-in types and class enum's custom parameters

Definition at line 57 of file TtFullHadKinFitter.cc.

References setupFitter().

                                                                                              :
  TopKinFitter(maxNrIter, maxDeltaS, maxF, mW, mTop),
  b_(0), bBar_(0), lightQ_(0), lightQBar_(0), lightP_(0), lightPBar_(0),
  udscResolutions_(udscResolutions), bResolutions_(bResolutions),
  jetEnergyResolutionScaleFactors_(jetEnergyResolutionScaleFactors),
  jetEnergyResolutionEtaBinning_(jetEnergyResolutionEtaBinning),
  jetParam_(jetParam), constraints_(constraints)
{
  setupFitter();
}

TtFullHadKinFitter::~TtFullHadKinFitter ( )

default destructor

Definition at line 74 of file TtFullHadKinFitter.cc.

References b_, bBar_, covM_, lightP_, lightPBar_, lightQ_, lightQBar_, and massConstr_.

{
  delete b_; 
  delete bBar_; 
  delete lightQ_;
  delete lightQBar_; 
  delete lightP_; 
  delete lightPBar_;
  delete covM_;
  for(std::map<Constraint, TFitConstraintM*>::iterator it = massConstr_.begin(); it != massConstr_.end(); ++it)
    delete it->second;
}

Member Function Documentation

TtHadEvtSolution TtFullHadKinFitter::addKinFitInfo ( TtHadEvtSolution * asol )

add kin fit information to the old event solution (in for legacy reasons)

Definition at line 265 of file TtFullHadKinFitter.cc.

Referenced by TtHadEvtSolutionMaker::produce().

{
  TtHadEvtSolution fitsol(*asol);

  std::vector<pat::Jet> jets;
  jets.resize(6);
  jets[TtFullHadEvtPartons::LightQ   ] = fitsol.getCalHadp();
  jets[TtFullHadEvtPartons::LightQBar] = fitsol.getCalHadq();
  jets[TtFullHadEvtPartons::B        ] = fitsol.getCalHadb();
  jets[TtFullHadEvtPartons::LightP   ] = fitsol.getCalHadj();
  jets[TtFullHadEvtPartons::LightPBar] = fitsol.getCalHadk();
  jets[TtFullHadEvtPartons::BBar     ] = fitsol.getCalHadbbar();

  fit( jets);

  // add fitted information to the solution
  if (fitter_->getStatus() == 0) {
    // finally fill the fitted particles
    fitsol.setFitHadb(fittedB_);
    fitsol.setFitHadp(fittedLightQ_);
    fitsol.setFitHadq(fittedLightQBar_);
    fitsol.setFitHadk(fittedLightP_);
    fitsol.setFitHadj(fittedLightPBar_);
    fitsol.setFitHadbbar(fittedBBar_);

    // store the fit's chi2 probability
    fitsol.setProbChi2( fitProb() );
  }
  return fitsol;
}

int TtFullHadKinFitter::fit ( const std::vector< pat::Jet > & jets )

kinematic fit interface

Definition at line 199 of file TtFullHadKinFitter.cc.

References b, b_, TtFullHadDaughter::BBar, bBar_, edm::errors::Configuration, covM_, reco::LeafCandidate::energy(), Exception, TKinFitter::fit(), fittedB_, fittedBBar_, fittedLightP_, fittedLightPBar_, fittedLightQ_, fittedLightQBar_, TopKinFitter::fitter_, TAbsFitParticle::getCurr4Vec(), TKinFitter::getStatus(), jetParam_, TtFullHadDaughter::LightP, lightP_, TtFullHadDaughter::LightPBar, lightPBar_, TtFullHadDaughter::LightQ, lightQ_, TtFullHadDaughter::LightQBar, lightQBar_, reco::LeafCandidate::px(), reco::LeafCandidate::py(), reco::LeafCandidate::pz(), TAbsFitParticle::setCovMatrix(), TAbsFitParticle::setIni4Vec(), and CovarianceMatrix::setupMatrix().

Referenced by addKinFitInfo().

{
  if( jets.size()<6 ){
    throw edm::Exception( edm::errors::Configuration, "Cannot run the TtFullHadKinFitter with less than 6 jets" );
  }

  // get jets in right order
  const pat::Jet& b         = jets[TtFullHadEvtPartons::B        ];
  const pat::Jet& bBar      = jets[TtFullHadEvtPartons::BBar     ];
  const pat::Jet& lightQ    = jets[TtFullHadEvtPartons::LightQ   ];
  const pat::Jet& lightQBar = jets[TtFullHadEvtPartons::LightQBar];
  const pat::Jet& lightP    = jets[TtFullHadEvtPartons::LightP   ];
  const pat::Jet& lightPBar = jets[TtFullHadEvtPartons::LightPBar];
 
  // initialize particles
  const TLorentzVector p4B( b.px(), b.py(), b.pz(), b.energy() );
  const TLorentzVector p4BBar( bBar.px(), bBar.py(), bBar.pz(), bBar.energy() );
  const TLorentzVector p4LightQ( lightQ.px(), lightQ.py(), lightQ.pz(), lightQ.energy() );
  const TLorentzVector p4LightQBar( lightQBar.px(), lightQBar.py(), lightQBar.pz(), lightQBar.energy() );
  const TLorentzVector p4LightP( lightP.px(), lightP.py(), lightP.pz(), lightP.energy() );
  const TLorentzVector p4LightPBar( lightPBar.px(), lightPBar.py(), lightPBar.pz(), lightPBar.energy() );

  // initialize covariance matrices
  TMatrixD m1 = covM_->setupMatrix(lightQ,    jetParam_);
  TMatrixD m2 = covM_->setupMatrix(lightQBar, jetParam_);
  TMatrixD m3 = covM_->setupMatrix(b,         jetParam_, "bjets");
  TMatrixD m4 = covM_->setupMatrix(lightP,    jetParam_);
  TMatrixD m5 = covM_->setupMatrix(lightPBar, jetParam_);
  TMatrixD m6 = covM_->setupMatrix(bBar     , jetParam_, "bjets");

  // set the kinematics of the objects to be fitted
  b_        ->setIni4Vec(&p4B        );
  bBar_     ->setIni4Vec(&p4BBar     );
  lightQ_   ->setIni4Vec(&p4LightQ   );
  lightQBar_->setIni4Vec(&p4LightQBar);
  lightP_   ->setIni4Vec(&p4LightP   );
  lightPBar_->setIni4Vec(&p4LightPBar);
  
  // initialize covariance matrices
  lightQ_   ->setCovMatrix( &m1);
  lightQBar_->setCovMatrix( &m2);
  b_        ->setCovMatrix( &m3);
  lightP_   ->setCovMatrix( &m4);
  lightPBar_->setCovMatrix( &m5);
  bBar_     ->setCovMatrix( &m6);
  
  // perform the fit!
  fitter_->fit();
  
  // add fitted information to the solution
  if( fitter_->getStatus()==0 ){
    // read back jet kinematics
    fittedB_= pat::Particle(reco::LeafCandidate(0, math::XYZTLorentzVector(b_->getCurr4Vec()->X(), b_->getCurr4Vec()->Y(), b_->getCurr4Vec()->Z(), b_->getCurr4Vec()->E()), math::XYZPoint()));
    fittedLightQ_   = pat::Particle(reco::LeafCandidate(0, math::XYZTLorentzVector(lightQ_->getCurr4Vec()->X(), lightQ_->getCurr4Vec()->Y(), lightQ_->getCurr4Vec()->Z(), lightQ_->getCurr4Vec()->E()), math::XYZPoint()));
    fittedLightQBar_= pat::Particle(reco::LeafCandidate(0, math::XYZTLorentzVector(lightQBar_->getCurr4Vec()->X(), lightQBar_->getCurr4Vec()->Y(), lightQBar_->getCurr4Vec()->Z(), lightQBar_->getCurr4Vec()->E()), math::XYZPoint()));


    fittedBBar_= pat::Particle(reco::LeafCandidate(0, math::XYZTLorentzVector(bBar_->getCurr4Vec()->X(), bBar_->getCurr4Vec()->Y(), bBar_->getCurr4Vec()->Z(), bBar_->getCurr4Vec()->E()), math::XYZPoint()));
    fittedLightP_   = pat::Particle(reco::LeafCandidate(0, math::XYZTLorentzVector(lightP_->getCurr4Vec()->X(), lightP_->getCurr4Vec()->Y(), lightP_->getCurr4Vec()->Z(), lightP_->getCurr4Vec()->E()), math::XYZPoint()));
    fittedLightPBar_= pat::Particle(reco::LeafCandidate(0, math::XYZTLorentzVector(lightPBar_->getCurr4Vec()->X(), lightPBar_->getCurr4Vec()->Y(), lightPBar_->getCurr4Vec()->Z(), lightPBar_->getCurr4Vec()->E()), math::XYZPoint()));
  }
  return fitter_->getStatus();
}

const pat::Particle TtFullHadKinFitter::fittedB ( ) const [inline]

return fitted b quark candidate

Definition at line 60 of file TtFullHadKinFitter.h.

References fittedB_, TopKinFitter::fitter_, and TKinFitter::getStatus().

{ return (fitter_->getStatus()==0 ? fittedB_ : pat::Particle()); };

const pat::Particle TtFullHadKinFitter::fittedBBar ( ) const [inline]

return fitted b quark candidate

Definition at line 62 of file TtFullHadKinFitter.h.

References fittedBBar_, TopKinFitter::fitter_, and TKinFitter::getStatus().

{ return (fitter_->getStatus()==0 ? fittedBBar_ : pat::Particle()); };

const pat::Particle TtFullHadKinFitter::fittedLightP ( ) const [inline]

return fitted light quark candidate

Definition at line 68 of file TtFullHadKinFitter.h.

References fittedLightP_, TopKinFitter::fitter_, and TKinFitter::getStatus().

{ return (fitter_->getStatus()==0 ? fittedLightP_ : pat::Particle()); };

const pat::Particle TtFullHadKinFitter::fittedLightPBar ( ) const [inline]

return fitted light quark candidate

Definition at line 70 of file TtFullHadKinFitter.h.

References fittedLightPBar_, TopKinFitter::fitter_, and TKinFitter::getStatus().

{ return (fitter_->getStatus()==0 ? fittedLightPBar_ : pat::Particle()); };

const pat::Particle TtFullHadKinFitter::fittedLightQ ( ) const [inline]

return fitted light quark candidate

Definition at line 64 of file TtFullHadKinFitter.h.

References fittedLightQ_, TopKinFitter::fitter_, and TKinFitter::getStatus().

{ return (fitter_->getStatus()==0 ? fittedLightQ_ : pat::Particle()); };

const pat::Particle TtFullHadKinFitter::fittedLightQBar ( ) const [inline]

return fitted light quark candidate

Definition at line 66 of file TtFullHadKinFitter.h.

References fittedLightQBar_, TopKinFitter::fitter_, and TKinFitter::getStatus().

{ return (fitter_->getStatus()==0 ? fittedLightQBar_ : pat::Particle()); };

std::vector< TtFullHadKinFitter::Constraint > TtFullHadKinFitter::intToConstraint ( std::vector< unsigned int > constraints )

used to convert vector of int's to vector of constraints (just used in TtFullHadKinFitter(int, int, double, double, std::vector<unsigned int>))

Definition at line 28 of file TtFullHadKinFitter.cc.

References i.

{
  std::vector<TtFullHadKinFitter::Constraint> cConstraints;
  cConstraints.resize(constraints.size());
  for(unsigned int i=0;i<constraints.size();++i)
    {
      cConstraints[i]=(Constraint)constraints[i];
    }
  return cConstraints;
}

void TtFullHadKinFitter::printSetup ( ) const [private]

print fitter setup

Definition at line 89 of file TtFullHadKinFitter.cc.

References constraints_, i, jetParam_, kEqualTopMasses, kTopBarMass, kTopMass, kWMinusMass, kWPlusMass, TopKinFitter::maxDeltaS_, TopKinFitter::maxF_, TopKinFitter::maxNrIter_, TopKinFitter::mTop_, TopKinFitter::mW_, and TopKinFitter::param().

Referenced by setupFitter().

{
  std::stringstream constr;
  for(unsigned int i=0; i<constraints_.size(); ++i){
    switch(constraints_[i]){
    case kWPlusMass      : constr << "    * W+-mass   (" << mW_   << " GeV) \n"; break;
    case kWMinusMass     : constr << "    * W--mass   (" << mW_   << " GeV) \n"; break;
    case kTopMass        : constr << "    * t-mass    (" << mTop_ << " GeV) \n"; break;
    case kTopBarMass     : constr << "    * tBar-mass (" << mTop_ << " GeV) \n"; break;
    case kEqualTopMasses : constr << "    * equal t-masses \n"; break;
    }
  }
  edm::LogVerbatim( "TtFullHadKinFitter" ) 
    << "\n"
    << "+++++++++++ TtFullHadKinFitter Setup ++++++++++++ \n"
    << "  Parametrization:                                \n" 
    << "   * jet : " << param(jetParam_) << "\n"
    << "  Constraints:                                    \n"
    <<    constr.str()
    << "  Max(No iterations): " << maxNrIter_ << "\n"
    << "  Max(deltaS)       : " << maxDeltaS_ << "\n"
    << "  Max(F)            : " << maxF_      << "\n"
    << "+++++++++++++++++++++++++++++++++++++++++++++++++ \n";
}

void TtFullHadKinFitter::setupConstraints ( ) [private]

initialize constraints

Definition at line 150 of file TtFullHadKinFitter.cc.

References b_, bBar_, kEqualTopMasses, kTopBarMass, kTopMass, kWMinusMass, kWPlusMass, lightP_, lightPBar_, lightQ_, lightQBar_, massConstr_, TopKinFitter::mTop_, and TopKinFitter::mW_.

Referenced by setupFitter().

{
  massConstr_[kWPlusMass     ] = new TFitConstraintM("WPlusMass"     , "WPlusMass"      ,  0,  0, mW_   );
  massConstr_[kWMinusMass    ] = new TFitConstraintM("WMinusMass"    , "WMinusMass"     ,  0,  0, mW_   );
  massConstr_[kTopMass       ] = new TFitConstraintM("TopMass"       , "TopMass"        ,  0,  0, mTop_ );
  massConstr_[kTopBarMass    ] = new TFitConstraintM("TopBarMass"    , "TopBarMass"     ,  0,  0, mTop_ );
  massConstr_[kEqualTopMasses] = new TFitConstraintM("EqualTopMasses", "EqualTopMasses" ,  0,  0, 0     );
  
  massConstr_[kWPlusMass     ]->addParticles1(lightQ_, lightQBar_);
  massConstr_[kWMinusMass    ]->addParticles1(lightP_, lightPBar_);
  massConstr_[kTopMass       ]->addParticles1(b_, lightQ_, lightQBar_);
  massConstr_[kTopBarMass    ]->addParticles1(bBar_, lightP_, lightPBar_);
  massConstr_[kEqualTopMasses]->addParticles1(b_, lightQ_, lightQBar_);
  massConstr_[kEqualTopMasses]->addParticles2(bBar_, lightP_, lightPBar_);

}

void TtFullHadKinFitter::setupFitter ( ) [private]

setup fitter

Definition at line 169 of file TtFullHadKinFitter.cc.

References TKinFitter::addConstraint(), TKinFitter::addMeasParticle(), b_, bBar_, bResolutions_, constraints_, covM_, TopKinFitter::fitter_, i, jetEnergyResolutionEtaBinning_, jetEnergyResolutionScaleFactors_, lightP_, lightPBar_, lightQ_, lightQBar_, massConstr_, printSetup(), setupConstraints(), setupJets(), and udscResolutions_.

Referenced by TtFullHadKinFitter().

{
  printSetup();
  setupJets();
  setupConstraints();

  // add measured particles
  fitter_->addMeasParticle(b_);
  fitter_->addMeasParticle(bBar_);
  fitter_->addMeasParticle(lightQ_);
  fitter_->addMeasParticle(lightQBar_);
  fitter_->addMeasParticle(lightP_);
  fitter_->addMeasParticle(lightPBar_);

  // add constraints
  for(unsigned int i=0; i<constraints_.size(); i++){
    fitter_->addConstraint(massConstr_[constraints_[i]]);
  }

  // initialize helper class used to bring the resolutions into covariance matrices
  if(udscResolutions_->size() &&  bResolutions_->size())
    covM_ = new CovarianceMatrix(*udscResolutions_, *bResolutions_,
                                 *jetEnergyResolutionScaleFactors_,
                                 *jetEnergyResolutionEtaBinning_);
  else
    covM_ = new CovarianceMatrix();
}

void TtFullHadKinFitter::setupJets ( ) [private]

initialize jet inputs

Definition at line 116 of file TtFullHadKinFitter.cc.

References b_, bBar_, jetParam_, TopKinFitter::kEMom, TopKinFitter::kEtEtaPhi, TopKinFitter::kEtThetaPhi, lightP_, lightPBar_, lightQ_, and lightQBar_.

Referenced by setupFitter().

{
  TMatrixD empty3x3(3,3); 
  TMatrixD empty4x4(4,4);
  switch(jetParam_){ // setup jets according to parameterization
  case kEMom :
    b_        = new TFitParticleEMomDev   ("Jet1", "Jet1", 0, &empty4x4);
    bBar_     = new TFitParticleEMomDev   ("Jet2", "Jet2", 0, &empty4x4);
    lightQ_   = new TFitParticleEMomDev   ("Jet3", "Jet3", 0, &empty4x4);
    lightQBar_= new TFitParticleEMomDev   ("Jet4", "Jet4", 0, &empty4x4);
    lightP_   = new TFitParticleEMomDev   ("Jet5", "Jet5", 0, &empty4x4);
    lightPBar_= new TFitParticleEMomDev   ("Jet6", "Jet6", 0, &empty4x4);
    break;
  case kEtEtaPhi :
    b_        = new TFitParticleEtEtaPhi  ("Jet1", "Jet1", 0, &empty3x3);
    bBar_     = new TFitParticleEtEtaPhi  ("Jet2", "Jet2", 0, &empty3x3);
    lightQ_   = new TFitParticleEtEtaPhi  ("Jet3", "Jet3", 0, &empty3x3);
    lightQBar_= new TFitParticleEtEtaPhi  ("Jet4", "Jet4", 0, &empty3x3);
    lightP_   = new TFitParticleEtEtaPhi  ("Jet5", "Jet5", 0, &empty3x3);
    lightPBar_= new TFitParticleEtEtaPhi  ("Jet6", "Jet6", 0, &empty3x3);
    break;
  case kEtThetaPhi :
    b_        = new TFitParticleEtThetaPhi("Jet1", "Jet1", 0, &empty3x3);
    bBar_     = new TFitParticleEtThetaPhi("Jet2", "Jet2", 0, &empty3x3);
    lightQ_   = new TFitParticleEtThetaPhi("Jet3", "Jet3", 0, &empty3x3);
    lightQBar_= new TFitParticleEtThetaPhi("Jet4", "Jet4", 0, &empty3x3);
    lightP_   = new TFitParticleEtThetaPhi("Jet5", "Jet5", 0, &empty3x3);
    lightPBar_= new TFitParticleEtThetaPhi("Jet6", "Jet6", 0, &empty3x3);
    break;
  }
}