TrackPool Class Reference

#include <TrackPool.h>

Inheritance diagram for TrackPool:


Public Member Functions
	TrackPool ()
	~TrackPool ()
void	AddTrack (const int number, const double mass, const RecMdcTrack *trk)
void	AddTrack (const int number, const double mass, const RecMdcKalTrack *trk)
void	AddTrack (const int number, const double mass, const RecEmcShower *trk)
void	AddTrack (const int number, const WTrackParameter wtrk)
void	AddMissTrack (const int number, const double mass)
void	AddMissTrack (const int number, const double mass, const HepLorentzVector p4)
void	AddMissTrack (const int number, const double mass, const RecEmcShower *trk)
void	AddMissTrack (const int number, const RecEmcShower *trk)
void	AddMissTrack (const int number, const HepLorentzVector p4)
void	AddTrackVertex (const int number, const double mass, const RecEmcShower *trk)
std::vector< int >	AddList (int n1)
std::vector< int >	AddList (int n1, int n2)
std::vector< int >	AddList (int n1, int n2, int n3)
std::vector< int >	AddList (int n1, int n2, int n3, int n4)
std::vector< int >	AddList (int n1, int n2, int n3, int n4, int n5)
std::vector< int >	AddList (int n1, int n2, int n3, int n4, int n5, int n6)
std::vector< int >	AddList (int n1, int n2, int n3, int n4, int n5, int n6, int n7)
std::vector< int >	AddList (int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8)
std::vector< int >	AddList (int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9)
std::vector< int >	AddList (int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9, int n10)
std::vector< int >	AddList (int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9, int n10, int n11)
std::vector< int >	AddList (int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9, int n10, int n11, int n12)
std::vector< WTrackParameter >	wTrackOrigin () const
std::vector< WTrackParameter >	wTrackInfit () const
std::vector< int >	wTrackList () const
WTrackParameter	wTrackOrigin (int n) const
WTrackParameter	wTrackInfit (int n) const
int	wTrackList (int n) const
int	numberWTrack () const
std::vector< GammaShape >	GammaShapeValue () const
std::vector< int >	GammaShapeList () const
GammaShape	GammaShapeValue (int n) const
int	GammaShapeList (int n) const
int	numberGammaShape () const
void	setWTrackOrigin (const int n, const WTrackParameter wtrk)
void	setWTrackInfit (const int n, const WTrackParameter wtrk)
void	setWTrackOrigin (const WTrackParameter wtrk)
void	setWTrackInfit (const WTrackParameter wtrk)
void	setWTrackList (const int n)
void	clearWTrackOrigin ()
void	clearWTrackInfit ()
void	clearWTrackList ()
void	clearone ()
void	cleartwo ()
int	numberone () const
int	numbertwo () const
vector< int >	mappositionA () const
vector< int >	mappositionB () const
vector< int >	mapkinematic () const
void	clearMapkinematic ()
void	clearMappositionA ()
void	clearMappositionB ()
void	setMapkinematic (const int n)
void	setMappositionA (const int n)
void	setMappositionB (const int n)
void	setGammaShape (const int n, const GammaShape gammashape)
void	setGammaShape (const GammaShape gammashape)
void	setGammaShapeList (const int n)
void	clearGammaShape ()
void	clearGammaShapeList ()
void	setBeamPosition (const HepPoint3D BeamPosition)
void	setVBeamPosition (const HepSymMatrix VBeamPosition)
HepPoint3D	getBeamPosition () const
HepSymMatrix	getVBeamPosition () const
Private Attributes
std::vector< WTrackParameter >	m_wtrk_origin
std::vector< WTrackParameter >	m_wtrk_infit
std::vector< int >	m_lwtrk
int	m_numberone
int	m_numbertwo
std::vector< GammaShape >	m_gammashape
std::vector< int >	m_lgammashape
std::vector< int >	m_mapkinematic
std::vector< int >	m_mappositionA
std::vector< int >	m_mappositionB
HepPoint3D	m_BeamPosition
HepSymMatrix	m_VBeamPosition

Detailed Description

Definition at line 28 of file TrackPool.h.

Constructor & Destructor Documentation

TrackPool::TrackPool ( )

Definition at line 6 of file TrackPool.cxx.

References clearGammaShape(), clearGammaShapeList(), clearMapkinematic(), clearMappositionA(), clearMappositionB(), clearWTrackInfit(), clearWTrackList(), clearWTrackOrigin(), m_numberone, m_numbertwo, setBeamPosition(), and setVBeamPosition().

00006                      {
00007     clearWTrackOrigin();
00008     clearWTrackInfit();
00009     clearWTrackList();
00010     clearGammaShape();
00011     clearGammaShapeList();
00012     clearMapkinematic();
00013     clearMappositionA();
00014     clearMappositionB();
00015     setBeamPosition(HepPoint3D(0.0,0.0,0.0));
00016     setVBeamPosition(HepSymMatrix(3,0));
00017     m_numberone = 0;
00018     m_numbertwo = 0;
00019 }

TrackPool::~TrackPool ( ) [inline]

Definition at line 34 of file TrackPool.h.

00034 {;}

Member Function Documentation

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2,
		int	n3,
		int	n4,
		int	n5,
		int	n6,
		int	n7,
		int	n8,
		int	n9,
		int	n10,
		int	n11,
		int	n12
	)

Definition at line 618 of file TrackPool.cxx.

00619                                            {
00620     std::vector<int> lis;
00621     lis.clear();
00622     lis.push_back(n1);
00623     lis.push_back(n2);
00624     lis.push_back(n3);
00625     lis.push_back(n4);
00626     lis.push_back(n5);
00627     lis.push_back(n6);
00628     lis.push_back(n7);
00629     lis.push_back(n8);
00630     lis.push_back(n9);
00631     lis.push_back(n10);
00632     lis.push_back(n11);
00633     lis.push_back(n12);
00634     return lis;
00635 }

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2,
		int	n3,
		int	n4,
		int	n5,
		int	n6,
		int	n7,
		int	n8,
		int	n9,
		int	n10,
		int	n11
	)

Definition at line 600 of file TrackPool.cxx.

00601                                   {
00602     std::vector<int> lis;
00603     lis.clear();
00604     lis.push_back(n1);
00605     lis.push_back(n2);
00606     lis.push_back(n3);
00607     lis.push_back(n4);
00608     lis.push_back(n5);
00609     lis.push_back(n6);
00610     lis.push_back(n7);
00611     lis.push_back(n8);
00612     lis.push_back(n9);
00613     lis.push_back(n10);
00614     lis.push_back(n11);
00615     return lis;
00616 }

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2,
		int	n3,
		int	n4,
		int	n5,
		int	n6,
		int	n7,
		int	n8,
		int	n9,
		int	n10
	)

