EdbDisplay Class Reference

#include <EdbDisplay.h>

Inheritance diagram for EdbDisplay:

Collaboration diagram for EdbDisplay:

Public Member Functions
void	AcceptModifiedParams ()
void	AcceptModifiedTrackParams ()
void	AcceptModifiedVTX ()
void	CancelDialogModifiedParams ()
void	CancelDialogModifiedTrackParams ()
void	CancelModifiedVTX ()
void	ClearSegmentEnv ()
void	CloseDialogModifiedParams ()
void	CloseDialogModifiedTrackParams ()
void	CloseDialogModifiedVTX ()
void	Delete ()
void	DeleteModifiedVTX ()
void	DialogModifiedVTX ()
void	DialogNeighborParameters ()
void	DialogTrackParameters ()
void	DrawAllObjects ()
void	DrawRef (float start[3], float end[3])
void	DrawSegmentExtrapolationLine (const EdbSegP &s, float zmin, float zmax)
void	DrawVertexEnvironment ()
void	DrawVTXTracks (char *type, EdbVertex *v=0)
	EdbDisplay ()
	EdbDisplay (const char *title, EdbLayer &la, TCanvas *Canvas=0)
	EdbDisplay (const char *title, Float_t x0, Float_t x1, Float_t y0, Float_t y1, Float_t z0, Float_t z1, TCanvas *Canvas=0)
void	GuessRange (float margZmin=3000, float margZmax=1000, float margR=300)
void	Refresh ()
void	RemoveTrackFromTable (int ivt=0)
EdbSegG *	SegLine (const EdbSegP *seg)
void	SelectVertexTracks (TObjArray *vtx)
void	Set0 ()
void	SetArrSegG (TObjArray *arrg)
void	SetArrSegP (TObjArray *arr)
void	SetArrTr (TObjArray *arr)
void	SetArrV (TObjArray *arrv)
void	SetDrawTracks (int opt)
void	SetDrawVertex (int opt)
void	SetVerRec (EdbVertexRec *evr)
void	TrackDraw (EdbTrackP *tr, Color_t kColor=kWhite)
void	UndoModifiedVTX ()
EdbVertexRec *	VerRec () const
void	VertexDraw (EdbVertex *v)
	~EdbDisplay ()
Public Member Functions inherited from EdbDisplayBase
virtual void	Clear ()
virtual void	ClearNewVTX ()
virtual void	ClearPreVTX ()
virtual void	CreateCanvasVTX ()
virtual void	DisplayButtons ()
virtual Int_t	DistancetoPrimitive (Int_t px, Int_t py)
virtual void	Draw (Option_t *option="")
virtual void	DrawAcc ()
virtual void	DrawAllViews ()
virtual void	DrawCan ()
virtual void	DrawDetector ()
virtual void	DrawEnv ()
virtual void	DrawNewBut (char *text)
virtual void	DrawNewVTX (char *text)
virtual void	DrawOldBut (char *text)
virtual void	DrawOldVTX (char *text)
virtual void	DrawPreBut (char *text)
virtual void	DrawPreVTX (char *text)
virtual void	DrawTitle (Option_t *option="")
virtual void	DrawUnd ()
virtual void	DrawView (Float_t theta, Float_t phi, Float_t psi=0)
virtual void	DrawViewGL ()
virtual void	DrawViewX3D ()
	EdbDisplayBase ()
	EdbDisplayBase (const char *title, Float_t x0, Float_t x1, Float_t y0, Float_t y1, Float_t z0, Float_t z1, TCanvas *Canvas=0)
virtual void	ExecuteEvent (Int_t event, Int_t px, Int_t py)
Bool_t	GetDrawDet () const
virtual char *	GetObjectInfo (int px, int py) const
virtual void	SetColorBG (int color=1)
virtual void	SetDetector (TGeoVolume *det)
virtual void	SetDrawDet (Bool_t fflag)
virtual void	SetLineWidth (int width=1)
virtual void	SetPickMode ()
virtual void	SetRange (Float_t x0, Float_t x1, Float_t y0, Float_t y1, Float_t z0, Float_t z1)
virtual void	SetRotate ()
virtual void	SetStyle (int Style=0)
virtual void	SetView (Float_t theta, Float_t phi, Float_t psi=0)
virtual void	SetZoomMode ()
virtual void	SwDrawDet ()
virtual void	UnZoom ()
	~EdbDisplayBase ()

Static Public Member Functions
static EdbDisplay *	EdbDisplayExist (const char *title)

Public Attributes
TObjArray *	eArrSegG
TObjArray *	eArrSegP
TObjArray *	eArrSegPSave
TObjArray *	eArrTr
TObjArray *	eArrTrSave
TObjArray *	eArrV
TObjArray *	eArrVSave
TList	eCreatedTracks
Double_t	eDpat
Int_t	eFromPlate
Double_t	eImpMax
Int_t	eIndVert
Int_t	eIndVertSave
Double_t	eM
Double_t	eP
EdbVertex *	ePrevious
Double_t	eRadMax
EdbSegP *	eSegment
TPolyMarker3D *	eSegPM
Double_t	eSegWmin
Double_t	eTImpMax
Int_t	eToPlate
Double_t	eTProbMin
EdbTrackP *	eTrack
EdbTrackP *	eTrack1
EdbTrackP *	eTrack2
EdbVertexRec *	eVerRec
EdbVertex *	eVertex
Bool_t	eWait_Answer
EdbVertex *	eWorking
Public Attributes inherited from EdbDisplayBase
TCanvas *	fCanvas
TCanvas *	fCanvasTRK
TCanvas *	fCanvasVTX
TPad *	fPad
TPaveText *	fVTXTRKInfo

Private Attributes
TArrayI *	eColors
Int_t	eDrawTracks
Int_t	eDrawVertex
TArrayF *	eDZs
TGNumberEntry *	fNumericEntries [3]

Additional Inherited Members
Protected Attributes inherited from EdbDisplayBase
TButton *	fAccButton
TButton *	fAllButton
TArc *	fArcButton
TPad *	fButtons
TButton *	fCanButton
char	fCanvasName [128]
Int_t	fColorBG
TGeoVolume *	fDetector
Bool_t	fDrawAllViews
Bool_t	fDrawDet
TButton *	fEnvButton
TText *	fHdrVTX
Width_t	fLineWidth
TGMainFrame *	fMain
TButton *	fNewBut
TText *	fNewVTX
TButton *	fOldBut
TText *	fOldVTX
Float_t	fPhi
TButton *	fPickButton
TButton *	fPreBut
TText *	fPreVTX
Float_t	fPsi
TButton *	fRemBut [50]
Int_t	fStyle
Float_t	fTheta
char	fTitle [128]
TPad *	fTrigPad
TButton *	fUndButton
TButton *	fUnZoomButton
Edb3DView *	fView
TPaveText *	fVTXTracks
Float_t	fVx0
Float_t	fVx1
Float_t	fVy0
Float_t	fVy1
Float_t	fVz0
Float_t	fVz1
TButton *	fZoomButton
Int_t	fZoomMode
Int_t	fZooms
Double_t	fZoomX0 [kMAXZOOMS]
Double_t	fZoomX1 [kMAXZOOMS]
Double_t	fZoomY0 [kMAXZOOMS]
Double_t	fZoomY1 [kMAXZOOMS]

Constructor & Destructor Documentation

EdbDisplay() [1/3]

EdbDisplay::EdbDisplay ( )

inline

: EdbDisplayBase() {Set0();}

~EdbDisplay()

EdbDisplay::~EdbDisplay

(

)

{
  DeleteModifiedVTX();
 
  if (gROOT->GetListOfSpecials()->FindObject(this))
    gROOT->GetListOfSpecials()->Remove(this);
 
  SafeDelete(fCanvasVTX);
  SafeDelete(fCanvasTRK);
  SafeDelete(eWorking);
  SafeDelete(ePrevious);
 
  if (eArrSegPSave) SafeDelete(eArrSegP);
  if (eArrVSave)    SafeDelete(eArrV);
  if (eArrTrSave)   SafeDelete(eArrTr);
 
  //SafeDelete(eArrSegG);
}

EdbDisplay() [2/3]

EdbDisplay::EdbDisplay ( const char *  title, Float_t  x0, Float_t  x1, Float_t  y0, Float_t  y1, Float_t  z0, Float_t  z1, TCanvas *  Canvas = 0  )

inline

                              : 
    EdbDisplayBase(title, x0, x1, y0, y1, z0, z1, Canvas) {Set0();}

EdbDisplay() [3/3]

EdbDisplay::EdbDisplay ( const char *  title, EdbLayer &  la, TCanvas *  Canvas = 0  )

inline

                                                                     : 
      EdbDisplayBase(title, la.Xmin(), la.Xmax(), la.Ymin(), la.Ymax(), 
             la.Zmin(), la.Zmax(), Canvas)
      {Set0();}

Member Function Documentation

AcceptModifiedParams()

void EdbDisplay::AcceptModifiedParams

(

)

{
    eWait_Answer = false;
    if(fNumericEntries[0]) eRadMax = fNumericEntries[0]->GetIntNumber();
    if(fNumericEntries[1]) eDpat   = fNumericEntries[1]->GetIntNumber();
    if(fNumericEntries[2]) eImpMax = fNumericEntries[2]->GetIntNumber();
    if(fNumericEntries[3]) eSegWmin= fNumericEntries[3]->GetIntNumber();
 
    for (Int_t i = 0; i < 4; i++) SafeDelete(fNumericEntries[i]);
 
    fMain->SendCloseMessage();
    fMain = 0;
}

AcceptModifiedTrackParams()

void EdbDisplay::AcceptModifiedTrackParams

(

)

{
    eWait_Answer = false;
    if(fNumericEntries[0]) eP = fNumericEntries[0]->GetNumber();
    if(fNumericEntries[1]) eM = fNumericEntries[1]->GetNumber();
    if(fNumericEntries[2]) eTImpMax  = fNumericEntries[2]->GetNumber();
    if(fNumericEntries[3]) eTProbMin = fNumericEntries[3]->GetNumber();
    for (Int_t i = 0; i < 4; i++) SafeDelete(fNumericEntries[i]);
    fMain->SendCloseMessage();
    fMain = 0;
}

