InternalParticle Class Reference

another unnecessary layer of abstraction More...

#include <InternalParticle.h>

Inheritance diagram for InternalParticle:

Collaboration diagram for InternalParticle:

Public Types
enum	TFParticleType {   kInteractionPoint ,   kOrigin ,   kComposite ,   kRecoResonance ,   kInternalParticle ,   kRecoTrack ,   kResonance ,   kRecoPhoton ,   kRecoKlong ,   kMissingParticle }
	particle types More...
typedef std::vector< Constraint >	constraintlist
	alias
typedef std::vector< std::pair< const ParticleBase *, int > >	indexmap
	alias

Public Member Functions
	InternalParticle (Belle2::Particle *particle, const ParticleBase *mother, const ConstraintConfiguration &config, bool forceFitAll)
	constructor
virtual	~InternalParticle ()
	destructor
virtual ErrCode	initCovariance (FitParams &) const override
	init covariance
ErrCode	projectKineConstraint (const FitParams &, Projection &) const
	project kinematical constraint
ErrCode	projectBeamConstraint (const FitParams &, Projection &) const
	project beam four momentum constraint
virtual void	forceP4Sum (FitParams &) const override
	enforce conservation of momentum sum
virtual ErrCode	initParticleWithMother (FitParams &fitparams) override
	init particle in case it has a mother
virtual ErrCode	initMotherlessParticle (FitParams &fitparams) override
	init particle in case it has no mother
ErrCode	projectConstraint (const Constraint::Type type, const FitParams &fitparams, Projection &p) const override
	find out which constraint it is and project
virtual int	dim () const override
	space reserved in fit params, if has mother then it has tau
virtual int	type () const override
	type
virtual int	posIndex () const override
	position index in fit params
virtual int	tauIndex () const override
	tau index in fit params only if it has a mother
virtual int	momIndex () const override
	momentum index in fit params depending on whether it has a mother
virtual bool	hasEnergy () const override
	has energy in fitparams
virtual bool	hasPosition () const override
	has position index
virtual std::string	parname (int index) const override
	name
virtual void	addToConstraintList (constraintlist &list, int depth) const override
	add to constraint list
void	setMassConstraint (bool b)
	set mass constraint flag
virtual void	updateIndex (int &offset)
	this sets the index for momentum, position, etc.
const ParticleBase *	locate (Belle2::Particle *particle) const
	get particle base from basf2 particle
Belle2::Particle *	particle () const
	get basf2 particle
int	index () const
	get index
const ParticleBase *	mother () const
	getMother() / hasMother()
virtual ErrCode	projectGeoConstraint (const FitParams &, Projection &) const
	project geometrical constraint
virtual ErrCode	projectMassConstraintParticle (const FitParams &, Projection &) const
	project mass constraint using the particles parameters
virtual ErrCode	projectMassConstraintDaughters (const FitParams &, Projection &) const
	project mass constraint using the parameters of the daughters
virtual ErrCode	projectMassConstraint (const FitParams &, Projection &) const
	project mass constraint abstract
int	eneIndex () const
	get energy index
virtual double	chiSquare (const FitParams &) const
	get chi2
int	charge () const
	get charge
virtual ParticleBase *	addDaughter (Belle2::Particle *, const ConstraintConfiguration &config, bool forceFitAll=false)
	add daughter
virtual void	removeDaughter (const ParticleBase *pb)
	remove daughter
virtual void	retrieveIndexMap (indexmap &anindexmap) const
	get index map
void	setMother (const ParticleBase *m)
	set mother
void	collectVertexDaughters (std::vector< ParticleBase * > &particles, int posindex)
	get vertex daughters
virtual int	nFinalChargedCandidates () const
	number of charged candidates

Static Public Member Functions
static ParticleBase *	createParticle (Belle2::Particle *particle, const ParticleBase *mother, const ConstraintConfiguration &config, bool forceFitAll=false)
	create the according treeFitter particle obj for a basf2 particle type
static ParticleBase *	createOrigin (Belle2::Particle *daughter, const ConstraintConfiguration &config, bool forceFitAll)
	create a custom origin particle or a beamspot

Protected Types
typedef std::vector< ParticleBase * >	ParticleContainer
	just an alias

Protected Member Functions
ErrCode	initMomentum (FitParams &fitparams) const
	init momentum of *this and daughters
ErrCode	initTau (FitParams &par) const
	initialises tau as a length
void	setIndex (int i)
	set Index (in statevector)

Static Protected Member Functions
static bool	isAResonance (Belle2::Particle *particle)
	controls if a particle is treated as a resonance(lifetime=0) or a particle that has a finite lifetime.

Protected Attributes
Belle2::Particle *	m_particle
	pointer to framework type
const ParticleBase *	m_mother
	motherparticle
std::vector< ParticleBase * >	m_daughters
	daughter container
bool	m_isStronglyDecayingResonance
	decay length less than 1 micron
const ConstraintConfiguration *	m_config
	has all the constraint config

Static Private Member Functions
static bool	compTrkTransverseMomentum (const RecoTrack *lhs, const RecoTrack *rhs)
	compare transverse track momentum

Private Attributes
bool	m_massconstraint
	has mass constraint
bool	m_beamconstraint
	has beam constraint
bool	m_shares_vertex_with_mother
	shares vertex with mother, that means decay vertex = productionvertex
bool	m_geo_constraint
	use a geo metric constraint
bool	m_lifetimeconstraint
	has lifetime constraint
bool	m_isconversion
	is conversion
bool	m_automatic_vertex_constraining
	automatically figure out if mother and particle vertex should be the same and also add geometric constraints
