EdbSegG Class Reference

#include <EdbDisplay.h>

Inheritance diagram for EdbSegG:

Collaboration diagram for EdbSegG:

Public Member Functions
virtual void	AddAsTrackToVertex ()
virtual void	AddToNewTrack ()
virtual void	AddToNewTrackAndFit ()
virtual void	DumpSegment ()
	EdbSegG ()
	EdbSegG (EdbDisplay *D)
	EdbSegG (EdbSegP &s)
	EdbSegG (Int_t nhits)
	EdbSegG (Int_t nhits, EdbDisplay *D)
virtual const char *	GetName () const
virtual char *	GetObjectInfo (int px, int py) const
virtual const char *	GetTitle () const
virtual void	InfoSegSeg ()
virtual void	InfoSegVert ()
virtual void	InspectSegment ()
virtual void	RemoveFromTrack ()
virtual void	SetAsWorking ()
void	SetSeg (const EdbSegP *s)
virtual void	SplitTrack ()
float	X ()
float	Y ()
float	Z ()
virtual	~EdbSegG ()

Private Attributes
EdbDisplay *	eD
const EdbSegP *	eSeg

Constructor & Destructor Documentation

EdbSegG() [1/5]

EdbSegG::EdbSegG ( )

inline

{eSeg=0; eD=0;}

EdbSegG() [2/5]

EdbSegG::EdbSegG

(

EdbSegP &

s

)

                             : TPolyLine3D(2)
{
  eSeg=0;
  eD = 0;
  float dz = TMath::Abs(s.DZ())/2.; if(dz<0.001) dz=10;
  SetPoint(0,
       s.X() - s.TX()*dz,
       s.Y() - s.TY()*dz,
       s.Z() -           dz);
  SetPoint(1,
       s.X() + s.TX()*dz,
       s.Y() + s.TY()*dz,
       s.Z() +           dz);
 
  SetLineColor(kRed);
  SetLineWidth(1);
}

EdbSegG() [3/5]

EdbSegG::EdbSegG ( EdbDisplay *  D )

inline

{eSeg=0; eD=D;}

EdbSegG() [4/5]

EdbSegG::EdbSegG ( Int_t  nhits )

inline

:TPolyLine3D(nhits) {eSeg=0; eD=0;}

EdbSegG() [5/5]

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

inline

:TPolyLine3D(nhits) {eSeg=0; eD=D;}

~EdbSegG()

virtual EdbSegG::~EdbSegG ( )

inlinevirtual

{}

Member Function Documentation

AddAsTrackToVertex()

void EdbSegG::AddAsTrackToVertex ( )

virtual

{
  char text[512];
  EdbVTA *vta = 0;
//  if (eD) if (!(eD->eVerRec)) eD->eVerRec = ((EdbVertexRec *)(gROOT->GetListOfSpecials()->FindObject("EdbVertexRec")));
  if (eD->eVerRec) if (eD->eVerRec->IsA() != EdbVertexRec::Class()) eD->eVerRec = 0;
  if (!eD->eVerRec) {printf("Error: EdbDisplay:AddAsTrackToVertex: EdbVertexRec not defined, use SetVerRec(...)\n"); fflush(stdout); return;}
  if (eSeg && eD)
  {
    if (eD->eWait_Answer) return;
    if (!(eD->eVertex))
    {
    
        printf("No working vertex selected!\n");
        fflush(stdout);
        return;
    }
    if (eSeg->Track() >= 0)
    {
    
        printf("Segment already belong to a track!\n");
        fflush(stdout);
        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;
    }
    }
    float mass = 0.139; //pion
    float momentum = 0.1; // 100 MeV
    if (eD->eP > 0.) momentum = eD->eP;
    if (eD->eM > 0.) mass = eD->eM;
    EdbTrackP *Tr = new EdbTrackP((EdbSegP *)eSeg, mass);
    Tr->SetP(momentum);
    Tr->FitTrackKFS();
    float ImpMaxSave = (eD->eVerRec)->eImpMax;
    (eD->eVerRec)->eImpMax = eD->eTImpMax;
    float ProbMinSave = (eD->eVerRec)->eProbMin;
    (eD->eVerRec)->eProbMin = eD->eTProbMin;
//    printf(" seg id %d x %f y %f z %f\n", eSeg->ID(), eSeg->X(), eSeg->Y(), eSeg->Z());
    if ((vta = (eD->eVerRec)->AddTrack(*(eD->eWorking), Tr, 1)))
    {
    if ( Tr->Z() >= (eD->eWorking)->VZ() ) vta->SetZpos(1);
    else vta->SetZpos(0);
//  printf(" tr  id %d x %f y %f z %f\n", Tr->ID(), Tr->X(), Tr->Y(), Tr->Z());
    Tr->AddVTA(vta);
//  (eD->eWorking)->ResetTracks();
    (eD->eArrTr)->Add(Tr);
    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->eIndVert >= 0) 
    {
//      eD->eArrV->RemoveAt(eD->eIndVert);
        eD->eArrV->AddAt(eD->eWorking, eD->eIndVert);
    }   
    (eD->eCreatedTracks).Add(Tr);
    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=%f. Change ProbMin with 'TrackParams' button!\n", eD->eTProbMin);
    fflush(stdout);
    delete Tr;
    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;
    }
  }
}