Definition at line 583 of file TrackPool.cxx.

00584                          {
00585     std::vector<int> lis;
00586     lis.clear();
00587     lis.push_back(n1);
00588     lis.push_back(n2);
00589     lis.push_back(n3);
00590     lis.push_back(n4);
00591     lis.push_back(n5);
00592     lis.push_back(n6);
00593     lis.push_back(n7);
00594     lis.push_back(n8);
00595     lis.push_back(n9);
00596     lis.push_back(n10);
00597     return lis;
00598 }

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2,
		int	n3,
		int	n4,
		int	n5,
		int	n6,
		int	n7,
		int	n8,
		int	n9
	)

Definition at line 567 of file TrackPool.cxx.

00568                 {
00569     std::vector<int> lis;
00570     lis.clear();
00571     lis.push_back(n1);
00572     lis.push_back(n2);
00573     lis.push_back(n3);
00574     lis.push_back(n4);
00575     lis.push_back(n5);
00576     lis.push_back(n6);
00577     lis.push_back(n7);
00578     lis.push_back(n8);
00579     lis.push_back(n9);
00580     return lis;
00581 }

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2,
		int	n3,
		int	n4,
		int	n5,
		int	n6,
		int	n7,
		int	n8
	)

Definition at line 553 of file TrackPool.cxx.

00553                                                                                                 {
00554     std::vector<int> lis;
00555     lis.clear();
00556     lis.push_back(n1);
00557     lis.push_back(n2);
00558     lis.push_back(n3);
00559     lis.push_back(n4);
00560     lis.push_back(n5);
00561     lis.push_back(n6);
00562     lis.push_back(n7);
00563     lis.push_back(n8);
00564     return lis;
00565 }

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2,
		int	n3,
		int	n4,
		int	n5,
		int	n6,
		int	n7
	)

Definition at line 540 of file TrackPool.cxx.

00540                                                                                         {
00541     std::vector<int> lis;
00542     lis.clear();
00543     lis.push_back(n1);
00544     lis.push_back(n2);
00545     lis.push_back(n3);
00546     lis.push_back(n4);
00547     lis.push_back(n5);
00548     lis.push_back(n6);
00549     lis.push_back(n7);
00550     return lis;
00551 }

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2,
		int	n3,
		int	n4,
		int	n5,
		int	n6
	)

Definition at line 528 of file TrackPool.cxx.

00528                                                                                 {
00529     std::vector<int> lis;
00530     lis.clear();
00531     lis.push_back(n1);
00532     lis.push_back(n2);
00533     lis.push_back(n3);
00534     lis.push_back(n4);
00535     lis.push_back(n5);
00536     lis.push_back(n6);
00537     return lis;
00538 }

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2,
		int	n3,
		int	n4,
		int	n5
	)

Definition at line 517 of file TrackPool.cxx.

00517                                                                         {
00518     std::vector<int> lis;
00519     lis.clear();
00520     lis.push_back(n1);
00521     lis.push_back(n2);
00522     lis.push_back(n3);
00523     lis.push_back(n4);
00524     lis.push_back(n5);
00525     return lis;
00526 }

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2,
		int	n3,
		int	n4
	)

Definition at line 507 of file TrackPool.cxx.

00507                                                                 {
00508     std::vector<int> lis;
00509     lis.clear();
00510     lis.push_back(n1);
00511     lis.push_back(n2);
00512     lis.push_back(n3);
00513     lis.push_back(n4);
00514     return lis;
00515 }

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2,
		int	n3
	)

Definition at line 498 of file TrackPool.cxx.

00498                                                         {
00499     std::vector<int> lis;
00500     lis.clear();
00501     lis.push_back(n1);
00502     lis.push_back(n2);
00503     lis.push_back(n3);
00504     return lis;
00505 }

std::vector< int > TrackPool::AddList	(	int	n1,
		int	n2
	)

Definition at line 490 of file TrackPool.cxx.

00490                                                 {
00491     std::vector<int> lis;
00492     lis.clear();
00493     lis.push_back(n1);
00494     lis.push_back(n2);
00495     return lis;
00496 }

std::vector< int > TrackPool::AddList ( int n1 )

Definition at line 483 of file TrackPool.cxx.

Referenced by VertexFit::AddBeamFit(), KinematicFit::AddResonance(), KalmanKinematicFit::AddResonance(), KinematicFit::AddTotalEnergy(), KalmanKinematicFit::AddTotalEnergy(), KinematicFit::AddTotalMomentum(), KalmanKinematicFit::AddTotalMomentum(), and VertexFit::AddVertex().

00483                                         {
00484     std::vector<int> lis;
00485     lis.clear();
00486     lis.push_back(n1);
00487     return lis;
00488 }

void TrackPool::AddMissTrack	(	const int	number,
		const HepLorentzVector	p4
	)

Definition at line 403 of file TrackPool.cxx.

References genRecEmupikp::i, ganga-rec::j, m_numberone, m_numbertwo, WTrackParameter::setEw(), setMapkinematic(), setMappositionA(), setMappositionB(), WTrackParameter::setType(), setWTrackInfit(), setWTrackList(), and setWTrackOrigin().

00403                                                                   {
00404     double dphi = 1E+3;
00405     double dthe = 1E+3;
00406     double dE = 1E+3;
00407     WTrackParameter wtrk(p4, dphi, dthe, dE);
00408     HepSymMatrix Ew = HepSymMatrix(7,0);
00409     for (int i = 0; i < 7; i++) {
00410         for (int j = 0; j < 7; j++) {
00411             if(i==j)    Ew[i][j] = 1E+6;
00412         }
00413     }
00414     wtrk.setType(1);
00415     wtrk.setEw(Ew);
00416     setWTrackOrigin(wtrk);
00417     setWTrackInfit(wtrk);
00418     setWTrackList(number);
00419     setMapkinematic(2);
00420     setMappositionA(m_numberone);
00421     setMappositionB(m_numbertwo);
00422     m_numbertwo = m_numbertwo + 4;     
00423 }

void TrackPool::AddMissTrack	(	const int	number,
		const RecEmcShower *	trk
	)

Definition at line 250 of file TrackPool.cxx.