int	m_index
	index
std::string	m_name
	name

Detailed Description

another unnecessary layer of abstraction

Definition at line 17 of file InternalParticle.h.

Member Typedef Documentation

constraintlist

typedef std::vector<Constraint> constraintlist

inherited

alias

Definition at line 52 of file ParticleBase.h.

indexmap

typedef std::vector< std::pair<const ParticleBase*, int> > indexmap

inherited

alias

Definition at line 55 of file ParticleBase.h.

ParticleContainer

typedef std::vector<ParticleBase*> ParticleContainer

protectedinherited

just an alias

Definition at line 178 of file ParticleBase.h.

Member Enumeration Documentation

TFParticleType

enum TFParticleType

inherited

particle types

Definition at line 30 of file ParticleBase.h.

                        {kInteractionPoint,
                         kOrigin,
                         kComposite,
                         kRecoResonance,
                         kInternalParticle,
                         kRecoTrack,
                         kResonance,
                         kRecoPhoton,
                         kRecoKlong,
                         kMissingParticle
                        };

Constructor & Destructor Documentation

InternalParticle()

InternalParticle	(	Belle2::Particle *	particle,
		const ParticleBase *	mother,
		const ConstraintConfiguration &	config,
		bool	forceFitAll
	)

constructor

Definition at line 41 of file InternalParticle.cc.

                                      :
    ParticleBase(particle, mother, &config),// config pointer here to allow final states not to have it
    m_massconstraint(false),
    m_beamconstraint(false),
    m_lifetimeconstraint(false),
    m_isconversion(false),
    m_automatic_vertex_constraining(config.m_automatic_vertex_constraining)
  {
    if (particle) {
      for (auto daughter : particle->getDaughters()) {
        addDaughter(daughter, config, forceFitAll);
      }
    } else {
      B2ERROR("Trying to create an InternalParticle from NULL. This should never happen.");
    }
 
    m_massconstraint = std::find(config.m_massConstraintListPDG.begin(), config.m_massConstraintListPDG.end(),
                                 std::abs(m_particle->getPDGCode())) != config.m_massConstraintListPDG.end();
 
    m_beamconstraint = (std::abs(m_particle->getPDGCode()) == config.m_beamConstraintPDG);
 
    if (!m_automatic_vertex_constraining) {
      // if this is a hadronically decaying resonance it is useful to constraint the decay vertex to its mothers decay vertex.
      //
      m_shares_vertex_with_mother  = std::find(config.m_fixedToMotherVertexListPDG.begin(),
                                               config.m_fixedToMotherVertexListPDG.end(),
                                               std::abs(m_particle->getPDGCode())) != config.m_fixedToMotherVertexListPDG.end() && this->mother();
 
      // use geo constraint if this particle is in the list to constrain
      m_geo_constraint = std::find(config.m_geoConstraintListPDG.begin(),
                                   config.m_geoConstraintListPDG.end(),
                                   std::abs(m_particle->getPDGCode())) != config.m_geoConstraintListPDG.end()  && this->mother() && !m_shares_vertex_with_mother;
    } else {
      m_shares_vertex_with_mother = this->mother() && m_isStronglyDecayingResonance;
      m_geo_constraint = this->mother() && !m_shares_vertex_with_mother;
    }
  }

~InternalParticle()

virtual ~InternalParticle ( )

inlinevirtual

destructor

Definition at line 29 of file InternalParticle.h.

{};

Member Function Documentation

addDaughter()

ParticleBase * addDaughter ( Belle2::Particle *  cand, const ConstraintConfiguration &  config, bool  forceFitAll = false  )

virtualinherited

add daughter

Definition at line 65 of file ParticleBase.cc.

  {
    auto newDaughter = ParticleBase::createParticle(cand, this, config, forceFitAll);
    m_daughters.push_back(newDaughter);
    return m_daughters.back();
  }

addToConstraintList()

void addToConstraintList ( constraintlist &  list, int  depth  ) const

overridevirtual

add to constraint list

Implements ParticleBase.

Definition at line 376 of file InternalParticle.cc.

  {
 
    for (auto daughter : m_daughters) {
      daughter->addToConstraintList(list, depth - 1);
    }
    if (tauIndex() >= 0 && m_lifetimeconstraint) {
      list.push_back(Constraint(this, Constraint::lifetime, depth, 1));
    }
    if (momIndex() >= 0) {
      list.push_back(Constraint(this, Constraint::kinematic, depth, 4, 3));
    }
    if (m_geo_constraint) {
      assert(m_config);
      const int dim = m_config->m_originDimension == 2 && std::abs(m_particle->getPDGCode()) == m_config->m_headOfTreePDG ? 2 : 3;
      list.push_back(Constraint(this, Constraint::geometric, depth, dim, 3));
    }
    if (m_massconstraint) {
      list.push_back(Constraint(this, Constraint::mass, depth, 1, 3));
    }
    if (m_beamconstraint) {
      assert(m_config);
      list.push_back(Constraint(this, Constraint::beam, depth, 4, 3));
    }
 
  }

charge()

int charge ( ) const

inlineinherited

get charge

Definition at line 144 of file ParticleBase.h.

    {
      if (m_particle->getPDGCode()) {
        double fltcharge = m_particle->getCharge();
        return fltcharge < 0 ? int(fltcharge - 0.5) : int(fltcharge + 0.5);
      } else {
        return m_particle->getCharge() > 0 ? 1 : (m_particle->getCharge() < 0 ? -1 : 0);
      }
    }

chiSquare()

double chiSquare ( const FitParams &  fitparams ) const

virtualinherited

get chi2

