EdbVertexComb Class Reference

#include <EdbVertexComb.h>

Inheritance diagram for EdbVertexComb:

Collaboration diagram for EdbVertexComb:

Public Member Functions
void	AddTrack (EdbTrackP *t)
EdbVertex *	CheckVTX (TObjArray &tracks)
void	ClearDoublets (TObjArray &topoarr)
void	CopyPar (EdbVertexComb &comb)
	EdbVertexComb ()
	EdbVertexComb (TObjArray &tracks)
int	FindTopologies ()
void	FormVertices ()
EdbTopology *	GetTopology (int i) const
EdbVertex *	GetVertex (int i) const
EdbVertexComb *	GetVertexComb (int i) const
bool	IsAcceptable (EdbVertex &v)
int	Ntr () const
int	Nvtx () const
void	PrintTeoricalCombinations (Int_t n)
void	PrintTopologies ()
void	PrintTracks ()
void	SelectTopologies (TObjArray &topoarr)
void	Set0 ()
void	SetTracksErrors ()
void	SetTracksErrors (EdbScanCond &cond)
void	SetTracksErrors (TObjArray &tracks, EdbScanCond &cond)
void	SortTopologies (TObjArray &topoarr)
virtual	~EdbVertexComb ()

Public Attributes
EdbScanCond	eCond
Int_t	eNProngMinV
	min prongs to accept the vertex for topology calculation More...
TObjArray	eOther
	recursive array of EdbVertexComb objects in multyvertex case More...
Float_t	eProbDetached
	default probability for the detached track (1-prong vertex) More...
Float_t	eProbMinV
	min probability to accept the vertex for topology calculation More...
Int_t	eRecursion
	recursion level (0 - no recursion) More...
Int_t	eRecursionMax
	number of vertex/event to be searched More...
TObjArray	eTopologies
	found EdbTopologies sorted by rating More...
TObjArray	eTracks
	input EdbTracks More...
TObjArray	eVertices
	output vertices More...
EdbVertexPar	eVPar
Float_t	eZ0
	input parameter: the first approximation for the vertex z-position More...

Constructor & Destructor Documentation

EdbVertexComb() [1/2]

EdbVertexComb::EdbVertexComb ( )

inline

{ Set0(); }

EdbVertexComb() [2/2]

EdbVertexComb::EdbVertexComb

(

TObjArray &

tracks

)

{
  Set0();
  eTracks = tracks;
}

~EdbVertexComb()

EdbVertexComb::~EdbVertexComb ( )

virtual

{
}

Member Function Documentation

AddTrack()

void EdbVertexComb::AddTrack ( EdbTrackP *  t )

inline

{ eTracks.Add(t); }

CheckVTX()

EdbVertex * EdbVertexComb::CheckVTX

(

TObjArray &

tracks

)

{
  if(tracks.GetEntries() < 2 ) return 0;
  EdbVertexRec evr(eVPar);
  EdbPVRec *pvr = new EdbPVRec();
  pvr->SetScanCond( new EdbScanCond(eCond) );
  evr.SetPVRec(pvr);
  return evr.Make1Vertex( tracks, eZ0 );
}

ClearDoublets()

void EdbVertexComb::ClearDoublets

(

TObjArray &

topoarr

)

{
  int nremove=1;
  do {
    nremove=0;
    int nt = topoarr.GetEntries(); if(!nt) return;
    for(int i=nt-1; i>0; i--) {
      EdbTopology *t  = (EdbTopology*)topoarr.At(i);
      EdbTopology *tn = (EdbTopology*)topoarr.At(i-1);
      if( t->IsEqual(*tn) ) { topoarr.RemoveAt(i); nremove++; }
    }
    topoarr.Compress();
  } while(nremove);
}

CopyPar()

void EdbVertexComb::CopyPar

(

EdbVertexComb &

comb

)

{
  eRecursionMax   = comb.eRecursionMax;
  eRecursion      = comb.eRecursion;
  eCond           = comb.eCond;
  eVPar           = comb.eVPar;
  eZ0             = comb.eZ0;
  eProbMinV       = comb.eProbMinV;
  eNProngMinV     = comb.eNProngMinV;
}

FindTopologies()

int EdbVertexComb::FindTopologies

(

)

