Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

SecondVertexFit Class Reference

#include <SecondVertexFit.h>

Inheritance diagram for SecondVertexFit:

TrackPool TrackPool List of all members.

Public Member Functions

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< 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)
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)
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)
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)
std::vector< int > AddList (int n1, int n2, int n3)
std::vector< int > AddList (int n1, int n2)
std::vector< int > AddList (int n1)
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< 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)
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)
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)
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)
std::vector< int > AddList (int n1, int n2, int n3)
std::vector< int > AddList (int n1, int n2)
std::vector< int > AddList (int n1)
void AddMissTrack (const int number, const HepLorentzVector p4)
void AddMissTrack (const int number, const RecEmcShower *trk)
void AddMissTrack (const int number, const double mass, const RecEmcShower *trk)
void AddMissTrack (const int number, const double mass, const HepLorentzVector p4)
void AddMissTrack (const int number, const double mass)
void AddMissTrack (const int number, const HepLorentzVector p4)
void AddMissTrack (const int number, const RecEmcShower *trk)
void AddMissTrack (const int number, const double mass, const RecEmcShower *trk)
void AddMissTrack (const int number, const double mass, const HepLorentzVector p4)
void AddMissTrack (const int number, const double mass)
void AddTrack (const int number, const WTrackParameter wtrk)
void AddTrack (const int number, const double mass, const RecEmcShower *trk)
void AddTrack (const int number, const double mass, const RecMdcKalTrack *trk)
void AddTrack (const int number, const double mass, const RecMdcTrack *trk)
void AddTrack (const int number, const WTrackParameter wtrk)
void AddTrack (const int number, const double mass, const RecEmcShower *trk)
void AddTrack (const int number, const double mass, const RecMdcKalTrack *trk)
void AddTrack (const int number, const double mass, const RecMdcTrack *trk)
void AddTrackVertex (const int number, const double mass, const RecEmcShower *trk)
void AddTrackVertex (const int number, const double mass, const RecEmcShower *trk)
double chisq () const
double chisq () const
void clearGammaShape ()
void clearGammaShape ()
void clearGammaShapeList ()
void clearGammaShapeList ()
void clearMapkinematic ()
void clearMapkinematic ()
void clearMappositionA ()
void clearMappositionA ()
void clearMappositionB ()
void clearMappositionB ()
void clearone ()
void clearone ()
void cleartwo ()
void cleartwo ()
void clearWTrackInfit ()
void clearWTrackInfit ()
void clearWTrackList ()
void clearWTrackList ()
void clearWTrackOrigin ()
void clearWTrackOrigin ()
HepPoint3D crossPoint () const
HepPoint3D crossPoint () const
Hep3Vector crossVector () const
Hep3Vector crossVector () const
double ctau () const
double ctau () const
double ctauError () const
double ctauError () const
double decayLength () const
double decayLength () const
double decayLengthError () const
double decayLengthError () const
bool Fit ()
bool Fit ()
int GammaShapeList (int n) const
std::vector< int > GammaShapeList () const
int GammaShapeList (int n) const
std::vector< int > GammaShapeList () const
GammaShape GammaShapeValue (int n) const
std::vector< GammaShape > GammaShapeValue () const
GammaShape GammaShapeValue (int n) const
std::vector< GammaShape > GammaShapeValue () const
HepPoint3D getBeamPosition () const
HepPoint3D getBeamPosition () const
HepSymMatrix getVBeamPosition () const
HepSymMatrix getVBeamPosition () const
void init ()
void init ()
vector< int > mapkinematic () const
vector< int > mapkinematic () const
vector< int > mappositionA () const
vector< int > mappositionA () const
vector< int > mappositionB () const
vector< int > mappositionB () const
int numberGammaShape () const
int numberGammaShape () const
int numberone () const
int numberone () const
int numbertwo () const
int numbertwo () const
int numberWTrack () const
int numberWTrack () const
HepLorentzVector p4par () const
HepLorentzVector p4par () const
void setBeamPosition (const HepPoint3D BeamPosition)
void setBeamPosition (const HepPoint3D BeamPosition)
void setChisqCut (const double chicut=500, const double chiter=1.0e-2)
void setChisqCut (const double chicut=500, const double chiter=1.0e-2)
void setGammaShape (const GammaShape gammashape)
void setGammaShape (const int n, const GammaShape gammashape)
void setGammaShape (const GammaShape gammashape)
void setGammaShape (const int n, const GammaShape gammashape)
void setGammaShapeList (const int n)
void setGammaShapeList (const int n)
void setIterNumber (const int niter=10)
void setIterNumber (const int niter=10)
void setMapkinematic (const int n)
void setMapkinematic (const int n)
void setMappositionA (const int n)
void setMappositionA (const int n)
void setMappositionB (const int n)
void setMappositionB (const int n)
void setPrimaryVertex (const VertexParameter vpar)
void setPrimaryVertex (const VertexParameter vpar)
void setVBeamPosition (const HepSymMatrix VBeamPosition)
void setVBeamPosition (const HepSymMatrix VBeamPosition)
void setVpar (const VertexParameter vpar)
void setVpar (const VertexParameter vpar)
void setWTrackInfit (const WTrackParameter wtrk)
void setWTrackInfit (const int n, const WTrackParameter wtrk)
void setWTrackInfit (const WTrackParameter wtrk)
void setWTrackInfit (const int n, const WTrackParameter wtrk)
void setWTrackList (const int n)
void setWTrackList (const int n)
void setWTrackOrigin (const WTrackParameter wtrk)
void setWTrackOrigin (const int n, const WTrackParameter wtrk)
void setWTrackOrigin (const WTrackParameter wtrk)
void setWTrackOrigin (const int n, const WTrackParameter wtrk)
VertexParameter vpar () const
VertexParameter vpar () const
WTrackParameter wpar () const
WTrackParameter wpar () const
WTrackParameter wTrackInfit (int n) const
std::vector< WTrackParameter > wTrackInfit () const
WTrackParameter wTrackInfit (int n) const
std::vector< WTrackParameter > wTrackInfit () const
int wTrackList (int n) const
std::vector< int > wTrackList () const
int wTrackList (int n) const
std::vector< int > wTrackList () const
WTrackParameter wTrackOrigin (int n) const
std::vector< WTrackParameter > wTrackOrigin () const
WTrackParameter wTrackOrigin (int n) const
std::vector< WTrackParameter > wTrackOrigin () const
 ~SecondVertexFit ()
 ~SecondVertexFit ()

