EdbTrackAssembler Class Reference

#include <EdbScanTracking.h>

Inheritance diagram for EdbTrackAssembler:

Collaboration diagram for EdbTrackAssembler:

Public Member Functions
bool	AcceptDZGap (EdbTrackP &t, float z)
void	AddPattern (EdbPattern &p)
EdbTrackP *	AddSegment (EdbSegP &s)
EdbTrackP *	AddSegmentAsTrack (EdbSegP &s)
void	CheckPatternAlignment (EdbPattern &p, EdbPlateP &plate, int nsegmin, EdbAffine2D &acorr)
void	CombTracks (TObjArray &selected)
void	DoubletsFilterOut (EdbPattern &p)
	EdbTrackAssembler ()
void	ExtrapolateTracksToZ (float z, int nsegmin=0)
void	ExtrapolateTracksToZ_mcs3 (float z, int nsegmin=0)
void	FillTrZMap ()
void	FillXYseg (EdbPattern &p)
void	FitTracks ()
void	InitTrZMap ()
void	InitTrZMap (const char *str)
void	InitTrZMap (int nx, float xmi, float xma, int ny, float ymi, float yma, int ncell)
float	ProbSeg (EdbSegP &s1, EdbSegP &s2)
void	RecalculateSegmentsProb (EdbTrackP &t)
bool	SameSegment (EdbSegP &s1, EdbSegP &s2)
void	SetMomentum (float p)
void	SetRadLength (float x0)
void	SetSegmentsErrors ()
TObjArray &	Tracks ()
virtual	~EdbTrackAssembler ()

Public Attributes
int	eCollisionsRate
EdbScanCond	eCond
int	eDoUseMCS
float	eDRmax
float	eDTmax
float	eDZGapMax
TH1F *	eHistNcnd
TH1F *	eHistProbAll
TH1F *	eHistProbBest
TH1F *	eHistThetaAll
TH1F *	eHistThetaBest
TH2F *	eHistTXTYseg
TH3F *	eHistXYPseg
TH3F *	eHistXYPsegNB
TH2F *	eHistXYseg
float	eProbMin

Private Attributes
Int_t	eCellN
EdbTrackFitter	eFitter
Float_t	eMapMarg
EdbPattern	eSegments
TObjArray	eTracks
TObjArray	eTrZ
EdbCell2	eTrZMap
Float_t	eZ

Constructor & Destructor Documentation

EdbTrackAssembler()

EdbTrackAssembler::EdbTrackAssembler

(

)

{
  eMapMarg = 50.; // [microns]
  eZ = 0;
  eCellN=10;    //mean n/cell
  eDTmax=0.07;
  eDRmax=45.;
  eDZGapMax = 5000;
  eProbMin = 0.001;
  eCollisionsRate=0;
  
  eHistNcnd     = new TH1F("Ncnd","number of candidates after preliminary selection", 20,0.5,20.5);
  eHistProbBest = new TH1F("ProbBest","prob for best selected candidate", 250,0,1);
  eHistProbAll  = new TH1F("ProbAll","prob for all candidates", 250,0,1);
  eHistThetaBest = new TH1F("ThetaBest","angle theta for best selected candidate", 180,0,TMath::PiOver2());
  eHistThetaAll  = new TH1F("ThetaAll","angle theta for all candidates", 180,0,TMath::PiOver2());
  eHistXYseg=0;
  eHistXYPseg=0;     // all segments
  eHistXYPsegNB=0;   // no-beam (thetaMin=0.02, thetaMax=0.5)
  eHistTXTYseg=0;
 
    // for basetracks:
  eCond.SetDefault();
  eCond.SetSigma0( 4, 4, 0.005, 0.005 );
  eCond.SetPulsRamp0(14., 21.);
  eCond.SetPulsRamp04(14., 21.);
}

~EdbTrackAssembler()

virtual EdbTrackAssembler::~EdbTrackAssembler ( )

virtual

Member Function Documentation

AcceptDZGap()

bool EdbTrackAssembler::AcceptDZGap	(	EdbTrackP &	t,
		float	z
	)