Definition at line 231 of file ParticleBase.cc.

  {
    double rc = 0;
    for (auto* daughter : m_daughters) {
      rc += daughter->chiSquare(fitparams);
    }
    return rc;
  }

collectVertexDaughters()

void collectVertexDaughters ( std::vector< ParticleBase * > &  particles, int  posindex  )

inherited

get vertex daughters

Definition at line 156 of file ParticleBase.cc.

  {
    if (mother() && mother()->posIndex() == posindex) {
      particles.push_back(this);
    }
 
    for (auto* daughter : m_daughters) {
      daughter->collectVertexDaughters(particles, posindex);
    }
  }

compTrkTransverseMomentum()

bool compTrkTransverseMomentum ( const RecoTrack *  lhs, const RecoTrack *  rhs  )

staticprivate

compare transverse track momentum

Definition at line 83 of file InternalParticle.cc.

  {
 
    return lhs->particle()->getMomentum().Rho() > rhs->particle()->getMomentum().Rho();
  }

createOrigin()

ParticleBase * createOrigin ( Belle2::Particle *  daughter, const ConstraintConfiguration &  config, bool  forceFitAll  )

staticinherited

create a custom origin particle or a beamspot

Definition at line 93 of file ParticleBase.cc.

  {
    return new Origin(daughter, config, forceFitAll);
  }

createParticle()

ParticleBase * createParticle ( Belle2::Particle *  particle, const ParticleBase *  mother, const ConstraintConfiguration &  config, bool  forceFitAll = false  )

staticinherited

create the according treeFitter particle obj for a basf2 particle type

Definition at line 102 of file ParticleBase.cc.

  {
    ParticleBase* rc = nullptr;
 
    if (!mother) { // If there is no mother, this is the 'head of tree' particle (is never a resonance)
      rc = new InternalParticle(particle, nullptr, config, forceFitAll);
    } else if (particle->hasExtraInfo("bremsCorrected") // Has Bremsstrahlungs-recovery
               && particle->getExtraInfo("bremsCorrected") != 0) { // and gammas are attached
      rc = new Composite(particle, mother, config, true);
      // if no gamma is attached, it is treated as a RecoTrack
    } else if (particle->hasExtraInfo("treeFitterTreatMeAsInvisible")
               && particle->getExtraInfo("treeFitterTreatMeAsInvisible") == 1) { // dummy particles with invisible flag
      rc = new RecoResonance(particle, mother, config);
    } else if (particle->getTrack()) { // external reconstructed track
      rc = new RecoTrack(particle, mother);
    } else if (particle->getECLCluster()) { // external reconstructed photon
      rc = new RecoPhoton(particle, mother);
    } else if (particle->getKLMCluster()) { // external reconstructed klong
      rc = new RecoKlong(particle, mother);
    } else if (particle->getMdstArrayIndex()) { // external composite e.g. V0
      rc = new InternalParticle(particle, mother, config, forceFitAll);
    } else { // 'internal' particles
      if (isAResonance(particle)) {
        rc = new Resonance(particle, mother, config, forceFitAll);
      } else {
        rc = new InternalParticle(particle, mother, config, forceFitAll);
      }
    }
    return rc;
  }

dim()

int dim ( ) const

overridevirtual

space reserved in fit params, if has mother then it has tau

Implements ParticleBase.

Reimplemented in Resonance.

Definition at line 336 of file InternalParticle.cc.

  {
    // { x, y, z, tau, px, py, pz, E }
    // the last 4 always exists for composite particles
    // tau index only exist with a vertex and geo constraint
    //
    if (m_shares_vertex_with_mother) { return 4; }
    else if (!m_geo_constraint) { return 7; }
    else { return 8; }
  }

eneIndex()

int eneIndex ( ) const

inlineinherited

get energy index

Definition at line 138 of file ParticleBase.h.

{ return hasEnergy() ? momIndex() + 3 : -1 ; }

forceP4Sum()

void forceP4Sum ( FitParams &  fitparams ) const

overridevirtual

enforce conservation of momentum sum

Reimplemented from ParticleBase.

Definition at line 411 of file InternalParticle.cc.

  {
    for (const auto daughter : m_daughters) {
      daughter->forceP4Sum(fitparams);
    }
    const int momindex = momIndex();
    if (momindex > 0) {
      const int dim = hasEnergy() ? 4 : 3;
      Projection p(fitparams.getDimensionOfState(), dim);
      projectKineConstraint(fitparams, p);
      fitparams.getStateVector().segment(momindex, dim) -= p.getResiduals().segment(0, dim);
    }
  }

hasEnergy()

virtual bool hasEnergy ( ) const

inlineoverridevirtual

has energy in fitparams

Reimplemented from ParticleBase.

Definition at line 68 of file InternalParticle.h.

{ return true ; }

hasPosition()

bool hasPosition ( ) const

overridevirtual

has position index

Reimplemented from ParticleBase.

Reimplemented in Resonance.

Definition at line 369 of file InternalParticle.cc.

  {
    //  does this particle have a position index (decayvertex)
    //  true in any case
    return true;
  }

index()

int index ( ) const

inlineinherited

get index

Definition at line 95 of file ParticleBase.h.

{ return m_index ; }

initCovariance()

ErrCode initCovariance ( FitParams &  fitparams ) const

overridevirtual

init covariance

Reimplemented from ParticleBase.

Definition at line 226 of file InternalParticle.cc.

  {
    ErrCode status;
    ParticleBase::initCovariance(fitparams);
    for (auto daughter : m_daughters) {
      status |= daughter->initCovariance(fitparams);
    }
    return status;
  }

initMomentum()