AddToNewTrack()

void EdbSegG::AddToNewTrack ( )

virtual

{
  if (eSeg && eD)
  {
    if (eSeg->Track() >= 0)
    {
        printf("This segment alredy belong to a track!\n");
        fflush(stdout);
        return;
    }
    if (eD->eTrack)
    {
        if ((eD->eTrack)->NF())
        {
        delete eD->eTrack;
        eD->eTrack = 0;
        }
    }
    if (!eD->eTrack) eD->eTrack = new EdbTrackP();
    (eD->eTrack)->AddSegment((EdbSegP *)eSeg);
  }
}

AddToNewTrackAndFit()

void EdbSegG::AddToNewTrackAndFit ( )

virtual

{
  if (eSeg && eD)
  {
    if (eSeg->Track() >= 0)
    {
        printf("This segment already belong to a track!\n");
        fflush(stdout);
        return;
    }
    if (!eD->eTrack) eD->eTrack = new EdbTrackP();
    (eD->eTrack)->AddSegment((EdbSegP *)eSeg);
    float mass = 0.139; //pion
    float momentum = 1.; // 1000 MeV
    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);
    //if (eD->eArrSegP) (eD->eArrSegP)->Remove((TObject *)eSeg);
    //if (eD->eArrSegPSave) (eD->eArrSegPSave)->Remove((TObject *)eSeg);
    eD->Draw();
  }
}

DumpSegment()

void EdbSegG::DumpSegment ( )

virtual

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

GetName()

const char * EdbSegG::GetName ( ) const

virtual

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

GetObjectInfo()

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

virtual

{
    static char coordinates[80];
    if (eSeg) sprintf(coordinates, "X = %.1f, Y = %.1f, Z = %.1f, TX = %.3f, TY = %.3f PH = %d", 
              eSeg->X(), eSeg->Y(), eSeg->Z(), eSeg->TX(), eSeg->TY(), (int)eSeg->W() );
    else strcpy(coordinates, "Segment address not defined");
    return coordinates;
}

GetTitle()

const char * EdbSegG::GetTitle ( ) const

virtual

{
    static char title[80];
    if (eSeg) sprintf(title, "Segment ID %d, PID %d, Track %d", eSeg->ID(), eSeg->PID(), eSeg->Track());
    else strcpy(title, "Segment address not defined");
    return title;
}

InfoSegSeg()

void EdbSegG::InfoSegSeg ( )

virtual