References cos(), DstEmcShower::dphi(), DstEmcShower::dtheta(), DstEmcShower::energy(), WTrackParameter::Ew(), m_BeamPosition, m_numberone, m_numbertwo, m_VBeamPosition, mass, DstEmcShower::phi(), setGammaShape(), setGammaShapeList(), setMapkinematic(), setMappositionA(), setMappositionB(), WTrackParameter::setPlmp(), WTrackParameter::setType(), WTrackParameter::setVplm(), WTrackParameter::setW(), setWTrackInfit(), setWTrackList(), setWTrackOrigin(), sin(), DstEmcShower::theta(), DstEmcShower::x(), x, DstEmcShower::y(), and DstEmcShower::z().

00250                                                                       {
00251     //
00252     //parameters: phi lambda mass E
00253     //
00254 
00255     double mass = 0;
00256     double ptrk = trk->energy();
00257     double e = sqrt(ptrk*ptrk + mass * mass);
00258     double the = trk->theta();
00259     double phi = trk->phi();
00260     HepLorentzVector p4( e* sin(the) * cos(phi),
00261             e * sin(the) * sin(phi),
00262             e * cos(the),
00263             e);
00264     double dphi = trk->dphi();
00265     double dthe = trk->dtheta();
00266     double de   = 1E+6;
00267     double x = trk->x();
00268     double y = trk->y();
00269     double z = trk->z();
00270 
00271     HepPoint3D x3 (x, y ,z);
00272     WTrackParameter wtrk(x3, p4 ,dphi ,dthe, de);
00273     HepSymMatrix Vpe = HepSymMatrix(2,0);
00274     //=== get Vclus===
00275     HepSymMatrix Vclus = HepSymMatrix (3,0);
00276     Vclus = (wtrk.Ew()).sub(5,7);
00277     double xpr = x - m_BeamPosition[0];
00278     double ypr = y - m_BeamPosition[1];
00279     double zpr = z - m_BeamPosition[2];
00280     double Rpr = sqrt(xpr*xpr + ypr*ypr);
00281     // === get jacobi ===   
00282     HepMatrix J(2,3,0);
00283     J[0][0] = -ypr/(Rpr*Rpr);
00284     J[0][1] = xpr/(Rpr*Rpr);
00285     J[1][0] = -xpr * zpr/(Rpr*Rpr*Rpr);
00286     J[1][1] = -ypr * zpr/(Rpr*Rpr*Rpr);
00287     J[1][2] = 1/Rpr;
00288     Vpe = Vclus.similarity(J) + m_VBeamPosition.similarity(J);
00289     Vpe[0][1]=0;
00290     double phipre = atan(ypr/xpr);
00291 
00292     if(xpr<0){
00293         phipre = atan(ypr/xpr) + 3.1415926;
00294     }
00295     double lambdapre = zpr/Rpr;
00296 
00297 
00298     HepVector plmp(4 , 0);
00299     plmp[0] = phipre;
00300     plmp[1] = lambdapre;
00301     plmp[2] = mass;
00302     plmp[3] = e;
00303     wtrk.setPlmp(plmp);
00304 
00305     HepSymMatrix Vplm(2,0);
00306     Vplm[0][0] = Vpe[0][0];
00307     Vplm[1][1] = Vpe[1][1];
00308     wtrk.setVplm(Vplm);
00309 
00310 
00311 
00312     // === set p4 ===
00313     double p0x = ptrk*cos(phipre)/sqrt(1 + lambdapre*lambdapre);
00314     double p0y = ptrk*sin(phipre)/sqrt(1 + lambdapre*lambdapre);
00315     double p0z = ptrk*lambdapre/sqrt(1 + lambdapre*lambdapre);
00316     double p0e = e;
00317 
00318     wtrk.setW(0,p0x);
00319     wtrk.setW(1,p0y);
00320     wtrk.setW(2,p0z);
00321     wtrk.setW(3,p0e);
00322 
00323     wtrk.setType(1);
00324     setWTrackOrigin(wtrk);
00325     setWTrackInfit(wtrk);
00326     setWTrackList(number);
00327     GammaShape gtrk(p4,dphi,dthe,de);
00328     setGammaShape(gtrk);
00329     setGammaShapeList(number);
00330     setMapkinematic(4);
00331     setMappositionA(m_numberone);
00332     setMappositionB(m_numbertwo);
00333 
00334     m_numberone = m_numberone + 2;
00335     m_numbertwo = m_numbertwo + 2;
00336 }

void TrackPool::AddMissTrack	(	const int	number,
		const double	mass,
		const RecEmcShower *	trk
	)

Definition at line 159 of file TrackPool.cxx.

References cos(), DstEmcShower::dphi(), DstEmcShower::dtheta(), DstEmcShower::energy(), WTrackParameter::Ew(), m_BeamPosition, m_numberone, m_numbertwo, m_VBeamPosition, DstEmcShower::phi(), setGammaShape(), setGammaShapeList(), setMapkinematic(), setMappositionA(), setMappositionB(), WTrackParameter::setPlmp(), WTrackParameter::setType(), WTrackParameter::setVplm(), WTrackParameter::setW(), setWTrackInfit(), setWTrackList(), setWTrackOrigin(), sin(), DstEmcShower::theta(), DstEmcShower::x(), x, DstEmcShower::y(), and DstEmcShower::z().