AcceptModifiedVTX()

void EdbDisplay::AcceptModifiedVTX

(

)

{
    EdbVertex *eVe = 0;
    if (eArrVSave || eArrTrSave || eArrSegPSave) DrawAllObjects();
    if (ePrevious && (ePrevious != eVertex) && (ePrevious != eWorking))
    {
    delete ePrevious;
    ePrevious = 0;
    }
    if (eWorking && eVertex)
    {
    //if (!eVerRec) eVerRec = ((EdbVertexRec*)(gROOT->GetListOfSpecials()->FindObject("EdbVertexRec")));
    if (eVerRec) if (eVerRec->IsA() != EdbVertexRec::Class()) eVerRec = 0;
    if (!eVerRec) {printf("Error: EdbDisplay:AcceptModifiedVTX: EdbVertexRec not defined, use SetVerRec(...)\n"); return;}
        EdbVertex *eW = eWorking;
    int ind = eVertex->ID();
    if (ind < 0)
    {
        if (eVerRec->eVTX)
        {
        ind = eVerRec->eVTX->GetEntriesFast();
        }
        else
        {
            eVerRec->eVTX = new TObjArray(10);
            ind = 0;
        }
    }
    eW->SetID(ind);
    eW->SetQuality(eW->V()->prob()/
               (eW->V()->vtx_cov_x()+eW->V()->vtx_cov_y()));
    if (eVerRec)
    {
        int ntr = eVertex->N();
//      printf("ind %d ntr %d\n", ind, ntr);
//      fflush(stdout);
        for(int i=0; i<ntr; i++)
        {
//      printf("    %d\n", i);
//      fflush(stdout);
        (eVerRec->eVTA).Remove(eVertex->GetVTa(i));
        }
    }
    int indd = -1;
//  if (!eArrV) eArrV = new TObjArray(10);
    if (eArrV) indd = eArrV->IndexOf(eVertex);
    if (indd >= 0)
    {
//      eArrV->RemoveAt(indd);
        eArrV->AddAt(eW, indd);
    }
    eVe = eVertex;
    EdbTrackP *tr = 0;
 
    TObjArray *etr = 0;
    if (eVerRec) etr = eVerRec->eEdbTracks;
    int trind = 0;
    if (etr) trind = etr->GetEntriesFast();
    for (int i = 0; i < eCreatedTracks.GetSize(); i++)
    {
        tr = (EdbTrackP *)(eCreatedTracks.At(i));
        if (tr)
        {
//          printf("i %d id %d\n", i, tr->ID());
//          fflush(stdout);
//      if (tr->VTAS() || tr->VTAE())
//      {
            tr->SetID(trind++);
            if (etr) etr->Add(tr);
            if (eArrTr) eArrTr->Add(tr);
//          printf("     id %d\n", tr->ID());
//          fflush(stdout);
//      }
//      else delete tr;
        } 
    }
    eCreatedTracks.Clear();
 
    delete eVertex; //?????????
    eVertex = 0;
 
    eW->ResetTracks();
 
    int ntr = eW->N();
    int ifl = 0;
    for(int i=0; i<ntr; i++)
    {
        tr = eW->GetTrack(i);
        if (eTrack)
        {
          if (tr == eTrack)
          {
            TObjArray *etr = 0;
            if (eVerRec) etr = eVerRec->eEdbTracks;
            int trind = 0;
            if (etr) trind = etr->GetEntriesFast();
            eTrack->SetID(trind);
            if (etr) etr->Add(eTrack);
            eTrack->SetSegmentsTrack();
            eTrack = 0;
          }
        }
        if (eW->Zpos(i)) ifl = ifl | 1; 
        else         ifl = ifl | 2; 
        if (tr && eArrTr)
        {
            indd = eArrTr->IndexOf(tr);
            if (indd < 0)
            {
            eArrTr->Add(tr);
            }
        }
    }
    ifl = 4 - ifl;
    if (ifl == 3) ifl = 0;
    if (eW->Nv()) ifl += 3;
    eW->SetFlag(ifl);
    if (eVerRec)
    {
//      eVerRec->eVTX->RemoveAt(ind);
        if (eVerRec->eVTX) eVerRec->eVTX->AddAt(eW, ind);
        for(int i=0; i<ntr; i++)
        {
        eVerRec->AddVTA(eW->GetVTa(i));
        }
    }
    }
    if (eVertex && eVertex->ID() < 0 && !eWorking)
    {
    int ind = 0;
    if (eVerRec->eVTX)
        {
        ind = eVerRec->eVTX->GetEntriesFast();
        }
    else
        {
            eVerRec->eVTX = new TObjArray(10);
            ind = 0;
        }
    eVertex->SetID(ind);
//  if (!eArrV) eArrV = new TObjArray(10);
    if (eArrV) eArrV->Add(eVertex);
    EdbTrackP *tr = 0;
    TObjArray *etr = 0;
    if (eVerRec) etr = eVerRec->eEdbTracks;
    int trind = 0;
    if (etr) trind = etr->GetEntriesFast();
    for (int i = 0; i < eCreatedTracks.GetSize(); i++)
    {
        tr = (EdbTrackP *)(eCreatedTracks.At(i));
        if (tr)
        {
//      if (tr->VTAS() || tr->VTAE())
//      {
            tr->SetID(trind++);
            if (etr) etr->Add(tr);
            if (eArrTr) eArrTr->Add(tr);
//      }
//      else delete tr;
        } 
    }
    eCreatedTracks.Clear();
 
    eVertex->ResetTracks();
    int ntr = eVertex->N();
    int ifl = 0;
    int indd = 0;
    for(int i=0; i<ntr; i++)
    {
        tr = eVertex->GetTrack(i);
        if (eTrack)
        {
          if (tr == eTrack)
          {
            TObjArray *etr = 0;
            if (eVerRec) etr = eVerRec->eEdbTracks;
            int trind = 0;
            if (etr) trind = etr->GetEntriesFast();
            eTrack->SetID(trind);
            if (etr) etr->Add(eTrack);
            eTrack->SetSegmentsTrack();
            eTrack = 0;
          }
        }
        if (eVertex->Zpos(i)) ifl = ifl | 1; 
        else              ifl = ifl | 2; 
        if (tr && eArrTr)
        {
            indd = eArrTr->IndexOf(tr);
            if (indd < 0)
            {
            eArrTr->Add(tr);
            }
        }
    }
    ifl = 4 - ifl;
    if (ifl == 3) ifl = 0;
    if (eVertex->Nv()) ifl += 3;
    eVertex->SetFlag(ifl);
    if (eVerRec)
    {
//      eVerRec->eVTX->RemoveAt(ind);
        if (!(eVerRec->eVTX)) eVerRec->eVTX = new TObjArray(10);
        eVerRec->eVTX->Add(eVertex);
        for(int i=0; i<ntr; i++)
        {
        eVerRec->AddVTA(eVertex->GetVTa(i));
        }
    }
    }
    eWorking = 0;
    eVertex = 0;
    TList *li = fTrigPad->GetListOfPrimitives();
    if (li)
    {
    li->Remove(fUndButton);
    li->Remove(fAccButton);
    li->Remove(fCanButton);
    li->Remove(fEnvButton);
    }
    fTrigPad->cd();
    fTrigPad->Update();
    fTrigPad->Draw();
 
    fPad->cd();
    if (eWait_Answer) CloseDialogModifiedVTX();
    if (fCanvasVTX) fCanvasVTX->Close();
    fCanvasVTX = 0;
    Draw();
    //if (eVe) delete eVe;
    eIndVert = -1;
}

CancelDialogModifiedParams()

void EdbDisplay::CancelDialogModifiedParams

(

)

{
    eWait_Answer = false;
    for (Int_t i = 0; i < 3; i++) SafeDelete(fNumericEntries[i]);
    fMain->SendCloseMessage();
    fMain = 0;
}

CancelDialogModifiedTrackParams()

void EdbDisplay::CancelDialogModifiedTrackParams

(

)

{
    eWait_Answer = false;
    for (Int_t i = 0; i < 4; i++) SafeDelete(fNumericEntries[i]);
    fMain->SendCloseMessage();
    fMain = 0;
}

CancelModifiedVTX()

void EdbDisplay::CancelModifiedVTX

(

)

{
    if (eArrVSave || eArrTrSave || eArrSegPSave) DrawAllObjects();
    if (eWorking)
    {
    delete eWorking;
    eWorking = 0;
    }
    if (ePrevious)
    {
    delete ePrevious;
    ePrevious = 0;
    }
    if (eVertex)
    {
    if (eVertex->ID() < 0)
    {
        if (eArrV) 
        {
            eArrV->Remove(eVertex);
        eArrV->Compress();
        }   
        delete eVertex;
        eVertex = 0;
    }
    else
    {
        (eVertex)->ResetTracks();
    }
    }
    TList *li = fTrigPad->GetListOfPrimitives();
    if (li)
    {
    li->Remove(fUndButton);
    li->Remove(fAccButton);
    li->Remove(fCanButton);
    li->Remove(fEnvButton);
    }
 
    EdbTrackP *tr = 0;
 
    for (int i = 0; i < eCreatedTracks.GetSize(); i++)
    {
    tr = (EdbTrackP *)eCreatedTracks.At(i);
    if (tr)
    {
        if (eArrTr) if (eArrTr->FindObject(tr))
        {
        eArrTr->Remove(tr);
        eArrTr->Compress();
        }
        if (eArrTrSave) if (eArrTrSave->FindObject(tr))
        {
        eArrTrSave->Remove(tr);
        eArrTrSave->Compress();
        }
        delete tr;
    } 
    }
    eCreatedTracks.Clear();
 
    if (eArrV && (eIndVert >= 0) && eVertex) 
    {
//      eArrV->RemoveAt(eIndVert);
        eArrV->AddAt(eVertex, eIndVert);
    }   
    fTrigPad->cd();
    fTrigPad->Update();
    fTrigPad->Draw();
    fPad->cd();
    if (eWait_Answer) CloseDialogModifiedVTX();
    if (fCanvasVTX) fCanvasVTX->Close();
    fCanvasVTX = 0;
    eIndVert = -1;
    eVertex = 0;
    Draw();
}