{
  if (!(eD->eSegment))
  {
    
        printf("No working segment selected!\n");
        fflush(stdout);
        return;
  }
  EdbSegP *s = eD->eSegment;
  char CanvasTRKName[140];
  strcpy(CanvasTRKName, "SEG-");
  strcat(CanvasTRKName, (eD->fCanvas)->GetName());
  if ((eD->fCanvasTRK = (TCanvas *)(gROOT->GetListOfCanvases()->FindObject(CanvasTRKName))))
  {
    (eD->fCanvasTRK)->SetTitle("Segment - Segment 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, "Segment - Segment 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];
  TText *t = 0;
 
  strcpy(line, "  Segment   ID          X          Y          Z          TX         TY");
  t = (eD->fVTXTRKInfo)->AddText(line);
  t->SetTextColor(kBlue);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
 
  sprintf(line,"            %-4d        %-8.1f   %-8.1f   %-8.1f   %-7.4f    %-7.4f",
              s->ID(), s->X(), s->Y(), s->Z(),
              s->TX(), s->TY());
  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, "  Segment   ID          X          Y          Z          TX         TY");
  t = (eD->fVTXTRKInfo)->AddText(line);
  t->SetTextColor(kBlue);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
 
  sprintf(line,"            %-4d        %-8.1f   %-8.1f   %-8.1f   %-7.4f    %-7.4f",
              eSeg->ID(), eSeg->X(), eSeg->Y(), eSeg->Z(),
              eSeg->TX(), eSeg->TY());
  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);
 
  float dx   = eSeg->X() - s->X();
  float dy   = eSeg->Y() - s->Y();
  float dz   = eSeg->Z() - s->Z();
  float dist = TMath::Sqrt(dx*dx + dy*dy + dz*dz);
 
  float mass = 0.139; //pion
  float momentum = .1; // 100 MeV
  if (eD->eP > 0.) momentum = eD->eP;
  if (eD->eM > 0.) mass = eD->eM;
  EdbTrackP *tr1 = new EdbTrackP((EdbSegP *)s, mass);
  tr1->SetP(momentum);
  tr1->FitTrackKFS();
  EdbTrackP *tr2 = new EdbTrackP((EdbSegP *)eSeg, mass);
  tr2->SetP(momentum);
  tr2->FitTrackKFS();
  EdbSegP *seg1 = (EdbSegP *)(tr1->TrackZmax());
  seg1->SetP(momentum);
  EdbSegP *seg2 = (EdbSegP *)(tr2->TrackZmax());
  seg2->SetP(momentum);
  if (eD->eVerRec)
  {
    float chi2 = (eD->eVerRec)->TdistanceChi2(*seg1, *seg2, mass);
    float impa = (eD->eVerRec)->Tdistance(*s, *eSeg);
    sprintf(line, "  Segment - Segment  impact = %-6.1f, chi2 = %-7.1f, distance = %-8.1f", impa, chi2, dist);
  }
  else
  {
    sprintf(line, "  Impossible to calculate impact and chi2 - No eVerRec defined!");
    printf("Error: EdbDisplay:AddAsTrackToVertex: EdbVertexRec not defined, use SetVerRec(...)\n");
    fflush(stdout);
  }
  delete tr1;
  delete tr2;
  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();
}

InfoSegVert()

void EdbSegG::InfoSegVert ( )

virtual

{
  if (!(eD->eVertex))
  {
    
        printf("No working vertex selected!\n");
        fflush(stdout);
        return;
  }
  int zpos = 1;
  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("Segment - 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, "Segment - 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];
  EdbSegP *s = (EdbSegP *)eSeg;  
  TText *t = 0;
 
  strcpy(line, "  Segment   ID          X          Y          Z          TX         TY        PH");
  t = (eD->fVTXTRKInfo)->AddText(line);
  t->SetTextColor(kBlue);
  t->SetTextSize(0.03);
  t->SetTextAlign(12);
  t->SetTextFont(102);
 
  sprintf(line,"            %-4d        %-8.1f   %-8.1f   %-8.1f   %-7.4f    %-7.4f    %-4d",
      s->ID(), s->X(), s->Y(), s->Z(), s->TX(), s->TY(), (int)s->W() );
  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);
 
  float dx   = v->VX() - s->X();
  float dy   = v->VY() - s->Y();
  float dz   = v->VZ() - s->Z();
  float dist = TMath::Sqrt(dx*dx + dy*dy + dz*dz);
 
  float mass = 0.139; //pion
  float momentum = 0.1; // 100 MeV
  if (eD->eP > 0.) momentum = eD->eP;
  if (eD->eM > 0.) mass = eD->eM;
  EdbTrackP *tr = new EdbTrackP((EdbSegP *)eSeg, mass);
  tr->SetP(momentum);
  tr->FitTrackKFS();
 
  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);
  delete tr;
  sprintf(line, "  Segment - 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();
}

InspectSegment()

void EdbSegG::InspectSegment ( )

virtual

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

RemoveFromTrack()

void EdbSegG::RemoveFromTrack ( )

virtual