Static Public Member Functions

SecondVertexFit * instance ()
SecondVertexFit * instance ()

Private Member Functions

 SecondVertexFit ()
 SecondVertexFit ()

Private Attributes

double m_chicut
double m_chisq
double m_chiter
HepVector m_crxyz
double m_ctau
double m_ctau_error
double m_lxyz
double m_lxyz_error
int m_niter
HepLorentzVector m_p4par
VertexParameter m_vpar_primary
VertexParameter m_vpar_secondary
WTrackParameter m_wtrk

Static Private Attributes

SecondVertexFit * m_pointer
SecondVertexFit * m_pointer = 0

Constructor & Destructor Documentation

SecondVertexFit::~SecondVertexFit (   ) 
  

00065 {
00066 //      if(m_pointer) delete m_pointer;
00067 }

SecondVertexFit::SecondVertexFit (   )  [private]
  

00054 {
00055         HepVector vx(3,0);
00056         m_vpar_primary.setVx(vx);
00057         HepSymMatrix evx(3,0);
00058         evx[0][0] = 0.1 * 0.1;
00059         evx[1][1] = 0.1 * 0.1;
00060         evx[2][2] = 1.5 * 1.5;
00061         m_vpar_primary.setEvx(evx);
00062 }

SecondVertexFit::~SecondVertexFit (   ) 
 

SecondVertexFit::SecondVertexFit (   )  [private]
 

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
)  [inherited]
 

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
)  [inherited]
 

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
)  [inherited]
 

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

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

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

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

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

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

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

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