ClearSegmentEnv()

void EdbDisplay::ClearSegmentEnv

(

)

{
    if (fPad->GetListOfPrimitives()->FindObject(eSegPM))
    {
        fPad->GetListOfPrimitives()->Remove(eSegPM);
    }
    delete eSegPM;
    eSegPM = 0;
    TList *li = fTrigPad->GetListOfPrimitives();
    if (eArrVSave || eArrSegPSave || eArrTrSave)
    {
        li->Remove(fAllButton);
        delete eArrV;
        eArrV = eArrVSave;
        eArrVSave = 0;
        if (eArrTrSave)
        {
        delete eArrTr;
        eArrTr = eArrTrSave;
        eArrTrSave = 0;
        }
        if (eArrSegPSave)
        {
        delete eArrSegP;
        eArrSegP = eArrSegPSave;
        eArrSegPSave = 0;
        }
        Draw();    
    }
    else li->Remove(fEnvButton);
}

CloseDialogModifiedParams()

void EdbDisplay::CloseDialogModifiedParams

(

)

{
    eWait_Answer = false;
    fMain = 0;
}

CloseDialogModifiedTrackParams()

void EdbDisplay::CloseDialogModifiedTrackParams

(

)

{
    eWait_Answer = false;
    fMain = 0;
}

CloseDialogModifiedVTX()

void EdbDisplay::CloseDialogModifiedVTX

(

)

{
    eWait_Answer = false;
    fMain->SendCloseMessage();
    fMain = 0;
}

Delete()

void EdbDisplay::Delete

(

)

{
  DeleteModifiedVTX();
 
  if (gROOT->GetListOfSpecials()->FindObject(this))
    gROOT->GetListOfSpecials()->Remove(this);
 
  SafeDelete(fCanvasVTX);
  SafeDelete(fCanvasTRK);
  SafeDelete(eWorking);
  SafeDelete(ePrevious);
 
  if (eArrSegPSave) SafeDelete(eArrSegP);
  if (eArrVSave)    SafeDelete(eArrV);
  if (eArrTrSave)   SafeDelete(eArrTr);
}

DeleteModifiedVTX()

void EdbDisplay::DeleteModifiedVTX

(

)

{
    if (eWorking)
    {
    delete eWorking;
    eWorking = 0;
    }
    if (ePrevious)
    {
    delete ePrevious;
    ePrevious = 0;
    }
    if (eVertex)
    {
    if (eVertex->ID() < 0)
    {
        if (eArrV) 
        {
            eArrV->Remove(eVertex);
        eArrV->Compress();
        }   
        delete eVertex;
        eVertex = 0;
    }
    else
    {
        (eVertex)->ResetTracks();
    }
    }
 
    EdbTrackP *tr = 0;
 
    for (int i = 0; i < eCreatedTracks.GetSize(); i++)
    {
    tr = (EdbTrackP *)eCreatedTracks.At(i);
    if (tr)
    {
        if (eArrTr) if (eArrTr->FindObject(tr))
        {
        eArrTr->Remove(tr);
        eArrTr->Compress();
        }
        if (eArrTrSave) if (eArrTrSave->FindObject(tr))
        {
        eArrTrSave->Remove(tr);
        eArrTrSave->Compress();
        }
        delete tr;
    } 
    }
    eCreatedTracks.Clear();
 
    if (eArrVSave || eArrTrSave || eArrSegPSave)
    {
    delete eArrV;
    eArrV = eArrVSave;
    eArrVSave = 0;
    delete eArrTr;
    eArrTr = eArrTrSave;
    eArrTrSave = 0;
    delete eArrSegP;
    eArrSegP = eArrSegPSave;
    eArrSegPSave = 0;
    eIndVert = eIndVertSave;
    }
    if (eArrV && (eIndVert >= 0) && eVertex) 
    {
//      eArrV->RemoveAt(eIndVert);
        eArrV->AddAt(eVertex, eIndVert);
        eIndVert = -1;
    }   
}

DialogModifiedVTX()

void EdbDisplay::DialogModifiedVTX

(

)

{
    eWait_Answer = true;
    fMain = new TGMainFrame(gClient->GetRoot(), 250, 40);
    TGMainFrame *fTra = fMain;
    TGHorizontalFrame *fFrame = new TGHorizontalFrame(fTra, 220, 30);
    char cmda[256];
    sprintf(cmda,
    "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->AcceptModifiedVTX()",fTitle);
    TGTextButton *abut = new TGTextButton(fFrame, "&Accept", cmda);
    fFrame->AddFrame(abut,
             new TGLayoutHints(kLHintsCenterY | kLHintsLeft,
             5,5,3,4));
 
    char cmdc[256];
    sprintf(cmdc,
    "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->CancelModifiedVTX()",fTitle);
    TGTextButton *cbut = new TGTextButton(fFrame, "&Cancel", cmdc);
    fFrame->AddFrame(cbut,
             new TGLayoutHints(kLHintsCenterY | kLHintsRight,
                 5, 5, 4, 4));
    fFrame->Resize(210, 30);
 
    fTra->AddFrame(fFrame,
           new TGLayoutHints(kLHintsCenterY | kLHintsCenterX,
           5, 5, 4, 4));
 
    fTra->MapSubwindows();
    fTra->Resize(220, fTra->GetDefaultHeight());
    fTra->SetWindowName("Modified Vertex Exist!");
    fTra->MapWindow();
}

DialogNeighborParameters()

void EdbDisplay::DialogNeighborParameters

(

)

{
    if (eRadMax == 0)
    {
    printf("No neighborhood in EdbPVGen object!\n");
    fflush(stdout);
    return;
    }
 
    eWait_Answer = true;
 
    fMain = new TGMainFrame(gClient->GetRoot(), 260, 340);
    TGMainFrame *fTra = fMain;
 
//    fTra->Connect("CloseWindow()", "EdbDisplay", this, "CloseDialogModifiedParams()");
 
   // use hierarchical cleaning
//    fTra->SetCleanup(kDeepCleanup);
 
    TGHorizontalFrame *fF[4] = {0,0,0,0};
    TGLabel *fLabel[4] = {0,0,0,0};
    Double_t parinit[4] = {eRadMax, eDpat,  eImpMax, eSegWmin};
    Double_t parmax[4] =  { 150000.,   50.,   10000., 1000. };
    Double_t parmin[4] =  {    0.,    0.,      0.,    0. };
    //if (eVerRec) if (eVerRec->ePVR) parmax[1] = ((eVerRec->ePVR)->Npatterns()-1);
    char *parlabel[4] = {"Maximal radius","+/- patterns", "Maximal impact", "Minimal seg W"};
 
    TGGC myGC = *(gClient->GetResourcePool()->GetFrameGC());
    TGFont *myfont = gClient->GetFont("-adobe-helvetica-bold-r-*-*-12-*-*-*-*-*-iso8859-1");
    if (myfont) myGC.SetFont(myfont->GetFontHandle());
 
    TGVerticalFrame *fF1 = new TGVerticalFrame(fTra, 240, 250);
    TGLayoutHints *fL1 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2, 2, 2, 2);
    fTra->AddFrame(fF1, fL1);
    TGLayoutHints *fL2 = new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 2, 2, 2, 2);
    for (int i = 0; i < 4; i++) {
      fF[i] = new TGHorizontalFrame(fF1, 220, 35);
      fF1->AddFrame(fF[i], fL2);
      fNumericEntries[i] = new TGNumberEntry(fF[i], parinit[i], 12, i+1000,
                                 TGNumberFormat::kNESInteger,
                 TGNumberFormat::kNEANonNegative,
                 TGNumberFormat::kNELLimitMinMax,
                 parmin[i], parmax[i]);
      fF[i]->AddFrame(fNumericEntries[i], fL2);
      fLabel[i] = new TGLabel(fF[i], parlabel[i], myGC(), myfont->GetFontStruct());
      fF[i]->AddFrame(fLabel[i], fL2);
    }
 
    TGHorizontalFrame *fFrame = new TGHorizontalFrame(fTra, 220, 30);
    char cmda[256];
    sprintf(cmda,
    "((EdbDisplay*)((gROOT->GetListOfSpecials())->FindObject(\"%s\")))->AcceptModifiedParams()",fTitle);
    TGTextButton *abut = new TGTextButton(fFrame, "&Accept", cmda);
    fFrame->AddFrame(abut,
             new TGLayoutHints(kLHintsCenterY | kLHintsLeft,
             5,5,3,4));
 
    char cmdc[256];
    sprintf(cmdc,
    "((EdbDisplay*)((gROOT->GetListOfSpecials())->FindObject(\"%s\")))->CancelDialogModifiedParams()",fTitle);
    TGTextButton *cbut = new TGTextButton(fFrame, "&Cancel", cmdc);
    fFrame->AddFrame(cbut,
             new TGLayoutHints(kLHintsCenterY | kLHintsRight,
                 5, 5, 4, 4));
//    fFrame->Resize(220, 30);
 
    fTra->AddFrame(fFrame,
           new TGLayoutHints(kLHintsCenterY | kLHintsCenterX,
           5, 5, 4, 4));
 
    fTra->MapSubwindows();
    fTra->Resize(260, fTra->GetDefaultHeight());
    fTra->SetWindowName("Neighborhood Parameters");
    fTra->MapWindow();
    gClient->WaitFor(fTra);
}

DialogTrackParameters()

void EdbDisplay::DialogTrackParameters

(

)

