EdbView Class Reference

#include <EdbView.h>

Inheritance diagram for EdbView:

Collaboration diagram for EdbView:

Public Member Functions
EdbCluster *	AddCluster (EdbCluster *c)
EdbCluster *	AddCluster (float x, float y, float z, float a, float v, int f, int s, int seg=-1)
void	AddFrame (EdbFrame *frame)
void	AddFrame (int id, float z, int ncl=0, int npix=0)
EdbSegment *	AddSegment (EdbSegment &s)
void	AddSegment (EdbSegment *s)
EdbSegment *	AddSegment (float x, float y, float z, float tx, float ty, float dz=0, int side=0, int puls=0, int id=-1)
void	AddTrack (EdbTrack *t)
int	AttachClustersToSegments ()
int	AttachClustersToSegmentsFast ()
int	AttachClustersToSegmentsSlow ()
int	AttachSegmentsToTracks ()
void	Clear ()
void	DeleteClustersFog ()
void	Draw (Option_t *option="")
TPolyMarker3D *	DrawClustersFog (Option_t *opt=0) const
TPolyMarker3D *	DrawClustersSegments (Option_t *opt=0) const
	EdbView ()
void	GenerateClustersFog (float density)
void	GenerateClustersSegment (EdbSegment *segment, int n0=25, float sigma=.1)
void	GenerateClustersTrack (EdbTrack *track, int n0=25, float sigma=.1)
void	GenerateFrames (int n=32)
Int_t	GetAreaID () const
EdbCluster *	GetCluster (int i) const
TClonesArray *	GetClusters () const
void *	GetClustersAddr ()
TList *	GetClustersFrame (int frame) const
Float_t	GetDZbot () const
Float_t	GetDZtop () const
EdbFrame *	GetFrame (int i) const
TClonesArray *	GetFrames () const
void *	GetFramesAddr ()
EdbViewHeader *	GetHeader () const
void *	GetHeaderAddr ()
Long_t	GetLastSystemTime () const
Int_t	GetNframes () const
Int_t	GetNframesBot () const
Int_t	GetNframesTop () const
EdbSegment *	GetSegment (int i) const
TClonesArray *	GetSegments () const
void *	GetSegmentsAddr ()
TObjArray *	GetSegmentsClusters () const
Int_t	GetTime () const
EdbTrack *	GetTrack (int i) const
TClonesArray *	GetTracks () const
void *	GetTracksAddr ()
Int_t	GetViewID () const
Float_t	GetXview () const
Float_t	GetYview () const
Float_t	GetZ0bot () const
Float_t	GetZ0top () const
Float_t	GetZ1 () const
Float_t	GetZ2 () const
Float_t	GetZ3 () const
Float_t	GetZ4 () const
Int_t	Nclusters () const
Int_t	Nsegments () const
Int_t	Ntracks () const
void	Print (Option_t *opt=0) const
void	PrintClusters (Option_t *opt=0) const
Int_t	ReadView (char *fname)
void	Scale (float zscale)
void	SetAreaID (int id)
void	SetCoordXY (float x, float y)
void	SetCoordZ (float z1, float z2, float z3, float z4)
void	SetLastSystemTime (Long_t time)
void	SetNframes (int top, int bot)
void	Shift (float zshift)
void	Transform (const EdbAffine2D *aff)
float	Xmin () const
float	Ymin () const
float	ZFrameMax () const
float	ZFrameMin () const
float	Zmax () const
float	Zmin () const
virtual	~EdbView ()

Private Attributes
TClonesArray *	eClusters
TClonesArray *	eFrames
EdbViewHeader *	eHeader
Long_t	eLastSystemTime
TClonesArray *	eSegments
TClonesArray *	eTracks

Constructor & Destructor Documentation

EdbView()

EdbView::EdbView

(

)

~EdbView()

EdbView::~EdbView ( )

virtual