ErrCode initMomentum ( FitParams &  fitparams ) const

protected

init momentum of *this and daughters

Definition at line 206 of file InternalParticle.cc.

  {
    int momindex = momIndex();
    fitparams.getStateVector().segment(momindex, 4) = Eigen::Matrix<double, 4, 1>::Zero(4);
 
    for (auto daughter : m_daughters) {
      int daumomindex = daughter->momIndex();
      int maxrow = daughter->hasEnergy() ? 4 : 3;
 
      double e2 = fitparams.getStateVector().segment(daumomindex, maxrow).squaredNorm();
      fitparams.getStateVector().segment(momindex, maxrow) += fitparams.getStateVector().segment(daumomindex, maxrow);
 
      if (maxrow == 3) {
        double mass = daughter->particle()->getPDGMass();
        fitparams.getStateVector()(momindex + 3) += std::sqrt(e2 + mass * mass);
      }
    }
    return ErrCode(ErrCode::Status::success);
  }

initMotherlessParticle()

ErrCode initMotherlessParticle ( FitParams &  fitparams )

overridevirtual

init particle in case it has no mother

(0,0,0) is the best guess in any other case

Implements ParticleBase.

Reimplemented in Resonance.

Definition at line 89 of file InternalParticle.cc.

  {
    ErrCode status ;
    for (auto daughter : m_daughters) {
      status |= daughter->initMotherlessParticle(fitparams);
    }
 
    int posindex = posIndex();
    // FIXME update this and check if this position is already initialised
    // lower stream vertices might be better
    if (hasPosition()) {
      fitparams.getStateVector().segment(posindex, 3) = Eigen::Matrix<double, 3, 1>::Zero(3);
 
      std::vector<ParticleBase*> alldaughters;
      ParticleBase::collectVertexDaughters(alldaughters, posindex);
 
      std::vector<ParticleBase*> vtxdaughters;
 
      vector<RecoTrack*> trkdaughters;
      for (auto daughter : alldaughters) {
        if (daughter->type() == ParticleBase::TFParticleType::kRecoTrack) {
          trkdaughters.push_back(static_cast<RecoTrack*>(daughter));
        } else if (daughter->hasPosition()
                   && fitparams.getStateVector()(daughter->posIndex()) != 0) {
          vtxdaughters.push_back(daughter);
        }
      }
 
      if (trkdaughters.size() >= 2) {
 
        auto v0 = particle()->getV0();
        auto dummy_vertex = ROOT::Math::XYZVector(0, 0, 0);
 
        bool initWithV0 = false;
        if (v0 && v0->getFittedVertexPosition() != dummy_vertex) {
          auto part_dau1 = particle()->getDaughter(0);
          auto part_dau2 = particle()->getDaughter(1);
 
          auto recotrack_dau1 = std::find_if(trkdaughters.begin(), trkdaughters.end(),
          [&part_dau1](RecoTrack * rt) { return rt->particle()->getMdstArrayIndex() == part_dau1->getMdstArrayIndex(); });
          auto recotrack_dau2 = std::find_if(trkdaughters.begin(), trkdaughters.end(),
          [&part_dau2](RecoTrack * rt) { return rt->particle()->getMdstArrayIndex() == part_dau2->getMdstArrayIndex(); });
 
          if (recotrack_dau1 == trkdaughters.end() || recotrack_dau2 == trkdaughters.end()) {
            B2WARNING("V0 daughter particles do not match with RecoTracks.");
          } else {
            double X_V0(v0->getFittedVertexX()), Y_V0(v0->getFittedVertexY()), Z_V0(v0->getFittedVertexZ());
            fitparams.getStateVector()(posindex)     = X_V0;
            fitparams.getStateVector()(posindex + 1) = Y_V0;
            fitparams.getStateVector()(posindex + 2) = Z_V0;
 
            Belle2::Helix helix1 = v0->getTrackFitResults().first->getHelix();
            Belle2::Helix helix2 = v0->getTrackFitResults().second->getHelix();
 
            (*recotrack_dau1)->setFlightLength(helix1.getArcLength2DAtXY(X_V0, Y_V0));
            (*recotrack_dau2)->setFlightLength(helix2.getArcLength2DAtXY(X_V0, Y_V0));
 
            initWithV0 = true;
          }
        }
 
        if (!initWithV0) {
          std::sort(trkdaughters.begin(), trkdaughters.end(), compTrkTransverseMomentum);
 
          RecoTrack* dau1 = trkdaughters[0];
          RecoTrack* dau2 = trkdaughters[1];
 
          Belle2::Helix helix1 = dau1->particle()->getTrackFitResult()->getHelix();
          Belle2::Helix helix2 = dau2->particle()->getTrackFitResult()->getHelix();
 
          double flt1(0), flt2(0);
          Belle2::B2Vector3D v;
          HelixUtils::helixPoca(helix1, helix2, flt1, flt2, v, m_isconversion);
 
          fitparams.getStateVector()(posindex)     = v.X();
          fitparams.getStateVector()(posindex + 1) = v.Y();
          fitparams.getStateVector()(posindex + 2) = v.Z();
 
          dau1->setFlightLength(flt1);
          dau2->setFlightLength(flt2);
        }
 
      } else if (false && trkdaughters.size() + vtxdaughters.size() >= 2)  {
        // TODO switched off waiting for refactoring of init1 and init2 functions (does not affect performance)
      } else if (mother() && mother()->posIndex() >= 0) {
        const int posindexmother = mother()->posIndex();
        const int dim = m_config->m_originDimension; //TODO access mother
        fitparams.getStateVector().segment(posindex, dim) = fitparams.getStateVector().segment(posindexmother, dim);
      } else {
        fitparams.getStateVector().segment(posindex, 3) = Eigen::Matrix<double, 1, 3>::Zero(3);
      }
    }
 
    for (auto daughter :  m_daughters) {
      daughter->initParticleWithMother(fitparams);
    }
 
    initMomentum(fitparams);
    return status;
  }