{
    eWait_Answer = true;
 
    fMain = new TGMainFrame(gClient->GetRoot(), 280, 360);
    TGMainFrame *fTra = fMain;
 
//    fTra->Connect("CloseWindow()", "EdbDisplay", this, "CloseDialogModifiedParams()");
 
   // use hierarchical cleaning
//    fTra->SetCleanup(kDeepCleanup);
 
    TGHorizontalFrame *fF[4] = {0,0,0,0};
    TGLabel *fLabel[4] = {0,0,0,0};
    Double_t parinit[4] = {    eP,    eM, eTImpMax, eTProbMin};
    Double_t parmax[4] =  { 1000.,   10., 1000000.,        1.};
    Double_t parmin[4] =  {    0.,    0.,       0.,        0.};
    char *parlabel[4] = {"Momentum","Mass", "MaxImpact", "MinProb"};
 
    TGGC myGC = *(gClient->GetResourcePool()->GetFrameGC());
    TGFont *myfont = gClient->GetFont("-adobe-helvetica-bold-r-*-*-12-*-*-*-*-*-iso8859-1");
    if (myfont) myGC.SetFont(myfont->GetFontHandle());
 
    TGVerticalFrame *fF1 = new TGVerticalFrame(fTra, 260, 250);
    TGLayoutHints *fL1 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2, 2, 2, 2);
    fTra->AddFrame(fF1, fL1);
    TGLayoutHints *fL2 = new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 2, 2, 2, 2);
    for (int i = 0; i < 4; i++) {
      fF[i] = new TGHorizontalFrame(fF1, 240, 35);
      fF1->AddFrame(fF[i], fL2);
      fNumericEntries[i] = new TGNumberEntry(fF[i], parinit[i], 12, i+2000,
                                 TGNumberFormat::kNESReal,
                 TGNumberFormat::kNEANonNegative,
                 TGNumberFormat::kNELLimitMinMax,
                 parmin[i], parmax[i]);
      fF[i]->AddFrame(fNumericEntries[i], fL2);
      fLabel[i] = new TGLabel(fF[i], parlabel[i], myGC(), myfont->GetFontStruct());
      fF[i]->AddFrame(fLabel[i], fL2);
    }
 
    TGHorizontalFrame *fFrame = new TGHorizontalFrame(fTra, 240, 30);
    char cmda[256];
    sprintf(cmda,
//    "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject((TObject *)0x%08x)))->AcceptModifiedTrackParams()",this);
    "((EdbDisplay*)((gROOT->GetListOfSpecials())->FindObject(\"%s\")))->AcceptModifiedTrackParams()",fTitle);
    TGTextButton *abut = new TGTextButton(fFrame, "&Accept", cmda);
    fFrame->AddFrame(abut,
             new TGLayoutHints(kLHintsCenterY | kLHintsLeft,
             5,5,3,4));
 
    char cmdc[256];
    sprintf(cmdc,
    "((EdbDisplay*)((gROOT->GetListOfSpecials())->FindObject(\"%s\")))->CancelDialogModifiedTrackParams()",fTitle);
    TGTextButton *cbut = new TGTextButton(fFrame, "&Cancel", cmdc);
    fFrame->AddFrame(cbut,
             new TGLayoutHints(kLHintsCenterY | kLHintsRight,
                 5, 5, 4, 4));
//    fFrame->Resize(220, 30);
 
    fTra->AddFrame(fFrame,
           new TGLayoutHints(kLHintsCenterY | kLHintsCenterX,
           5, 5, 4, 4));
 
    fTra->MapSubwindows();
    fTra->Resize(280, fTra->GetDefaultHeight());
    fTra->SetWindowName("Track Parameters");
    fTra->MapWindow();
    gClient->WaitFor(fTra);
}

DrawAllObjects()

void EdbDisplay::DrawAllObjects

(

)

{
    fTrigPad->cd();
    fTrigPad->GetListOfPrimitives()->Remove(fAllButton);
    if (fStyle/2 == 1)
    fEnvButton->SetFillColor(33);
    else
    fEnvButton->SetFillColor(38);
    fTrigPad->GetListOfPrimitives()->Add(fEnvButton);
    fEnvButton->SetPad(0.05,0.47,0.95,0.56);
    fEnvButton->Draw();
    fTrigPad->Modified(kTRUE);
    fTrigPad->Update();
    fTrigPad->Draw();
    fPad->cd();
 
    if (eArrVSave || eArrTrSave || eArrSegPSave)
    {
    delete eArrV;
    eArrV = eArrVSave;
    eArrVSave = 0;
    eIndVert = eIndVertSave;
    delete eArrTr;
    eArrTr = eArrTrSave;
    eArrTrSave = 0;
    delete eArrSegP;
    eArrSegP = eArrSegPSave;
    eArrSegPSave = 0;
    }
    if (eArrV && eWorking && (eIndVert >= 0)) 
    {
//  eArrV->RemoveAt(eIndVert);
    eArrV->AddAt(eWorking, eIndVert);
    }
    Draw();    
}

DrawRef()

void EdbDisplay::DrawRef	(	float	start[3],
		float	end[3]
	)

{
  // reference vector to indicate the direction (ie scanback track) can be drawn
 
  TPolyLine3D *line = new TPolyLine3D(2);
  line->SetPoint(0, start[0],start[1], start[2] );
  line->SetPoint(1,   end[0],  end[1],   end[2] );
  line->SetLineColor(kGreen);
  line->SetLineWidth(fLineWidth);
  line->SetBit(kCannotPick);
  line->Draw();
 
  TPolyMarker3D *mark = new TPolyMarker3D(1);
  mark->SetPoint(0, start[0],start[1], start[2] );
  mark->SetMarkerColor(kGreen);
  mark->SetMarkerStyle(kMultiply);
  mark->SetMarkerSize(1.2);
  mark->Draw();
}

DrawSegmentExtrapolationLine()

void EdbDisplay::DrawSegmentExtrapolationLine	(	const EdbSegP &	s,
		float	zmin,
		float	zmax
	)

{
   EdbSegP start(s);
   EdbSegP end(s);
   start.PropagateTo(zmin);
   start.PropagateTo(zmax);
   TPolyLine3D *trline = new TPolyLine3D(2);
   trline->SetPoint(0, start.X(),start.Y(),start.Z() );
   trline->SetPoint( 1,   end.X(),  end.Y(),  end.Z() );
   if (fStyle/2 == 1) trline->SetLineColor(kBlack);
   else               trline->SetLineColor(kWhite);
   trline->SetLineWidth(1);
   trline->SetBit(kCannotPick);
   trline->Draw();
   Log(3,"EdbDisplay::DrawSegmentExtrapolationLine", "(%f %f %f) -> (%f %f %f)", start.X(),start.Y(),start.Z(), end.X(),  end.Y(),  end.Z());
}

DrawVertexEnvironment()

void EdbDisplay::DrawVertexEnvironment

(

)

{
    if (eRadMax == 0)
    {
    printf("No neighborhood in EdbPVRec object!\n");
    fflush(stdout);
    return;
    }
    //if (!eVerRec) eVerRec = ((EdbVertexRec *)(gROOT->GetListOfSpecials()->FindObject("EdbVertexRec")));
    if (eVerRec) if((eVerRec->IsA()) != EdbVertexRec::Class()) eVerRec = 0;
    if (!eVerRec)
       {printf("Error: EdbDisplay:DrawVertexEnvironment: EdbVertexRec not defined, use SetVerRec(...)\n"); fflush(stdout); return;}
    if (!eVertex && !eSegment)
       {printf("Error: EdbDisplay:DrawVertexEnvironment: Working vertex (or segment) not defined\n"); fflush(stdout); return;}
    
    fTrigPad->cd();
    fTrigPad->GetListOfPrimitives()->Remove(fEnvButton);
    if (fStyle/2 == 1)
    fAllButton->SetFillColor(33);
    else
    fAllButton->SetFillColor(38);
    fTrigPad->GetListOfPrimitives()->Add(fAllButton);
    fAllButton->SetPad(0.05,0.47,0.95,0.56);
    fAllButton->Draw();
    fTrigPad->Modified(kTRUE);
    fTrigPad->Update();
    fTrigPad->Draw();
    fPad->cd();
 
    EdbVertex *eW = eVertex;
    EdbTrackP *tr = 0;
    if (eWorking) eW = eWorking;
    float Rmax = eRadMax, ImpMax = eImpMax;
    int Dpat = (int)eDpat;
 
    eArrTrSave  = eArrTr; 
    eArrSegPSave  = eArrSegP; 
    eArrVSave  = eArrV;
    eIndVertSave = eIndVert; 
    eArrV = new TObjArray(20);
    eArrTr = new TObjArray(20);
    eArrSegP = new TObjArray(20);
 
    if (eW)
    {
    eVerRec->VertexNeighbor(eW, Rmax, Dpat, ImpMax);
    eArrV->Add(eW);
    int ntr = eW->N();
    for(int i=0; i<ntr; i++)
    {
        eArrTr->Add((tr = eW->GetTrack(i)));
    }
    int nntr = eW->Nn();
    EdbVTA *vta = 0;
    for(int i=0; i<nntr; i++)
    {
    if ((vta = eW->GetVTn(i)))
    {
        if (vta->Flag() == 0) //track
        {
        eArrTr->Add((tr = vta->GetTrack()));
        }
        else if (vta->Flag() == 1) //segment
        {
        eArrSegP->Add((EdbSegP *)(vta->GetTrack()));
        }
        else if (vta->Flag() == 3) //vertex
        {
        eArrV->Add((EdbVertex *)(vta->GetTrack()));
        }
    }
    }
    eIndVert = eArrV->IndexOf(eW);
    }
    else if (eSegment)
    {
    eIndVert = -1;
    eVerRec->SegmentNeighbor(eSegment, Rmax, Dpat, ImpMax, eSegWmin, eArrSegP, eArrTr, eArrV);
    if (eArrV->GetEntriesFast()) eDrawVertex = 1;
    }
    Draw();
}

DrawVTXTracks()

void EdbDisplay::DrawVTXTracks	(	char *	type,
		EdbVertex *	v = 0
	)