std::vector<int> TrackPool::AddList (  int  n1  )  [inherited]
 

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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  )  [inherited]
  

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
)  [inherited]
 

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

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

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

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

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

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
  

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
)  [inherited]
 

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

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

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

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

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
)  [inherited]
  

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
)  [inherited]
 

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

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
)  [inherited]
 

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

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 }

double SecondVertexFit::chisq (   )  const [inline]
  

00041 {return m_chisq;}

double SecondVertexFit::chisq (   )  const [inline]
  

00041 {return m_chisq;}

void TrackPool::clearGammaShape (   )  [inline, inherited]
  

00133 {m_gammashape.clear();}

void TrackPool::clearGammaShape (   )  [inline, inherited]
  

00133 {m_gammashape.clear();}

void TrackPool::clearGammaShapeList (   )  [inline, inherited]
  

00134 {m_lgammashape.clear();}

void TrackPool::clearGammaShapeList (   )  [inline, inherited]
  

00134 {m_lgammashape.clear();}

void TrackPool::clearMapkinematic (   )  [inline, inherited]
  

00118 {m_mapkinematic.clear();}

void TrackPool::clearMapkinematic (   )  [inline, inherited]
  

00118 {m_mapkinematic.clear();}

void TrackPool::clearMappositionA (   )  [inline, inherited]
  

00119 {m_mappositionA.clear();}

void TrackPool::clearMappositionA (   )  [inline, inherited]
  

00119 {m_mappositionA.clear();}

void TrackPool::clearMappositionB (   )  [inline, inherited]
  

00120 {m_mappositionB.clear();}

void TrackPool::clearMappositionB (   )  [inline, inherited]
  

00120 {m_mappositionB.clear();}

void TrackPool::clearone (   )  [inline, inherited]
  

00109 {m_numberone = 0;}

void TrackPool::clearone (   )  [inline, inherited]
  

00109 {m_numberone = 0;}

void TrackPool::cleartwo (   )  [inline, inherited]
  

00110 {m_numbertwo = 0;}

void TrackPool::cleartwo (   )  [inline, inherited]
  

00110 {m_numbertwo = 0;}

void TrackPool::clearWTrackInfit (   )  [inline, inherited]
  

00106 {m_wtrk_infit.clear();}

void TrackPool::clearWTrackInfit (   )  [inline, inherited]
  

00106 {m_wtrk_infit.clear();}

void TrackPool::clearWTrackList (   )  [inline, inherited]
  

00107 {m_lwtrk.clear();}

void TrackPool::clearWTrackList (   )  [inline, inherited]
  

00107 {m_lwtrk.clear();}

void TrackPool::clearWTrackOrigin (   )  [inline, inherited]
  

00105 {m_wtrk_origin.clear();}

void TrackPool::clearWTrackOrigin (   )  [inline, inherited]
  

00105 {m_wtrk_origin.clear();}

HepPoint3D SecondVertexFit::crossPoint (   )  const [inline]
 

HepPoint3D SecondVertexFit::crossPoint (   )  const [inline]
  

00076 {
00077         return HepPoint3D(m_crxyz[0], m_crxyz[1], m_crxyz[2]);
00078 }

Hep3Vector SecondVertexFit::crossVector (   )  const [inline]
 

Hep3Vector SecondVertexFit::crossVector (   )  const [inline]
  

00081 {
00082         return Hep3Vector(m_crxyz[0] - m_vpar_primary.Vx()[0], 
00083                           m_crxyz[1] - m_vpar_primary.Vx()[1],
00084                           m_crxyz[2] - m_vpar_primary.Vx()[2]);
00085 }

double SecondVertexFit::ctau (   )  const [inline]
  

00044 {return m_ctau;}

double SecondVertexFit::ctau (   )  const [inline]
  

00044 {return m_ctau;}

double SecondVertexFit::ctauError (   )  const [inline]
  