{
  if (eSeg && eD)
  {
    int ind = 0;
    if ((ind = eSeg->Track()) < 0)
    {
        printf("This segment not included in a track!\n");
        fflush(stdout);
        return;
    }
    if (eD->eVerRec) if (eD->eVerRec->IsA() != EdbVertexRec::Class()) eD->eVerRec = 0;
    if (!eD->eVerRec) {printf("Error: EdbDisplay:RemoveFromTrack: EdbVertexRec not defined, use SetVerRec(...)\n"); fflush(stdout); return;}
    TObjArray *etr = 0;
    if (eD->eVerRec) etr = (eD->eVerRec)->eEdbTracks;
    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;
    }
    if (tr->N() < 2)
    {
        printf("Only one segment in track - delete track insted!\n");
        fflush(stdout);
        return;
    }
    if (tr->VTAS() || tr->VTAE())
    {
        printf("Track belong to a vertex - impossible operate with it!\n");
        fflush(stdout);
        return;
    }
    tr->RemoveSegment((EdbSegP *)eSeg);
    float X0 = 0.;
    if (eD->eVerRec) if ((eD->eVerRec)->ePVR) X0 = (((eD->eVerRec)->ePVR)->GetScanCond())->RadX0();
    tr->FitTrackKFS(true, X0, 0);
    if (!(eD->eArrSegP)) eD->eArrSegP = new TObjArray();
    if(!((eD->eArrSegP)->FindObject(eSeg))) (eD->eArrSegP)->Add((EdbSegP *)eSeg);
    if (eD->eArrTrSave)
    {
        if (!(eD->eArrSegPSave)) eD->eArrSegPSave = new TObjArray();
        if(!((eD->eArrSegPSave)->FindObject(eSeg))) eD->eArrSegPSave->Add((EdbSegP *)eSeg);
    }
    eD->Draw();
  }
}

SetAsWorking()

void EdbSegG::SetAsWorking ( )

virtual

{
  EdbDisplay *eDs = 0;
  EdbSegP    *eSegs = 0;
  eDs = eD;
  eSegs = (EdbSegP *)eSeg;
  if (eDs && eSegs)
  {
    if (eDs->eSegment == eSegs) return;
    if (eDs->eWait_Answer) return;
    if (eDs->eVertex)
    {
    if (eDs->eWorking)
    {
        eDs->DialogModifiedVTX();
        return;
    }
    else 
    {
        eDs->CancelModifiedVTX();
    }
    }
    if (eDs->eSegPM)
    { 
    if (eDs->fPad->GetListOfPrimitives()->FindObject(eDs->eSegPM))
    {
        eDs->fPad->GetListOfPrimitives()->Remove(eDs->eSegPM);
    }
    delete eDs->eSegPM;
    eDs->eSegPM = 0;
    }
    if (!(eDs->eArrSegP)) 
    {
    eDs->eArrSegP = new TObjArray(20);
    eDs->eArrSegP->Add((TObject *)eSegs);
    eDs->Draw();
    }
    else
    { 
 
    if (!(eDs->eArrSegP->FindObject(eSegs)))
    {
        eDs->eArrSegP->Add((TObject *)eSegs);
        eDs->Draw();
    }
    }
    eDs->eSegment = (EdbSegP *)eSegs;
    eDs->DrawEnv();
    eDs->eSegPM = new TPolyMarker3D(1);
    eDs->eSegPM->SetMarkerStyle(kFullCircle);
    if(eSegs) {
      float dz = TMath::Abs(eSegs->DZ()/2.);
      eDs->eSegPM->SetPoint(0, 
                eSegs->X() + eSegs->TX()*dz,
            eSegs->Y() + eSegs->TY()*dz,
            eSegs->Z() +            dz);
      eDs->eSegPM->SetMarkerColor(kGreen);
      eDs->eSegPM->SetMarkerSize(1.2);
      eDs->eSegPM->AppendPad();
      eDs->eSegPM->Draw();
    }
  }
}

SetSeg()

void EdbSegG::SetSeg ( const EdbSegP *  s )

inline

{eSeg=s;}

SplitTrack()

void EdbSegG::SplitTrack ( )

virtual