{
  //  Clear();
 
  if(eClusters)  { eClusters->Delete(); SafeDelete(eClusters); }
  if(eSegments)  { eSegments->Delete(); SafeDelete(eSegments); }
  if(eTracks)    { eTracks->Delete();   SafeDelete(eTracks);   }
  if(eHeader)    SafeDelete(eHeader);
  if(eFrames)    { eFrames->Delete();   SafeDelete(eFrames);   }
}

Member Function Documentation

AddCluster() [1/2]

EdbCluster* EdbView::AddCluster ( EdbCluster *  c )

inline

    {return (EdbCluster*)(new((*eClusters)[eClusters->GetLast()+1])  EdbCluster( *c )); }

AddCluster() [2/2]

EdbCluster* EdbView::AddCluster ( float  x, float  y, float  z, float  a, float  v, int  f, int  s, int  seg = -1  )

inline

    {return (EdbCluster*)(new((*eClusters)[eClusters->GetLast()+1])  EdbCluster(x,y,z, a,v,f,s,seg)); }

AddFrame() [1/2]

void EdbView::AddFrame

(

EdbFrame *

frame

)

{
  int i = eFrames->GetLast()+1;
  new((*eFrames)[i++])  EdbFrame( *frame );
 
  //printf("EdbView::AddFrame: \n");
  //frame->Print();
}

AddFrame() [2/2]

void EdbView::AddFrame	(	int	id,
		float	z,
		int	ncl = 0,
		int	npix = 0
	)

{
  int i = eFrames->GetLast()+1;
  new((*eFrames)[i++])  EdbFrame( id,z,ncl,npix );
}

AddSegment() [1/3]

EdbSegment * EdbView::AddSegment

(

EdbSegment &

s

)

{
  // return directly pointer to the segment
  int i = eSegments->GetLast()+1;
  return new((*eSegments)[i++])  EdbSegment( s );
}

AddSegment() [2/3]

void EdbView::AddSegment

(

EdbSegment *

s

)

{
  int i = eSegments->GetLast()+1;
  new((*eSegments)[i++])  EdbSegment( *s );
}

AddSegment() [3/3]

EdbSegment* EdbView::AddSegment ( float  x, float  y, float  z, float  tx, float  ty, float  dz = 0, int  side = 0, int  puls = 0, int  id = -1  )

inline

    {return (EdbSegment*)(new((*eSegments)[eSegments->GetLast()+1])  EdbSegment(x,y,z, tx,ty, dz, side, puls, id)); }

AddTrack()

void EdbView::AddTrack

(

EdbTrack *

t

)

{
  int i = eTracks->GetLast()+1;
  new((*eTracks)[i++])  EdbTrack( *t );
}

AttachClustersToSegments()

int EdbView::AttachClustersToSegments

(

)

{
  int nca=-1;
  nca = AttachClustersToSegmentsFast();
  if(nca<0)  {
    nca = AttachClustersToSegmentsSlow();
    printf("AttachClustersToSegments: segments do not sorted - use slow algorithm!\n");
  }
  return nca;
}

AttachClustersToSegmentsFast()

int EdbView::AttachClustersToSegmentsFast

(

)

{
  // assume that cluster->GetSegment() == segment entry :
 
  EdbCluster *cl=0;
  int ncl = eClusters->GetLast()+1;
  EdbSegment *seg=0;
  int nseg = eSegments->GetLast()+1;
 
  // TODO: why elements not cleared???
 
//    for(int is=0; is<nseg; is++){
//      seg = (EdbSegment*)(eSegments->UncheckedAt(is));
//      if(seg->GetNelements()>0) seg->GetElements()->Clear();
//    }
 
  int iseg;
  int nca=0;
  for(int i=0; i<ncl; i++){
    cl = (EdbCluster*)(eClusters->UncheckedAt(i));
    iseg=cl->GetSegment();
    if( iseg < 0 )      continue;
    if( iseg > nseg-1 ) return -1;
    seg = (EdbSegment*)(eSegments->At(iseg));
    seg->AddElement(cl);
    nca++;
    if(seg->GetNelements()>seg->GetPuls()) {
      printf("AttachClustersToSegmentsFast: ncl(%d) > puls(%d)    %d\n", 
         seg->GetNelements(),seg->GetPuls(), seg->GetID());
      printf("Area: %d View: %d  Segment: %d, i,iseg = %d %d\n",GetAreaID(), GetViewID(), seg->GetID(), i,iseg);
    }
 
  }
  return nca;
}