{
  float z1 = t.GetSegmentFirst()->Z();
  float z2 = t.GetSegmentLast()->Z();
  if(Min( Abs(z1-z), Abs(z2-z)) > eDZGapMax ) return false;
  return true;
}

AddPattern()

void EdbTrackAssembler::AddPattern

(

EdbPattern &

p

)

{
   //int ntrBefore=eTracks.GetEntriesFast();
    //if(ntrBefore>0) ExtrapolateTracksToZ(p.Z());
    
    //DoubletsFilterOut();
  int nseg = p.N();
  Log(3,"EdbTrackAssembler::AddPattern","try to add %d segments",p.N());
  int attached=0;
  for(int j=0; j<nseg; j++) {
    EdbSegP *s = p.GetSegment(j);
    if(s->Flag()==-10)   continue;
    s->SetErrors();
    eCond.FillErrorsCov(s->TX(),s->TY(),s->COV());
    if( !AddSegment( *s ) )
      AddSegmentAsTrack( *s );
    else {
      attached++;
      s->SetTrack(1);
    }
  }
  // calculate lost segments
  int losttrack=0;
  int lostflag=0;
  for(int j=0; j<nseg; j++) {
    EdbSegP *s = p.GetSegment(j);
    if(s->Flag()!=-10)
    {
      if(s->Track()==-1) losttrack++;
    } else lostflag++;
    //AddSegmentAsTrack( *(p.GetSegment(j)) );
  }
  int ntrAfter = eTracks.GetEntriesFast();
    //int totSegTr=0;
    //for(int i=0; i<ntrAfter; i++) totSegTr += ((EdbTrackP*)(eTracks.At(i)))->N();
  Log(2,"EdbTrackAssembler::AddPattern","with z=%10.2f   %d/%d attached/tried; collisions/lt/lf: %d/%d/%d;  tracks: %d",
      p.Z(), attached, nseg, eCollisionsRate,losttrack,lostflag, ntrAfter );
  eCollisionsRate=0;
}

AddSegment()

EdbTrackP * EdbTrackAssembler::AddSegment

(

EdbSegP &

s

)

{
  TObjArray trsel;
  float v[2] = { s.X(), s.Y() };
  int nsel =  eTrZMap.SelectObjectsC( v, eDRmax, trsel );
//  int nsel =  eTrZMap.SelectObjectsC( v, eDRmax+50 , trsel );
  Log(4,"EdbTrackAssembler::AddSegment", "nsel = %d",nsel);
  if(!nsel) { 
    return 0;  }
    float prob, probmax = eProbMin;
    EdbSegP *ssbest = 0;
    int ncnd = 0;
    for(int i=0; i<nsel; i++) {
      EdbSegP *ss = (EdbSegP*)(trsel.At(i));
      prob = ProbSeg( *ss, s );
      Log(4,"EdbTrackAssembler::AddSegment", "prob(probmin) = %f (%f) ",prob, eProbMin);
      if(prob<eProbMin) continue;
      ncnd++;
      if(eHistProbAll) eHistProbAll->Fill(prob);
      if(eHistThetaAll) eHistThetaAll->Fill(ATan(ss->Theta()));
      if( prob > probmax ) { ssbest = ss; probmax=prob; }
    }
    if(!ssbest)  return 0;
    s.SetProb(probmax);
    if(eHistNcnd)     eHistNcnd->Fill(ncnd);
    if(eHistProbBest) eHistProbBest->Fill(probmax);
    if(eHistThetaBest) eHistThetaBest->Fill(ATan(ssbest->Theta()));
    EdbTrackP *t = (EdbTrackP*)(ssbest);
    EdbSegP *sz = t->GetSegmentWithClosestZ( t->Z(), 45. );
    if(!sz) t->AddSegment( eSegments.AddSegment(s) );
    else {
      if( !SameSegment(s,*sz) ) {
        if( s.Prob() > sz->Prob() )  t->SubstituteSegment( sz ,  eSegments.AddSegment(s) );
    sz->SetTrack(-1);
        eCollisionsRate++;
      }
    }
    return t;
}

AddSegmentAsTrack()

EdbTrackP * EdbTrackAssembler::AddSegmentAsTrack

(

EdbSegP &

s

)