00160                                  {
00161     //
00162     //parameters: phi lambda mass ptrk
00163     //
00164     double ptrk = trk->energy();
00165     double e = sqrt(ptrk*ptrk + mass * mass);
00166     double the = trk->theta();
00167     double phi = trk->phi();
00168     HepLorentzVector p4( e* sin(the) * cos(phi), 
00169             e * sin(the) * sin(phi),
00170             e * cos(the),
00171             e);
00172     double dphi = trk->dphi();
00173     double dthe = trk->dtheta();
00174     double de   = 1E+6;
00175     double x = trk->x();
00176     double y = trk->y();
00177     double z = trk->z();
00178 
00179     HepPoint3D x3 (x, y ,z);
00180     WTrackParameter wtrk(x3, p4 ,dphi ,dthe, de);
00181     HepSymMatrix Vpe = HepSymMatrix(2,0);
00182     //=== get Vclus===
00183     HepSymMatrix Vclus = HepSymMatrix (3,0);
00184     Vclus = (wtrk.Ew()).sub(5,7);
00185     double xpr = x - m_BeamPosition[0];
00186     double ypr = y - m_BeamPosition[1];
00187     double zpr = z - m_BeamPosition[2];
00188     double Rpr = sqrt(xpr*xpr + ypr*ypr);
00189     // === get jacobi ===   
00190     HepMatrix J(2,3,0);
00191     J[0][0] = -ypr/(Rpr*Rpr);
00192     J[0][1] = xpr/(Rpr*Rpr);
00193     J[1][0] = -xpr * zpr/(Rpr*Rpr*Rpr);
00194     J[1][1] = -ypr * zpr/(Rpr*Rpr*Rpr);
00195     J[1][2] = 1/Rpr;
00196     Vpe = Vclus.similarity(J) + m_VBeamPosition.similarity(J);
00197     Vpe[0][1]=0;
00198 
00199     double phipre = atan(ypr/xpr);
00200 
00201     if(xpr<0){
00202         phipre = atan(ypr/xpr) + 3.1415926;
00203     } 
00204     double lambdapre = zpr/Rpr;  
00205 
00206 
00207     HepVector plmp(4 , 0);
00208     plmp[0] = phipre;
00209     plmp[1] = lambdapre;
00210     plmp[2] = mass;
00211     plmp[3] = ptrk;
00212     wtrk.setPlmp(plmp);
00213 
00214     HepSymMatrix Vplm(3,0);
00215     Vplm[0][0] = Vpe[0][0];
00216     Vplm[1][1] = Vpe[1][1];
00217     wtrk.setVplm(Vplm);
00218 
00219 
00220 
00221     // === set p4 ===
00222     double p0x = ptrk*cos(phipre)/sqrt(1 + lambdapre*lambdapre);
00223     double p0y = ptrk*sin(phipre)/sqrt(1 + lambdapre*lambdapre);  
00224     double p0z = ptrk*lambdapre/sqrt(1 + lambdapre*lambdapre);
00225     double p0e = e;
00226 
00227     wtrk.setW(0,p0x);
00228     wtrk.setW(1,p0y);
00229     wtrk.setW(2,p0z);
00230     wtrk.setW(3,p0e);
00231 
00232     wtrk.setType(1);
00233     setWTrackOrigin(wtrk);
00234     setWTrackInfit(wtrk);
00235     setWTrackList(number);
00236     GammaShape gtrk(p4,dphi,dthe,de);
00237     setGammaShape(gtrk);
00238     setGammaShapeList(number);
00239     setMapkinematic(5);
00240     setMappositionA(m_numberone);
00241     setMappositionB(m_numbertwo);
00242 
00243     m_numberone = m_numberone + 3;
00244     m_numbertwo = m_numbertwo + 1;
00245 }

void TrackPool::AddMissTrack	(	const int	number,
		const double	mass,
		const HepLorentzVector	p4
	)

Definition at line 341 of file TrackPool.cxx.

References WTrackParameter::Lambda(), m_numberone, m_numbertwo, setMapkinematic(), setMappositionA(), setMappositionB(), WTrackParameter::setPlmp(), WTrackParameter::setType(), WTrackParameter::setVplm(), setWTrackInfit(), setWTrackList(), and setWTrackOrigin().

00341                                                                                            {
00342     //
00343     //parameters: mass px py pz
00344     //  
00345 
00346     double dphi = 1E+6;
00347     double dthe = 1E+6;
00348     double dE = 1E+6;
00349     WTrackParameter wtrk(p4, dphi, dthe, dE);
00350     HepVector plmp(4, 0);
00351     double phipre = atan(p4[1]/p4[0]);
00352 
00353     if(p4[0]<0){
00354         phipre = atan(p4[1]/p4[0]) + 3.1415926;
00355     }
00356     plmp[0] = phipre;
00357     plmp[1] = wtrk.Lambda();
00358     plmp[2] = mass;
00359     plmp[3] = p4[3];
00360     HepSymMatrix Vplm(3, 0);
00361     wtrk.setPlmp(plmp);
00362     wtrk.setVplm(Vplm);
00363     wtrk.setType(1);
00364     setWTrackOrigin(wtrk);
00365     setWTrackInfit(wtrk); 
00366     setWTrackList(number);
00367     setMapkinematic(3);
00368     setMappositionA(m_numberone);
00369     setMappositionB(m_numbertwo);
00370     m_numberone = m_numberone + 1;
00371     m_numbertwo = m_numbertwo + 3;
00372 }

void TrackPool::AddMissTrack	(	const int	number,
		const double	mass
	)

Definition at line 375 of file TrackPool.cxx.

References m_numberone, m_numbertwo, WTrackParameter::setEw(), setMapkinematic(), setMappositionA(), setMappositionB(), WTrackParameter::setMass(), WTrackParameter::setW(), setWTrackInfit(), setWTrackList(), setWTrackOrigin(), and w.

00375                                                                 {
00376     //
00377     //parameters: mass px py pz, but px,py,pz 's error matrix is set as 10e^6
00378     //
00379     WTrackParameter wtrk;
00380     wtrk.setMass(mass);
00381     HepVector w(7,0);
00382     HepSymMatrix Ew(7,0);
00383     w[0] = 0.2;
00384     w[1] = 0.2;
00385     w[2] = 0.2;
00386     w[3] = sqrt(0.2*0.2*3 + mass*mass);
00387     Ew[0][0] = 1E+6;
00388     Ew[1][1] = 1E+6;
00389     Ew[2][2] = 1E+6;
00390     wtrk.setW(w);
00391     wtrk.setEw(Ew);
00392     setWTrackOrigin(wtrk);
00393     setWTrackInfit(wtrk);
00394     setWTrackList(number);
00395     setMapkinematic(7);
00396     setMappositionA(m_numberone);
00397     setMappositionB(m_numbertwo);
00398     m_numberone = m_numberone + 4;
00399 
00400 }

void TrackPool::AddTrack	(	const int	number,
		const WTrackParameter	wtrk
	)

Definition at line 429 of file TrackPool.cxx.

References m_numberone, m_numbertwo, numberWTrack(), setMapkinematic(), setMappositionA(), setMappositionB(), setWTrackInfit(), setWTrackList(), and setWTrackOrigin().

00429                                                                {
00430     setWTrackOrigin(wtrk);
00431     setWTrackInfit(wtrk);
00432     setWTrackList(number);
00433     if(number != numberWTrack()-1) {
00434         std::cout << "TrackPool: wrong track index" <<" " 
00435             <<number<<" , " <<numberWTrack()<< std::endl;
00436     }
00437     setMapkinematic(0);
00438     setMappositionA(m_numberone); 
00439     setMappositionB(m_numbertwo);
00440     m_numberone = m_numberone + 4;
00441 }

