VERTEX::MassC Class Reference

#include <VtMassC.hh>

Collaboration diagram for VERTEX::MassC:

Public Member Functions
— Constructors —
	MassC ()
	MassC (double m)
	construct from mass of mother particle More...
	~MassC ()
— Access functions —
void	push_back (Relation &r)
	add Track to mass constraint More...
void	push_back (Relation *r)
	add Track to mass contraint More...
double	mass () const
	get mass constraint More...
void	mass (double m)
	set mass constraint More...
double	galp () const
	constraint $\vec{g}(\vec{\alpha}^{(0)})$ More...

— Expert functions —
double	m_mass
double	m_SE
MATRIX::VtVector	m_Sl
Rel_v	m_rel
double	m_galp
void	print (std::ostream &os) const
	called by operator<<() More...
void	calc_Sl ()
	compute mass constraint $\vec{g}(\vec{\alpha}^{(0)})$ More...
const bool	check_kinematic () const
	check kinematic boundary More...
const MATRIX::VtVector	gam (const Relation &) const
	return $\Gamma_{li}$ More...

Detailed Description

Mass Constraint class

Constructor & Destructor Documentation

MassC() [1/2]

VERTEX::MassC::MassC

(

)

              :
    m_mass(0.),
    m_SE  (0.),
    m_Sl  (MATRIX::VtVector(3)),
    m_galp(0.)
  {}

MassC() [2/2]

VERTEX::MassC::MassC

(

double

m

)

construct from mass of mother particle

                      :
    m_mass(m),
    m_SE  (0.),
    m_Sl  (MATRIX::VtVector(3)),
    m_galp(0.)
  {}

~MassC()

VERTEX::MassC::~MassC

(

)

                {
    const Rel_cit end = m_rel.end();
    for(Rel_cit it = m_rel.begin(); it != end; ++it)
      (*it)->massc.remove(this);
  }

Member Function Documentation

calc_Sl()

void VERTEX::MassC::calc_Sl

(

)

compute mass constraint $\vec{g}(\vec{\alpha}^{(0)})$

                      {
 
    m_SE = 0.;
    m_Sl.clear();
 
    // copute S_l^E, S_l (int Vt: eq. 41,42)
    const Rel_cit end = m_rel.end();
    for(Rel_cit it = m_rel.begin(); it != end; ++it) {
      const Kalman& kal = (*it)->kalman;
      double p = kal.alpc()[2];
      m_SE    += kal.erg();    // in Vt: SE
      m_Sl[0] += p * kal.xn(); // in Vt: Sx
      m_Sl[1] += p * kal.yn(); // in Vt: Sy
      m_Sl[2] += p * kal.zn(); // in Vt: Sz
    }
 
    // compute g_l(alpha) (in Vt: eq. 43)
    m_galp = sqr(m_SE) - m_Sl*m_Sl - sqr(m_mass);
 
#ifdef VtDEBUG
    cout << " m_mass: " << m_mass << endl;
    cout << " SE: " << m_SE    << endl;
    cout << " Sx: " << m_Sl[0] << endl;
    cout << " Sy: " << m_Sl[1] << endl;
    cout << " Sz: " << m_Sl[2] << endl;
    cout << " m_galp: " << m_galp << endl;
#endif
 
    return;
  }

check_kinematic()

const bool VERTEX::MassC::check_kinematic

(

)

const

check kinematic boundary

                                          {
    double sum =  0.;
 
    // sum up rest-masses
    const Rel_cit end = m_rel.end();
    for(Rel_cit it = m_rel.begin(); it != end; ++it) {
      sum += (*it)->track.rm();
    }
 
    // if sum of track rest-masses is greater than rest-mass of mother
    // particle, something is wrong
    return ((sqr(sum) - sqr(m_mass))>=0.) ? false : true;
  }

galp()

double VERTEX::MassC::galp ( ) const

inline

constraint $\vec{g}(\vec{\alpha}^{(0)})$

{ return m_galp; }

gam()

const VtVector VERTEX::MassC::gam

(

const Relation &

rel

)

const

return $\Gamma_{li}$

                                                     {
    const Kalman& kal = rel.kalman;
    double p = kal.alpc()[2];
    
    // vector dg_l/dalpha_i
    VtVector gam(3);
 
    double fac = -2. * p * kal.zn();
 
    // compute eq. 44
    VtVector nn(1.-sqr(kal.xn()), -kal.xn()*kal.yn(), -kal.xn()*kal.zn());
    gam[0] = fac * (nn * m_Sl);
 
    // comupte eq. 45
    VtVector nm(-kal.xn()*kal.yn(), 1.-sqr(kal.yn()), -kal.yn()*kal.zn());
    gam[1] = fac * (nm * m_Sl);
 
    // compute eq. 43
    gam[2] = 2. * (p * m_SE / kal.erg() - kal.nalpc() * m_Sl);
 
#ifdef VtDEBUG
    cout << " gam: " << gam << endl;
#endif
    return gam;
  }

mass() [1/2]

double VERTEX::MassC::mass ( ) const

inline

get mass constraint

{ return m_mass; }

mass() [2/2]

void VERTEX::MassC::mass ( double  m )

inline

set mass constraint

{ m_mass = m; }

print()

void VERTEX::MassC::print

(

std::ostream &

os

)

const

called by operator<<()

                                        {
    os.setf(ios::right,ios::adjustfield);
    os.setf(ios::fixed,ios::floatfield);
    
    os << "mass: " << mass() << ", no. of tracks: " << m_rel.size();
    return;
  }

push_back() [1/2]

void VERTEX::MassC::push_back ( Relation &  r )

inline

add Track to mass constraint

{ push_back(&r); }

push_back() [2/2]

void VERTEX::MassC::push_back

(

Relation *

r

)

add Track to mass contraint

                                   {
    m_rel.push_back(r);
    r->massc.push_back(this);
  }

Member Data Documentation

m_galp

double VERTEX::MassC::m_galp

private

m_mass

double VERTEX::MassC::m_mass

private

m_rel

Rel_v VERTEX::MassC::m_rel

private

m_SE

double VERTEX::MassC::m_SE

private

m_Sl

MATRIX::VtVector VERTEX::MassC::m_Sl

private

---

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

• src/libVt++/vt++/include/VtMassC.hh
• src/libVt++/vt++/VtMassC.C