initParticleWithMother()

ErrCode initParticleWithMother ( FitParams &  fitparams )

overridevirtual

init particle in case it has a mother

Implements ParticleBase.

Reimplemented in Resonance.

Definition at line 191 of file InternalParticle.cc.

  {
    int posindex = posIndex();
    if (hasPosition() &&
        mother() &&
        fitparams.getStateVector()(posindex) == 0 &&
        fitparams.getStateVector()(posindex + 1) == 0 && \
        fitparams.getStateVector()(posindex + 2) == 0) {
      const int posindexmom = mother()->posIndex();
      const int dim = m_config->m_originDimension; //TODO access mother?
      fitparams.getStateVector().segment(posindex, dim) = fitparams.getStateVector().segment(posindexmom, dim);
    }
    return initTau(fitparams);
  }

initTau()

ErrCode initTau ( FitParams &  par ) const

protectedinherited

initialises tau as a length

Definition at line 426 of file ParticleBase.cc.

  {
    const int tauindex = tauIndex();
    if (tauindex >= 0 && hasPosition()) {
 
      const int posindex = posIndex();
      const int mother_ps_index = mother()->posIndex();
      const int dim  = m_config->m_originDimension; // TODO can we configure this to be particle specific?
 
      // tau has different meaning depending on the dimension of the constraint
      // 2-> use x-y projection
      const Eigen::Matrix < double, 1, -1, 1, 1, 3 > vertex_dist =
        fitparams.getStateVector().segment(posindex, dim) - fitparams.getStateVector().segment(mother_ps_index, dim);
      const Eigen::Matrix < double, 1, -1, 1, 1, 3 >
      mom = fitparams.getStateVector().segment(posindex, dim) - fitparams.getStateVector().segment(mother_ps_index, dim);
 
      // if an intermediate vertex is not well defined by a track or so it will be initialised with 0
      // same for the momentum of for example B0, it might be initialised with 0
      // in those cases use pdg value
      const double mom_norm = mom.norm();
      const double dot = std::abs(vertex_dist.dot(mom));
      const double tau = dot / mom_norm;
      if (0 == mom_norm || 0 == dot) {
        const double mass = m_particle->getPDGMass();
        if (mass > 0)
          fitparams.getStateVector()(tauindex) = m_particle->getPDGLifetime() * 1e9 * Belle2::Const::speedOfLight / mass;
        else
          fitparams.getStateVector()(tauindex) = 0;
      } else {
        fitparams.getStateVector()(tauindex) = tau;
      }
    }
 
    return ErrCode(ErrCode::Status::success);
  }

isAResonance()

bool isAResonance ( Belle2::Particle *  particle )

staticprotectedinherited

controls if a particle is treated as a resonance(lifetime=0) or a particle that has a finite lifetime.

A finite life time means it will register a geo constraint for this particle

Definition at line 134 of file ParticleBase.cc.

  {
    bool rc = false ;
    const int pdgcode = std::abs(particle->getPDGCode());
 
    if (pdgcode && !(particle->getMdstArrayIndex())) {
      switch (pdgcode) {
        case 22:  //photon conversion
          rc = false;
          break ;
 
        case -11: //bremsstrahlung
        case 11:
          rc = true ;
          break ;
        default: //everything with boosted flight length less than 1 micrometer
          rc = (pdgcode && particle->getPDGLifetime() < 1e-14);
      }
    }
    return rc ;
  }

locate()

const ParticleBase * locate ( Belle2::Particle *  particle ) const

inherited

get particle base from basf2 particle

Definition at line 211 of file ParticleBase.cc.

  {
    const ParticleBase* rc = (m_particle == particle) ? this : nullptr;
    if (!rc) {
      for (auto* daughter : m_daughters) {
        rc = daughter->locate(particle);
        if (rc) {break;}
      }
    }
    return rc;
  }

momIndex()

int momIndex ( ) const

overridevirtual

momentum index in fit params depending on whether it has a mother

indexing in { x, y, z, tau, px, py, pz, E } but tau is not existing for all InternalParticles

Reimplemented from ParticleBase.

Reimplemented in Resonance.

Definition at line 353 of file InternalParticle.cc.

  {
    if (m_geo_constraint && !m_shares_vertex_with_mother) { return this->index() + 4; }
 
    if (m_shares_vertex_with_mother) { return this->index(); }
 
    if (!m_geo_constraint) {return index() + 3 ;}
 
    // this will crash the initialisation
    return -1;
  }

mother()

const ParticleBase * mother ( ) const

inlineinherited

getMother() / hasMother()

Definition at line 98 of file ParticleBase.h.

{ return m_mother; };

nFinalChargedCandidates()

int nFinalChargedCandidates ( ) const

virtualinherited

number of charged candidates

Reimplemented in RecoTrack.

Definition at line 240 of file ParticleBase.cc.

  {
    int rc = 0;
    for (auto* daughter : m_daughters) {
      rc += daughter->nFinalChargedCandidates();
    }
    return rc;
  }

parname()

std::string parname ( int  index ) const

overridevirtual

name

Reimplemented from ParticleBase.

Reimplemented in Resonance.

Definition at line 404 of file InternalParticle.cc.

  {
    int id = thisindex;
    if (!mother() && id >= 3) {++id;}
    return ParticleBase::parname(id);
  }