void TrackPool::AddTrack	(	const int	number,
		const double	mass,
		const RecEmcShower *	trk
	)

Definition at line 44 of file TrackPool.cxx.

References EvtCyclic3::B, cos(), DstEmcShower::dE(), DstEmcShower::dphi(), DstEmcShower::dtheta(), DstEmcShower::energy(), WTrackParameter::Ew(), m_BeamPosition, m_numberone, m_numbertwo, m_VBeamPosition, numberWTrack(), DstEmcShower::phi(), WTrackParameter::setEw(), setGammaShape(), setGammaShapeList(), setMapkinematic(), setMappositionA(), setMappositionB(), WTrackParameter::setPlmp(), WTrackParameter::setVplm(), WTrackParameter::setW(), setWTrackInfit(), setWTrackList(), setWTrackOrigin(), sin(), DstEmcShower::theta(), DstEmcShower::x(), x, DstEmcShower::y(), and DstEmcShower::z().

00045                                  {
00046     //
00047     //parameters: phi lambda mass energy
00048     //  
00049     double ptrk = trk->energy();
00050     double e = sqrt(ptrk*ptrk + mass * mass);
00051     double the = trk->theta();
00052     double phi = trk->phi();
00053     HepLorentzVector p4(ptrk * sin(the) * cos(phi), 
00054             ptrk * sin(the) * sin(phi),
00055             ptrk * cos(the),
00056             e);
00057     double dphi = trk->dphi();
00058     double dthe = trk->dtheta();
00059     double de   = trk->dE();
00060     double x = trk->x();
00061     double y = trk->y();
00062     double z = trk->z();
00063     HepPoint3D x3 (x, y ,z);
00064     WTrackParameter wtrk(x3, p4 ,dphi ,dthe, de);
00065     HepSymMatrix Vpl = HepSymMatrix(2,0);
00066     //=== get Vclus===
00067     HepSymMatrix Vclus = HepSymMatrix (3,0);
00068     Vclus = (wtrk.Ew()).sub(5,7);
00069     double xpr = x - m_BeamPosition[0];
00070     double ypr = y - m_BeamPosition[1];
00071     double zpr = z - m_BeamPosition[2];
00072     double Rpr = sqrt(xpr*xpr + ypr*ypr);
00073     // === get jacobi ===   
00074     HepMatrix J(2,3,0);
00075     J[0][0] = -ypr/(Rpr*Rpr);
00076     J[0][1] = xpr/(Rpr*Rpr);
00077     J[1][0] = -xpr * zpr/(Rpr*Rpr*Rpr);
00078     J[1][1] = -ypr * zpr/(Rpr*Rpr*Rpr);
00079     J[1][2] = 1/Rpr;
00080     Vpl = Vclus.similarity(J) + m_VBeamPosition.similarity(J);
00081     Vpl[0][1]=0;
00082     // === get phipre, lambda===
00083 
00084     double phipre = atan(ypr/xpr);
00085 
00086     if(xpr<0){
00087         phipre = atan(ypr/xpr) + 3.1415926;
00088     }
00089     double lambdapre = zpr/Rpr;
00090 
00091 
00092     // === set p4 ===
00093     double p0x = ptrk*cos(phipre)/sqrt(1 + lambdapre*lambdapre);
00094     double p0y = ptrk*sin(phipre)/sqrt(1 + lambdapre*lambdapre);
00095     double p0z = ptrk*lambdapre/sqrt(1 + lambdapre*lambdapre);
00096     double p0e = e;
00097 
00098 
00099     double p0ver = sqrt(p0x*p0x + p0y*p0y);
00100 
00101 
00102     HepMatrix B(4,3,0);
00103     B[0][0] = -p0y;
00104     B[0][1] = -p0z * p0x * p0ver/(p0e * p0e);
00105     B[0][2] = p0x/p0e;
00106     B[1][0] = p0x;
00107     B[1][1] = -p0z * p0y * p0ver/(p0e * p0e);
00108     B[1][2] = p0y/p0e;
00109     B[2][1] = p0ver * p0ver * p0ver/(p0e * p0e);
00110     B[2][2] = p0z/p0e;
00111     B[3][2] = 1;
00112 
00113     HepSymMatrix Vple(3,0);
00114     Vple[0][0] = Vpl[0][0];
00115     Vple[1][1] = Vpl[1][1];
00116     Vple[2][2] = de * de;
00117 
00118     HepSymMatrix Vpxyze(4,0);
00119     Vpxyze = Vple.similarity(B);
00120 
00121     wtrk.setW(0,p0x);
00122     wtrk.setW(1,p0y);
00123     wtrk.setW(2,p0z);
00124     wtrk.setW(3,p0e);
00125 
00126     wtrk.setEw(Vpxyze);
00127 
00128     HepSymMatrix Vplme(4,0);
00129     Vplme[0][0] = Vpl[0][0];
00130     Vplme[1][1] = Vpl[1][1];
00131     Vplme[3][3] = de * de;
00132     wtrk.setVplm(Vplme); 
00133 
00134     HepVector plmp(4 , 0);
00135     plmp[0] = phipre;
00136     plmp[1] = lambdapre;
00137     plmp[2] = mass;
00138     plmp[3] = e;
00139     wtrk.setPlmp(plmp);
00140 
00141 
00142     setWTrackOrigin(wtrk);
00143     setWTrackInfit(wtrk);
00144     setWTrackList(number);
00145     if(number != numberWTrack()-1) {
00146         std::cout << "TrackPool: wrong track index" <<" " 
00147             <<number<<" , " <<numberWTrack()<< std::endl;
00148     }
00149     GammaShape gtrk(p4,dphi,dthe,de);
00150     setGammaShape(gtrk);
00151     setGammaShapeList(number);
00152     setMapkinematic(1);
00153     setMappositionA(m_numberone);
00154     setMappositionB(m_numbertwo);
00155     m_numberone = m_numberone + 4;
00156 }

void TrackPool::AddTrack	(	const int	number,
		const double	mass,
		const RecMdcKalTrack *	trk
	)

void TrackPool::AddTrack	(	const int	number,
		const double	mass,
		const RecMdcTrack *	trk
	)

Definition at line 22 of file TrackPool.cxx.