00045 {return m_ctau_error;}

double SecondVertexFit::ctauError (   )  const [inline]
  

00045 {return m_ctau_error;}

double SecondVertexFit::decayLength (   )  const [inline]
  

00042 {return m_lxyz;}

double SecondVertexFit::decayLength (   )  const [inline]
  

00042 {return m_lxyz;}

double SecondVertexFit::decayLengthError (   )  const [inline]
  

00043 {return m_lxyz_error;}

double SecondVertexFit::decayLengthError (   )  const [inline]
  

00043 {return m_lxyz_error;}

bool SecondVertexFit::Fit (   ) 
 

bool SecondVertexFit::Fit (   ) 
  

00087 {
00088 //      const double alpha = -0.00299792458;
00089 //      const double field = 1.0;
00090 //      double field_p = VertexFitBField::instance()->getBFieldZ(m_vpar_primary.vx());
00091 //      double field_s = VertexFitBField::instance()->getBFieldZ(m_vpar_secondary.vx());
00092 //      double field = (field_p + field_s) * 0.5 ;
00093 //      std::cout << "field in SeconVertexFit= " << field << std::endl;
00094 
00095         bool okfit = false;
00096 
00097         HepVector aOrigin(10, 0);
00098         HepVector aInfit(10, 0);
00099         HepSymMatrix VaOrigin(10, 0);
00100         HepSymMatrix VaInfit(10, 0);
00101         aOrigin.sub(1, wTrackOrigin(0).w());
00102         aOrigin.sub(8, m_vpar_primary.Vx());
00103         VaOrigin.sub(1, wTrackOrigin(0).Ew());
00104         VaOrigin.sub(8, m_vpar_primary.Evx());
00105         HepVector ctOrigin(1, 0);
00106         HepVector ctInfit(1, 0);
00107         HepSymMatrix Vct(1, 0);
00108         aInfit  = aOrigin;
00109         ctInfit = ctOrigin;
00110 
00111         std::vector<double> chisq;
00112         chisq.clear();
00113         double chi2 = 999;
00114         for(int it = 0; it < m_niter; it++)
00115         {
00116                 HepMatrix D(3, 10, 0);
00117                 HepLorentzVector p4par = HepLorentzVector(aInfit[0], aInfit[1], aInfit[2], aInfit[3]);
00118                 HepMatrix E(3,1,0);
00119                 HepVector d(3, 0);
00120                 if (wTrackOrigin(0).charge() == 0) 
00121                 {
00122                         D[0][4] = -1.0;
00123                         D[0][7] = 1.0;
00124                         D[1][5] = -1.0;
00125                         D[1][8] = 1.0;
00126                         D[2][6] = -1.0;
00127                         D[2][9] = 1.0;
00128 
00129                         E[0][0] = p4par.px()/p4par.m();
00130                         E[1][0] = p4par.py()/p4par.m();
00131                         E[2][0] = p4par.pz()/p4par.m();
00132 
00133                         d[0] = aInfit[7]-aInfit[4]+ctInfit[0]*p4par.px()/p4par.m();
00134                         d[1] = aInfit[8]-aInfit[5]+ctInfit[0]*p4par.py()/p4par.m();
00135                         d[2] = aInfit[9]-aInfit[6]+ctInfit[0]*p4par.pz()/p4par.m();
00136                 }
00137                 else 
00138                 {
00139                         double afield = VertexFitBField::instance()->getCBz(m_vpar_primary.Vx(), m_vpar_secondary.Vx());
00140                         double a = afield * wTrackOrigin(0).charge();
00141                         D[0][4] = -1.0;
00142                         D[0][7] = 1.0;
00143                         D[1][5] = -1.0;
00144                         D[1][8] = 1.0;
00145                         D[2][6] = -1.0;
00146                         D[2][9] = 1.0;
00147 
00148                         E[0][0] = p4par.px() / p4par.m() * cos(a * ctInfit[0] / p4par.m()) + p4par.py() / p4par.m() * sin(a * ctInfit[0] / p4par.m());
00149                         E[1][0] = p4par.py() / p4par.m() * cos(a * ctInfit[0] / p4par.m()) - p4par.px() / p4par.m() * sin(a * ctInfit[0] / p4par.m());
00150                         E[2][0] = p4par.pz() / p4par.m();
00151 
00152                         d[0] = aInfit[7] - aInfit[4]+p4par.px()/a * sin(a * ctInfit[0]/p4par.m()) + p4par.py()/a*(1-cos(a*ctInfit[0]/p4par.m()));
00153                         d[1] = aInfit[8] - aInfit[5]+p4par.py()/a * sin(a * ctInfit[0]/p4par.m()) - p4par.px()/a*(1-cos(a*ctInfit[0]/p4par.m()));
00154                         d[2] = aInfit[9] - aInfit[6]+ctInfit[0]*p4par.pz()/p4par.m();
00155                 }
00156                 
00157                 HepSymMatrix VD(3, 0);
00158                 HepVector dela0(10, 0);
00159                 HepVector lambda0(3, 0);
00160                 HepVector delct(1, 0);
00161                 HepVector lambda(3, 0);
00162                 int ifail;
00163 
00164                 VD      = (VaOrigin.similarity(D)).inverse(ifail);
00165                 dela0   = aOrigin - aInfit;
00166                 lambda0 = VD*(D*dela0 + d);
00167                 Vct     = (VD.similarity(E.T())).inverse(ifail);
00168                 delct   = -(Vct * E.T()) * lambda0;
00169                 ctInfit = ctInfit + delct;
00170                 lambda  = lambda0 + (VD * E) * delct;
00171                 aInfit  = aOrigin - (VaOrigin * D.T()) * lambda;
00172                 chi2    = dot(lambda, D*dela0 + d);
00173                 VaInfit = VaOrigin - (VD.similarity(D.T())).similarity(VaOrigin);
00174                 VaInfit = VaInfit + (((Vct.similarity(E)).similarity(VD)).similarity(D.T())).similarity(VaOrigin);
00175 
00176                 chisq.push_back(chi2);
00177 
00178                 if(it > 0) 
00179                 {
00180                         double delchi = chisq[it] - chisq[it-1];
00181                         if (fabs(delchi) < m_chiter) 
00182                         {
00183 //                              std::cout <<"Fit(): pass all " << it <<" , " << delchi << std::endl;
00184                                 break;
00185                         }
00186                 }
00187         }
00188         if (chi2 < 0 || chi2 > m_chicut)
00189                 return okfit;
00190 
00191         HepLorentzVector p4par = HepLorentzVector(aInfit[0], aInfit[1], aInfit[2], aInfit[3]);
00192         m_ctau       = ctInfit[0];
00193         m_ctau_error = sqrt(Vct[0][0]);
00194         m_lxyz       = ctInfit[0] * p4par.rho() / p4par.m();
00195         m_lxyz_error = sqrt(Vct[0][0]) * p4par.rho() / p4par.m();
00196         m_chisq      = chi2;
00197         m_p4par      = p4par;
00198         for(int i = 0; i < 3; i++)
00199                 m_crxyz[i] = aInfit[4+i];
00200         HepVector w(7, 0);
00201         HepSymMatrix Ew(7, 0);
00202         for(int i = 0; i < 7; i++) 
00203         {
00204                 w[i] = aInfit[i];
00205                 for(int j = 0; j < 7; j++) 
00206                 {
00207                         Ew[i][j] = VaInfit[i][j];
00208                 }
00209         }
00210         m_wtrk.setW(w);
00211         m_wtrk.setEw(Ew);
00212         m_wtrk.setCharge(wTrackOrigin(0).charge());
00213         okfit = true;
00214         return okfit;
00215 }

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