{
  EdbTrackP *t = new EdbTrackP( eSegments.AddSegment(s), 0.139);    // EdbTrackAssembler is owner of segments
  s.SetTrack(0);
  eTracks.Add(t);
  return t;
}

CheckPatternAlignment()

void EdbTrackAssembler::CheckPatternAlignment	(	EdbPattern &	p,
		EdbPlateP &	plate,
		int	nsegmin,
		EdbAffine2D &	acorr
	)

{
  Log(0,"EdbTrackAssembler::CheckPatternAlignment","%s with %d segments",p.ScanID().AsString(),p.N());
  
  if(eDoUseMCS==3)     ExtrapolateTracksToZ_mcs3( p.Z(), nsegmin);
  else                 ExtrapolateTracksToZ( p.Z(), nsegmin);
  int ntr = eTrZ.GetEntriesFast();
  EdbPattern ptr( 0, 0, p.Z(), ntr ); 
  for(int i=0; i<ntr; i++) ptr.AddSegment( *((EdbSegP*)(eTrZ.UncheckedAt(i))) );
    
  EdbPlateAlignment al;
  //al.InitOutputFile(Form("%s_real.root",p.ScanID().AsString()));
  al.SetSigma( 1.5, 0.003 );
  al.eOffsetMax = 100.;
  al.eDZ        = 0;
  al.eDPHI      = 0.00;
  al.SetDoublets(0.3,0.3,0.001,0.001);
    //al.eDoCoarse=1;
 
  p.Transform(&acorr);
  plate.GetAffineXY()->Transform(&acorr);
 
  al.Align(ptr,p,0);
  
  EdbAffine2D *aff = al.eCorrL[0].GetAffineXY();
  aff->Invert();
  aff->Print();
  acorr.Transform(aff);
  p.Transform(aff);
  plate.GetAffineXY()->Transform(aff);
  
  EdbAffine2D *afftxty = al.eCorrL[0].GetAffineTXTY();
  afftxty->Invert();
  afftxty->Print();
  p.TransformA(afftxty);
  plate.GetAffineTXTY()->Transform(afftxty);
}

CombTracks()

void EdbTrackAssembler::CombTracks

(

TObjArray &

selected

)

{
    // eliminate crossing&overlapping tracks with multiple segments usage
  
  int nsegMin=2;
  int nGapMax=50;
  
  int ntr = eTracks.GetEntriesFast();
  Log(3,"EdbTrackAssembler::CombTracks","Comb %d tracks");
  
    // *** sort tracks by quality
  
  TIndexCell cn;  //"nseg:prob:entry"
  Long_t v[3];
  
  int nsegtot=0;
  EdbTrackP *tr=0;
  for(int i=0; i<ntr; i++) {
    tr = (EdbTrackP*)(eTracks.At(i));
    if( tr->Flag() == -10 ) continue;
    if( tr->N() < nsegMin ) continue;
    tr->SetID(i);
    tr->SetCounters();
    nsegtot += tr->SetSegmentsTrack(-1);
    v[0]= -(tr->N());
    v[1]= (Long_t)((1.-tr->Prob())*100);
    v[2]= i;
    cn.Add(3,v);
  }
  cn.Sort();
  
  Log(3,"EdbTrackAssembler::CombTracks","%d tracks with %d segments for processing...",ntr,nsegtot);
  
    // *** set track ID for segments attached to
  
  TIndexCell *cp=0, *c=0;
  int nn=cn.GetEntriesFast();
  for(int i=nn-1; i>=0; i--) {
    cp = cn.At(i);                              // tracks with fixed npl
    int np = cp->GetEntriesFast();
    for(int ip=np-1; ip>=0; ip--) {
      c = cp->At(ip);                           // tracks with fixed Npl & Prob
      int nt = c->GetEntriesFast();
      for(int it=0; it<nt; it++) {
        tr = (EdbTrackP*)(eTracks.At( c->At(it)->Value() ) );
        tr->SetSegmentsTrack();
      }
    }
  }
  
  
  cp=0;   c=0;
  nn=cn.GetEntriesFast();
  for(int i=0; i<nn; i++) {
    cp = cn.At(i);                              // tracks with fixed npl
 
    int np = cp->GetEntriesFast();
    for(int ip=0; ip<np; ip++) {
      c = cp->At(ip);                           // tracks with fixed Npl & Prob
 
      int nt = c->GetEntriesFast();
      for(int it=0; it<nt; it++) {
  
        tr = (EdbTrackP*)(eTracks.At( c->At(it)->Value() ) );
 
        if(tr->RemoveAliasSegments()>0){
          if(tr->N()<nsegMin)             tr->SetFlag(-10);
          if(tr->CheckMaxGap()>nGapMax)   tr->SetFlag(-10);
        }
 
        if( tr->Flag() != -10 ) selected.Add(tr);
      }
    }
  }
 
}