References DstMdcTrack::err(), ers::error, DstMdcTrack::helix(), genRecEmupikp::i, m_numberone, m_numbertwo, numberWTrack(), setMapkinematic(), setMappositionA(), setMappositionB(), setWTrackInfit(), setWTrackList(), and setWTrackOrigin().

Referenced by DQAKsInfo::calculate(), LambdaReconstruction::execute(), KShortReconstruction::execute(), PrimaryVertex::execute(), Pi0EtaToGGRecAlg::execute(), BeamParams::execute(), CalibEventSelect::execute(), JsiLL::execute(), DQARhopi::execute(), DQAKsKpi::execute(), incllambda::execute(), inclks::execute(), Rhopi::execute(), Ppjrhopi::execute(), Gam4pikp::execute(), Pipipi0::MTotal(), Pipi::MTotal(), Kpipi0pi0::MTotal(), Kpipi0::MTotal(), Kpi::MTotal(), Kkpipi::MTotal(), Kkpi0::MTotal(), Kk::MTotal(), K3pipi0::MTotal(), K3pi::MTotal(), K0pipipi0::MTotal(), K0pipi::MTotal(), K0pi0::MTotal(), K0kpi::MTotal(), K0kk::MTotal(), LocalKsSelector::operator()(), Pi0::Pi0ListToTDS(), utility::SecondaryVFit(), and utility::vfit().

00023                                 {
00024     HepVector helix(5,0);
00025     double error[15];
00026     for(int i = 0; i < 5; i++)
00027         helix[i] = trk->helix(i);
00028     for(int i = 0; i < 15; i++)
00029         error[i] = trk->err(i);
00030     WTrackParameter wtrk(mass, helix, error);
00031     setWTrackOrigin(wtrk);
00032     setWTrackInfit(wtrk);
00033     setWTrackList(number);
00034     if(number != numberWTrack()-1) {
00035         std::cout << "TrackPool: wrong track index" <<" " 
00036             <<number<<" , " <<numberWTrack()<< std::endl;
00037     }
00038     setMapkinematic(0);
00039     setMappositionA(m_numberone);
00040     setMappositionB(m_numbertwo);
00041     m_numberone = m_numberone + 4;
00042 }

void TrackPool::AddTrackVertex	(	const int	number,
		const double	mass,
		const RecEmcShower *	trk
	)

Definition at line 444 of file TrackPool.cxx.

References cos(), DstEmcShower::dE(), DstEmcShower::dphi(), DstEmcShower::dtheta(), DstEmcShower::energy(), m_numberone, m_numbertwo, numberWTrack(), DstEmcShower::phi(), setGammaShape(), setGammaShapeList(), setMapkinematic(), setMappositionA(), setMappositionB(), setWTrackInfit(), setWTrackList(), setWTrackOrigin(), sin(), DstEmcShower::theta(), DstEmcShower::x(), x, DstEmcShower::y(), and DstEmcShower::z().

00444                                                                                            {
00445     double ptrk = trk->energy();
00446     double e = sqrt(ptrk*ptrk + mass * mass);
00447     double the = trk->theta();
00448     double phi = trk->phi();
00449     HepLorentzVector p4(ptrk * sin(the) * cos(phi), 
00450             ptrk * sin(the) * sin(phi),
00451             ptrk * cos(the),
00452             e);
00453     double dphi = trk->dphi();
00454     double dthe = trk->dtheta();
00455     double de   = trk->dE();
00456     double x = trk->x();
00457     double y = trk->y();
00458     double z = trk->z();
00459     HepPoint3D x3 (x, y ,z);
00460     WTrackParameter wtrk(x3, p4 ,dphi ,dthe, de);
00461     setWTrackOrigin(wtrk);
00462     setWTrackInfit(wtrk);
00463     setWTrackList(number);
00464     if(number != numberWTrack()-1) {
00465         std::cout << "TrackPool: wrong track index" <<" " 
00466             <<number<<" , " <<numberWTrack()<< std::endl;
00467     }
00468     GammaShape gtrk(p4,dphi,dthe,de);
00469     setGammaShape(gtrk);
00470     setGammaShapeList(number);
00471     setMapkinematic(6);
00472     m_numbertwo = 0;
00473     setMappositionA(m_numberone);
00474     setMappositionB(m_numbertwo);
00475 
00476     m_numberone = m_numberone + 4;
00477     m_numbertwo = m_numbertwo + 3;
00478 }

void TrackPool::clearGammaShape ( ) [inline]

Definition at line 139 of file TrackPool.h.

References m_gammashape.

Referenced by VertexFit::init(), KinematicFit::init(), KalmanKinematicFit::init(), and TrackPool().

00139 {m_gammashape.clear();}

void TrackPool::clearGammaShapeList ( ) [inline]

Definition at line 140 of file TrackPool.h.

References m_lgammashape.

Referenced by VertexFit::init(), KinematicFit::init(), KalmanKinematicFit::init(), and TrackPool().

00140 {m_lgammashape.clear();}

void TrackPool::clearMapkinematic ( ) [inline]

Definition at line 124 of file TrackPool.h.

References m_mapkinematic.

Referenced by VertexFit::init(), KinematicFit::init(), KalmanKinematicFit::init(), and TrackPool().

00124 {m_mapkinematic.clear();}

void TrackPool::clearMappositionA ( ) [inline]

Definition at line 125 of file TrackPool.h.

References m_mappositionA.

Referenced by VertexFit::init(), KinematicFit::init(), KalmanKinematicFit::init(), and TrackPool().

00125 {m_mappositionA.clear();}

void TrackPool::clearMappositionB ( ) [inline]

Definition at line 126 of file TrackPool.h.

References m_mappositionB.

Referenced by VertexFit::init(), KinematicFit::init(), KalmanKinematicFit::init(), and TrackPool().

00126 {m_mappositionB.clear();}

void TrackPool::clearone ( ) [inline]

Definition at line 115 of file TrackPool.h.

References m_numberone.

Referenced by VertexFit::init(), KinematicFit::init(), and KalmanKinematicFit::init().

00115 {m_numberone = 0;}

void TrackPool::cleartwo ( ) [inline]

Definition at line 116 of file TrackPool.h.

References m_numbertwo.

Referenced by VertexFit::init(), KinematicFit::init(), and KalmanKinematicFit::init().

00116 {m_numbertwo = 0;}

void TrackPool::clearWTrackInfit ( ) [inline]

Definition at line 112 of file TrackPool.h.

References m_wtrk_infit.

Referenced by VertexFit::init(), SecondVertexFit::init(), KinematicFit::init(), KalmanKinematicFit::init(), and TrackPool().