00092 {return m_lgammashape[n];}

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

00090 {return m_lgammashape;}

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

00092 {return m_lgammashape[n];}

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

00090 {return m_lgammashape;}

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

00091 {return m_gammashape[n];}

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

00089 {return m_gammashape;}

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

00091 {return m_gammashape[n];}

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

00089 {return m_gammashape;}

HepPoint3D TrackPool::getBeamPosition (   )  const [inline, inherited]
  

00141 {return m_BeamPosition;}

HepPoint3D TrackPool::getBeamPosition (   )  const [inline, inherited]
  

00141 {return m_BeamPosition;}

HepSymMatrix TrackPool::getVBeamPosition (   )  const [inline, inherited]
  

00142 {return m_VBeamPosition;}

HepSymMatrix TrackPool::getVBeamPosition (   )  const [inline, inherited]
  

00142 {return m_VBeamPosition;}

void SecondVertexFit::init (   ) 
 

void SecondVertexFit::init (   ) 
  

00070 {
00071         clearWTrackOrigin();
00072         clearWTrackInfit();
00073         clearWTrackList();
00074         m_vpar_secondary = VertexParameter();
00075         m_lxyz       = 0;
00076         m_lxyz_error = 0;
00077         m_p4par      = HepLorentzVector(0, 0, 0, 0);
00078         m_crxyz      = HepVector(3, 0);
00079         m_chisq      = 9999;
00080         m_wtrk       = WTrackParameter();
00081         m_niter      = 10;
00082         m_chicut     = 500;
00083         m_chiter     = 1.0e-2;
00084 }