{
  if (eSeg && eD)
  {
    int ind = 0;
    if ((ind = eSeg->Track()) < 0)
    {
        printf("This segment not included in a track!\n");
        fflush(stdout);
        return;
    }
    if (eD->eVerRec) if (eD->eVerRec->IsA() != EdbVertexRec::Class()) eD->eVerRec = 0;
    if (!eD->eVerRec) {printf("Error: EdbDisplay:SplitTrack: EdbVertexRec not defined, use SetVerRec(...)\n"); fflush(stdout); return;}
    TObjArray *etr = 0;
    if (eD->eVerRec) etr = (eD->eVerRec)->eEdbTracks;
    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;
    }
    if (tr->N() < 2)
    {
        printf("Only one segment in track - delete track insted!\n");
        fflush(stdout);
        return;
    }
    if (tr->VTAS() || tr->VTAE())
    {
        printf("Track belong to a vertex - impossible operate with it!\n");
        fflush(stdout);
        return;
    }
    if (eD->eTrack1)
    {
        printf("Intermediate track already exist - fix it!\n");
        fflush(stdout);
        return;
    }
    if (eD->eTrack2)
    {
        printf("Intermediate track already exist - fix it!\n");
        fflush(stdout);
        return;
    }
    EdbSegP *seg = 0;
    eD->eTrack1 = new EdbTrackP();
    eD->eTrack2 = new EdbTrackP();
        for(int is=0; is<tr->N(); is++) {
        seg = tr->GetSegment(is);
        if (seg->Z() <= eSeg->Z()) (eD->eTrack1)->AddSegment((EdbSegP *)seg);
        else                       (eD->eTrack2)->AddSegment((EdbSegP *)seg);
    }
    tr->SetFlag(-10);
    tr->SetSegmentsTrack(-2-(tr->ID()+1));
    if(eD->eArrTr) if((eD->eArrTr)->FindObject(tr))
    {
        eD->eArrTr->Remove(tr);
        eD->eArrTr->Compress();
        if (!(eD->eArrSegP)) eD->eArrSegP = new TObjArray();
            for(int is=0; is<tr->N(); is++) {
        seg = tr->GetSegment(is);
        if(eD->eArrSegP) if(!((eD->eArrSegP)->FindObject(seg))) eD->eArrSegP->Add(seg);
        }
    }
    if(eD->eArrTrSave) if((eD->eArrTrSave)->FindObject(tr))
    {
        eD->eArrTrSave->Remove(tr);
        eD->eArrTrSave->Compress();
        if (!(eD->eArrSegPSave)) eD->eArrSegPSave = new TObjArray();
            for(int is=0; is<tr->N(); is++) {
        seg = tr->GetSegment(is);
        if(eD->eArrSegPSave) if(!((eD->eArrSegPSave)->FindObject(seg))) eD->eArrSegPSave->Add(seg);
        }
    }
    eD->Draw();
    float mass = tr->M();
    float momentum = tr->P();
    if (eD->eP > 0.) momentum = eD->eP;
    if (eD->eM > 0.) mass = eD->eM;
 
    eD->eTrack1->SetM(mass);
    eD->eTrack1->SetP(momentum);
    float X0 = 0.;
    if (eD->eVerRec) if ((eD->eVerRec)->ePVR) X0 = (((eD->eVerRec)->ePVR)->GetScanCond())->RadX0();
    eD->eTrack1->FitTrackKFS(true, X0, 0);
    if (!eD->eArrTr) eD->eArrTr = new TObjArray();
    (eD->eArrTr)->Add(eD->eTrack1);
    if (eD->eArrTrSave) (eD->eArrTrSave)->Add(eD->eTrack1);
 
    eD->eTrack2->SetM(mass);
    eD->eTrack2->SetP(momentum);
    eD->eTrack2->FitTrackKFS(true, X0, 0);
    (eD->eArrTr)->Add(eD->eTrack2);
    if (eD->eArrTrSave) (eD->eArrTrSave)->Add(eD->eTrack2);
 
    eD->Draw();
  }
}

X()

float EdbSegG::X ( )

inline

{ return GetP()[0]; }

Y()

float EdbSegG::Y ( )

inline

{ return GetP()[1]; }

Z()

float EdbSegG::Z ( )

inline

{ return GetP()[2]; }

Member Data Documentation

eD

EdbDisplay* EdbSegG::eD

private

eSeg

const EdbSegP* EdbSegG::eSeg

private

---

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

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