00112 {m_wtrk_infit.clear();}

void TrackPool::clearWTrackList ( ) [inline]

Definition at line 113 of file TrackPool.h.

References m_lwtrk.

Referenced by VertexFit::init(), SecondVertexFit::init(), KinematicFit::init(), KalmanKinematicFit::init(), and TrackPool().

00113 {m_lwtrk.clear();}

void TrackPool::clearWTrackOrigin ( ) [inline]

Definition at line 111 of file TrackPool.h.

References m_wtrk_origin.

Referenced by VertexFit::init(), SecondVertexFit::init(), KinematicFit::init(), KalmanKinematicFit::init(), and TrackPool().

00111 {m_wtrk_origin.clear();}

int TrackPool::GammaShapeList ( int n ) const [inline]

Definition at line 98 of file TrackPool.h.

References m_lgammashape.

00098 {return m_lgammashape[n];}

std::vector<int> TrackPool::GammaShapeList ( ) const [inline]

Definition at line 96 of file TrackPool.h.

References m_lgammashape.

Referenced by KinematicFit::gda(), and KalmanKinematicFit::gda().

00096 {return m_lgammashape;}

GammaShape TrackPool::GammaShapeValue ( int n ) const [inline]

Definition at line 97 of file TrackPool.h.

References m_gammashape.

00097 {return m_gammashape[n];}

std::vector<GammaShape> TrackPool::GammaShapeValue ( ) const [inline]

Definition at line 95 of file TrackPool.h.

References m_gammashape.

Referenced by KinematicFit::gda(), and KalmanKinematicFit::gda().

00095 {return m_gammashape;}

HepPoint3D TrackPool::getBeamPosition ( ) const [inline]

Definition at line 147 of file TrackPool.h.

References m_BeamPosition.

Referenced by KalmanKinematicFit::Fit().

00147 {return m_BeamPosition;}

HepSymMatrix TrackPool::getVBeamPosition ( ) const [inline]

Definition at line 148 of file TrackPool.h.

References m_VBeamPosition.

Referenced by KalmanKinematicFit::Fit().

00148 {return m_VBeamPosition;}

vector<int> TrackPool::mapkinematic ( ) const [inline]

Definition at line 122 of file TrackPool.h.

References m_mapkinematic.

Referenced by KalmanKinematicFit::Fit(), KalmanKinematicFit::gda(), KalmanKinematicFit::getCInfit(), KalmanKinematicFit::getCOrigin(), KalmanKinematicFit::pInfit(), KalmanKinematicFit::pOrigin(), KalmanKinematicFit::pull(), and KalmanKinematicFit::updateConstraints().

00122 {return m_mapkinematic;}

vector<int> TrackPool::mappositionA ( ) const [inline]

Definition at line 120 of file TrackPool.h.

References m_mappositionA.

00120 {return m_mappositionA;}

vector<int> TrackPool::mappositionB ( ) const [inline]

Definition at line 121 of file TrackPool.h.

References m_mappositionB.

00121 {return m_mappositionB;}

int TrackPool::numberGammaShape ( ) const [inline]

Definition at line 99 of file TrackPool.h.

References m_lgammashape.

Referenced by KinematicFit::gda(), and KalmanKinematicFit::gda().

00099 { return ((int)(m_lgammashape.size()) );}

int TrackPool::numberone ( ) const [inline]

Definition at line 117 of file TrackPool.h.

References m_numberone.

Referenced by KalmanKinematicFit::BuildVirtualParticle(), KalmanKinematicFit::Fit(), KalmanKinematicFit::fit(), and KalmanKinematicFit::upCovmtx().

00117 {return m_numberone;}

int TrackPool::numbertwo ( ) const [inline]

Definition at line 118 of file TrackPool.h.

References m_numbertwo.

Referenced by KalmanKinematicFit::Fit(), KalmanKinematicFit::fit(), and KalmanKinematicFit::upCovmtx().

00118 {return m_numbertwo;}

int TrackPool::numberWTrack ( ) const [inline]

Definition at line 79 of file TrackPool.h.

References m_lwtrk.

Referenced by KinematicFit::AddFourMomentum(), KalmanKinematicFit::AddFourMomentum(), KinematicFit::AddThreeMomentum(), KalmanKinematicFit::AddThreeMomentum(), AddTrack(), AddTrackVertex(), VertexFit::Fit(), KinematicFit::Fit(), KinematicFit::fit(), KalmanKinematicFit::Fit(), KalmanKinematicFit::fit(), KinematicFit::gda(), KalmanKinematicFit::gda(), and KinematicFit::upCovmtx().

00079 { return ((int)(m_lwtrk.size()));}

void TrackPool::setBeamPosition ( const HepPoint3D BeamPosition ) [inline]

Definition at line 143 of file TrackPool.h.

References m_BeamPosition.

Referenced by Gam4pikp::execute(), KinematicFit::init(), KalmanKinematicFit::init(), and TrackPool().

00143 {m_BeamPosition = BeamPosition;}

void TrackPool::setGammaShape ( const GammaShape gammashape ) [inline]

Definition at line 136 of file TrackPool.h.

References m_gammashape.

00136 {m_gammashape.push_back(gammashape);}

void TrackPool::setGammaShape	(	const int	n,
		const GammaShape	gammashape
	)			`[inline]`

Definition at line 135 of file TrackPool.h.

References m_gammashape.

Referenced by AddMissTrack(), AddTrack(), and AddTrackVertex().

00135 {m_gammashape[n] = gammashape;}

void TrackPool::setGammaShapeList ( const int n ) [inline]

Definition at line 137 of file TrackPool.h.

References m_lgammashape.

Referenced by AddMissTrack(), AddTrack(), and AddTrackVertex().

00137 {m_lgammashape.push_back(n);}

void TrackPool::setMapkinematic ( const int n ) [inline]

Definition at line 128 of file TrackPool.h.

References m_mapkinematic.

Referenced by AddMissTrack(), AddTrack(), and AddTrackVertex().

00128 {m_mapkinematic.push_back(n);}

void TrackPool::setMappositionA ( const int n ) [inline]

Definition at line 129 of file TrackPool.h.

References m_mappositionA.

Referenced by AddMissTrack(), AddTrack(), and AddTrackVertex().

00129 {m_mappositionA.push_back(n);}

void TrackPool::setMappositionB ( const int n ) [inline]

Definition at line 130 of file TrackPool.h.

References m_mappositionB.