AttachClustersToSegmentsSlow()

int EdbView::AttachClustersToSegmentsSlow

(

)

{
  // if segments do not ordered :
 
  EdbCluster *cl=0;
  int ncl = eClusters->GetLast()+1;
 
  EdbSegment *seg=0;
  int nseg = eSegments->GetLast()+1;
  int id,nca=0;
  for(int is=0; is<nseg; is++){
    seg = (EdbSegment*)(eSegments->UncheckedAt(is));
    if(seg->GetNelements()>0) seg->GetElements()->Clear();
    id = seg->GetID();
    for(int i=0; i<ncl; i++){
      cl = (EdbCluster*)(eClusters->UncheckedAt(i));
      if( cl->GetSegment() != id ) continue;
      seg->AddElement(cl);
      nca++;
    }
  }
  return nca;
}

AttachSegmentsToTracks()

int EdbView::AttachSegmentsToTracks

(

)

{
  // Assumed that:
  // tracks.eID                       - number of segments in a track
  // Segments are written consecutively in the order they appear in microtracks (i.e. m0c0,m0c1,m0c2,m1c0,m1c1,m2c0,m2c1...)
 
  int nseg = eSegments->GetLast()+1; if(nseg<1) return 0;
  int ntr = eTracks->GetLast()+1;     if(ntr<1) return 0;
 
  int icnt=0;
  for(int itr=0; itr<ntr; itr++)
  {
    EdbTrack *t = (EdbTrack*)(eTracks->UncheckedAt(itr));
    if(!t) continue;
    int nst = t->GetID(); if(nst<1) continue;
    if( t->GetElements() ) t->GetElements()->Clear();
    for(int ist=0; ist<nst; ist++)
    {
      if(icnt >= nseg) break;
      EdbSegment *s = (EdbSegment*)(eSegments->UncheckedAt(icnt++));
      if(s) t->AddElement(s);
    }
  }
  Log(3,"EdbView::AttachSegmentsToTracks", "ntr = %d nseg = %d icnt = %d",ntr,nseg,icnt);
  return icnt;
}

Clear()

void EdbView::Clear

(

)

{
  if(eClusters) { eClusters->Clear(); }
  if(eSegments) { 
    TObjArray *e=0;
    for(int i=0; i<Nsegments(); i++) {
      e=((EdbSegment*)eSegments->At(i))->GetElements();
      if( e ) e->Clear();
    }
    eSegments->Clear(); 
  }
  if(eTracks)   { eTracks->Clear();   }
  if(eFrames)   { eFrames->Clear();   }
}

DeleteClustersFog()

void EdbView::DeleteClustersFog

(

)

{
  EdbCluster     *cluster  =0;
 
  int ncl = Nclusters();
  for( int icl=0; icl<ncl; icl++) {
    cluster = (EdbCluster*)(eClusters->UncheckedAt(icl));
    if( cluster->GetSegment() < 0 )     eClusters->Remove(cluster);
  }
 
  eClusters->Compress();
}

Draw()

void EdbView::Draw

(

Option_t *

option = ""

)

{
  float xmin=-200, xmax=200;
  float ymin=-150, ymax=150;
  //float xmin=GetXview()-500, xmax=xmin+1000.;
  //float ymin=GetYview()-500, ymax=ymin+1000.;
 
  float zmin = TMath::Min( GetZ1(), GetZ4() );
  float zmax = TMath::Max( GetZ1(), GetZ4() );
 
  TH3F *hist = new TH3F("hist","title",1,xmin,xmax,1,ymin,ymax,1,zmin,zmax);
  //TH3F *hist = new TH3F("hist","title",1,0,512,1,0,512,1,zmin,zmax);
 
  hist->Draw();
 
  if(eClusters) {
    TPolyMarker3D *marksFog = DrawClustersFog();
    marksFog->SetMarkerColor(kBlue);
    marksFog->SetMarkerStyle(21);
    marksFog->SetMarkerSize(.3);
    marksFog->Draw();
 
    TPolyMarker3D *marksSeg = DrawClustersSegments();
    marksSeg->SetMarkerColor(kRed);
    marksSeg->SetMarkerStyle(21);
    marksSeg->SetMarkerSize(.3);
    marksSeg->Draw();
  }
 
  if(eTracks) {
    // Draw tracks ....
 
    EdbTrack   *tr = 0;
    int ntr = Ntracks();
    
    for(int itr=0; itr<ntr; itr++) {
      tr = (EdbTrack*)eTracks->At(itr);
      
      TPolyLine3D *line = new TPolyLine3D(2);
      line->SetPoint(0, tr->GetX0(), tr->GetY0(), tr->GetZ0() );
      line->SetPoint(1, 
             tr->GetX0() + tr->GetTx()*tr->GetDz(),
             tr->GetY0() + tr->GetTy()*tr->GetDz(),
             tr->GetZ0()+              tr->GetDz() );
 
      line->SetLineColor(kGreen);
      line->SetLineWidth(10);
      line->Draw();
    }
  }
 
  if(eSegments) {
    // Draw segments ....
 
    EdbSegment   *seg = 0;
    int nseg =  Nsegments();
 
    for(int iseg=0; iseg<nseg; iseg++) {
      seg = (EdbSegment*)eSegments->At(iseg);
      
      TPolyLine3D *line = new TPolyLine3D(2);
      line->SetPoint(0, seg->GetX0(), seg->GetY0(), seg->GetZ0() );
      line->SetPoint(1, 
             seg->GetX0() + seg->GetTx()*seg->GetDz(),
             seg->GetY0() + seg->GetTy()*seg->GetDz(),
             seg->GetZ0()+               seg->GetDz() );
      line->Draw();
    }
  }
 
}

DrawClustersFog()

TPolyMarker3D * EdbView::DrawClustersFog

(

Option_t *

opt = 0

)

const

{
  EdbCluster *cluster=0;
  int ncl = eClusters->GetLast()+1;
 
  TPolyMarker3D *marks = new TPolyMarker3D(ncl,1);
 
  for(int i=0; i<ncl; i++){
    cluster = (EdbCluster*)(eClusters->At(i));
    if( cluster->GetSegment() < 0 ) 
      marks->SetNextPoint( cluster->GetX(), cluster->GetY(), cluster->GetZ() );
  }
  return marks;
}

DrawClustersSegments()

TPolyMarker3D * EdbView::DrawClustersSegments

(

Option_t *

opt = 0

)

const

{
  EdbCluster *cluster=0;
  int ncl = eClusters->GetLast()+1;
 
  TPolyMarker3D *marks = new TPolyMarker3D(ncl,1);
 
  for(int i=0; i<ncl; i++){
    cluster = (EdbCluster*)(eClusters->At(i));
    if( cluster->GetSegment() >= 0 ) 
      marks->SetNextPoint( cluster->GetX(), cluster->GetY(), cluster->GetZ() );
  }
  return marks;
}

GenerateClustersFog()

void EdbView::GenerateClustersFog

(

float

density

)

{
  float  x1=0, x2=512;
  float  y1=0, y2=512;
 
  float x=0,y=0,z=0; 
  int   area=0, volume=0, frame=0, side=0;
 
  float z1 = GetZ1();
  float z2 = GetZ2();
  float z3 = GetZ3();
  float z4 = GetZ4();
 
  float activeVolume = TMath::Abs((x2-x1)*(y2-y1)*( z2-z1 + z4-z3 ));
  int   nClusters    = (int)( density*activeVolume/(10*10*10) );
 
  int   ft = GetNframesTop();
  int   fb = GetNframesBot();
  int   nf = ft+fb;
 
  for( int i=0; i<nClusters; i++ ){
 
    frame = gRandom->Integer( nf );
    if( frame < ft )   {
      side = 0;
      z    = z1 + (z2-z1)/ft * frame;
    }
    else {
      side = 1;
      z    = z3 + (z4-z3)/fb * (frame-ft);
    }
  
    x      = x1 + gRandom->Rndm()*(x2-x1);
    y      = y1 + gRandom->Rndm()*(y2-y1);
    area   = (int)gRandom->Exp(5);
    volume = gRandom->Poisson(50);
 
    AddCluster(x,y,z, area,volume, frame, side);
  }
}

GenerateClustersSegment()

void EdbView::GenerateClustersSegment	(	EdbSegment *	segment,
		int	n0 = 25,
		float	sigma = .1
	)

{
  //    n0    - mean number of grains/100 microns
  //    sigma - XY dispersion in microns
 
  float xmin = 0;
  float ymin = 0;
  float xmax = 512;
  float ymax = 512;
 
  float  length0  = 100./n0;    // mean flight length [microns]
 
  float x0 = segment->GetX0();
  float y0 = segment->GetY0();
  float z0 = segment->GetZ0();
  float dz = segment->GetDz();
  float x=0,y=0,z=0;
  float path=0;
  int area=0, volume=0, frame=-1;
  int side=segment->GetSide();
  int seg=segment->GetID();
 
  float tx = segment->GetTx();
  float ty = segment->GetTy();
 
  length0 = length0/sqrt( 1 + tx*tx + ty*ty );
 
  int ncl=0;
 
  while( 1 ) {
    path += gRandom->Exp(length0); 
    if( path>dz)   break;
    z = z0+path;
    x = x0 + tx*path + gRandom->Gaus(0,sigma);
    y = y0 + ty*path + gRandom->Gaus(0,sigma);
 
    if( x < xmin )   continue;
    if( x > xmax )   continue;
    if( y < ymin )   continue;
    if( y > ymax )   continue;
 
    volume = gRandom->Poisson(50);
    AddCluster(x,y,z, area, volume, frame, side, seg );
    ncl++;
  }
  segment->SetPuls(ncl);
}

GenerateClustersTrack()

void EdbView::GenerateClustersTrack	(	EdbTrack *	track,
		int	n0 = 25,
		float	sigma = .1
	)

{
  EdbSegment segment;
 
  int  count = Nsegments();
  float x0 = track->GetX0();
  float y0 = track->GetY0();
  float z1 = GetZ1();
  float z2 = GetZ2();
  float z3 = GetZ3();
  float z4 = GetZ4();
  float tx = track->GetTx();
  float ty = track->GetTy();
 
  segment.Set( x0,y0,  z1, tx, ty, z2-z1, 0, -1, count );
  AddSegment(&segment);
  GenerateClustersSegment( GetSegment(Nsegments()-1), 25, .3 );
 
  x0 = x0 + (z3-z1)*tx;
  y0 = y0 + (z3-z1)*ty;
  count = Nsegments();
 
  segment.Set( x0,y0,  z3, tx, ty, z4-z3, 1, -1, count );
  AddSegment(&segment);
  GenerateClustersSegment( GetSegment(Nsegments()-1), 25, .3 );
}

GenerateFrames()

void EdbView::GenerateFrames

(

int

n = 32

)

{
  if(eFrames) eFrames->Clear();
 
  EdbFrame *frame=0;
 
  for( int ifr=0; ifr<n; ifr++) {
    frame = new EdbFrame( ifr,2,3,"123456" );
    AddFrame(frame);
  }
}

GetAreaID()

Int_t EdbView::GetAreaID ( ) const

inline

{ if(eHeader) return GetHeader()->GetAreaID(); else return 0;}

GetCluster()

EdbCluster* EdbView::GetCluster ( int  i ) const

inline

{ return (EdbCluster*)eClusters->At(i); }

GetClusters()

TClonesArray* EdbView::GetClusters ( ) const

inline

{ return eClusters; }

GetClustersAddr()

void* EdbView::GetClustersAddr ( )

inline

{ return &eClusters; }

GetClustersFrame()

TList * EdbView::GetClustersFrame

(

int

frame

)

const

{
  TList *list = new TList();
 
  EdbCluster *cluster=0;
  int ncl = eClusters->GetLast()+1;
 
  for(int i=0; i<ncl; i++){
    cluster = (EdbCluster*)(eClusters->UncheckedAt(i));
    if( cluster->GetFrame() == frame )  list->Add(cluster);
  }
  return list;
}

GetDZbot()

Float_t EdbView::GetDZbot ( ) const

inline

{ if(eHeader) return GetHeader()->GetDZbot();  else return 0; }

GetDZtop()

Float_t EdbView::GetDZtop ( ) const

inline

{ if(eHeader) return GetHeader()->GetDZtop();  else return 0; }

GetFrame()

EdbFrame* EdbView::GetFrame ( int  i ) const

inline

{ return (EdbFrame*)eFrames->At(i); }

GetFrames()

TClonesArray* EdbView::GetFrames ( ) const

inline

{ return eFrames;   }

GetFramesAddr()

void* EdbView::GetFramesAddr ( )

inline

{ return &eFrames;   }

GetHeader()

EdbViewHeader* EdbView::GetHeader ( ) const

inline

{ return eHeader;   }

GetHeaderAddr()

void* EdbView::GetHeaderAddr ( )

inline

{ return &eHeader;   }

GetLastSystemTime()

Long_t EdbView::GetLastSystemTime ( ) const

inline

{ return eLastSystemTime; }

GetNframes()

Int_t EdbView::GetNframes ( ) const

inline

{ return GetNframesTop()+GetNframesBot(); }

GetNframesBot()

Int_t EdbView::GetNframesBot ( ) const

inline

{ if(eHeader) return GetHeader()->GetNframesBot();   else return 0;  }

GetNframesTop()

Int_t EdbView::GetNframesTop ( ) const

inline

{ if(eHeader) return GetHeader()->GetNframesTop();   else return 0;  }

GetSegment()

EdbSegment* EdbView::GetSegment ( int  i ) const

inline

{ return (EdbSegment*)eSegments->At(i); }

GetSegments()

TClonesArray* EdbView::GetSegments ( ) const

inline

{ return eSegments; }

GetSegmentsAddr()

void* EdbView::GetSegmentsAddr ( )

inline

{ return &eSegments; }

GetSegmentsClusters()

TObjArray * EdbView::GetSegmentsClusters

(

)

const

{
  int nseg = eSegments->GetLast()+1;
  TObjArray *segments = new TObjArray(nseg);
  
  EdbSegment *seg1=0, *seg2=0;
  
  for(int iseg=0; iseg<nseg; iseg++) {
    seg1 = (EdbSegment*)eSegments->At(iseg);
    seg2 = new EdbSegment(*seg1);
    segments->Add(seg2);
  }
 
  EdbCluster *cl1=0, *cl2=0;
 
  int ncl = eClusters->GetLast()+1;
  int segID=-1;
 
  for(int i=0; i<ncl; i++) {
    cl1 = (EdbCluster*)eClusters->At(i);
    segID = cl1->GetSegment();
    if( segID < 0)      continue;
    if( segID > nseg)   continue;
    cl2 = new EdbCluster(*cl1);
    seg1 = (EdbSegment*)segments->At(segID);
    seg1->AddElement(cl2);
  }
    
  return segments;
}

GetTime()

Int_t EdbView::GetTime ( ) const

inline

{ if(eHeader) return GetHeader()->GetTime();  else return 0;  }

GetTrack()

EdbTrack* EdbView::GetTrack ( int  i ) const

inline

{ return (EdbTrack*)eTracks->At(i); }

GetTracks()

TClonesArray* EdbView::GetTracks ( ) const

inline

{ return eTracks;   }

GetTracksAddr()

void* EdbView::GetTracksAddr ( )

inline

{ return &eTracks;   }

GetViewID()

Int_t EdbView::GetViewID ( ) const

inline

{ if(eHeader) return GetHeader()->GetViewID(); else return 0;}

GetXview()

Float_t EdbView::GetXview ( ) const

inline

{ if(eHeader) return GetHeader()->GetXview();  else return 0; }

GetYview()

Float_t EdbView::GetYview ( ) const

inline

{ if(eHeader) return GetHeader()->GetYview();  else return 0; }

GetZ0bot()

Float_t EdbView::GetZ0bot ( ) const

inline

{ if(eHeader) return GetHeader()->GetZ0bot();  else return 0; }

GetZ0top()

Float_t EdbView::GetZ0top ( ) const

inline

{ if(eHeader) return GetHeader()->GetZ0top();  else return 0; }

GetZ1()

Float_t EdbView::GetZ1 ( void  ) const

inline

{ if(eHeader) return GetHeader()->GetZ1();  else return 0; }

GetZ2()

Float_t EdbView::GetZ2 ( void  ) const

inline

{ if(eHeader) return GetHeader()->GetZ2();  else return 0; }

GetZ3()

Float_t EdbView::GetZ3 ( void  ) const

inline

{ if(eHeader) return GetHeader()->GetZ3();  else return 0; }

GetZ4()

Float_t EdbView::GetZ4 ( void  ) const

inline

{ if(eHeader) return GetHeader()->GetZ4();  else return 0; }

Nclusters()

Int_t EdbView::Nclusters ( ) const

inline

{ return eClusters->GetLast()+1; }

Nsegments()

Int_t EdbView::Nsegments ( ) const

inline

{ return eSegments->GetLast()+1; }

Ntracks()

Int_t EdbView::Ntracks ( ) const

inline

{ return eTracks->GetLast()+1; }

Print()

void EdbView::Print

(

Option_t *

opt = 0

)

const

{
  printf("\nEdbView: ");
  if(eClusters) printf(  "\t %d clusters\n", eClusters->GetLast()+1);
  if(eSegments) printf("\t\t %d segments\n", eSegments->GetLast()+1);
  if(eTracks)   printf("\t\t %d tracks  \n", eTracks->GetLast()+1);
  if(eFrames)   printf("\t\t %d frames  \n", eFrames->GetLast()+1);
  eHeader->Print();
}

PrintClusters()

void EdbView::PrintClusters

(

Option_t *

opt = 0

)

const

{
  EdbCluster     *cluster  =0;
 
  int ncl = eClusters->GetLast()+1;
  for( int icl=0; icl<ncl; icl++) {
    cluster = (EdbCluster*)(eClusters->UncheckedAt(icl));
    cluster->Print();
  }  
}

ReadView()

int EdbView::ReadView

(

char *

fname

)

{
  FILE *fp = fopen(fname,"r");
  fclose(fp);
  return 0;
}

Scale()

void EdbView::Scale

(

float

zscale

)

{
  // scale all z coordinates and angles to the given factor
  EdbCluster *c=0;
  EdbSegment *s=0;
  EdbTrack   *t=0;
  if(eClusters) {
    int ncl=Nclusters();
    for( int i=0; i<ncl; i++ ) {  
      c = GetCluster(i); 
      c->SetZ( c->GetZ()*zscale ); 
    }
  }
  if(eSegments) {
    int nseg=Nsegments();
    for( int i=0; i<nseg; i++ ) { 
      s = GetSegment(i); 
      s->SetZ0( s->GetZ0()*zscale ); 
      s->SetTx( s->GetTx()/zscale ); 
      s->SetTy( s->GetTy()/zscale ); 
    }
  }
  if(eTracks) {
    int ntr=Ntracks();
    for( int i=0; i<ntr; i++ ) {
      t = GetTrack(i);
      t->SetZ0( t->GetZ0()*zscale ); 
      t->SetTx( t->GetTx()/zscale ); 
      t->SetTy( t->GetTy()/zscale );
    }
  }
}

SetAreaID()

void EdbView::SetAreaID ( int  id )

inline

{ GetHeader()->SetAreaID(id); }

SetCoordXY()

void EdbView::SetCoordXY ( float  x, float  y  )

inline

{ GetHeader()->SetCoordXY(x,y); }

SetCoordZ()

void EdbView::SetCoordZ ( float  z1, float  z2, float  z3, float  z4  )

inline

    { GetHeader()->SetCoordZ(z1,z2,z3,z4); }

SetLastSystemTime()

void EdbView::SetLastSystemTime ( Long_t  time )

inline

{ eLastSystemTime=time; }

SetNframes()

void EdbView::SetNframes ( int  top, int  bot  )

inline

{ GetHeader()->SetNframes(top,bot); }

Shift()

void EdbView::Shift

(

float

zshift

)

{
  // shift all z coordinates to the given offset
  EdbCluster *c=0;
  EdbSegment *s=0;
  EdbTrack   *t=0;
  if(eClusters) {
    int ncl=Nclusters();
    for( int i=0; i<ncl; i++ ) {  
      c = GetCluster(i); 
      c->SetZ( c->GetZ()+zshift ); 
    }
  }
  if(eSegments) {
    int nseg=Nsegments();
    for( int i=0; i<nseg; i++ ) { 
      s = GetSegment(i); 
      s->SetZ0( s->GetZ0()+zshift ); 
    }
  }
  if(eTracks) {
    int ntr=Ntracks();
    for( int i=0; i<ntr; i++ ) {
      t = GetTrack(i);
      t->SetZ0( t->GetZ0()+zshift ); 
    }
  }
}

Transform()

void EdbView::Transform

(

const EdbAffine2D *

aff

)

{
  if(eClusters) {
    int ncl=Nclusters();
    for( int i=0; i<ncl; i++ )   ((EdbPoint2D*)(GetCluster(i)))->Transform(aff);
  }
  if(eSegments) {
    int nseg=Nsegments();
    for( int i=0; i<nseg; i++ )   GetSegment(i)->Transform(aff);
  }
  if(eTracks) {
    int ntr=Ntracks();
    for( int i=0; i<ntr; i++ )     GetTrack(i)->Transform(aff);
  }
}

Xmin()

float EdbView::Xmin ( ) const

inline

{ return 0; }  // View coordinates are in pixels

Ymin()

float EdbView::Ymin ( ) const

inline

{ return 0; }  //  starting from 0

ZFrameMax()

float EdbView::ZFrameMax

(

)

const

{
  float zmax=GetFrame(0)->GetZ();
  for(int i=1; i<GetNframes(); i++) 
    {
      float z = GetFrame(i)->GetZ();
      if(z>zmax) zmax=z;
    }
  return zmax;
}

ZFrameMin()

float EdbView::ZFrameMin

(

)

const

{
  float zmin=GetFrame(0)->GetZ();
  for(int i=1; i<GetNframes(); i++) 
    {
      float z = GetFrame(i)->GetZ();
      if(z<zmin) zmin=z;
    }
  return zmin;
}

Zmax()

float EdbView::Zmax ( ) const

inline

{return TMath::Max( GetZ1(), GetZ4() );}

Zmin()

float EdbView::Zmin ( ) const

inline

{return TMath::Min( GetZ1(), GetZ4() );}

Member Data Documentation

eClusters

TClonesArray* EdbView::eClusters

private

eFrames

TClonesArray* EdbView::eFrames

private

eHeader

EdbViewHeader* EdbView::eHeader

private

eLastSystemTime

Long_t EdbView::eLastSystemTime

private

eSegments

TClonesArray* EdbView::eSegments

private

eTracks

TClonesArray* EdbView::eTracks

private

---

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

• src/libEdb/EdbView.h
• src/libEdb/EdbView.cxx