EdbTrackAssembler Class Reference

generic class for the tracks assembling from segments More...

#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)
	owner of the segments!!! More...
EdbTrackP *	AddSegmentAsTrack (EdbSegP &s)
void	CheckPatternAlignment (EdbPattern &p, EdbPlateP &plate, int nsegmin)
void	CombTracks (TObjArray &selected)
void	DoubletsFilterOut (EdbPattern &p)
	EdbTrackAssembler ()
void	ExtrapolateTracksToZ (float z, int nsegmin=0)
void	FillTrZMap ()
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
bool	eDoUseMCS
	flag to use MultipleScattering addition for chi2 More...
float	eDRmax
	position acceptance for the fast preselection More...
float	eDTmax
	angular acceptance for the fast preselection More...
float	eDZGapMax
	maxgap acceptance for the fast preselection More...
TH1F *	eHistNcnd
	number of candidates after preliminary selection More...
TH1F *	eHistProbAll
	prob of all candidate More...
TH1F *	eHistProbBest
	prob of the best candidate More...
TH1F *	eHistThetaAll
	theta of all candidate More...
TH1F *	eHistThetaBest
	theta of the best candidate More...
float	eProbMin
	min acceptable probability for segments preselection More...

Private Attributes
Int_t	eCellN
	mean cell occupancy More...
EdbTrackFitter	eFitter
Float_t	eMapMarg
	margin for the map creation More...
EdbPattern	eSegments
	all segments of tracks More...
TObjArray	eTracks
	array of tracks (EdbTrackP) (owner of tracks) More...
TObjArray	eTrZ
	"predictions" - tracks extrapolated to the given z (not owner) More...
EdbCell2	eTrZMap
	map of predictions at given eZ More...
Float_t	eZ
	the z-position More...

Detailed Description

generic class for the tracks assembling from segments

//////////////////////////////////////////////////////////////////////// // EdbScanTracking // // To handle tracking in the scanset (IO) // // ////////////////////////////////////////////////////////////////////////

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());
 
    // 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.GetEntries();
    //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( *(p.GetSegment(j)) ) )
      AddSegmentAsTrack( *(p.GetSegment(j)) );
    else attached++;
  }
  int ntrAfter = eTracks.GetEntries();
    //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; total collisions: %d;  tracks: %d",
      p.Z(), attached, nseg, eCollisionsRate, ntrAfter );
}

AddSegment()

EdbTrackP * EdbTrackAssembler::AddSegment

(

EdbSegP &

s

)

owner of the segments!!!

{
  TObjArray trsel;
  float v[2] = { s.X(), s.Y() };
  int nsel =  eTrZMap.SelectObjectsC( v, eDRmax+50 , trsel );
  Log(3,"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(3,"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) );
        eCollisionsRate++;
      }
    }
    return t;
}

AddSegmentAsTrack()

EdbTrackP * EdbTrackAssembler::AddSegmentAsTrack

(

EdbSegP &

s

)

{
  if(s.W()<16    )  return 0;
  if(s.Chi2()>2.5)  return 0;
  EdbTrackP *t = new EdbTrackP( eSegments.AddSegment(s), 0.139);    // EdbTrackAssembler is owner of segments 
  eTracks.Add(t);
    //EdbSegP ss;
    //t->MakePredictionTo(eZ,ss);
    //eTrZ.AddSegment(ss);
  return t;
}

CheckPatternAlignment()

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