Referenced by AddMissTrack(), AddTrack(), and AddTrackVertex().

00130 {m_mappositionB.push_back(n);}

void TrackPool::setVBeamPosition ( const HepSymMatrix VBeamPosition ) [inline]

Definition at line 144 of file TrackPool.h.

References m_VBeamPosition.

Referenced by Gam4pikp::execute(), KinematicFit::init(), KalmanKinematicFit::init(), and TrackPool().

00144 {m_VBeamPosition = VBeamPosition;}

void TrackPool::setWTrackInfit ( const WTrackParameter wtrk ) [inline]

Definition at line 108 of file TrackPool.h.

References m_wtrk_infit.

00108 {m_wtrk_infit.push_back(wtrk);}

void TrackPool::setWTrackInfit	(	const int	n,
		const WTrackParameter	wtrk
	)			`[inline]`

Definition at line 106 of file TrackPool.h.

References m_wtrk_infit.

Referenced by AddMissTrack(), AddTrack(), AddTrackVertex(), VertexFit::BeamFit(), KinematicFit::covMatrix(), VertexFit::Fit(), KinematicFit::Fit(), KalmanKinematicFit::Fit(), KinematicFit::pull(), KalmanKinematicFit::pull(), VertexFit::swimVertex(), and KinematicFit::upCovmtx().

00106 {m_wtrk_infit[n] = wtrk;}

void TrackPool::setWTrackList ( const int n ) [inline]

Definition at line 109 of file TrackPool.h.

References m_lwtrk.

Referenced by AddMissTrack(), AddTrack(), and AddTrackVertex().

00109 {m_lwtrk.push_back(n);}

void TrackPool::setWTrackOrigin ( const WTrackParameter wtrk ) [inline]

Definition at line 107 of file TrackPool.h.

References m_wtrk_origin.

00107 {m_wtrk_origin.push_back(wtrk);}

void TrackPool::setWTrackOrigin	(	const int	n,
		const WTrackParameter	wtrk
	)			`[inline]`

Definition at line 105 of file TrackPool.h.

References m_wtrk_origin.

Referenced by AddMissTrack(), AddTrack(), and AddTrackVertex().

00105 {m_wtrk_origin[n] = wtrk;}

WTrackParameter TrackPool::wTrackInfit ( int n ) const [inline]

Definition at line 76 of file TrackPool.h.

References m_wtrk_infit.

00076 {return m_wtrk_infit[n];}

std::vector<WTrackParameter> TrackPool::wTrackInfit ( ) const [inline]

Definition at line 73 of file TrackPool.h.

References m_wtrk_infit.

Referenced by VertexFit::BeamFit(), VertexFit::BuildVirtualParticle(), KinematicFit::BuildVirtualParticle(), KalmanKinematicFit::BuildVirtualParticle(), KinematicFit::covMatrix(), VertexFit::Ew(), KinematicFit::infit(), KalmanKinematicFit::infit(), VertexFit::pfit(), KinematicFit::pull(), KalmanKinematicFit::pull(), VertexFit::swimVertex(), KinematicFit::upCovmtx(), VertexFit::w(), VertexFit::wtrk(), and VertexFit::xfit().

00073 {return m_wtrk_infit;}

int TrackPool::wTrackList ( int n ) const [inline]

Definition at line 77 of file TrackPool.h.

References m_lwtrk.

00077 {return m_lwtrk[n];}

std::vector<int> TrackPool::wTrackList ( ) const [inline]

Definition at line 74 of file TrackPool.h.

References m_lwtrk.

00074 {return m_lwtrk;}

WTrackParameter TrackPool::wTrackOrigin ( int n ) const [inline]

Definition at line 75 of file TrackPool.h.

References m_wtrk_origin.

00075 {return m_wtrk_origin[n];}

std::vector<WTrackParameter> TrackPool::wTrackOrigin ( ) const [inline]

Member Data Documentation

HepPoint3D TrackPool::m_BeamPosition [private]

Definition at line 180 of file TrackPool.h.

Referenced by AddMissTrack(), AddTrack(), getBeamPosition(), and setBeamPosition().

std::vector<GammaShape> TrackPool::m_gammashape [private]

Definition at line 172 of file TrackPool.h.

Referenced by clearGammaShape(), GammaShapeValue(), and setGammaShape().

std::vector<int> TrackPool::m_lgammashape [private]

Definition at line 173 of file TrackPool.h.

Referenced by clearGammaShapeList(), GammaShapeList(), numberGammaShape(), and setGammaShapeList().

std::vector<int> TrackPool::m_lwtrk [private]

Definition at line 157 of file TrackPool.h.

Referenced by clearWTrackList(), numberWTrack(), setWTrackList(), and wTrackList().

std::vector<int> TrackPool::m_mapkinematic [private]

Definition at line 175 of file TrackPool.h.

Referenced by clearMapkinematic(), mapkinematic(), and setMapkinematic().

std::vector<int> TrackPool::m_mappositionA [private]

Definition at line 176 of file TrackPool.h.

Referenced by clearMappositionA(), mappositionA(), and setMappositionA().

std::vector<int> TrackPool::m_mappositionB [private]

Definition at line 177 of file TrackPool.h.

Referenced by clearMappositionB(), mappositionB(), and setMappositionB().

int TrackPool::m_numberone [private]

Definition at line 168 of file TrackPool.h.

Referenced by AddMissTrack(), AddTrack(), AddTrackVertex(), clearone(), numberone(), and TrackPool().

int TrackPool::m_numbertwo [private]

Definition at line 169 of file TrackPool.h.

Referenced by AddMissTrack(), AddTrack(), AddTrackVertex(), cleartwo(), numbertwo(), and TrackPool().

HepSymMatrix TrackPool::m_VBeamPosition [private]

Definition at line 181 of file TrackPool.h.

Referenced by AddMissTrack(), AddTrack(), getVBeamPosition(), and setVBeamPosition().

std::vector<WTrackParameter> TrackPool::m_wtrk_infit [private]

Definition at line 156 of file TrackPool.h.

Referenced by clearWTrackInfit(), setWTrackInfit(), and wTrackInfit().

std::vector<WTrackParameter> TrackPool::m_wtrk_origin [private]

Definition at line 155 of file TrackPool.h.

Referenced by clearWTrackOrigin(), setWTrackOrigin(), and wTrackOrigin().

Generated on Tue Nov 29 23:36:09 2016 for BOSS_7.0.2 by

1.4.7

TrackPool Class Reference

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation