EdbTrackG Class Reference

#include <EdbDisplay.h>

Inheritance diagram for EdbTrackG:

Collaboration diagram for EdbTrackG:

Public Member Functions
virtual void	AddToNewTrack ()
virtual void	AddToNewTrackAndFit ()
virtual void	AddTrackToVertex ()
virtual void	DeleteTrack ()
virtual void	DumpTrack ()
	EdbTrackG ()
	EdbTrackG (EdbDisplay *D)
	EdbTrackG (Int_t nhits, EdbDisplay *D)
virtual void	EstimateMomentum ()
virtual void	FixNewTrack ()
virtual const char *	GetName () const
virtual char *	GetObjectInfo (int px, int py) const
virtual const char *	GetTitle () const
virtual void	InfoTrackVert ()
virtual void	InspectTrack ()
virtual void	RemoveTrackFromVertex ()
virtual void	SetAsWorkingVertex ()
void	SetTrack (EdbTrackP *tr)
virtual void	UndoNewTrack ()
virtual void	UndoRemoveKink ()
virtual void	UndoSplit ()
virtual	~EdbTrackG ()

Private Attributes
EdbDisplay *	eD
EdbTrackP *	eTr

Constructor & Destructor Documentation

EdbTrackG() [1/3]

EdbTrackG::EdbTrackG ( )

inline

{eTr=0; eD=0;}

EdbTrackG() [2/3]

EdbTrackG::EdbTrackG ( EdbDisplay *  D )

inline

{eTr=0; eD=D;}

EdbTrackG() [3/3]

EdbTrackG::EdbTrackG ( Int_t  nhits, EdbDisplay *  D  )

inline

:TPolyMarker3D(nhits) {eTr=0; eD=D;}

~EdbTrackG()

virtual EdbTrackG::~EdbTrackG ( )

inlinevirtual

{}

Member Function Documentation

AddToNewTrack()

void EdbTrackG::AddToNewTrack ( )

virtual

{
  if (eTr && eD)
  {
    if (eTr->VTAS() || eTr->VTAE())
    {
        printf("Track belong to a vertex - impossible destroy it!\n");
        fflush(stdout);
        return;
    }
    if (eD->eTrack)
    {
        if ((eD->eTrack)->NF())
        {
        delete eD->eTrack;
        eD->eTrack = 0;
        }
    }
    EdbSegP *seg = 0;
    if (!eD->eTrack) eD->eTrack = new EdbTrackP();
        for(int is=0; is<eTr->N(); is++) {
        seg = eTr->GetSegment(is);
        (eD->eTrack)->AddSegment((EdbSegP *)seg);
    }
    eTr->SetFlag(-10);
    eTr->SetSegmentsTrack(-2-(eTr->ID()+1));
    if(eD->eArrTr) if((eD->eArrTr)->FindObject(eTr))
    {
        eD->eArrTr->Remove(eTr);
        eD->eArrTr->Compress();
        if (!(eD->eArrSegP)) eD->eArrSegP = new TObjArray();
            for(int is=0; is<eTr->N(); is++) {
        seg = eTr->GetSegment(is);
        if(eD->eArrSegP) if(!((eD->eArrSegP)->FindObject(seg))) eD->eArrSegP->Add(seg);
        }
    }
    if(eD->eArrTrSave) if((eD->eArrTrSave)->FindObject(eTr))
    {
        eD->eArrTrSave->Remove(eTr);
        eD->eArrTrSave->Compress();
        if (!(eD->eArrSegPSave)) eD->eArrSegPSave = new TObjArray();
            for(int is=0; is<eTr->N(); is++) {
        seg = eTr->GetSegment(is);
        if(eD->eArrSegPSave) if(!((eD->eArrSegPSave)->FindObject(seg))) eD->eArrSegPSave->Add(seg);
        }
    }
    eD->Draw();
  }
}

AddToNewTrackAndFit()

void EdbTrackG::AddToNewTrackAndFit ( )

virtual

{
  if (eTr && eD)
  {
    if (eTr->VTAS() || eTr->VTAE())
    {
        printf("Track belong to a vertex - impossible destroy it!\n");
        fflush(stdout);
        return;
    }
    EdbSegP *seg = 0;
    if (!eD->eTrack) eD->eTrack = new EdbTrackP();
        for(int is=0; is<eTr->N(); is++) {
        seg = eTr->GetSegment(is);
        (eD->eTrack)->AddSegment((EdbSegP *)seg);
    }
    eTr->SetFlag(-10);
    eTr->SetSegmentsTrack(-2-(eTr->ID()+1));
    if(eD->eArrTr) if((eD->eArrTr)->FindObject(eTr))
    {
        eD->eArrTr->Remove(eTr);
        eD->eArrTr->Compress();
        if (!(eD->eArrSegP)) eD->eArrSegP = new TObjArray();
            for(int is=0; is<eTr->N(); is++) {
        seg = eTr->GetSegment(is);
        if(eD->eArrSegP) if(!((eD->eArrSegP)->FindObject(seg))) eD->eArrSegP->Add(seg);
        }
    }
    if(eD->eArrTrSave) if((eD->eArrTrSave)->FindObject(eTr))
    {
        eD->eArrTrSave->Remove(eTr);
        eD->eArrTrSave->Compress();
        if (!(eD->eArrSegPSave)) eD->eArrSegPSave = new TObjArray();
            for(int is=0; is<eTr->N(); is++) {
        seg = eTr->GetSegment(is);
        if(eD->eArrSegPSave) if(!((eD->eArrSegPSave)->FindObject(seg))) eD->eArrSegPSave->Add(seg);
        }
    }
    eD->Draw();
    float mass = eTr->M();
    float momentum = eTr->P();
    if (eD->eP > 0.) momentum = eD->eP;
    if (eD->eM > 0.) mass = eD->eM;
    eD->eTrack->SetM(mass);
    eD->eTrack->SetP(momentum);
    float X0 = 0.;
    if (eD->eVerRec) if ((eD->eVerRec)->ePVR) X0 = (((eD->eVerRec)->ePVR)->GetScanCond())->RadX0();
    eD->eTrack->FitTrackKFS(true, X0, 0);
    if (!eD->eArrTr) eD->eArrTr = new TObjArray();
    (eD->eArrTr)->Add(eD->eTrack);
    if (eD->eArrTrSave) (eD->eArrTrSave)->Add(eD->eTrack);
    eD->Draw();
  }
}

AddTrackToVertex()

void EdbTrackG::AddTrackToVertex ( )

virtual

{
  char text[512];
  int zpos = 1, zpos2 = 1;
  EdbVTA *vta = 0;
  EdbVertex *old = 0, *eVs = 0;
  EdbTrackP *eTr2 = 0;
  if (eTr && eD)
  {
    if (eD->eWait_Answer) return;
    if (!(eD->eVertex))
    {
    
        printf("No working vertex selected!\n");
        fflush(stdout);
        return;
    }
    if (GetMarkerColor() == kRed) zpos = 0;
    if ((old = eTr->VertexS()) && (zpos == 1))
    {
    
        printf("Track alredy connected to a vertex by this edge!\n");
        fflush(stdout);
        return;
    }
//    {
//  if (old != eD->eVertex && old != eD->ePrevious && old != eD->eWorking) return;
//    } 
    if ((old = eTr->VertexE()) && (zpos == 0))
    {
    
        printf("Track alredy connected to a vertex by this edge!\n");
        fflush(stdout);
        return;
    }
//    {
//  if (old != eD->eVertex && old != eD->ePrevious && old != eD->eWorking) return;
//    } 
    if (eD->eVerRec) if (eD->eVerRec->IsA() != EdbVertexRec::Class()) eD->eVerRec = 0;
    if (!eD->eVerRec) {printf("Error: EdbDisplay:AddTrackToVertex: EdbVertexRec not defined, use SetVerRec(...)\n"); fflush(stdout); return;}
    double ImpMaxSave = 0.;
    double ProbMinSave = 0.;
    if (eD->eVertex->N() == 1 && eD->eVertex->ID() < 0)
    {
    ImpMaxSave = (eD->eVerRec)->eImpMax;
    (eD->eVerRec)->eImpMax = eD->eTImpMax;
    ProbMinSave = (eD->eVerRec)->eProbMin;
    (eD->eVerRec)->eProbMin = eD->eTProbMin;
    eTr2 = (eD->eVertex)->GetTrack(0);
    zpos2 = (eD->eVertex)->Zpos(0);
    if((eVs = eD->eVerRec->ProbVertex2(eTr2, eTr, zpos2, zpos)))
    {
        if (eD->eArrV) 
        {
        if (eD->eArrV->FindObject(eD->eVertex))
        {
            eD->eArrV->Remove(eD->eVertex);
            eD->eArrV->Add(eVs);
        }
        }
        delete eD->eVertex;
        eVs->SetID(-1);
        eD->eVertex = eVs;
        eD->CreateCanvasVTX();
        eVs->V()->rmsDistAngle();
        sprintf(text,"Creat   %-4d  %-4d  %-8.1f   %-8.1f   %-8.1f   %-6.1f %-7.1f  %-7.5f",
        eVs->ID(), eVs->N(), eVs->VX(), eVs->VY(), eVs->VZ(), eVs->V()->dist(),
        eVs->V()->chi2()/eVs->V()->ndf(), eVs->V()->prob());
        eD->DrawOldVTX(text);
        eD->DrawVTXTracks("Created", eD->eVertex);
        eD->DrawEnv();
        eD->Draw();
    }
    else
    {
        printf("EdbTrackG::AddTrackToVertex: New vertex not created! May be Prob < ProbMin=%f. Change ProbMin with 'TrackParams' button!\n",eD->eTProbMin);
    }
    (eD->eVerRec)->eImpMax = ImpMaxSave;
    (eD->eVerRec)->eProbMin = ProbMinSave;
    return;
    }
    EdbVertex *ePreviousSaved = eD->ePrevious;
    if (eD->eWorking == 0)
    {
    eD->eWorking = new EdbVertex();
    int ntr = eD->eVertex->N();
    int i = 0, n = 0;
    for(i=0; i<ntr; i++)
    {
        if ((vta = (eD->eVerRec)->AddTrack(*(eD->eWorking), (eD->eVertex)->GetTrack(i), (eD->eVertex)->Zpos(i))))
        {
        (eD->eVertex)->GetTrack(i)->AddVTA(vta);
        n++;
        }
    }
    if (n < 2)
    {
        delete eD->eWorking;
        if (eD->ePrevious)
        {
        eD->eWorking = eD->ePrevious;
        (eD->eWorking)->ResetTracks();
        }
        else
        {
        eD->eWorking = 0;
        (eD->eVertex)->ResetTracks();
        }
        printf("Can't create working copy of the vertex!\n");
        fflush(stdout);
        return;
    }
 
    if (!((eD->eVerRec)->MakeV(*(eD->eWorking))))
    {
        delete eD->eWorking;
        if (eD->ePrevious)
        {
        eD->eWorking = eD->ePrevious;
        (eD->eWorking)->ResetTracks();
        }
        else
        {
        eD->eWorking = 0;
        (eD->eVertex)->ResetTracks();
        }
        printf("Can't create working copy of the vertex!\n");
        fflush(stdout);
        return;
    }
    }
    else
    {
//  if (ePrevious) delete ePrevious;
    eD->ePrevious = eD->eWorking;
    eD->eWorking = new EdbVertex();
    int ntr = eD->ePrevious->N();
    int i = 0, n = 0;
    for(i=0; i<ntr; i++)
    {
        if ((vta = (eD->eVerRec)->AddTrack(*(eD->eWorking),(eD->ePrevious)->GetTrack(i), (eD->ePrevious)->Zpos(i))))
        {
        ((eD->ePrevious)->GetTrack(i))->AddVTA(vta);
        n++;
        }
    }
    if (n < 2)
    {
        delete eD->eWorking;
        if (eD->ePrevious)
        {
        eD->eWorking = eD->ePrevious;
        (eD->eWorking)->ResetTracks();
        eD->ePrevious = ePreviousSaved;
        }
        else
        {
        eD->eWorking = 0;
        (eD->eVertex)->ResetTracks();
        }
        printf("Can't create working copy of the vertex!\n");
        fflush(stdout);
        return;
    }
 
    if (!((eD->eVerRec)->MakeV(*(eD->eWorking))))
    {
        delete eD->eWorking;
        if (eD->ePrevious)
        {
        eD->eWorking = eD->ePrevious;
        (eD->eWorking)->ResetTracks();
        eD->ePrevious = ePreviousSaved;
        }
        else
        {
        eD->eWorking = 0;
        (eD->eVertex)->ResetTracks();
        }
        printf("Can't create working copy of the vertex!\n");
        fflush(stdout);
        return;
    }
    }
    ImpMaxSave = (eD->eVerRec)->eImpMax;
    (eD->eVerRec)->eImpMax = eD->eTImpMax;
    ProbMinSave = (eD->eVerRec)->eProbMin;
    (eD->eVerRec)->eProbMin = eD->eTProbMin;
    if ((vta = (eD->eVerRec)->AddTrack(*(eD->eWorking), eTr, zpos)))
    {
    eTr->AddVTA(vta);
    EdbVertex *eW = eD->eWorking;
    eW->SetID(eD->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());
    eD->DrawOldBut("Original");
    if (eD->ePrevious)
    {
        eD->DrawNewVTX(text);
        eD->DrawNewBut("Modified");
        eW = eD->ePrevious;
        eW->V()->rmsDistAngle();
        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());
        eD->DrawPreVTX(text);
        eD->DrawPreBut("Previous");
    }
    else
    {
        eD->DrawPreVTX(text);
        eD->DrawPreBut("Modified");
        if (eD->eVertex->ID() >= 0)
        {
        eD->DrawAcc();
        eD->DrawCan();
        eD->DrawUnd();
        }
    }
//  eD->DrawOldBut("Original");
    eD->DrawVTXTracks("Modified", eD->eWorking);
    if (eD->eArrV && (eD->eIndVert >= 0)) 
    {
//      eD->eArrV->RemoveAt(eD->eIndVert);
        eD->eArrV->AddAt(eD->eWorking, eD->eIndVert);
    }   
    eD->Draw();
    if (ePreviousSaved) delete ePreviousSaved;
    ePreviousSaved = 0;
    (eD->eVerRec)->eImpMax = ImpMaxSave;
    (eD->eVerRec)->eProbMin = ProbMinSave;
    }
    else
    {
    printf("Track not added! May be Prob < ProbMin. Change ProbMin with 'TrackParams' button!\n");
    fflush(stdout);
    delete eD->eWorking;
    if (eD->ePrevious)
    {
        eD->eWorking = eD->ePrevious;
        (eD->eWorking)->ResetTracks();
        eD->ePrevious = ePreviousSaved;
    }
    else
    {
        eD->eWorking = 0;
        (eD->eVertex)->ResetTracks();
    }
    (eD->eVerRec)->eImpMax = ImpMaxSave;
    (eD->eVerRec)->eProbMin = ProbMinSave;
    return;
    }
  }
}

DeleteTrack()

void EdbTrackG::DeleteTrack ( )

virtual

{
  if (eTr && eD)
  {
    if (eTr->VTAS() || eTr->VTAE())
    {
        printf("Track belong to a vertex - impossible delete it!\n");
        fflush(stdout);
        return;
    }
    eTr->SetFlag(-10);
    eTr->SetSegmentsTrack(-1);
    EdbSegP *seg = 0;
    if(eD->eArrTr) if((eD->eArrTr)->FindObject(eTr))
    {
        eD->eArrTr->Remove(eTr);
        eD->eArrTr->Compress();
        if (!(eD->eArrSegP)) eD->eArrSegP = new TObjArray();
            for(int is=0; is<eTr->N(); is++) {
        seg = eTr->GetSegment(is);
        if(eD->eArrSegP) if(!((eD->eArrSegP)->FindObject(seg))) eD->eArrSegP->Add(seg);
        }
    }
    if(eD->eArrTrSave) if((eD->eArrTrSave)->FindObject(eTr))
    {
        eD->eArrTrSave->Remove(eTr);
        eD->eArrTr->Compress();
        if (!(eD->eArrSegPSave)) eD->eArrSegPSave = new TObjArray();
            for(int is=0; is<eTr->N(); is++) {
        seg = eTr->GetSegment(is);
        if(eD->eArrSegPSave) if(!((eD->eArrSegPSave)->FindObject(seg))) eD->eArrSegPSave->Add(seg);
        }
    }
    eD->Draw();
  }
}

DumpTrack()

void EdbTrackG::DumpTrack ( )

virtual

{
  if (eTr) eTr->Print();
}

EstimateMomentum()

void EdbTrackG::EstimateMomentum ( )

virtual

{
  if (!eTr) return;
  EdbMomentumEstimator me;
  me.PMSang(*eTr);
  me.DrawPlots();
}

FixNewTrack()

void EdbTrackG::FixNewTrack ( )

virtual

{
  if (eTr && eD)
  {
    if (eD->eTrack)
    {
        if (eTr == eD->eTrack)
        {
            TObjArray *etr = 0;
            if (eD->eVerRec) etr = (eD->eVerRec)->eEdbTracks;
            int trind = 0;
            if (etr) trind = etr->GetEntriesFast();
            (eD->eTrack)->SetID(trind);
            if (etr) etr->Add(eD->eTrack);
            (eD->eTrack)->SetSegmentsTrack();
            eD->eTrack = 0;
            eD->Draw();
        }
    }
    if (eD->eTrack1)
    {
        if (eTr == eD->eTrack1)
        {
            TObjArray *etr = 0;
            if (eD->eVerRec) etr = (eD->eVerRec)->eEdbTracks;
            int trind = 0;
            if (etr) trind = etr->GetEntriesFast();
            (eD->eTrack1)->SetID(trind);
            if (etr) etr->Add(eD->eTrack1);
            (eD->eTrack1)->SetSegmentsTrack();
            eD->eTrack1 = 0;
            eD->Draw();
        }
    }
 
    if (eD->eTrack2)
    {
        if (eTr == eD->eTrack2)
        {
            TObjArray *etr = 0;
            if (eD->eVerRec) etr = (eD->eVerRec)->eEdbTracks;
            int trind = 0;
            if (etr) trind = etr->GetEntriesFast();
            (eD->eTrack2)->SetID(trind);
            if (etr) etr->Add(eD->eTrack2);
            (eD->eTrack2)->SetSegmentsTrack();
            eD->eTrack2 = 0;
            eD->Draw();
        }
    }
  }
}

GetName()

const char * EdbTrackG::GetName ( ) const

virtual

{
    static char name[] = "Track";
    return name;
}

GetObjectInfo()

char * EdbTrackG::GetObjectInfo ( int  px, int  py  ) const

virtual

{
    static char coordinates[80];
    float tx = 0., ty = 0., z = 0.;
    int zpos = 1;
    if (GetMarkerColor() == kRed) zpos = 0;
    if( zpos == 0 )
      {
             tx = (eTr->TrackZmax())->TX();
             ty = (eTr->TrackZmax())->TY();
             z  = (eTr->TrackZmax())->Z();
      }
    else
      {
             tx = (eTr->TrackZmin())->TX();
             ty = (eTr->TrackZmin())->TY();
             z  = (eTr->TrackZmin())->Z();
      }
    sprintf(coordinates, "X = %.1f, Y = %.1f, Z = %.1f, TX = %.3f, TY = %.3f", eTr->X(), eTr->Y(), z, tx, ty);
    return coordinates;
}

GetTitle()

const char * EdbTrackG::GetTitle ( ) const

virtual

{
    static char title[80];
    if (eTr) sprintf(title, "Track ID %d, Nseg %d, Prob %.4f, P %.3f", eTr->ID(), eTr->N(), eTr->Prob(), eTr->P());   
    else strcpy(title, "Track address not defined");
    return title;
}

InfoTrackVert()

void EdbTrackG::InfoTrackVert ( )

virtual

{
  if (!(eD->eVertex))
  {
    
        printf("No working vertex selected!\n");
        fflush(stdout);
        return;
  }
  int zpos = 1;
  if (GetMarkerColor() == kRed) zpos = 0;
  EdbVertex *v = eD->eVertex;
  if (eD->eWorking) v = eD->eWorking;
  char CanvasTRKName[140];
  strcpy(CanvasTRKName, "TRK-");
  strcat(CanvasTRKName, (eD->fCanvas)->GetName());
  if ((eD->fCanvasTRK = (TCanvas *)(gROOT->GetListOfCanvases()->FindObject(CanvasTRKName))))
  {
    (eD->fCanvasTRK)->SetTitle("Track - Vertex relation parameters");
    (eD->fCanvasTRK)->Clear();
    (eD->fCanvasTRK)->Modified();
    (eD->fCanvasTRK)->Update();
  }
  else
  {
    int xpos = (eD->fCanvas)->GetWindowTopX()+(eD->fCanvas)->GetWw();
    int ypos = (eD->fCanvas)->GetWindowTopY();
    eD->fCanvasTRK = new TCanvas(CanvasTRKName, "Track - Vertex relation parameters",
                 -xpos, ypos, 640, 330);
//    (eD->fCanvasTRK)->ToggleEventStatus();
  }
  if (eD->fVTXTRKInfo)
  {
    (eD->fVTXTRKInfo)->Clear();
  }
  else
  {
    eD->fVTXTRKInfo = new TPaveText(0.05, 0.05, 0.95, 0.95);
    (eD->fVTXTRKInfo)->ResetBit(kCanDelete);
  }
  char line[128];
  EdbTrackP *tr = eTr;  
  TText *t = 0;
 
  strcpy(line, " Track     ID   Nseg   Mass       P       Chi2/ndf    Prob");
  t = (eD->fVTXTRKInfo)->AddText(line);
  t->SetTextColor(kBlue);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
 
  sprintf(line,"         %4d  %4d   %7.4f  %7.2f    %5.2f     %7.4f",
              tr->ID(), tr->N(), tr->M(), tr->P(),
              tr->Chi2()/tr->N(), tr->Prob());
  t = (eD->fVTXTRKInfo)->AddText(line);
  t->SetTextColor(kBlack);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
 
//  t = (eD->fVTXTRKInfo)->AddText("");
//  t->SetTextColor(kBlack);
//  t->SetTextSize(0.03);
//  t->SetTextAlign(12);
//  t->SetTextFont(102);
 
  strcpy(line, "  Vertex    ID    Mult  X          Y          Z          Dist   Chi2     Prob");
  t = (eD->fVTXTRKInfo)->AddText(line);
  t->SetTextColor(kBlue);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
 
  sprintf(line,"            %-4d  %-4d  %-8.1f   %-8.1f   %-8.1f   %-6.1f %-7.1f  %-7.5f",
    v->ID(), v->N(), v->VX(), v->VY(), v->VZ(), v->V()->dist(),
    v->V()->chi2()/v->V()->ndf(), v->V()->prob());
  t = (eD->fVTXTRKInfo)->AddText(line);
  t->SetTextColor(kBlack);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
 
//  t = (eD->fVTXTRKInfo)->AddText("");
//  t->SetTextColor(kBlack);
//  t->SetTextSize(0.03);
//  t->SetTextAlign(12);
//  t->SetTextFont(102);
 
  EdbSegP *seg = tr->TrackExtremity( zpos );//, eUseSegPar);
  float dx   = v->VX() - seg->X();
  float dy   = v->VY() - seg->Y();
  float dz   = v->VZ() - seg->Z();
  float dist = TMath::Sqrt(dx*dx + dy*dy + dz*dz);
 
  float mass = tr->M();
  float momentum = tr->P();
  if (eD->eP > 0.) seg->SetP(eD->eP);
  if (eD->eM > 0.) tr->SetM(eD->eM);
 
  float X0 = 0.;
  if (eD->eVerRec) if ((eD->eVerRec)->ePVR)  X0 = (((eD->eVerRec)->ePVR)->GetScanCond())->RadX0();
 
  float chi2 = v->Chi2Track(tr, zpos, X0);
  float impa = v->DistTrack(tr, zpos, X0);
 
  seg->SetP(momentum);
  tr->SetM(mass);
 
  sprintf(line, "  Track - Vertex  impact = %-6.1f, chi2 = %-7.1f, distance = %-8.1f", impa, chi2, dist);
  t = (eD->fVTXTRKInfo)->AddText(line);
  t->SetTextColor(kRed);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
 
  t = (eD->fVTXTRKInfo)->AddText("");
  t->SetTextColor(kBlack);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
 
  (eD->fVTXTRKInfo)->Draw();
  (eD->fCanvasTRK)->Modified();
  (eD->fCanvasTRK)->Update();
}

InspectTrack()

void EdbTrackG::InspectTrack ( )

virtual

{
  if (eTr) eTr->Inspect();
}

RemoveTrackFromVertex()

void EdbTrackG::RemoveTrackFromVertex ( )

virtual

{
  char text[512];
  if (eTr && eD)
  {
    if (eD->eVerRec) if (eD->eVerRec->IsA() != EdbVertexRec::Class()) eD->eVerRec = 0;
    if (!eD->eVerRec) {printf("Error: EdbDisplay:RemoveTrackFromVertex: EdbVertexRec not defined, use SetVerRec(...)\n"); fflush(stdout); return;}
    if (eD->eWait_Answer) return;
    if (!(eD->eVertex))
    {
    
        printf("No working vertex selected!\n");
        fflush(stdout);
        return;
    }
    EdbVTA *vta = 0;
    EdbVertex *ePreviousSaved = eD->ePrevious;
    int n = 0;
    int ntr = 0;
    if (eD->eWorking == 0)
    {
    ntr = eD->eVertex->N();
    if (ntr < 3)
    {
    
        printf("Working vertex has 2 prongs only!\n");
        fflush(stdout);
        return;
    }
    eD->eWorking = new EdbVertex();
    int i = 0;
    for(i=0; i<ntr; i++)
    {
        if (eD->eVertex->GetTrack(i) == eTr)
        {
        eTr->ClearVTA(eD->eVertex->GetVTa(i));
        continue;
        }
        if ((vta = (eD->eVerRec)->AddTrack( *(eD->eWorking), (eD->eVertex)->GetTrack(i), (eD->eVertex)->Zpos(i))))
        {
        ((eD->eVertex)->GetTrack(i))->AddVTA(vta);
        n++;
        }
    }
    }
    else
    {
    ntr = eD->eWorking->N();
    if (ntr < 3)
    {
    
        printf("Working vertex has 2 prongs only!\n");
        fflush(stdout);
        return;
    }
    eD->ePrevious = eD->eWorking;
    eD->eWorking = new EdbVertex();
    int i = 0;
    for(i=0; i<ntr; i++)
    {
        if (eD->ePrevious->GetTrack(i) == eTr)
        {
        eTr->ClearVTA(eD->ePrevious->GetVTa(i));
        continue;
        }
        if ((vta = (eD->eVerRec)->AddTrack(*(eD->eWorking),(eD->ePrevious)->GetTrack(i), (eD->ePrevious)->Zpos(i))))
        {
        ((eD->ePrevious)->GetTrack(i))->AddVTA(vta);
        n++;
        }
    }
    }
    if ((n < 2)||(n == ntr))
    {
    delete eD->eWorking;
    if (eD->ePrevious)
    {
        eD->eWorking = eD->ePrevious;
        (eD->eWorking)->ResetTracks();
        eD->ePrevious = ePreviousSaved;
    }
    else
    {
        eD->eWorking = 0;
        (eD->eVertex)->ResetTracks();
    }
    printf("Can't create working copy of the vertex!\n");
    fflush(stdout);
    return;
    }
 
    if ((eD->eVerRec)->MakeV(*(eD->eWorking)))
    {
    EdbVertex *eW = eD->eWorking;
    eW->ResetTracks();
    eW->SetID(eD->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());
    eD->DrawOldBut("Original");
    if (eD->ePrevious)
    {
        eD->DrawNewVTX(text);
        eD->DrawNewBut("Modified");
        eW = eD->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());
        eD->DrawPreVTX(text);
        eD->DrawPreBut("Previous");
    }
    else
    {
        eD->DrawPreVTX(text);
        eD->DrawPreBut("Modified");
        if (eD->eVertex->ID() >= 0)
        {
        eD->DrawAcc();
        eD->DrawCan();
        eD->DrawUnd();
        }
    }
//  eD->DrawOldBut("Original");
    eD->DrawVTXTracks("Modified", eD->eWorking);
    if (eD->eArrV && (eD->eIndVert >= 0)) 
    {
//      eD->eArrV->RemoveAt(eD->eIndVert);
        eD->eArrV->AddAt(eD->eWorking, eD->eIndVert);
    }   
//  if ((eD->eCreatedTracks).FindObject(eTr))
//  {
//      (eD->eCreatedTracks).Remove(eTr);
//      if ( eD->eArrTr)
//      if ((eD->eArrTr)->FindObject(eTr)) (eD->eArrTr)->Remove(eTr);
//      if ( eD->eArrTrSave)
//      if ((eD->eArrTrSave)->FindObject(eTr)) (eD->eArrTrSave)->Remove(eTr);
//      delete eTr;
//  }
    eD->Draw();
    if (ePreviousSaved) delete ePreviousSaved;
    ePreviousSaved = 0;
    }
    else
    {
    delete eD->eWorking;
    if (eD->ePrevious)
    {
        eD->eWorking = eD->ePrevious;
        (eD->eWorking)->ResetTracks();
        eD->ePrevious = ePreviousSaved;
    }
    else
    {
        eD->eWorking = 0;
        (eD->eVertex)->ResetTracks();
    }
    printf("Can't create working copy of the vertex!\n");
    fflush(stdout);
    }
  }
}

SetAsWorkingVertex()

void EdbTrackG::SetAsWorkingVertex ( )

virtual

{
  printf("1\n");
  EdbTrackP *tr = 0;
  EdbDisplay *eDs = 0;
  EdbVTA *vta = 0;
  EdbVertex  *eVs = 0, *old = 0;
  int zpos = 1;
  eDs = eD;
  if (eDs && eTr)
  {
    if (eDs->eWait_Answer) return;
    if (eDs->eWorking)
    {
      eDs->DialogModifiedVTX();
      return;
    }
    if (eDs->eVertex)
    {
      if (eDs->eVertex->ID()<0 && eDs->eVertex->N() >= 2)
      {
        eDs->DialogModifiedVTX();
        return;
      }
    }
    if (eDs->eVertex)
    {
      eDs->CancelModifiedVTX();
    }
    if (eDs->eSegPM)
    { 
      eDs->ClearSegmentEnv();
    }
    if (GetMarkerColor() == kRed) zpos = 0;
    if ((old = eTr->VertexS()) && (zpos == 1))
    {
    
      printf("Track alredy connected to a vertex by this edge!\n");
      fflush(stdout);
      return;
    }
    if ((old = eTr->VertexE()) && (zpos == 0))
    {
    
      printf("Track alredy connected to a vertex by this edge!\n");
      fflush(stdout);
      return;
    }
    eVs = new EdbVertex();
    if ((vta = (eD->eVerRec)->AddTrack(*eVs, eTr, zpos)))
    {
      eTr->AddVTA(vta);
    }
    else
    {
      delete eVs;
      printf("Can't connect track to a vertex!\n");
      fflush(stdout);
      return;
    }
    double dz = 0.;
    EdbSegP *seg = 0;
    if( zpos == 0 )
    {
      seg = eTr->TrackZmax();
      dz = TMath::Abs(seg->DZ());
    }
    else
    {
      seg = eTr->TrackZmin();
    }
    if(!seg)
    {
      eVs->SetXYZ(eTr->X(), eTr->Y(), eTr->Z());
    }
    else
    {
      eVs->SetXYZ(seg->X()+seg->TX()*dz, seg->Y()+seg->TY()*dz, seg->Z()+dz);
    }
    printf("2\n");
    eVs->SetID(-1);
    SetMarkerColor(kGreen);
    eDs->eSegment = 0;
    eDs->eVertex = eVs;
    eDs->eWorking = 0;
    eDs->ePrevious = 0;
    eDs->eIndVert = -1;
    (eDs->eCreatedTracks).Clear();
    if (!(eDs->eArrV)) 
    {
      eDs->eArrV = new TObjArray(20);
      eDs->eArrV->Add((TObject *)eVs);
      if (!(eDs->eArrTr))  eDs->eArrTr = new TObjArray(20);
      for (int i=0; i<eVs->N(); i++)
      {
        tr = eVs->GetTrack(i);
        if(!(eDs->eArrTr->FindObject(tr))) eDs->eArrTr->Add(tr);
      }
      eDs->Draw();
    }
    else
    {
      if (!((eDs->eArrV)->FindObject(eVs)))
      {
        eDs->eArrV->Add(eVs);
        if (!(eDs->eArrTr))  eDs->eArrTr = new TObjArray(20);
        for (int i=0; i<eVs->N(); i++)
        {
          tr = eVs->GetTrack(i);
          if(!(eDs->eArrTr->FindObject(tr))) eDs->eArrTr->Add(tr);
        }
        eDs->Draw();
      }
    }
    //eD->DrawEnv();
    eD->DrawAcc();
    eD->DrawCan();
    eD->DrawUnd();
    eD->Draw();
    printf("3\n");
  }
}

SetTrack()

void EdbTrackG::SetTrack ( EdbTrackP *  tr )

inline

{eTr=tr;}

UndoNewTrack()

void EdbTrackG::UndoNewTrack ( )

virtual

{
    if (eD->eTrack && eD->eTrack == eTr)
    {
    if (eD->eVerRec) if (eD->eVerRec->IsA() != EdbVertexRec::Class()) eD->eVerRec = 0;
    if (!eD->eVerRec) {printf("Error: EdbDisplay:UndoNewTrack: EdbVertexRec not defined, use SetVerRec(...)\n"); fflush(stdout); return;}
    TObjArray *etr = 0;
    if (eD->eVerRec) etr = eD->eVerRec->eEdbTracks;
 
        for(int is=0; is<eD->eTrack->N(); is++) {
        EdbSegP *seg = eD->eTrack->GetSegment(is);
        if (seg->Track() == -2) seg->SetTrack(-1);
        else if (seg->Track() < -2)
        {
        int ind = -(seg->Track()+2) - 1;
        if (!etr)
        {
            printf("No information about tracks array!\n");
            fflush(stdout);
            return;
        }
        int trind = etr->GetEntriesFast();
        if (ind >= trind)
        {
            printf("Wrong track index in segment!\n");
            fflush(stdout);
            return;
        }
        EdbTrackP *tr = (EdbTrackP *)(etr->At(ind));
        if (!tr)
        {
            printf("Wrong track address in array!\n");
            fflush(stdout);
            return;
        }
        tr->SetFlag(0);
        tr->SetSegmentsTrack();
        if(eD->eArrTr) if(!((eD->eArrTr)->FindObject(tr)))
        {
            eD->eArrTr->Add(tr);
        }
        if(eD->eArrTrSave) if(!((eD->eArrTrSave)->FindObject(tr)))
        {
            eD->eArrTrSave->Add(tr);
        }
        }
    }
    if(eD->eArrTr) if((eD->eArrTr)->FindObject(eTr))
    {
        eD->eArrTr->Remove(eTr);
        eD->eArrTr->Compress();
    }
    if(eD->eArrTrSave) if((eD->eArrTrSave)->FindObject(eTr))
    {
        eD->eArrTrSave->Remove(eTr);
        eD->eArrTr->Compress();
    }
    eD->Draw();
    delete eD->eTrack;
    eD->eTrack = 0;
    }
    else
    {
    printf("No intermediate track or this one fixed already!\n");
    fflush(stdout);
    return;
    }
}

UndoRemoveKink()

void EdbTrackG::UndoRemoveKink ( )

virtual

{
    if (eD && eTr)
    {
    if (!(eD->eTrack))
    {
        printf("No joined track or this one fixed already!\n");
        fflush(stdout);
        return;
    }
    if (eD->eVerRec) if (eD->eVerRec->IsA() != EdbVertexRec::Class()) eD->eVerRec = 0;
    if (!eD->eVerRec) {printf("Error: EdbDisplay:UndoRemoveKink: EdbVertexRec not defined, use SetVerRec(...)\n"); fflush(stdout); return;}
    TObjArray *etr = 0;
    if (eD->eVerRec) etr = eD->eVerRec->eEdbTracks;
 
        for(int is=0; is<eD->eTrack->N(); is++) {
        EdbSegP *seg = eD->eTrack->GetSegment(is);
        if (seg->Track() == -2) seg->SetTrack(-1);
        else if (seg->Track() < -2)
        {
        int ind = -(seg->Track()+2) - 1;
        if (!etr)
        {
            printf("No information about tracks array!\n");
            fflush(stdout);
            return;
        }
        int trind = etr->GetEntriesFast();
        if (ind >= trind)
        {
            printf("Wrong track index in segment!\n");
            fflush(stdout);
            return;
        }
        EdbTrackP *tr = (EdbTrackP *)(etr->At(ind));
        if (!tr)
        {
            printf("Wrong track address in array!\n");
            fflush(stdout);
            return;
        }
        tr->SetFlag(0);
        tr->SetSegmentsTrack();
        if(eD->eArrTr) if(!((eD->eArrTr)->FindObject(tr)))
        {
            eD->eArrTr->Add(tr);
        }
        if(eD->eArrTrSave) if(!((eD->eArrTrSave)->FindObject(tr)))
        {
            eD->eArrTrSave->Add(tr);
        }
        EdbVertex *v = 0;
        if (tr->VTAS())
        {
            v = tr->VertexS();
            if (v)
            {
            if (v->Flag() == -11)
            {
                v->SetFlag(0);
                if(eD->eArrV) if(!((eD->eArrV)->FindObject(v)))
                {
                eD->eArrV->Add(v);
                }
                if(eD->eArrVSave) if(!((eD->eArrVSave)->FindObject(v)))
                {
                eD->eArrVSave->Add(v);
                }
            }
            }
        }
        if (tr->VTAE())
        {
            v = tr->VertexE();
            if (v)
            {
            if (v->Flag() == -11)
            {
                v->SetFlag(0);
                if(eD->eArrV) if(!((eD->eArrV)->FindObject(v)))
                {
                eD->eArrV->Add(v);
                }
                if(eD->eArrVSave) if(!((eD->eArrVSave)->FindObject(v)))
                {
                eD->eArrVSave->Add(v);
                }
            }
            }
        }
        }
    }
    if(eD->eArrTr) if((eD->eArrTr)->FindObject(eD->eTrack))
    {
        eD->eArrTr->Remove(eD->eTrack);
        eD->eArrTr->Compress();
    }
    if(eD->eArrTrSave) if((eD->eArrTrSave)->FindObject(eD->eTrack))
    {
        eD->eArrTrSave->Remove(eD->eTrack);
        eD->eArrTr->Compress();
    }
    eD->Draw();
    delete eD->eTrack;
    eD->eTrack = 0;
    }
    else
    {
    printf("No parts of splitted track or these ones fixed already!\n");
    fflush(stdout);
    return;
    }
}

UndoSplit()

void EdbTrackG::UndoSplit ( )

virtual

{
    if (eD->eTrack1 && eD->eTrack2 && ((eD->eTrack1 == eTr) || (eD->eTrack2 == eTr)))
    {
    if (eD->eVerRec) if (eD->eVerRec->IsA() != EdbVertexRec::Class()) eD->eVerRec = 0;
    if (!eD->eVerRec) {printf("Error: EdbDisplay:UndoSplit: EdbVertexRec not defined, use SetVerRec(...)\n"); fflush(stdout); return;}
    TObjArray *etr = 0;
    if (eD->eVerRec) etr = eD->eVerRec->eEdbTracks;
 
        for(int is=0; is<eD->eTrack1->N(); is++) {
        EdbSegP *seg = eD->eTrack1->GetSegment(is);
        if (seg->Track() == -2) seg->SetTrack(-1);
        else if (seg->Track() < -2)
        {
        int ind = -(seg->Track()+2) - 1;
        if (!etr)
        {
            printf("No information about tracks array!\n");
            fflush(stdout);
            return;
        }
        int trind = etr->GetEntriesFast();
        if (ind >= trind)
        {
            printf("Wrong track index in segment!\n");
            fflush(stdout);
            return;
        }
        EdbTrackP *tr = (EdbTrackP *)(etr->At(ind));
        if (!tr)
        {
            printf("Wrong track address in array!\n");
            fflush(stdout);
            return;
        }
        tr->SetFlag(0);
        tr->SetSegmentsTrack();
        if(eD->eArrTr) if(!((eD->eArrTr)->FindObject(tr)))
        {
            eD->eArrTr->Add(tr);
        }
        if(eD->eArrTrSave) if(!((eD->eArrTrSave)->FindObject(tr)))
        {
            eD->eArrTrSave->Add(tr);
        }
        }
    }
    if(eD->eArrTr) if((eD->eArrTr)->FindObject(eD->eTrack1))
    {
        eD->eArrTr->Remove(eD->eTrack1);
        eD->eArrTr->Compress();
    }
    if(eD->eArrTrSave) if((eD->eArrTrSave)->FindObject(eD->eTrack1))
    {
        eD->eArrTrSave->Remove(eD->eTrack1);
        eD->eArrTr->Compress();
    }
    if(eD->eArrTr) if((eD->eArrTr)->FindObject(eD->eTrack2))
    {
        eD->eArrTr->Remove(eD->eTrack2);
        eD->eArrTr->Compress();
    }
    if(eD->eArrTrSave) if((eD->eArrTrSave)->FindObject(eD->eTrack2))
    {
        eD->eArrTrSave->Remove(eD->eTrack2);
        eD->eArrTr->Compress();
    }
    eD->Draw();
    delete eD->eTrack1;
    eD->eTrack1 = 0;
    delete eD->eTrack2;
    eD->eTrack2 = 0;
    }
    else
    {
    printf("No parts of splitted track or these ones fixed already!\n");
    fflush(stdout);
    return;
    }
}

Member Data Documentation

eD

EdbDisplay* EdbTrackG::eD

private

eTr

EdbTrackP* EdbTrackG::eTr

private

---

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

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