DoubletsFilterOut()

void EdbTrackAssembler::DoubletsFilterOut

(

EdbPattern &

p

)

{
  EdbAlignmentV adup;
  adup.eDVsame[0]=adup.eDVsame[1]=10.;
  adup.eDVsame[2]=adup.eDVsame[3]=0.08;
  adup.FillGuessCell(p,p,1.);
  adup.FillCombinations();
  adup.DoubletsFilterOut(0);   // assign flag -10 to the duplicated segments
}

ExtrapolateTracksToZ()

void EdbTrackAssembler::ExtrapolateTracksToZ	(	float	z,
		int	nsegmin = 0
	)

{
  eTrZ.Clear();
  eTrZMap.CleanCells();
    
  eZ=z;
  int n=eTracks.GetEntriesFast();
  for(int i=0; i<n; i++) {
    EdbTrackP *t = (EdbTrackP*)(eTracks.At(i));
      
    if( t->N() < nsegmin )      continue;
    if( !AcceptDZGap(*t, z) )   continue;
    t->MakePredictionTo(eZ,*t); // keep the same behaviour as before: propagation with angle
    eTrZ.Add(t);
  }
}

ExtrapolateTracksToZ_mcs3()

void EdbTrackAssembler::ExtrapolateTracksToZ_mcs3	(	float	z,
		int	nsegmin = 0
	)

{
  eTrZ.Clear();
  eTrZMap.CleanCells();
    
  eZ=z;
  int n=eTracks.GetEntriesFast();
  for(int i=0; i<n; i++) {
    EdbTrackP *t = (EdbTrackP*)(eTracks.At(i));
    t->EstimatePositionAt(eZ,*t); //use angles if 1 seg, overwise use coordinates, t->DZ() - is gap
  }
 
  for(int i=0; i<n; i++)
  {
    EdbTrackP *t = (EdbTrackP*)(eTracks.At(i));
    if( Abs(t->DZ()) > eDZGapMax                 ) continue;
    if( t->N()<nsegmin                           ) continue;
    eTrZ.Add(t);
  }
  Log(2,"EdbTrackAssembler::ExtrapolateTracksToZ_mcs3","at z = %f nsegmin=%d  %d => %d",
      z,nsegmin, n, eTrZ.GetEntriesFast() );
}

FillTrZMap()

void EdbTrackAssembler::FillTrZMap

(

)

{
  int n=eTrZ.GetEntriesFast();
  Log(3,"EdbTrackAssembler::FillTrZMap", "with %d tracks",n);
  for(int i=0; i<n; i++) {
    EdbSegP *s = (EdbSegP*)(eTrZ.At(i));
    eTrZMap.AddObject( s->X(), s->Y(), s );
  }
  int nfill = eTrZMap.Integral();
  Log(3,"EdbTrackAssembler::FillTrZMap", "integral = %d", nfill );
  if( nfill != n) Log(1,"EdbTrackAssembler::FillTrZMap", "Warning! cell overflow: n = %d  nfill = %d", n, nfill);
}

FillXYseg()

void EdbTrackAssembler::FillXYseg

(

EdbPattern &

p

)