particle()

Belle2::Particle * particle ( ) const

inlineinherited

get basf2 particle

Definition at line 92 of file ParticleBase.h.

{ return m_particle ; }

posIndex()

int posIndex ( ) const

overridevirtual

position index in fit params

Reimplemented from ParticleBase.

Reimplemented in Resonance.

Definition at line 330 of file InternalParticle.cc.

  {
    // for example B0 and D* can share the same vertex
    return m_shares_vertex_with_mother ? this->mother()->posIndex() : index();
  }

projectBeamConstraint()

ErrCode projectBeamConstraint	(	const FitParams &	fitparams,
		Projection &	p
	)		const

project beam four momentum constraint

Definition at line 285 of file InternalParticle.cc.

  {
 
    const int momindex = momIndex() ;
 
    const Eigen::Matrix<double, 4, 1> fitMomE = fitparams.getStateVector().segment(momindex, 4);
 
    p.getResiduals() = m_config->m_beamMomE - fitMomE;
 
    for (int row = 0; row < 4; ++row) {
      p.getH()(row, momindex + row) = -1;
    }
 
    p.getV() =  m_config->m_beamCovariance;
 
    return ErrCode(ErrCode::Status::success) ;
  }

projectConstraint()

ErrCode projectConstraint ( const Constraint::Type  type, const FitParams &  fitparams, Projection &  p  ) const

overridevirtual

find out which constraint it is and project

Reimplemented from ParticleBase.

Definition at line 305 of file InternalParticle.cc.

  {
    ErrCode status;
    switch (type) {
      case Constraint::mass:
        status |= projectMassConstraint(fitparams, p);
        break;
      case Constraint::geometric:
        status |= projectGeoConstraint(fitparams, p);
        break;
      case Constraint::kinematic:
        status |= projectKineConstraint(fitparams, p);
        break;
      case Constraint::beam:
        status |= projectBeamConstraint(fitparams, p);
        break;
      default:
        status |= ParticleBase::projectConstraint(type, fitparams, p);
    }
 
    return status;
  }

projectGeoConstraint()

ErrCode projectGeoConstraint ( const FitParams &  fitparams, Projection &  p  ) const

virtualinherited

project geometrical constraint

the direction of the momentum is very well known from the kinematic constraints that is why we do not extract the distance as a vector here

Definition at line 249 of file ParticleBase.cc.

  {
    assert(m_config);
    // only allow 2d for head of tree particles that are beam constrained
    const int dim = m_config->m_originDimension == 2 && std::abs(m_particle->getPDGCode()) == m_config->m_headOfTreePDG ? 2 : 3;
    const int posindexmother = mother()->posIndex();
    const int posindex = posIndex();
    const int tauindex = tauIndex();
    const int momindex = momIndex();
 
    const double tau = fitparams.getStateVector()(tauindex);
    Eigen::Matrix < double, 1, -1, 1, 1, 3 > x_vec = fitparams.getStateVector().segment(posindex, dim);
    Eigen::Matrix < double, 1, -1, 1, 1, 3 > x_m = fitparams.getStateVector().segment(posindexmother, dim);
    Eigen::Matrix < double, 1, -1, 1, 1, 3 > p_vec = fitparams.getStateVector().segment(momindex, dim);
    const double mom = p_vec.norm();
    const double mom3 = mom * mom * mom;
 
    if (3 == dim) {
      // we can already set these
      //diagonal momentum
      p.getH()(0, momindex)     = tau * (p_vec(1) * p_vec(1) + p_vec(2) * p_vec(2)) / mom3 ;
      p.getH()(1, momindex + 1) = tau * (p_vec(0) * p_vec(0) + p_vec(2) * p_vec(2)) / mom3 ;
      p.getH()(2, momindex + 2) = tau * (p_vec(0) * p_vec(0) + p_vec(1) * p_vec(1)) / mom3 ;
 
      //offdiagonal momentum
      p.getH()(0, momindex + 1) = - tau * p_vec(0) * p_vec(1) / mom3 ;
      p.getH()(0, momindex + 2) = - tau * p_vec(0) * p_vec(2) / mom3 ;
 
      p.getH()(1, momindex + 0) = - tau * p_vec(1) * p_vec(0) / mom3 ;
      p.getH()(1, momindex + 2) = - tau * p_vec(1) * p_vec(2) / mom3 ;
 
      p.getH()(2, momindex + 0) = - tau * p_vec(2) * p_vec(0) / mom3 ;
      p.getH()(2, momindex + 1) = - tau * p_vec(2) * p_vec(1) / mom3 ;
 
    } else if (2 == dim) {
 
      // NOTE THAT THESE ARE DIFFERENT IN 2d
      p.getH()(0, momindex)     = tau * (p_vec(1) * p_vec(1)) / mom3 ;
      p.getH()(1, momindex + 1) = tau * (p_vec(0) * p_vec(0)) / mom3 ;
 
      //offdiagonal momentum
      p.getH()(0, momindex + 1) = - tau * p_vec(0) * p_vec(1) / mom3 ;
      p.getH()(1, momindex + 0) = - tau * p_vec(1) * p_vec(0) / mom3 ;
    } else {
      B2FATAL("Dimension of Geometric constraint is not 2 or 3. This will crash many things. You should feel bad.");
    }
 
    for (int row = 0; row < dim; ++row) {
 
      double posxmother = x_m(row);
      double posx       = x_vec(row);
      double momx       = p_vec(row);
 
      p.getResiduals()(row) = posxmother + tau * momx / mom - posx ;
      p.getH()(row, posindexmother + row) = 1;
      p.getH()(row, posindex + row) = -1;
      p.getH()(row, tauindex) = momx / mom;
    }
 
    return ErrCode(ErrCode::Status::success);
  }