{
  FormVertices();
  eTopologies.Clear();
  SelectTopologies(eTopologies);
  SortTopologies(eTopologies);
  ClearDoublets(eTopologies);
  int n = eTopologies.GetEntries();
  Log(2,"EdbVertexComb::FindTopologies"," %d input tracks, upto %d vtx to search  -> %d topologies found", eTracks.GetEntries(), eRecursionMax, n);
  return n;
}

FormVertices()

void EdbVertexComb::FormVertices

(

)

{
  if( eRecursion >= eRecursionMax )      return;
  int ntr = eTracks.GetEntries();
  if(ntr<eNProngMinV) return;
  if(ntr<2)           return;
  //if(nprongMin<2)   return 0;
 
  //float distMax=100000;
  for( int nitems=eNProngMinV; nitems <= ntr; nitems++ )
  {
    EdbCombGen comber(eTracks,nitems);
    TObjArray selected, other;
    while( comber.NextCombination(selected,other) ) {
       EdbVertex *v = CheckVTX(selected);
       if( v->V()->prob() < eProbMinV )  continue;
       //if( v->MinDist()   > distMax  ) continue;
       eVertices.Add(v);
       if(eRecursion<eRecursionMax) {
         EdbVertexComb *combo = new EdbVertexComb(other);
         combo->CopyPar(*this);
         combo->eRecursion++;
         eOther.Add(combo);
       }
    }
  }
 
  int nvtx = Nvtx();
  //printf("eRecursion = %d   nvtx = %d\n",eRecursion, nvtx);
  
  for(int i=0; i<nvtx; i++)   {
      EdbVertexComb *combo = (EdbVertexComb*)(eOther.At(i));
      if(combo) combo->FormVertices();
  }
}

GetTopology()

EdbTopology * EdbVertexComb::GetTopology ( int  i ) const

inline

{return ((EdbTopology*)(eTopologies.At(i)));}

GetVertex()

EdbVertex * EdbVertexComb::GetVertex ( int  i ) const

inline

{ return (EdbVertex *)eVertices.At(i); }

GetVertexComb()

EdbVertexComb * EdbVertexComb::GetVertexComb ( int  i ) const

inline

{ return (EdbVertexComb *)eOther.At(i); }

IsAcceptable()

bool EdbVertexComb::IsAcceptable

(

EdbVertex &

v

)

{
  if( v.V()->prob() > 0.001 ) return true;
  return false;
}

Ntr()

int EdbVertexComb::Ntr ( ) const

inline

{return eTracks.GetEntries();}

Nvtx()

int EdbVertexComb::Nvtx ( ) const

inline

{return eVertices.GetEntries();}

PrintTeoricalCombinations()

void EdbVertexComb::PrintTeoricalCombinations

(

Int_t

n

)

Print only the first level (1 vertex combinations)

{
  Long_t total=0;
  for(int i=1; i<=n; i++) {
    Long_t ncomb = (Long_t)(Factorial(n)/Factorial(n-i)/Factorial(i));
    printf("%8d of %8d = %16ld \n", i,n,ncomb);
    total +=ncomb;
  }
  printf("total = %ld\n",total);
}

PrintTopologies()

void EdbVertexComb::PrintTopologies

(

)

{
  int n = eTopologies.GetEntries();
  PrintTracks();
  for(int i=0; i<n; i++) GetTopology(i)->Print();
}

PrintTracks()

void EdbVertexComb::PrintTracks

(

)

{
  printf("\n---------------------------- Input Tracks --------------------------------------------------------\n");
  printf("  idtr         X            Y            Z      TX       TY         P    idpl\n");
  printf("--------------------------------------------------------------------------------------------------\n");
  int ntr = eTracks.GetEntries();
  for(int i=0; i<ntr; i++) {
    EdbTrackP *t = (EdbTrackP*)(eTracks.At(i));
    printf("%5d %12.2f %12.2f %12.2f %8.4f %8.4f %8.2f %4d\n"
        ,t->ID(), t->X(), t->Y(), t->Z(), t->TX(), t->TY(), t->P(), t->Plate() );
  }
  printf("--------------------------------------------------------------------------------------------------\n");
}

SelectTopologies()

void EdbVertexComb::SelectTopologies

(

TObjArray &

topoarr

)