{
  // test function probably to be moved out of this class
  float xmi=p.Xmin();
  float xma=p.Xmax();
  float ymi=p.Ymin();
  float yma=p.Ymax();
  if(!eHistXYseg) 
  {
    float dx= xma-xmi;
    float dy= yma-ymi;
    float nx= 3*dx/50;  //TODO: bin size as a parameter?
    float ny= 3*dy/50;
    eHistXYseg = new TH2F("XYseg", "XY overlap all beam-like segments used for tracking", 
              nx,xmi-dx,xma+dx,ny,ymi-dy,yma+dy );
  }
  if(!eHistXYPseg) 
  {
    float dx= xma-xmi;
    float dy= yma-ymi;
    float nx= 3*dx/50;  //TODO: bin size as a parameter?
    float ny= 3*dy/50;
    eHistXYPseg   = new TH3F("XYPseg", "XYP overlap all beam-like segments used for tracking", 
              nx,xmi-dx,xma+dx,ny,ymi-dy,yma+dy,60,0,60);
    eHistXYPsegNB = new TH3F("XYPsegNB", "XYP out of beam", 
              nx,xmi-dx,xma+dx,ny,ymi-dy,yma+dy,60,0,60);
  }
  if(!eHistTXTYseg) 
  {
    eHistTXTYseg = new TH2F("TXTYseg", "TXTY overlap all beam-like segments used for tracking", 
              200,-1,1,200,-1,1 );
  }
  int plate = p.ScanID().ePlate;
  int n=p.N();
  //TArrayF x(n),y(n);
  //int cnt=0;
  float thetaMin=0.02, thetaMax=0.5;
  for(int i=0; i<n; i++)
  {
    EdbSegP *s = p.GetSegment(i);
    eHistTXTYseg->Fill(s->TX(),s->TY());
    if(Abs(s->TX())<0.1&&Abs(s->TY())<0.1) 
    {
      eHistXYseg->Fill(s->X(),s->Y());
      eHistXYPseg->Fill(s->X(),s->Y(),plate);
      if(s->Theta()>=thetaMin&&s->Theta()<=thetaMax)   eHistXYPsegNB->Fill(s->X(),s->Y(),plate);
      //x[cnt++]=s->X();
      //y[cnt]  =s->Y(); 
    }
  }
  
  //gROOT->SetBatch(true);
  //TCanvas *c = new TCanvas("a","a",4000,4000);
  //TGraph *gr =  new TGraph(cnt,x.GetArray(),y.GetArray());
  //gr->SetMarkerStyle(1);
  //TH2F *hh = (TH2F*)(eHistXYseg->Clone("hh"));
  //hh->Reset();
  //hh->Draw();
  //gr->Draw("P");
  //c->Print("tt.gif+10");
  //delete gr;
  //delete c;
  //delete hh;
}

FitTracks()

void EdbTrackAssembler::FitTracks

(

)

{
  EdbTrackFitter fit;
 
  int ntr = eTracks.GetEntriesFast();
  for( int i=0; i<ntr; i++ )     {
    EdbTrackP *t = (EdbTrackP*)(eTracks.At(i));
    if(t->Flag()==-10) continue;
    int nseg=t->N();
    t->FitTrackKFS(0,10000);
        //fit.FitTrackLine(*t);
    if(nseg>1) RecalculateSegmentsProb(*t);
  }
}

InitTrZMap() [1/3]

void EdbTrackAssembler::InitTrZMap

(

)

{
  /*  float  mi[2] = {  eTrZ.Xmin()-eMapMarg, eTrZ.Ymin()-eMapMarg };
  float  ma[2] = {  eTrZ.Xmax()+eMapMarg, eTrZ.Ymax()+eMapMarg };
  float  dens = eTrZ.N()/( (ma[0]-mi[0])*(ma[1]-mi[1]));
  float  step=10000;
  if(dens>0.00000001) step = Sqrt( eCellN/dens );
  int    n[2] = { int((ma[0]-mi[0])/step)+1, int((ma[1]-mi[1])/step)+1 };
  float stepX = (ma[0]-mi[0])/n[0];
  float stepY = (ma[1]-mi[1])/n[1];
  n[0] = int((ma[0]-mi[0]+1.)/stepX);
  n[1] = int((ma[1]-mi[1]+1.)/stepY);
  eTrZMap.InitCell(3*eCellN, n, mi, ma);*/
}

InitTrZMap() [2/3]

void EdbTrackAssembler::InitTrZMap

(

const char *

str

)