projectKineConstraint()

ErrCode projectKineConstraint	(	const FitParams &	fitparams,
		Projection &	p
	)		const

project kinematical constraint

Definition at line 237 of file InternalParticle.cc.

  {
    const int momindex = momIndex();
 
    // `this` always has an energy row
    p.getResiduals().segment(0, 4) = fitparams.getStateVector().segment(momindex, 4);
 
    for (int imom = 0; imom < 4; ++imom) {
      p.getH()(imom, momindex + imom) = 1;
    }
 
    for (const auto daughter : m_daughters) {
      const int daumomindex = daughter->momIndex();
      const Eigen::Matrix<double, 1, 3> p3_vec = fitparams.getStateVector().segment(daumomindex, 3);
 
      // three momentum is easy just subtract the vectors
      p.getResiduals().segment(0, 3) -= p3_vec;
 
      // energy depends on the parametrisation!
      if (daughter->hasEnergy()) {
        p.getResiduals()(3) -= fitparams.getStateVector()(daumomindex + 3);
        p.getH()(3, daumomindex + 3) = -1; // d/dE -E
      } else {
        // m^2 + p^2 = E^2
        // so
        // E = sqrt(m^2 + p^2)
        const double mass = daughter->particle()->getPDGMass();
        const double p2 = p3_vec.squaredNorm();
        const double energy = std::sqrt(mass * mass + p2);
        p.getResiduals()(3) -= energy;
 
        for (unsigned i = 0; i < 3; ++i) {
          // d/dpx_i sqrt(m^2 + p^2)
          p.getH()(3, daumomindex + i) = -1 * p3_vec(i) / energy;
        }
      }
 
      // this has to be in any case
      // d/dp_i p_i
      for (unsigned i = 0; i < 3; ++i) {
        p.getH()(i, daumomindex + i) = -1;
      }
    }
    return ErrCode(ErrCode::Status::success);
  }

projectMassConstraint()

ErrCode projectMassConstraint ( const FitParams &  fitparams, Projection &  p  ) const

virtualinherited

project mass constraint abstract

Definition at line 405 of file ParticleBase.cc.

  {
    assert(m_config);
    if (m_config->m_massConstraintType == 0) {
      return projectMassConstraintParticle(fitparams, p);
    } else {
      return projectMassConstraintDaughters(fitparams, p);
    }
  }

projectMassConstraintDaughters()

ErrCode projectMassConstraintDaughters ( const FitParams &  fitparams, Projection &  p  ) const

virtualinherited

project mass constraint using the parameters of the daughters

be aware that the signs here are important E-|p|-m extracts a negative mass and messes with the momentum !

Definition at line 314 of file ParticleBase.cc.

  {
    const double mass = particle()->getPDGMass();
    const double mass2 = mass * mass;
    double px = 0;
    double py = 0;
    double pz = 0;
    double E  = 0;
 
    // the parameters of the daughters must be used otherwise the mass constraint does not have an effect on the extracted daughter momenta
    for (const auto* daughter : m_daughters) {
      const int momindex = daughter->momIndex();
      // in most cases the daughters will be final states so we cache the value to use it in the energy column
      const double px_daughter = fitparams.getStateVector()(momindex);
      const double py_daughter = fitparams.getStateVector()(momindex + 1);
      const double pz_daughter = fitparams.getStateVector()(momindex + 2);
 
      px += px_daughter;
      py += py_daughter;
      pz += pz_daughter;
      if (daughter->hasEnergy()) {
        E += fitparams.getStateVector()(momindex + 3);
      } else {
        // final states dont have an energy index
        const double m = daughter->particle()->getPDGMass();
        E += std::sqrt(m * m + px_daughter * px_daughter + py_daughter * py_daughter + pz_daughter * pz_daughter);
      }
    }
 
    p.getResiduals()(0) = mass2 - E * E + px * px + py * py + pz * pz;
 
    for (const auto* daughter : m_daughters) {
      //dr/dx = d/dx m2-{E1+E2+...}^2+{p1+p2+...}^2 = 2*x (x= E or p)
      const int momindex = daughter->momIndex();
      p.getH()(0, momindex)     = 2.0 * px;
      p.getH()(0, momindex + 1) = 2.0 * py;
      p.getH()(0, momindex + 2) = 2.0 * pz;
 
      if (daughter->hasEnergy()) {
        p.getH()(0, momindex + 3) = -2.0 * E;
      } else {
        const double px_daughter = fitparams.getStateVector()(momindex);
        const double py_daughter = fitparams.getStateVector()(momindex + 1);
        const double pz_daughter = fitparams.getStateVector()(momindex + 2);
        const double m = daughter->particle()->getPDGMass();
 
        const double E_daughter = std::sqrt(m * m + px_daughter * px_daughter + py_daughter * py_daughter + pz_daughter * pz_daughter);
        const double E_by_E_daughter = E / E_daughter;
        p.getH()(0, momindex)     -= 2.0 * E_by_E_daughter * px_daughter;
        p.getH()(0, momindex + 1) -= 2.0 * E_by_E_daughter * py_daughter;
        p.getH()(0, momindex + 2) -= 2.0 * E_by_E_daughter * pz_daughter;
      }
 
    }
    return ErrCode(ErrCode::Status::success);
  }

projectMassConstraintParticle()

ErrCode projectMassConstraintParticle ( const FitParams &  fitparams, Projection &  p  ) const

virtualinherited

project mass constraint using the particles parameters