{
  int nvtx = eVertices.GetEntries();
  Log(3,"EdbVertexComb::SelectTopologies","nvtx = %d",nvtx);
  if(!nvtx) return;
  for(int i=0; i<nvtx; i++)
  {
    EdbVertex *v = GetVertex(i);
    //if(!IsAcceptable(*v))  continue;
    
    TObjArray newarr;
    int nnew=0;
    EdbVertexComb *combo = GetVertexComb(i);
    if(combo) {
      combo->SelectTopologies(newarr);
      nnew=newarr.GetEntries();
    }
    if(!nnew) { 
      EdbTopology *topa = new EdbTopology();
      topa->AddSingleTracks(combo->eTracks);
      newarr.Add( topa ); 
      nnew+=1;
    }
    for(int j=0; j< nnew; j++) {
       EdbTopology *topa = (EdbTopology *)(newarr.At(j));
       topa->AddVertex( v );
       topoarr.Add( topa );
    }
  }
}

Set0()

void EdbVertexComb::Set0

(

)

{
  eRecursionMax   = 1;
  eRecursion      = 0;
  eZ0             = 0;
  eProbMinV       = 0.001;     // min probability to accept the vertex for topology calculation
  eNProngMinV     = 2;         // min prongs to accept the vertex for topology calculation
}

SetTracksErrors() [1/3]

void EdbVertexComb::SetTracksErrors ( )

inline

{ SetTracksErrors(eTracks,eCond); }

SetTracksErrors() [2/3]

void EdbVertexComb::SetTracksErrors ( EdbScanCond &  cond )

inline

{ eCond = cond; SetTracksErrors(); }

SetTracksErrors() [3/3]

void EdbVertexComb::SetTracksErrors	(	TObjArray &	tracks,
		EdbScanCond &	cond
	)

{
  int n = tracks.GetEntries();
  for(int i=0; i<n; i++) {
     EdbTrackP *t = (EdbTrackP*)tracks.At(i);
     int nseg = t->N();
     for(int j=0; j<nseg; j++) {
       EdbSegP   *s = t->GetSegment(j);
       s->SetErrors0();
       cond.FillErrorsCov( s->TX(),s->TY(), s->COV() );
     }
     t->FitTrackKFS();
  }
}

SortTopologies()

void EdbVertexComb::SortTopologies

(

TObjArray &

topoarr

)

{
  int nt = topoarr.GetEntries();
  TArrayF rating(nt);  TArrayI ind(nt);
  for(int i=0; i<nt; i++)     rating[i] =((EdbTopology*)topoarr.At(i))->Probability();
  Sort( nt, rating.GetArray(), ind.GetArray(), 1 );
  TObjArray tmparr(nt);
  for(int i=0; i<nt; i++)   tmparr.Add( topoarr.At(ind[i]) );
  topoarr.Clear();  topoarr.AddAll( &tmparr );
  
  for(int i=0; i<nt; i++)   ((EdbTopology*)topoarr.At(i))->OrderVtxByZ();
}

Member Data Documentation

eCond

EdbScanCond EdbVertexComb::eCond

eNProngMinV

Int_t EdbVertexComb::eNProngMinV

min prongs to accept the vertex for topology calculation

eOther

TObjArray EdbVertexComb::eOther

recursive array of EdbVertexComb objects in multyvertex case

eProbDetached

Float_t EdbVertexComb::eProbDetached

default probability for the detached track (1-prong vertex)

eProbMinV

Float_t EdbVertexComb::eProbMinV

min probability to accept the vertex for topology calculation

eRecursion

Int_t EdbVertexComb::eRecursion

recursion level (0 - no recursion)

eRecursionMax

Int_t EdbVertexComb::eRecursionMax

number of vertex/event to be searched

eTopologies

TObjArray EdbVertexComb::eTopologies

found EdbTopologies sorted by rating

eTracks

TObjArray EdbVertexComb::eTracks

input EdbTracks

eVertices

TObjArray EdbVertexComb::eVertices

output vertices

eVPar

EdbVertexPar EdbVertexComb::eVPar

eZ0

Float_t EdbVertexComb::eZ0

input parameter: the first approximation for the vertex z-position

---

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

• /home/antonio/fedra_doxygen/src/libEdr/EdbVertexComb.h
• /home/antonio/fedra_doxygen/src/libEdr/EdbVertexComb.cxx