{
  int   nx=0, ny=0, ncell=0;
  float xmi,xma, ymi, yma;
  sscanf(str,"%d %f %f %d %f %f %d",&nx,&xmi,&xma,&ny,&ymi,&yma,&ncell);
  InitTrZMap( nx,xmi,xma,ny,ymi,yma,ncell );
}

InitTrZMap() [3/3]

void EdbTrackAssembler::InitTrZMap	(	int	nx,
		float	xmi,
		float	xma,
		int	ny,
		float	ymi,
		float	yma,
		int	ncell
	)

{
  float  mi[2] = {  xmi, ymi };
  float  ma[2] = {  xma, yma };
  int     n[2] = { nx, ny };
  eTrZMap.InitCell(ncell, n, mi, ma);
}

ProbSeg()

float EdbTrackAssembler::ProbSeg	(	EdbSegP &	s1,
		EdbSegP &	s2
	)

workaround to get previous(not propagated) segment

{
  // return the probability that the second segment can belong to track defined by s1
  float dtx = s1.TX() - s2.TX();
  if( Abs( dtx ) > eDTmax )    return 0;
  float dty = s1.TY() - s2.TY();
  if( Abs( dty ) > eDTmax )    return 0;
  double dt2 = dtx*dtx +  dty*dty;
  if(dt2>eDTmax*eDTmax)        return 0;
  
  float dz = s2.Z()-s1.Z();
  float dx = s2.X() - (s1.X() + dz*s1.TX());
  if( Abs( dx ) > eDRmax )     return 0;
  float dy = s2.Y() - (s1.Y() + dz*s1.TY());
  if( Abs( dy ) > eDRmax )     return 0;
  double dr2 = dx*dx +  dy*dy;
  if(dr2>eDRmax*eDRmax)        return 0;
  
  float prob=0;
  if(eDoUseMCS==1){
    EdbTrackP* t = dynamic_cast<EdbTrackP*> (&s1);
    EdbSegP* seg = t?(const_cast<EdbSegP*>(t->TrackEnd())):0;
    prob = seg?(eFitter.ProbSegMCS(seg, &s2)):0;
  }
  else if(eDoUseMCS==20) // test: why the option 2 is not selective and with 100% collision rate?
  {
    EdbTrackP* t = dynamic_cast<EdbTrackP*> (&s1);
    EdbSegP* seg = t?(const_cast<EdbSegP*>(t->TrackEnd())):0;
    if(seg) {
      float prob1 = eFitter.ProbSegMCS(seg, &s2);
      float chi2 = eFitter.Chi2Seg( seg, &s2 );
 
      EdbSegP s;
      float chi3 = eFitter.Chi2PSeg( s1, s2, s, eCond, eCond );
      float chi0 = eFitter.Chi2SegM( s1, s2, s, eCond, eCond );
      
      float prob0 = (float)TMath::Prob( chi0*chi0, 4);
      float prob2 = (float)TMath::Prob( chi2*chi2, 4);
      float prob3 = (float)TMath::Prob( chi3*chi3, 4);
 
      printf("prob0,prob1, prob2, prob3:  %f %f  %f  %f \n", prob0,prob1, prob2, prob3 );
      prob=prob2;
    }
  }
  else if(eDoUseMCS==2)
  {
    EdbTrackP* t = dynamic_cast<EdbTrackP*> (&s1);
    EdbSegP* seg = t?(const_cast<EdbSegP*>(t->TrackEnd())):0;
    if(seg) {
      float chi = eFitter.Chi2Seg( seg, &s2 );
      prob = (float)TMath::Prob( chi*chi, 4);
    }
  }
  else if(eDoUseMCS==3)  // use coordinate information only (as for alignment)
  {
    EdbSegP s;
    float chi = eFitter.Chi2PSeg( s1, s2, s, eCond, eCond );
    prob = (float)TMath::Prob( chi*chi, 4);
  }
  else
  {
    EdbSegP s;
    float chi = eFitter.Chi2SegM( s1, s2, s, eCond, eCond );
    prob = (float)TMath::Prob( chi*chi, 4);
  }
  
  prob *= eCond.ProbSeg( s2.Theta(), s2.W() );            // the probability component depending on the grains number
  prob *= (float)TMath::Prob( s2.Chi2()*s2.Chi2(), 4 );   // the probability component depending on the segment strength
  return prob;
}