SecondVertexFit* SecondVertexFit::instance (   )  [static]
 

SecondVertexFit * SecondVertexFit::instance (   )  [static]
  

00046 {
00047         if (m_pointer) 
00048                 return m_pointer;
00049         m_pointer = new SecondVertexFit();
00050         return m_pointer;
00051 }

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

00116 {return m_mapkinematic;}

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

00116 {return m_mapkinematic;}

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

00114 {return m_mappositionA;}

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

00114 {return m_mappositionA;}

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

00115 {return m_mappositionB;}

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

00115 {return m_mappositionB;}

int TrackPool::numberGammaShape (   )  const [inline, inherited]
  

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

int TrackPool::numberGammaShape (   )  const [inline, inherited]
  

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

int TrackPool::numberone (   )  const [inline, inherited]
  

00111 {return m_numberone;}

int TrackPool::numberone (   )  const [inline, inherited]
  

00111 {return m_numberone;}

int TrackPool::numbertwo (   )  const [inline, inherited]
  

00112 {return m_numbertwo;}

int TrackPool::numbertwo (   )  const [inline, inherited]
  

00112 {return m_numbertwo;}

int TrackPool::numberWTrack (   )  const [inline, inherited]
  

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

int TrackPool::numberWTrack (   )  const [inline, inherited]
  

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

HepLorentzVector SecondVertexFit::p4par (   )  const [inline]
  

00047 {return m_p4par;}

HepLorentzVector SecondVertexFit::p4par (   )  const [inline]
  

00047 {return m_p4par;}

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

00137 {m_BeamPosition = BeamPosition;}

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

00137 {m_BeamPosition = BeamPosition;}

void SecondVertexFit::setChisqCut (  const double  chicut = 500,
const double  chiter = 1.0e-2
)  [inline]
  

00031 {m_chicut = chicut;m_chiter=chiter;}

void SecondVertexFit::setChisqCut (  const double  chicut = 500,
const double  chiter = 1.0e-2
)  [inline]
  

00031 {m_chicut = chicut;m_chiter=chiter;}

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

00130 {m_gammashape.push_back(gammashape);}

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

00129 {m_gammashape[n] = gammashape;}

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

00130 {m_gammashape.push_back(gammashape);}

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

00129 {m_gammashape[n] = gammashape;}

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

00131 {m_lgammashape.push_back(n);}

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

00131 {m_lgammashape.push_back(n);}

void SecondVertexFit::setIterNumber (  const int  niter = 10  )  [inline]
  

00030 {m_niter = niter;}

void SecondVertexFit::setIterNumber (  const int  niter = 10  )  [inline]
  