{
  EdbVertex *vv = v;
  if (!vv)
  {
    if (!strcmp(type, "Original") && eVertex)
    {
    vv = eVertex;
    }
    else if (!strcmp(type, "Previous") && ePrevious)
    {
    vv = ePrevious;
    }
    else if (!strcmp(type, "Modified") && eWorking)
    {
    vv = eWorking;
    }
  }
  if (!vv) return;
  bool drawrem = true;
  if (vv == eVertex && eWorking) drawrem = false;
  if (vv == ePrevious) drawrem = false;
 
  fCanvasVTX->cd();
 
  if (fVTXTracks)
  {
    fVTXTracks->Clear();
  }
  else
  {
    fVTXTracks = new TPaveText(0.05, 0.05, 0.95, 0.72);
    fVTXTracks->ResetBit(kCanDelete);
  }
  char line[128];
  EdbTrackP *tr = 0;  
  TText *t = 0;
  int ntr = vv->N();
  sprintf(line, "           Tracks parameters for %s vertex", type);
  t = fVTXTracks->AddText(line);
  t->SetTextColor(kBlue);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
  strcpy(line, "    #   ID   Nseg   Mass       P       Chi2/ndf    Prob     Chi2Contrib     Impact");
  t = fVTXTracks->AddText(line);
  t->SetTextColor(kBlue);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
  for (int i=0; i<ntr; i++)
  {
    tr = vv->GetTrack(i);
    sprintf(line,"%4d  %4d  %4d   %7.4f  %7.2f    %5.2f     %7.4f       %6.3f    %7.2f",
           i, tr->ID(), tr->N(), tr->M(), tr->P(),
              tr->Chi2()/tr->N(), tr->Prob(), vv->V()->track_chi2(i), vv->Impact(i));
    t = fVTXTracks->AddText(line);
    t->SetTextColor(kBlack);
    t->SetTextSize(0.03);
    t->SetTextAlign(12);
    t->SetTextFont(102);
  }
  t = fVTXTracks->AddText("");
  t->SetTextColor(kBlack);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
  fVTXTracks->Draw();
 
  float dy = 0.67/(2+ntr+1);
  for (int i=0; i<50; i++)
  {
    if (!drawrem)
    {
    if (fRemBut[i])
    {
        fRemBut[i]->Delete();
        fRemBut[i] = 0;
    }
    continue;
    }
    if ( i < ntr )
    {
      if (!fRemBut[i])
      {
    char but[256], tit[32]="Rem";
    sprintf(but,
    "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->RemoveTrackFromTable(%d)",fTitle,i);
    fRemBut[i] = new TButton(tit, but, 0.88, 0.635-(i+2)*dy, 0.94, 0.675-(i+2)*dy);
    fRemBut[i]->SetToolTipText("Remove corresponding track");
    fRemBut[i]->ResetBit(kCanDelete);
    fRemBut[i]->SetFillColor(38);
    sprintf(tit,"RemTr%d",i);
    fRemBut[i]->SetName(tit);
    fRemBut[i]->Draw();
      }
      else
      {
        fRemBut[i]->SetPad(0.88,0.635-(i+2)*dy,0.94,0.675-(i+2)*dy);
    fRemBut[i]->Draw();
      }
    }
    else if (fRemBut[i])
    {
    fRemBut[i]->Delete();
    fRemBut[i] = 0;
    }
  }
 
  fPad->Modified(kTRUE);
  fPad->Update();
}

EdbDisplayExist()

EdbDisplay * EdbDisplay::EdbDisplayExist ( const char *  title )

static

{
  TSeqCollection *l = gROOT->GetListOfSpecials();
  if (!l) return 0;
  EdbDisplay *ds = (EdbDisplay*)(l->FindObject(title));
  return ds;
}

GuessRange()

void EdbDisplay::GuessRange	(	float	margZmin = 3000,
		float	margZmax = 1000,
		float	margR = 300
	)

{
  // guess minimum display range to fit all objects
 
  float xmin=0,xmax=1,ymin=0,ymax=1,zmin=0,zmax=1;
 
  if (eArrSegG) {
    EdbSegG *s=0;
    for(int i=0; i<eArrSegG->GetEntriesFast(); i++) {
      s = (EdbSegG *)(eArrSegG->At(i));
      if(!s) continue;
      if(xmax-xmin<margR) {
        xmax=s->X()+margR;
        xmin=s->X()-margR;
        ymax=s->Y()+margR;
        ymin=s->Y()-margR;
        zmax=s->Z()+margZmax;
        zmin=s->Z()-margZmin;
      }
      if(xmax<s->X()+margR) xmax=s->X()+margR;
      if(xmin>s->X()-margR) xmin=s->X()-margR;
      if(ymax<s->Y()+margR) ymax=s->Y()+margR;
      if(ymin>s->Y()-margR) ymin=s->Y()-margR;
      if(zmax<s->Z()+margZmax) zmax=s->Z()+margZmax;
      if(zmin>s->Z()-margZmin) zmin=s->Z()-margZmin;
    }
  }
  
  if (eArrSegP) {
    EdbSegP *s=0;
    for(int i=0; i<eArrSegP->GetEntriesFast(); i++) {
      s = (EdbSegP *)(eArrSegP->At(i));
      if(!s) continue;
      if(xmax-xmin<margR) {
        xmax=s->X()+margR;
        xmin=s->X()-margR;
        ymax=s->Y()+margR;
        ymin=s->Y()-margR;
        zmax=s->Z()+margZmax;
        zmin=s->Z()-margZmin;
      }
      if(xmax<s->X()+margR) xmax=s->X()+margR;
      if(xmin>s->X()-margR) xmin=s->X()-margR;
      if(ymax<s->Y()+margR) ymax=s->Y()+margR;
      if(ymin>s->Y()-margR) ymin=s->Y()-margR;
      if(zmax<s->Z()+margZmax) zmax=s->Z()+margZmax;
      if(zmin>s->Z()-margZmin) zmin=s->Z()-margZmin;
    }
  }
 
  if (eArrV) {
    for(int i=0; i<eArrV->GetEntriesFast(); i++) {
      EdbVertex *v = (EdbVertex *)(eArrV->At(i));
      if(!v) continue;
      if(!v->V()) continue;
      if(!v->V()->valid()) continue;
      if(xmax-xmin<margR) {
    xmax=v->VX()+margR;
    xmin=v->VX()-margR;
    ymax=v->VY()+margR;
    ymin=v->VY()-margR;
    zmax=v->VZ()+margZmax;
    zmin=v->VZ()-margZmin;
      }
      if(xmax<v->VX()+margR) xmax=v->VX()+margR;
      if(xmin>v->VX()-margR) xmin=v->VX()-margR;
      if(ymax<v->VY()+margR) ymax=v->VY()+margR;
      if(ymin>v->VY()-margR) ymin=v->VY()-margR;
      if(zmax<v->VZ()+margZmax) zmax=v->VZ()+margZmax;
      if(zmin>v->VZ()-margZmin) zmin=v->VZ()-margZmin;
    }
  }
  
  if (eArrTr) {
    EdbTrackP *t;
    EdbSegP   *s;
    for(int i=0; i<eArrTr->GetEntriesFast(); i++) {
      t = (EdbTrackP *)eArrTr->At(i);
      if(!t) continue;
      for(int j=0; j<t->N(); j++) {
    s = t->GetSegment(j);
    if(!s) continue;
    if(xmax-xmin<margR) {
      xmax=s->X()+margR;
      xmin=s->X()-margR;
      ymax=s->Y()+margR;
      ymin=s->Y()-margR;
      zmax=s->Z()+margZmax;
      zmin=s->Z()-margZmin;
    }
    if(xmax<s->X()+margR) xmax=s->X()+margR;
    if(xmin>s->X()-margR) xmin=s->X()-margR;
    if(ymax<s->Y()+margR) ymax=s->Y()+margR;
    if(ymin>s->Y()-margR) ymin=s->Y()-margR;
    if(zmax<s->Z()+margZmax) zmax=s->Z()+margZmax;
    if(zmin>s->Z()-margZmin) zmin=s->Z()-margZmin;
      }
    }
  }
  if(gEDBDEBUGLEVEL>1) {
    printf("Guess Range:\n");
    printf("X: %10.1f %10.1f\n",xmin,xmax);
    printf("Y: %10.1f %10.1f\n",ymin,ymax);
    printf("Z: %10.1f %10.1f\n",zmin,zmax);
  }
  SetRange(xmin,xmax,ymin,ymax,zmin,zmax);
  fZooms=0;
}

Refresh()

void EdbDisplay::Refresh ( )

virtual

Reimplemented from EdbDisplayBase.

{
  EdbSegP *seg=0;
  if( eArrSegP ) {
    int nseg = eArrSegP->GetEntriesFast();
    printf("%d segments to draw...\n",nseg);
    for(int j=0;j<nseg;j++) {
      seg = (EdbSegP*)(eArrSegP->At(j));
      if (seg)
      {
        SegLine(seg)->Draw();
      }
    }
  }
 
 
  EdbTrackP *tr=0;
  if( eArrTr ) {
    int ntr = eArrTr->GetEntriesFast();
    printf("%d tracks to draw...\n",ntr);
    for(int j=0;j<ntr;j++) {
      tr = (EdbTrackP*)(eArrTr->At(j));
      if(tr)
      {
        TrackDraw(tr);
      }
    }
  }
 
  EdbVertex *v=0;
  if( eArrV ) {
    int nv = eArrV->GetEntriesFast();
    printf("%d vertices to draw...\n",nv);
    for(int j=0;j<nv;j++) {
      v = (EdbVertex*)(eArrV->At(j));
      if (v)
      {
        VertexDraw(v);
      }
    }
  }
 
  if( eArrSegG ) {
    int nseg = eArrSegG->GetEntriesFast();
    printf("%d Graph segments to draw...\n",nseg);
    for(int j=0;j<nseg;j++) {
      EdbSegG *sg = (EdbSegG*)(eArrSegG->At(j));
      if (sg)        sg->Draw();
    }
  }
 
  if (eSegment)
  {
    eSegPM = new TPolyMarker3D(1);
    eSegPM->SetMarkerStyle(kFullCircle);
    float dz = TMath::Abs(eSegment->DZ()/2.);
    eSegPM->SetPoint(0, 
                eSegment->X() + eSegment->TX()*dz,
            eSegment->Y() + eSegment->TY()*dz,
            eSegment->Z() +                dz);
    eSegPM->SetMarkerColor(kGreen);
    eSegPM->SetMarkerSize(1.2);
    eSegPM->SetBit(kCannotPick);
    eSegPM->Draw();
  }
}

RemoveTrackFromTable()