{
  Log(0,"EdbTrackAssembler::CheckPatternAlignment","");
  
  ExtrapolateTracksToZ( p.Z(), nsegmin);
  int ntr = eTrZ.GetEntries();
  EdbPattern ptr( 0, 0, p.Z(), ntr ); 
  for(int i=0; i<ntr; i++) ptr.AddSegment( *((EdbSegP*)(eTrZ.UncheckedAt(i))) );
    
  EdbPlateAlignment al;
  al.SetSigma( 25, 0.015 );
  al.eOffsetMax = 500.;
  al.eDZ        = 0;
  al.eDPHI      = 0.00;
    //al.eDoCoarse=1;
  al.Align(ptr,p,0);
  
  EdbAffine2D *aff = al.eCorrL[0].GetAffineXY();
  aff->Invert();
  aff->Print();
  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.GetEntries();
  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.GetEntries();
  for(int i=nn-1; i>=0; i--) {
    cp = cn.At(i);                              // tracks with fixed npl
    int np = cp->GetEntries();
    for(int ip=np-1; ip>=0; ip--) {
      c = cp->At(ip);                           // tracks with fixed Npl & Prob
      int nt = c->GetEntries();
      for(int it=0; it<nt; it++) {
        tr = (EdbTrackP*)(eTracks.At( c->At(it)->Value() ) );
        tr->SetSegmentsTrack();
      }
    }
  }
  
  
  cp=0;   c=0;
  nn=cn.GetEntries();
  for(int i=0; i<nn; i++) {
    cp = cn.At(i);                              // tracks with fixed npl
 
    int np = cp->GetEntries();
    for(int ip=0; ip<np; ip++) {
      c = cp->At(ip);                           // tracks with fixed Npl & Prob
 
      int nt = c->GetEntries();
      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.GetEntries();
  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);                        // extrapolation of tracks itself
      //((EdbSegP *)t)->PrintNice();
    eTrZ.Add(t);
  }
    
    //FillTrZMap();
    //if(gEDBDEBUGLEVEL>2) eTrZMap.PrintStat();
}

FillTrZMap()

void EdbTrackAssembler::FillTrZMap

(

)

{
  int n=eTrZ.GetEntries();
  Log(2,"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 );
  }
}

FitTracks()

void EdbTrackAssembler::FitTracks

(

)

{
  EdbTrackFitter fit;
 
  int ntr = eTracks.GetEntries();
  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
	)

return the probability that the second segment can belong to track defined by s1

workaround to get previous(not propagated) segment

{
  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==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);
    }
    if(prob<0.001&&gEDBDEBUGLEVEL>2) {
      Log(3,"EdbTrackAssembler::ProbSeg", "dx,dy,dz,dtx,dty: %f %f %f %f %f  prob= %f",dx,dy,dz,dtx,dty, prob);
      seg->Print();
      s2.Print();
      eCond.Print();
    }
 
   }
   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 proability component depending on the grains number
  prob *= (float)TMath::Prob( s2.Chi2()*s2.Chi2(), 4 );   // the proability 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.GetEntries();
    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

mean cell occupancy

eCollisionsRate

int EdbTrackAssembler::eCollisionsRate

eCond

EdbScanCond EdbTrackAssembler::eCond

eDoUseMCS

bool EdbTrackAssembler::eDoUseMCS

flag to use MultipleScattering addition for chi2

eDRmax

float EdbTrackAssembler::eDRmax

position acceptance for the fast preselection

eDTmax

float EdbTrackAssembler::eDTmax

angular acceptance for the fast preselection

eDZGapMax

float EdbTrackAssembler::eDZGapMax

maxgap acceptance for the fast preselection

eFitter

EdbTrackFitter EdbTrackAssembler::eFitter

private

eHistNcnd

TH1F* EdbTrackAssembler::eHistNcnd

number of candidates after preliminary selection

eHistProbAll

TH1F* EdbTrackAssembler::eHistProbAll

prob of all candidate

eHistProbBest

TH1F* EdbTrackAssembler::eHistProbBest

prob of the best candidate

eHistThetaAll

TH1F* EdbTrackAssembler::eHistThetaAll

theta of all candidate

eHistThetaBest

TH1F* EdbTrackAssembler::eHistThetaBest

theta of the best candidate

eMapMarg

Float_t EdbTrackAssembler::eMapMarg

private

margin for the map creation

eProbMin

float EdbTrackAssembler::eProbMin

min acceptable probability for segments preselection

eSegments

EdbPattern EdbTrackAssembler::eSegments

private

all segments of tracks

eTracks

TObjArray EdbTrackAssembler::eTracks

private

array of tracks (EdbTrackP) (owner of tracks)

eTrZ

TObjArray EdbTrackAssembler::eTrZ

private

"predictions" - tracks extrapolated to the given z (not owner)

eTrZMap

EdbCell2 EdbTrackAssembler::eTrZMap

private

map of predictions at given eZ

eZ

Float_t EdbTrackAssembler::eZ

private

the z-position

---

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

• /home/antonio/fedra_doxygen/src/libScan/EdbScanTracking.h
• /home/antonio/fedra_doxygen/src/libScan/EdbScanTracking.cxx