00030 {m_niter = niter;}

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

00122 {m_mapkinematic.push_back(n);}

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

00122 {m_mapkinematic.push_back(n);}

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

00123 {m_mappositionA.push_back(n);}

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

00123 {m_mappositionA.push_back(n);}

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

00124 {m_mappositionB.push_back(n);}

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

00124 {m_mappositionB.push_back(n);}

void SecondVertexFit::setPrimaryVertex (  const VertexParameter  vpar  )  [inline]
  

00035 {m_vpar_primary.setVx(vpar.Vx());m_vpar_primary.setEvx(vpar.Evx());}

void SecondVertexFit::setPrimaryVertex (  const VertexParameter  vpar  )  [inline]
  

00035 {m_vpar_primary.setVx(vpar.Vx());m_vpar_primary.setEvx(vpar.Evx());}

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

00138 {m_VBeamPosition = VBeamPosition;}

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

00138 {m_VBeamPosition = VBeamPosition;}

void SecondVertexFit::setVpar (  const VertexParameter  vpar  )  [inline]
  

00033 {m_vpar_secondary = vpar;}

void SecondVertexFit::setVpar (  const VertexParameter  vpar  )  [inline]
  

00033 {m_vpar_secondary = vpar;}

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

00102 {m_wtrk_infit.push_back(wtrk);}

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

00100 {m_wtrk_infit[n] = wtrk;}

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

00102 {m_wtrk_infit.push_back(wtrk);}

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

00100 {m_wtrk_infit[n] = wtrk;}

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

00103 {m_lwtrk.push_back(n);}

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

00103 {m_lwtrk.push_back(n);}

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

00101 {m_wtrk_origin.push_back(wtrk);}

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

00099 {m_wtrk_origin[n] = wtrk;}

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

00101 {m_wtrk_origin.push_back(wtrk);}

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

00099 {m_wtrk_origin[n] = wtrk;}

VertexParameter SecondVertexFit::vpar (   )  const [inline]
  

00049 {return m_vpar_secondary;}

VertexParameter SecondVertexFit::vpar (   )  const [inline]
  

00049 {return m_vpar_secondary;}

WTrackParameter SecondVertexFit::wpar (   )  const [inline]
  

00048 {return m_wtrk;}

WTrackParameter SecondVertexFit::wpar (   )  const [inline]
  

00048 {return m_wtrk;}

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

00070 {return m_wtrk_infit[n];}

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

00067 {return m_wtrk_infit;}

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

00070 {return m_wtrk_infit[n];}

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

00067 {return m_wtrk_infit;}

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

00071 {return m_lwtrk[n];}

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

00068 {return m_lwtrk;}

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

00071 {return m_lwtrk[n];}

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

00068 {return m_lwtrk;}

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

00069 {return m_wtrk_origin[n];}

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

00066 {return m_wtrk_origin;}

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

00069 {return m_wtrk_origin[n];}

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

00066 {return m_wtrk_origin;}

Member Data Documentation

double SecondVertexFit::m_chicut [private]
 

double SecondVertexFit::m_chisq [private]
 

double SecondVertexFit::m_chiter [private]
 

HepVector SecondVertexFit::m_crxyz [private]
 

double SecondVertexFit::m_ctau [private]
 

double SecondVertexFit::m_ctau_error [private]
 

double SecondVertexFit::m_lxyz [private]
 

double SecondVertexFit::m_lxyz_error [private]
 

int SecondVertexFit::m_niter [private]
 

HepLorentzVector SecondVertexFit::m_p4par [private]
 

SecondVertexFit* SecondVertexFit::m_pointer [static, private]
 

SecondVertexFit * SecondVertexFit::m_pointer = 0 [static, private]
 

VertexParameter SecondVertexFit::m_vpar_primary [private]
 

VertexParameter SecondVertexFit::m_vpar_secondary [private]
 

WTrackParameter SecondVertexFit::m_wtrk [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 18:49:33 2011 for BOSS6.5.5 by  doxygen 1.3.9.1