void EdbDisplay::RemoveTrackFromTable

(

int

ivt = 0

)

{
  char text[512];
  EdbTrackP *etr = 0;
  if (eWait_Answer) return;
  if (!(eVertex)) return;
  Log(3,"EdbDisplay::RemoveTrackFromTable","%d tracks in vertex before",eVertex->N());
  
  EdbVTA *vta = 0;
  EdbVertex *ePreviousSaved = ePrevious;
  int n = 0;
  int ntr = 0;
  if (eWorking == 0)
    {
      ntr = eVertex->N();
      if (ntr < 3)
    {
      
      printf("Working vertex has 2 prongs only!\n");
      fflush(stdout);
      return;
    }
      if (eVerRec) if (eVerRec->IsA() != EdbVertexRec::Class()) eVerRec = 0;
      if (!eVerRec) {
    printf("Error: EdbDisplay:RemoveTrackFromTable: EdbVertexRec not defined, use SetVerRec(...)\n"); 
    fflush(stdout); return;
      }
      eWorking = new EdbVertex();
      int i = 0;
      etr = eVertex->GetTrack(ivt);
      for(i=0; i<ntr; i++)
    {
      if (i == ivt)
        {
          etr->ClearVTA(eVertex->GetVTa(i));
          continue;
        }
      if ((vta = (eVerRec)->EdbVertexRec::AddTrack( *(eWorking), (eVertex)->GetTrack(i), (eVertex)->Zpos(i))))
        {
          ((eVertex)->GetTrack(i))->AddVTA(vta);
          n++;
        }
    }
    }
  else
    {
      ntr = eWorking->N();
      if (ntr < 3)
    {
      
      printf("Working vertex has 2 prongs only!\n");
      fflush(stdout);
      return;
    }
      if (eVerRec) if (eVerRec->IsA() != EdbVertexRec::Class()) eVerRec = 0;
      if (!eVerRec) {printf("Error: EdbDisplay:RemoveTrackFromTable: EdbVertexRec not defined, use SetVerRec(...)\n"); fflush(stdout); return;}
      etr = eWorking->GetTrack(ivt);
      ePrevious = eWorking;
      eWorking = new EdbVertex();
      int i = 0;
      for(i=0; i<ntr; i++)
    {
      if (i == ivt)
        {
          etr->ClearVTA(ePrevious->GetVTa(i));
          continue;
        }
      if ((vta = (eVerRec)->EdbVertexRec::AddTrack(*(eWorking),(ePrevious)->GetTrack(i), (ePrevious)->Zpos(i))))
        {
          ((ePrevious)->GetTrack(i))->AddVTA(vta);
          n++;
        }
    }
    }
  if ((n < 2)||(n == ntr))
    {
      delete eWorking;
      if (ePrevious)
    {
      eWorking = ePrevious;
      (eWorking)->ResetTracks();
      ePrevious = ePreviousSaved;
    }
      else
    {
      eWorking = 0;
      (eVertex)->ResetTracks();
    }
      printf("Can't create working copy of the vertex!\n");
      fflush(stdout);
      return;
    }
 
  if ((eVerRec)->MakeV(*(eWorking)))
    {
      EdbVertex *eW = eWorking;
      eW->ResetTracks();
      eW->SetID(eVertex->ID());
      eW->V()->rmsDistAngle();
      sprintf(text,"New     %-4d  %-4d  %-8.1f   %-8.1f   %-8.1f   %-6.1f %-7.1f  %-7.5f",
          eW->ID(), eW->N(), eW->VX(), eW->VY(), eW->VZ(), eW->V()->dist(),
          eW->V()->chi2()/eW->V()->ndf(), eW->V()->prob());
      DrawOldBut("Original");
      if (ePrevious)
    {
      DrawNewVTX(text);
      DrawNewBut("Modified");
      eW = ePrevious;
      sprintf(text,"Pre     %-4d  %-4d  %-8.1f   %-8.1f   %-8.1f   %-6.1f %-7.1f  %-7.5f",
          eW->ID(), eW->N(), eW->VX(), eW->VY(), eW->VZ(), eW->V()->dist(),
          eW->V()->chi2()/eW->V()->ndf(), eW->V()->prob());
      DrawPreVTX(text);
      DrawPreBut("Previous");
    }
      else
    {
      DrawPreVTX(text);
      DrawPreBut("Modified");
      if (eVertex->ID() >= 0)
        {
          DrawAcc();
          DrawCan();
          DrawUnd();
        }
    }
      //    DrawOldBut("Original");
      TButton *rm = fRemBut[ivt];
      fRemBut[ivt] = 0;
      DrawVTXTracks("Modified", eWorking);
      if (eArrV && (eIndVert >= 0)) 
    {
      //        eArrV->RemoveAt(eIndVert);
      eArrV->AddAt(eWorking, eIndVert);
    }   
      //    if (eCreatedTracks.FindObject(etr))
      //    {
      //        eCreatedTracks.Remove(etr);
      //        if ( eArrTr)
      //        if (eArrTr->FindObject(etr)) eArrTr->Remove(etr);
      //        if ( eArrTrSave)
      //        if (eArrTrSave->FindObject(etr)) eArrTrSave->Remove(etr);
      //        delete etr;
      //    } 
      fCanvas->cd();
      Draw();
      fPad->Update(); 
      if (ePreviousSaved) delete ePreviousSaved;
      ePreviousSaved = 0;
      fCanvasVTX->cd();
      if (rm) delete rm;
    }
  else
    {
      delete eWorking;
      if (ePrevious)
    {
      eWorking = ePrevious;
      (eWorking)->ResetTracks();
      ePrevious = ePreviousSaved;
    }
      else
    {
      eWorking = 0;
      (eVertex)->ResetTracks();
    }
      printf("Can't create new vertex after track removing!\n");
      fflush(stdout);
    }
}

SegLine()

EdbSegG * EdbDisplay::SegLine

(

const EdbSegP *

seg

)

---

{
  if (!seg) return 0;
  float dz = TMath::Abs(seg->DZ())/2.;
  EdbSegG *line = new EdbSegG(2, this);
  //line->SetPoint(0, seg->X(), seg->Y(), seg->Z()-dz );
  line->SetPoint(0,
                 seg->X() - seg->TX()*dz,
                 seg->Y() - seg->TY()*dz,
                 seg->Z() -           dz);
  line->SetPoint(1,
                 seg->X() + seg->TX()*dz,
                 seg->Y() + seg->TY()*dz,
                 seg->Z() +           dz);
 
  int npieces=eToPlate-eFromPlate;
  line->SetLineColor(gStyle->GetColorPalette(150+int(46.*(1.-1.*(seg->PID()-eFromPlate)/npieces))));  
  //line->SetLineColor( 2+seg->PID()%7 );
  Width_t lwf = int(seg->W()/10.);
  if (lwf > 3) lwf = 2;
  line->SetLineWidth(lwf*fLineWidth);
  if (seg->Track() <= -2) line->SetLineWidth(3*lwf*fLineWidth);
  line->SetSeg(seg);
  return line;
}

SelectVertexTracks()

void EdbDisplay::SelectVertexTracks

(

TObjArray *

vtx

)

{
  if (!vtx) return;
 
  if (!eArrTr) eArrTr = new TObjArray();
  else eArrTr->Clear();
 
  Int_t nv = vtx->GetEntriesFast();
 
  for (Int_t i = 0; i < nv; i++) {
    EdbVertex *vertex = (EdbVertex*)(vtx->At(i));
    if (!vertex || vertex->Flag() < 0) continue;
    for (Int_t j = 0; j < vertex->N(); j++) eArrTr->Add(vertex->GetTrack(j));
  }
}

Set0()

void EdbDisplay::Set0 ( )

virtual

Reimplemented from EdbDisplayBase.

{
  //eVerRec = ((EdbVertexRec *)(gROOT->GetListOfSpecials()->FindObject("EdbVertexRec")));
  //if (eVerRec) if (eVerRec->IsA() != EdbVertexRec::Class()) eVerRec = 0;
  //if (!eVerRec) {printf("Warning: EdbDisplay:Set0: EdbVertexRec not defined, use SetVerRec(...)\n");}
  eArrSegG = 0;
  eArrSegP = 0;
  eArrTr   = 0;
  eArrV    = 0;
  eArrSegPSave = 0;
  eArrTrSave   = 0;
  eArrVSave    = 0;
  eDrawTracks = 1;
  eDrawVertex = 0;
  eColors  = 0;
  eDZs     = 0;
  eVertex  = 0;
  eWorking = 0;
  ePrevious= 0;
  eSegment = 0;
  eTrack   = 0;
  eTrack1   = 0;
  eTrack2   = 0;
  eSegPM = 0;
  eWait_Answer = false;
  eIndVert = -1;
  eIndVertSave = -1;
  eRadMax = 10000.;
  eDpat = 2;
  eImpMax = 1000.;
  eSegWmin = 9;
  eP = 0.;
  eM = 0.;
  eTImpMax = 10000.;
  eTProbMin = 0.0;
  fNumericEntries[0] = 0;
  fNumericEntries[1] = 0;
  fNumericEntries[2] = 0;
  eFromPlate=1;
  eToPlate=57;
  if (fCanvas) fCanvas->Connect("Closed()", "EdbDisplay", this, "Delete()");
}

SetArrSegG()

void EdbDisplay::SetArrSegG ( TObjArray *  arrg )

inline

{eArrSegG = arrg;}

SetArrSegP()

void EdbDisplay::SetArrSegP

(

TObjArray *

arr

)

{
  eArrSegP=arr;
 
  float x = 0., y = 0., z = 0;
  float wx0 = fVx0, wy0 = fVy0, wz0 = fVz0;
  float wx1 = fVx1, wy1 = fVy1, wz1 = fVz1;
 
  EdbSegP *seg=0;
  if( eArrSegP ) {
    int nseg = eArrSegP->GetEntriesFast();
    for(int j=0;j<nseg;j++) {
      seg = (EdbSegP*)(eArrSegP->At(j));
      if (seg)
      {
    x = seg->X();
    y = seg->Y();
    z = seg->Z();
    if (fView == 0)
    {
        wx0 = x < wx0 ? x : wx0;
        wy0 = y < wy0 ? y : wy0;
        wz0 = z < wz0 ? z : wz0;
        wx1 = x > wx1 ? x : wx1;
        wy1 = y > wy1 ? y : wy1;
        wz1 = z > wz1 ? z : wz1;
    }
      }
    }
  }
  if (fView == 0)
  {
    if (wx0 < fVx0) fVx0 = wx0 - 500.;
    if (wy0 < fVy0) fVy0 = wy0 - 500.;
    if (wz0 < fVz0) fVz0 = wz0 - 500.;
    if (wx1 > fVx1) fVx1 = wx1 + 500.;
    if (wy1 > fVy1) fVy1 = wy1 + 500.;
    if (wz1 > fVz1) fVz1 = wz1 + 500.;
  }
}

SetArrTr()

void EdbDisplay::SetArrTr

(

TObjArray *

arr

)

{
  eArrTr=arr;
 
  float x = 0., y = 0., z = 0;
  float wx0 = fVx0, wy0 = fVy0, wz0 = fVz0;
  float wx1 = fVx1, wy1 = fVy1, wz1 = fVz1;
 
  EdbTrackP *tr=0;
  if( eArrTr ) {
    int ntr = eArrTr->GetEntriesFast();
    for(int j=0;j<ntr;j++) {
      tr = (EdbTrackP*)(eArrTr->At(j));
      if(tr)
      {
    if (fView == 0)
    {
        if (tr->NF())
        {
        x = tr->TrackZmin()->X();
        y = tr->TrackZmin()->Y();
        z = tr->TrackZmin()->Z();
        }
        else
        {
        eRadMax = 0;
        x = tr->GetSegmentFirst()->X();
        y = tr->GetSegmentFirst()->Y();
        z = tr->GetSegmentFirst()->Z();
        }
        wx0 = x < wx0 ? x : wx0;
        wy0 = y < wy0 ? y : wy0;
        wz0 = z < wz0 ? z : wz0;
        wx1 = x > wx1 ? x : wx1;
        wy1 = y > wy1 ? y : wy1;
        wz1 = z > wz1 ? z : wz1;
        if (tr->NF())
        {
        x = tr->TrackZmax()->X();
        y = tr->TrackZmax()->Y();
        z = tr->TrackZmax()->Z();
        }
        else
        {
        eRadMax = 0;
        x = tr->GetSegmentLast()->X();
        y = tr->GetSegmentLast()->Y();
        z = tr->GetSegmentLast()->Z();
        }
        wx0 = x < wx0 ? x : wx0;
        wy0 = y < wy0 ? y : wy0;
        wz0 = z < wz0 ? z : wz0;
        wx1 = x > wx1 ? x : wx1;
        wy1 = y > wy1 ? y : wy1;
        wz1 = z > wz1 ? z : wz1;
    }
      }
    }
  }
  if (fView == 0)
  {
    if (wx0 < fVx0) fVx0 = wx0 - 500.;
    if (wy0 < fVy0) fVy0 = wy0 - 500.;
    if (wz0 < fVz0) fVz0 = wz0 - 500.;
    if (wx1 > fVx1) fVx1 = wx1 + 500.;
    if (wy1 > fVy1) fVy1 = wy1 + 500.;
    if (wz1 > fVz1) fVz1 = wz1 + 500.;
  }
}

SetArrV()

void EdbDisplay::SetArrV

(

TObjArray *

arrv

)

{
  eArrV=arrv;
 
  float x = 0., y = 0., z = 0;
  float wx0 = fVx0, wy0 = fVy0, wz0 = fVz0;
  float wx1 = fVx1, wy1 = fVy1, wz1 = fVz1;
 
  EdbVertex *v=0;
  if( eArrV ) {
    int nv = eArrV->GetEntriesFast();
    for(int j=0;j<nv;j++) {
      v = (EdbVertex*)(eArrV->At(j));
      if (v)
      {
    if (fView == 0)
    {
        if (v->V())
        {
        x = v->VX();
        y = v->VY();
        z = v->VZ();
        }
        else
        {
        eRadMax = 0;
        x = v->X();
        y = v->Y();
        z = v->Z();
        }
        wx0 = x < wx0 ? x : wx0;
        wy0 = y < wy0 ? y : wy0;
        wz0 = z < wz0 ? z : wz0;
        wx1 = x > wx1 ? x : wx1;
        wy1 = y > wy1 ? y : wy1;
        wz1 = z > wz1 ? z : wz1;
    }
      }
    }
  }
  if (fView == 0)
  {
    if (wx0 < fVx0) fVx0 = wx0 - 500.;
    if (wy0 < fVy0) fVy0 = wy0 - 500.;
    if (wz0 < fVz0) fVz0 = wz0 - 500.;
    if (wx1 > fVx1) fVx1 = wx1 + 500.;
    if (wy1 > fVy1) fVy1 = wy1 + 500.;
    if (wz1 > fVz1) fVz1 = wz1 + 500.;
  }
}

SetDrawTracks()

void EdbDisplay::SetDrawTracks ( int  opt )

inline

{eDrawTracks=opt;}

SetDrawVertex()

void EdbDisplay::SetDrawVertex ( int  opt )

inline

{eDrawVertex=opt;}

SetVerRec()

void EdbDisplay::SetVerRec ( EdbVertexRec *  evr )

inline

{ eVerRec = evr; };

TrackDraw()

void EdbDisplay::TrackDraw	(	EdbTrackP *	tr,
		Color_t	kColor = kWhite
	)

{
  // eDrawTracks: 1 - draw fitted track dotted line only
  //              2 - draw also white marker at zmin
  //              3 - draw also red marker at zmax
  //              4 - draw also measured segments
  //              5 - draw fitted line and  measured segments, no markers 
  //              6 - draw measured segments only
  //              7 - draw measured segments only
  //              8 - draw only solid white track line
  //             14 - as "4" plus track extrapolation line
 
  if (!tr) return;
  TPolyLine3D *line=0;
  const EdbSegP *seg=0;
  float dz = 0.;
 
  if(eDrawTracks%10>0 && eDrawTracks%10<6) {   // only dotted track line
    line = new TPolyLine3D(tr->N());
    if (tr->NF())    {
      for(int is=0; is<tr->NF(); is++) {
    seg = tr->GetSegmentF(is);
    if(seg) 
    {
        if (is == 0)
        {
        dz = TMath::Abs(seg->DZ());
        line->SetPoint(is, seg->X()+seg->TX()*dz,
                   seg->Y()+seg->TY()*dz,
                   seg->Z()+          dz );
        }
        else
        {
        line->SetPoint(is, seg->X(), seg->Y(), seg->Z() );
        }
    }
      }
    }
    else      {
      for(int is=0; is<tr->N(); is++) {
    seg = tr->GetSegment(is);
    if(seg) 
    {
        if (is == 0)
        {
        dz = TMath::Abs(seg->DZ());
        line->SetPoint(is, seg->X()+seg->TX()*dz,
                   seg->Y()+seg->TY()*dz,
                   seg->Z()+          dz);
        }
        else
        {
        line->SetPoint(is, seg->X(), seg->Y(), seg->Z() );
        }
    }
      }
    }
    if (fStyle/2 == 1) line->SetLineColor(kBlack);
    else               line->SetLineColor(kColor);
    line->SetLineWidth(fLineWidth);
    line->SetBit(kCannotPick);
    if (tr->Flag() != -10)
    line->SetLineStyle(3);
    else
    line->SetLineStyle(4);
    line->Draw();
  }
 
  if(eDrawTracks%10>3 && eDrawTracks%10<8 && tr->N()>0 ) {
    for(int is=0; is<tr->N(); is++) {
      seg = tr->GetSegment(is);
      if (seg) SegLine(seg)->Draw();
    }
  }
 
  if(eDrawTracks%10>7) {
    line = new TPolyLine3D(tr->N());
    if (tr->NF()){
      for(int is=0; is<tr->NF(); is++) {
    seg = tr->GetSegmentF(is);
    if(seg) line->SetPoint(is, seg->X(), seg->Y(), seg->Z() );
      }
    }    else    {
      for(int is=0; is<tr->N(); is++) {
    seg = tr->GetSegment(is);
    if(seg) line->SetPoint(is, seg->X(), seg->Y(), seg->Z() );
      }
    }
    if (fStyle/2 == 1) line->SetLineColor(kBlack);
    else               line->SetLineColor(kColor);
    line->SetLineWidth(fLineWidth);
    line->SetLineStyle(1);
    line->Draw();
  }
 
  if(eDrawTracks%10>1 && eDrawTracks%10<5) {
    EdbTrackG *pms = new EdbTrackG(1, this);
    pms->SetTrack( tr );
    pms->SetMarkerStyle(kOpenCircle);
 
    if (tr->NF())      seg = tr->TrackZmin();
    else               seg = tr->GetSegmentFirst();
    if(seg) {
      pms->SetPoint(0, seg->X(), seg->Y(), seg->Z() );
      if (fStyle/2 == 1) pms->SetMarkerColor(kBlack);
      else               pms->SetMarkerColor(kColor);
      pms->SetMarkerSize(1.2);
      pms->Draw();
      //printf("White track edge, Id %d, Nseg %d.\n", tr->ID(), tr->N());
    }
  }
 
  if(eDrawTracks%10>2 && eDrawTracks%10<5) {
    EdbTrackG *pme = new EdbTrackG(1, this);
    pme->SetTrack( tr );
    pme->SetMarkerStyle(kOpenCircle);
 
    if (tr->NF())      seg = tr->TrackZmax();
    else               seg = tr->GetSegmentLast();
    if(seg) {
      pme->SetPoint(0, seg->X(), seg->Y(), seg->Z() );
//      dz = TMath::Abs(seg->DZ());
//      pme->SetPoint(0, seg->X()+seg->TX()*dz,
//                 seg->Y()+seg->TY()*dz,
//             seg->Z()+          dz);
      pme->SetMarkerColor(kRed);
      pme->SetMarkerSize(1.2);
      pme->Draw();
    }
  }
 
}

UndoModifiedVTX()