RecalculateSegmentsProb()

void EdbTrackAssembler::RecalculateSegmentsProb

(

EdbTrackP &

t

)

{
    // assumed that track is fitted: reset the segmets probabilities
  int n=tr.N();
  for(int i=0; i<n; i++) 
    tr.GetSegment(i)->SetProb( ProbSeg( *(tr.GetSegmentF(i)),  *(tr.GetSegment(i)) ) ); 
}

SameSegment()

bool EdbTrackAssembler::SameSegment	(	EdbSegP &	s1,
		EdbSegP &	s2
	)

{
  if( Abs( s1.X() - s2.X() )   <0.000001 &&
      Abs( s1.Y() - s2.Y() )   <0.000001 &&
      Abs( s1.TX()- s2.TX() )  <0.000001 &&
      Abs( s1.TY()- s2.TY() )  <0.000001 &&
      Abs( s1.W() - s2.W() )   <0.000001  )    return true;
  return false;
}

SetMomentum()

void EdbTrackAssembler::SetMomentum ( float  p )

inline

{eFitter.ePdef=p;}

SetRadLength()

void EdbTrackAssembler::SetRadLength ( float  x0 )

inline

{eFitter.eX0=x0; eCond.SetRadX0(x0);}

SetSegmentsErrors()

void EdbTrackAssembler::SetSegmentsErrors

(

)

{
  int ntr = eTracks.GetEntriesFast();
    for( int i=0; i<ntr; i++ )     {
      EdbTrackP *t = (EdbTrackP*)(eTracks.At(i));
      if(t->Flag()==-10) continue;
      int nseg=t->N();
      if(nseg>0)  { 
        for(int j=0; j<nseg; j++) {
          EdbSegP *s = t->GetSegment(j);
          s->SetErrors();
          eCond.FillErrorsCov(s->TX(),s->TY(),s->COV());
        }
      }
    }
}

Tracks()

TObjArray& EdbTrackAssembler::Tracks ( )

inline

{return eTracks;}

Member Data Documentation

eCellN

Int_t EdbTrackAssembler::eCellN

private

eCollisionsRate

int EdbTrackAssembler::eCollisionsRate

eCond

EdbScanCond EdbTrackAssembler::eCond

eDoUseMCS

int EdbTrackAssembler::eDoUseMCS

eDRmax

float EdbTrackAssembler::eDRmax

eDTmax

float EdbTrackAssembler::eDTmax

eDZGapMax

float EdbTrackAssembler::eDZGapMax

eFitter

EdbTrackFitter EdbTrackAssembler::eFitter

private

eHistNcnd

TH1F* EdbTrackAssembler::eHistNcnd

eHistProbAll

TH1F* EdbTrackAssembler::eHistProbAll

eHistProbBest

TH1F* EdbTrackAssembler::eHistProbBest

eHistThetaAll

TH1F* EdbTrackAssembler::eHistThetaAll

eHistThetaBest

TH1F* EdbTrackAssembler::eHistThetaBest

eHistTXTYseg

TH2F* EdbTrackAssembler::eHistTXTYseg

eHistXYPseg

TH3F* EdbTrackAssembler::eHistXYPseg

eHistXYPsegNB

TH3F* EdbTrackAssembler::eHistXYPsegNB

eHistXYseg

TH2F* EdbTrackAssembler::eHistXYseg

eMapMarg

Float_t EdbTrackAssembler::eMapMarg

private

eProbMin

float EdbTrackAssembler::eProbMin

eSegments

EdbPattern EdbTrackAssembler::eSegments

private

eTracks

TObjArray EdbTrackAssembler::eTracks

private

eTrZ

TObjArray EdbTrackAssembler::eTrZ

private

eTrZMap

EdbCell2 EdbTrackAssembler::eTrZMap

private

eZ

Float_t EdbTrackAssembler::eZ

private

---

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

• src/libScan/EdbScanTracking.h
• src/libScan/EdbScanTracking.cxx