be aware that the signs here are important E-|p|-m extracts a negative mass and messes with the momentum !

Definition at line 375 of file ParticleBase.cc.

  {
    const double mass = particle()->getPDGMass();
    const double mass2 = mass * mass;
    const int momindex = momIndex();
    const double px = fitparams.getStateVector()(momindex);
    const double py = fitparams.getStateVector()(momindex + 1);
    const double pz = fitparams.getStateVector()(momindex + 2);
    const double E  = fitparams.getStateVector()(momindex + 3);
 
    p.getResiduals()(0) = mass2 - E * E + px * px + py * py + pz * pz;
 
    p.getH()(0, momindex)     = 2.0 * px;
    p.getH()(0, momindex + 1) = 2.0 * py;
    p.getH()(0, momindex + 2) = 2.0 * pz;
    p.getH()(0, momindex + 3) = -2.0 * E;
 
    // TODO 0 in most cases -> needs special treatment if width=0 to not crash chi2 calculation
    // const double width = TDatabasePDG::Instance()->GetParticle(particle()->getPDGCode())->Width();
    // transport  measurement uncertainty into residual system
    // f' = sigma_x^2 * (df/dx)^2
    // p.getV()(0) = width * width * 4 * mass2;
 
    return ErrCode(ErrCode::Status::success);
  }

removeDaughter()

void removeDaughter ( const ParticleBase *  pb )

virtualinherited

remove daughter

Definition at line 73 of file ParticleBase.cc.

  {
    auto iter = std::find(m_daughters.begin(), m_daughters.end(), pb);
    if (iter != m_daughters.end()) {
      delete *iter;
      m_daughters.erase(iter);
    } else {
      B2ERROR("Cannot remove particle, because not found ...");
    }
  }

retrieveIndexMap()

void retrieveIndexMap ( indexmap &  anindexmap ) const

virtualinherited

get index map

Definition at line 223 of file ParticleBase.cc.

  {
    map.push_back(std::pair<const ParticleBase*, int>(this, index()));
    for (auto* daughter : m_daughters) {
      daughter->retrieveIndexMap(map);
    }
  }

setIndex()

void setIndex ( int  i )

inlineprotectedinherited

set Index (in statevector)

Definition at line 189 of file ParticleBase.h.

{ m_index = i ; }

setMassConstraint()

void setMassConstraint ( bool  b )

inline

set mass constraint flag

Definition at line 80 of file InternalParticle.h.

{ m_massconstraint = b ; }

setMother()

void setMother ( const ParticleBase *  m )

inlineinherited

set mother

Definition at line 164 of file ParticleBase.h.

{ m_mother = m ; }

tauIndex()

int tauIndex ( ) const

overridevirtual

tau index in fit params only if it has a mother

only exists if particle is geo constraint and has a mother

Reimplemented from ParticleBase.

Reimplemented in Resonance.

Definition at line 347 of file InternalParticle.cc.

  {
    return m_geo_constraint ? index() + 3 : -1;
  }

type()

virtual int type ( ) const

inlineoverridevirtual

type

Implements ParticleBase.

Reimplemented in Resonance.

Definition at line 56 of file InternalParticle.h.

{ return kInternalParticle ; }

updateIndex()

void updateIndex ( int &  offset )

virtualinherited

this sets the index for momentum, position, etc.

in the statevector

Definition at line 84 of file ParticleBase.cc.

  {
    for (auto* daughter : m_daughters) {
      daughter->updateIndex(offset);
    }
    m_index = offset;
    offset += dim();
  }

Member Data Documentation

m_automatic_vertex_constraining

bool m_automatic_vertex_constraining

private

automatically figure out if mother and particle vertex should be the same and also add geometric constraints

Definition at line 112 of file InternalParticle.h.

m_beamconstraint

bool m_beamconstraint

private

has beam constraint

Definition at line 96 of file InternalParticle.h.

m_config

const ConstraintConfiguration* m_config

protectedinherited

has all the constraint config

Definition at line 204 of file ParticleBase.h.

m_daughters

std::vector<ParticleBase*> m_daughters

protectedinherited

daughter container

Definition at line 198 of file ParticleBase.h.

m_geo_constraint

bool m_geo_constraint

private

use a geo metric constraint

Definition at line 102 of file InternalParticle.h.

m_index

int m_index

privateinherited

index

Definition at line 208 of file ParticleBase.h.

m_isconversion

bool m_isconversion

private

is conversion

Definition at line 108 of file InternalParticle.h.

m_isStronglyDecayingResonance

bool m_isStronglyDecayingResonance

protectedinherited

decay length less than 1 micron

Definition at line 201 of file ParticleBase.h.

m_lifetimeconstraint

bool m_lifetimeconstraint

private

has lifetime constraint

Definition at line 105 of file InternalParticle.h.

m_massconstraint

bool m_massconstraint

private

has mass constraint

Definition at line 93 of file InternalParticle.h.

m_mother

const ParticleBase* m_mother

protectedinherited

motherparticle

Definition at line 195 of file ParticleBase.h.

m_name

std::string m_name

privateinherited

name

Definition at line 211 of file ParticleBase.h.

m_particle

Belle2::Particle* m_particle

protectedinherited

pointer to framework type

Definition at line 192 of file ParticleBase.h.

m_shares_vertex_with_mother

bool m_shares_vertex_with_mother

private

shares vertex with mother, that means decay vertex = productionvertex

Definition at line 99 of file InternalParticle.h.

---

The documentation for this class was generated from the following files:

• analysis/VertexFitting/TreeFitter/include/InternalParticle.h
• analysis/VertexFitting/TreeFitter/src/InternalParticle.cc