void EdbDisplay::UndoModifiedVTX

(

)

{
    char text[512];
    EdbTrackP *LastCreated = 0;
    int CreatedInd = eCreatedTracks.GetSize();
    if (CreatedInd > 0) LastCreated = (EdbTrackP *)eCreatedTracks.At(CreatedInd-1); 
    if (ePrevious)
    {
    int InWork = 0;
    if (LastCreated)
    {
        for (int i=0; i<eWorking->N(); i++)
        if (eWorking->GetTrack(i) == LastCreated)
            InWork = 1;
    }
    int InPrev = 0;
    if (LastCreated)
    {
        for (int i=0; i<ePrevious->N(); i++)
        if (ePrevious->GetTrack(i) == LastCreated)
            InPrev = 1;
    }
    delete eWorking;
    if (InWork && !InPrev)
    {
        eCreatedTracks.Remove(LastCreated);
        if (eArrTr) if (eArrTr->FindObject(LastCreated))
        {
        eArrTr->Remove(LastCreated);
        eArrTr->Compress();
        }
        if (eArrTrSave) if (eArrTrSave->FindObject(LastCreated))
        {
        eArrTrSave->Remove(LastCreated);
        eArrTrSave->Compress();
        }
        delete LastCreated;
    }
    eWorking = ePrevious;
    (eWorking)->ResetTracks();
    EdbVertex *eW = eWorking;
    eW->V()->rmsDistAngle();
    sprintf(text,"New     %-4d  %-4d  %-8.1f   %-8.1f   %-8.1f   %-6.1f %-7.1f  %-7.5f",
    eW->ID(), eW->N(), eW->VX(), eW->VY(), eW->VZ(), eW->V()->dist(),
    eW->V()->chi2()/eW->V()->ndf(), eW->V()->prob());
    DrawPreVTX(text);
    DrawPreBut("Modified");
    ClearNewVTX();
    if (fNewBut)
    {
        delete fNewBut;
        fNewBut = 0;
    }
    ePrevious = 0;
    DrawVTXTracks("Modified", eWorking);
    if (eIndVert >= 0) 
    {
//      eArrV->RemoveAt(eIndVert);
        eArrV->AddAt(eWorking, eIndVert);
    }
    Draw(); 
    }
    else if (eWorking)
    {
    EdbTrackP *tr = eWorking->GetTrack(eWorking->N() - 1);
    delete eWorking;
    if (tr && eCreatedTracks.FindObject(tr))
    {
        eCreatedTracks.Remove(tr);
        if (eArrTr) if (eArrTr->FindObject(tr))
        {
        eArrTr->Remove(tr);
        eArrTr->Compress();
        }
        if (eArrTrSave) if (eArrTrSave->FindObject(tr))
        {
        eArrTrSave->Remove(tr);
        eArrTrSave->Compress();
        }
        delete tr;
    }
    (eVertex)->ResetTracks();
    EdbVertex *eW = eVertex;
    eW->V()->rmsDistAngle();
    sprintf(text,"Orig    %-4d  %-4d  %-8.1f   %-8.1f   %-8.1f   %-6.1f %-7.1f  %-7.5f",
    eW->ID(), eW->N(), eW->VX(), eW->VY(), eW->VZ(), eW->V()->dist(),
    eW->V()->chi2()/eW->V()->ndf(), eW->V()->prob());
    DrawOldVTX(text);
    ClearPreVTX();
    if (fPreBut)
    {
        delete fPreBut;
        fPreBut = 0;
    }
    if (fOldBut)
    {
        delete fOldBut;
        fOldBut = 0;
    }
    eWorking = 0;
    DrawVTXTracks("Original", eVertex);
    if (eArrV && (eIndVert >= 0)) 
    {
//      eArrV->RemoveAt(eIndVert);
        eArrV->AddAt(eVertex, eIndVert);
    }
    TList *li = fTrigPad->GetListOfPrimitives();
    if (li)
    {
        li->Remove(fUndButton);
        li->Remove(fAccButton);
        li->Remove(fCanButton);
    }
    Draw(); 
    }
}

VerRec()

EdbVertexRec* EdbDisplay::VerRec ( ) const

inline

{return eVerRec;}

VertexDraw()

void EdbDisplay::VertexDraw

(

EdbVertex *

v

)

{
  float xv,yv,zv;
  if (!vv) return;
  //if (vv->Flag() == -10) {
  Log(2,"EdbDisplay::VertexDraw","id=%d  %d-prong  flag = %d",  vv->ID(), vv->N(), vv->Flag() );
    //return;
    //}
  EdbVertexG *v = new EdbVertexG(this);
  v->SetVertex( vv );
 
  xv = vv->X();
  yv = vv->Y();
  zv = vv->Z();
 
  v->SetPoint(0, xv, yv, zv);
  v->SetMarkerStyle(kFullCircle);
  if (fStyle/2 == 1) v->SetMarkerColor(kBlack);
  else               v->SetMarkerColor(kWhite);
//  v->Draw();
 
  if (vv->V())
  {
//    v = new EdbVertexG(this);
//    v->SetVertex( vv );
 
    xv = vv->VX();
    yv = vv->VY();
    zv = vv->VZ();
    v->SetPoint(0, xv, yv, zv);
  }
  if (eWorking == vv)
  {
    v->SetMarkerColor(kGreen);
  }
  else if (eVertex == vv)
  {
    if (!eWorking) v->SetMarkerColor(kGreen);
    else
    {
        if (fStyle/2 == 1) v->SetMarkerColor(kBlack);
        else               v->SetMarkerColor(kWhite);
    }
  }
  else
  {
    if (fStyle/2 == 1) v->SetMarkerColor(kBlack);
    else               v->SetMarkerColor(kWhite);
  }
 
  if(vv->Flag()==-10)  v->SetMarkerStyle(kOpenStar);
  else                 v->SetMarkerStyle(kFullStar);
  v->SetMarkerSize(1.2);
  v->Draw();
 
 
  if(eDrawVertex>0) {
    TPolyLine3D *line=0;
    const EdbSegP *seg=0;
    EdbTrackP *tr=0;
    bool measured_segment = false;
    if (eVerRec) measured_segment = eVerRec->eUseSegPar;
    for(int i=0; i<vv->N(); i++ ) {
      tr = vv->GetTrack(i);
      if (!(tr->NF())) measured_segment = true;
 
      seg = vv->GetTrackV(i,measured_segment);         if(!seg) continue;
      line = new TPolyLine3D(2);
      line->SetPoint(0, xv,yv,zv );
      line->SetPoint(1, seg->X(), seg->Y(), seg->Z());
      if (fStyle/2 == 1) line->SetLineColor(kBlack);
      else               line->SetLineColor(kYellow);
      line->SetLineWidth(2);
      line->SetBit(kCannotPick);
      line->Draw();
      if(eDrawTracks>10)  DrawSegmentExtrapolationLine( *seg, seg->Z(), zv );
    }
    for(int i=0; i<vv->Nn(); i++ ) {    //draw auxillary tracks if any
      EdbVTA * vtn = vv->GetVTn(i);
      if (vtn->Flag() < 3){ //neighbor track
       EdbTrackP *t = vv->GetTrackN(i);
       TrackDraw(t);
       if(eDrawTracks>10)  DrawSegmentExtrapolationLine( *((EdbSegP *)t), t->Z(), zv );
      }
      else if (vtn->Flag()==3){ //neighbor vertex
       EdbVertex *neighv = (EdbVertex*) vv->GetTrackN(i);
       int currentdrawvertexopt = eDrawVertex;
       eDrawVertex= 0; //do not look for neighbors of this neighbor vertex
       VertexDraw(neighv);
       eDrawVertex = currentdrawvertexopt;
      }
    }
  }
}

Member Data Documentation

eArrSegG

TObjArray* EdbDisplay::eArrSegG

eArrSegP

TObjArray* EdbDisplay::eArrSegP

eArrSegPSave

TObjArray* EdbDisplay::eArrSegPSave

eArrTr

TObjArray* EdbDisplay::eArrTr

eArrTrSave

TObjArray* EdbDisplay::eArrTrSave

eArrV

TObjArray* EdbDisplay::eArrV

eArrVSave

TObjArray* EdbDisplay::eArrVSave

eColors

TArrayI* EdbDisplay::eColors

private

eCreatedTracks

TList EdbDisplay::eCreatedTracks

eDpat

Double_t EdbDisplay::eDpat

eDrawTracks

Int_t EdbDisplay::eDrawTracks

private

eDrawVertex

Int_t EdbDisplay::eDrawVertex

private

eDZs

TArrayF* EdbDisplay::eDZs

private

eFromPlate

Int_t EdbDisplay::eFromPlate

eImpMax

Double_t EdbDisplay::eImpMax

eIndVert

Int_t EdbDisplay::eIndVert

eIndVertSave

Int_t EdbDisplay::eIndVertSave

eM

Double_t EdbDisplay::eM

eP

Double_t EdbDisplay::eP

ePrevious

EdbVertex* EdbDisplay::ePrevious

eRadMax

Double_t EdbDisplay::eRadMax

eSegment

EdbSegP* EdbDisplay::eSegment

eSegPM

TPolyMarker3D* EdbDisplay::eSegPM

eSegWmin

Double_t EdbDisplay::eSegWmin

eTImpMax

Double_t EdbDisplay::eTImpMax

eToPlate

Int_t EdbDisplay::eToPlate

eTProbMin

Double_t EdbDisplay::eTProbMin

eTrack

EdbTrackP* EdbDisplay::eTrack

eTrack1

EdbTrackP* EdbDisplay::eTrack1

eTrack2

EdbTrackP* EdbDisplay::eTrack2

eVerRec

EdbVertexRec* EdbDisplay::eVerRec

eVertex

EdbVertex* EdbDisplay::eVertex

eWait_Answer

Bool_t EdbDisplay::eWait_Answer

eWorking

EdbVertex* EdbDisplay::eWorking

fNumericEntries

TGNumberEntry* EdbDisplay::fNumericEntries[3]

private

---

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

• src/libEdd/EdbDisplay.h
• src/libEdd/EdbDisplay.cxx