#include <EdbEDATrackSet.h>

Inheritance diagram for EdbEDATrackSet:

Collaboration diagram for EdbEDATrackSet:

[legend]

Public Types
enum	{ kEnd , kTop , kMiddle }

Public Member Functions
void	AddComment (EdbTrackP t, char cmt)

void	AddSegments (TObjArray *segments)

void	AddTrack (EdbTrackP *t)

void	AddTracks (TObjArray *arr)

void	AddTracksBase (TObjArray *tracksbase)

void	AddTracksPVR (EdbPVRec *pvr)

void	Clear ()

void	ClearComments ()

void	ClearTracks (void)

void	ClearTracksBase (void)

void	DoSelection ()

void	DoVertexing (EdbVertexRec *VR=NULL, int ntrkcut=3)

void	Draw (int redraw=kFALSE)

void	DrawSingleComment (EdbEDATrackComment *tcmt)

void	DrawSingleSegment (EdbSegP s, char elname, TEveCompound *cmp=NULL, int extendup=1, int extenddown=1)

void	DrawSingleTrack (EdbTrackP *t)

	EdbEDATrackSet (char title, TObjArray EdbTrackPArray=NULL)

int	FindDownstreamPlate ()

EdbTrackP *	FindTrack (EdbSegP *s, double dx=10, double dt=0.02)

EdbTrackP *	FindTrack (EdbTrackP *t)

EdbTrackP *	FindTrackLast (EdbSegP *s, double dx=20, double dt=0.03)

int	FindUpstreamPlate ()

EdbEDAAreaSet *	GetAreaSet ()

const char *	GetComment (EdbTrackP *t)

EdbDataSet *	GetDataSet ()

bool	GetDraw ()

bool	GetDrawMT ()

bool	GetDrawTrackAngle ()

bool	GetDrawTrackID ()

int	GetExtendMode ()

EdbID &	GetID ()

int	GetLayerColor (EdbSegP *s)

double	GetLayerLength (EdbSegP *s)

int	GetLayerWidth (EdbSegP *s)

EdbPVRec *	GetPVRec ()

EdbScanSet *	GetScanSet ()

int	GetTextColor ()

int	GetTextFont ()

int	GetTextPosition ()

int	GetTextSize ()

EdbTrackP *	GetTrack (EdbSegP *s)

EdbTrackP *	GetTrack (int i)

void	GetTrackAttribute (int track_color, int track_width, double track_length, int layer_color, int layer_width, double layer_length, int *layer_color_MT)

EdbTrackP *	GetTrackBase (int i)

int	GetTrackColor (EdbSegP *s)

double	GetTrackLength (EdbSegP *s, int updown=1)

TObjArray *	GetTracks ()

TObjArray *	GetTracksBase ()

int	GetTrackWidth (EdbSegP *s)

bool	IsMember (EdbTrackP *t)

void	MicroTrackSearch (EdbTrackP *t)

int	MicroTrackSearch (EdbTrackP t, EdbSegP pred, int ipl)

int	N ()

int	NBase ()

int	PrepareScanSetForMT ()

void	Print ()

void	ReadFile (char *filename=NULL, int datatype=100, TCut rcut="1")

EdbDataProc *	ReadLinkedTracks (char *lnkdef="lnk.def", TCut cut="1")

EdbDataProc *	ReadLinkedTracks (EdbDataProc *dproc)

EdbDataProc *	ReadLinkedTracksFile (char *filename="linked_tracks.root", TCut cut="1")

void	ReadListFile (char *filename=NULL, bool clear_previous=kTRUE)

void	ReadMxxFile (char *filename)

void	ReadPredictionScan (EdbID id, bool force_update_setroot=0)

void	ReadPredictionScan (EdbScanSet *ss)

void	ReadPredictionScan (int BRICK, int SBVERSION, int RUN_PRED, int UseMicrotrack=0)

void	ReadTextTracks (char *filename=NULL)

void	ReadTracksTree (char *scanset_filename, TCut cut="1")

void	ReadTracksTree (EdbID ID, TCut cut="1")

void	RemoveTrack (EdbTrackP *t)

void	RemoveTrackBase (EdbTrackP *t)

void	RemoveTracks (TObjArray *tracks)

void	ResetTrackAttribute (void)

void	RestorePrevious (void)

EdbTrackP *	SearchCorrespondTrack (EdbTrackP *t)

EdbTrackP *	SearchSegment (int ipl, int iseg)

EdbTrackP *	SearchTrack (int itrk)

void	SetAreaSet (EdbEDAAreaSet *set)

void	SetColorMode (int mode)

void	SetDataSet (EdbDataSet *dset)

void	SetDraw (bool b=kTRUE)

void	SetDrawAreaSet (bool draw=kTRUE)

void	SetDrawMT (bool b=kTRUE)

void	SetDrawTrackAngle (bool draw)

void	SetDrawTrackAngleG (bool draw)

void	SetDrawTrackID (bool draw)

void	SetDrawTrackIDG (bool draw)

void	SetExtendMode (int mode=kExtendAuto)

void	SetID (EdbID id)

void	SetInterpolation (int interpolation=kTRUE)

void	SetLayerLength (double length)

void	SetPVRec (EdbPVRec *pvr)

void	SetScanSet (EdbScanSet *ss)

void	SetTextAttribute (int size=14, int color=kWhite, int fontfile=4)

void	SetTextPosition (int pos)

void	SetTrack (EdbTrackP *t)

void	SetTrack (int itrack)

void	SetTrackAttribute (int track_color=-1, int track_width=1, double track_length=-1, int layer_color=kYellow, int layer_width=2, double layer_length=150, int layer_color_MT=kCyan)

void	SetTracks (TObjArray *tracks)

void	SetTracksAll (void)

void	SetTracksBase (TObjArray *tracksbase)

void	SetTracksNseg (int nsegcut=3)

void	SetTracksVertex (EdbVertex *v, bool clear_previous=kTRUE)

void	SetTracksVertices (TObjArray *vertices, bool clear_previous=kTRUE)

void	StorePrevious ()

char *	WriteListFile (char *filename=NULL, bool append=kFALSE, bool open_editor=kFALSE)

Public Member Functions inherited from EdbEDATrackSelection
void	DoSelection (TObjArray tracksbase, TObjArray tracks)

	EdbEDATrackSelection ()

bool	GetImpactSearch ()

int	GetNsegCut ()

double	GetPHCut ()

double	GetPHDTRMS ()

EdbRunTracking &	GetRunTracking ()

int	GetSideOutPlate ()

int	GetUpstreamPlate ()

int	ImpactSearch (EdbTrackP *t)

int	Neighborhood (EdbSegP s, double dmin=NULL)

void	Reset ()

void	SetAngle (double tx, double ty)

void	SetAngularCut (bool b=kTRUE)

void	SetClearPrevious (bool b=kTRUE)

void	SetCondBTDefault (EdbScanCond &cond)

void	SetCondMTDefault (EdbScanCond &cond)

void	SetCondTrackingDefault ()

void	SetDT (double dtx, double dty=-1)

void	SetDX (double dx)

void	SetImpactSearch (bool b=kTRUE, EdbVertex *v=NULL)

void	SetNeighborSearch (bool b=kTRUE, TObjArray *selected=NULL, double dzup=-1, double dzdown=-1)

void	SetNsegCut (int nseg)

void	SetPHCut (double phcut=0.0)

void	SetPHDTRMS (double slope)

void	SetRunTracking (EdbRunTracking &rt)

void	SetSideOut (bool b=kTRUE)

void	SetSideOutPlate (int npl)

void	SetUpstreamPlate (int ipl)

int	SideOut (EdbTrackP *t)

virtual	~EdbEDATrackSelection ()

Private Attributes
EdbEDAAreaSet *	eAreaSet

int	eColorMode

TObjArray *	eComments

EdbDataSet *	eDataSet

bool	eDraw
	control of drawing More...

bool	eDrawMT
	control of drawing microtrack More...

bool	eDrawTrackAngle
	control of Track Angle drawing. More...

bool	eDrawTrackAngleG
	Global control of Track angle drawing by Main tab. More...

bool	eDrawTrackID
	control of Track ID drawing More...

bool	eDrawTrackIDG
	Global control of Track ID drawing by Main tab. More...

int	eExtendMode

EdbID	eID

int	eInterpolation

int	eLayerColor

int	eLayerColorMT

double	eLayerLength

int	eLayerWidth

EdbPVRec *	ePVR
	pointer for original EdbPVRec. tracks are copied to eTracksBase through AddTracksPVR(). More...

EdbScanSet *	eScanSet

int	eTextColor

int	eTextFont

int	eTextPosition

int	eTextSize

int	eTrackColor

double	eTrackLength

TObjArray *	eTracks
	array of tracks to be drawn More...

TObjArray *	eTracksBase
	array of tracks, base of track search More...

TObjArray *	eTracksPrevious
	previous array of tracks More...

int	eTrackWidth

Additional Inherited Members
Public Attributes inherited from EdbEDATrackSelection
EdbRunTracking	eRunTracking
	Run Tracking for microtrack search. More...

EdbVertex *	eVertex

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
kEnd
kTop
kMiddle

226{ kEnd, kTop, kMiddle};

EdbEDATrackSet::kTop

@ kTop

Definition: EdbEDATrackSet.h:226

EdbEDATrackSet::kMiddle

@ kMiddle

Definition: EdbEDATrackSet.h:226

EdbEDATrackSet::kEnd

@ kEnd

Definition: EdbEDATrackSet.h:226

Constructor & Destructor Documentation

◆ EdbEDATrackSet()

EdbEDATrackSet::EdbEDATrackSet	(	char *	title,
		TObjArray *	EdbTrackPArray = `NULL`
	)

inline

            : eID(0,0,1,0), ePVR(NULL), eDataSet(NULL), eScanSet(NULL){
        SetName(title);
        eTracks         = new TObjArray;
        eTracksBase     = new TObjArray;
        eTracksPrevious = new TObjArray;
        eComments       = new TObjArray;
        eDraw = kTRUE;
        eColorMode = kCOLOR_BY_PH;
        
        eAreaSet = new EdbEDAAreaSet();
        
        SetTrackAttribute();
        SetTextAttribute();
        SetDrawMT(kTRUE);
        SetDrawTrackID(kTRUE);
        SetDrawTrackAngle(kTRUE);
        SetDrawTrackIDG(kFALSE);
        SetDrawTrackAngleG(kFALSE);
        SetExtendMode(kExtendAuto);
        SetInterpolation(kTRUE);
        
        eTextPosition = kEnd;
        
        if(EdbTrackPArray) {
            SetTracks(EdbTrackPArray);
            SetTracksBase(EdbTrackPArray);
        }
    }

Member Function Documentation

◆ AddComment()

void EdbEDATrackSet::AddComment	(	EdbTrackP *	t,
		char *	cmt
	)

inline

475{ eComments->Add(new EdbEDATrackComment(t,cmt));}

EdbEDATrackComment

Definition: EdbEDATrackSet.h:9

t

TTree * t

Definition: check_shower.C:4

◆ AddSegments()

void EdbEDATrackSet::AddSegments ( TObjArray * segments )

inline

                                         {
        if(segments==NULL) return;
        if(segments->GetEntries()==0) return;
        
        for(int i=0;i<segments->GetEntries();i++){
            EdbSegP *s = (EdbSegP *)segments->At(i);
            EdbTrackP *t = new EdbTrackP(s);
            t->SetCounters();
            t->SetPlate(s->Plate());
            AddTrack(t);
        }
        return;
    }

◆ AddTrack()

void EdbEDATrackSet::AddTrack ( EdbTrackP * t )

inline

Add a track to both eTracksBase and eTracks, if it is not yet registered.

                                   {
        if(eTracksBase->FindObject(t)==NULL) eTracksBase->Add(t);
        if(eTracks->FindObject(t)==NULL) eTracks->Add(t);
    }

◆ AddTracks()

void EdbEDATrackSet::AddTracks ( TObjArray * arr )

inline

Add tracks to both eTracksBase and eTracks, if it is not yet registerd.
arr is a TObjArray of EdbTrackP.

                                   {
        if(NULL==arr) return; for(int i=0;i<arr->GetEntries();i++) AddTrack( (EdbTrackP *) arr->At(i));
    }

◆ AddTracksBase()

void EdbEDATrackSet::AddTracksBase ( TObjArray * tracksbase )

inline

Add tracks to eTracksBase. tracksbase should be an array of EdbTrackP

                                              {
        if(tracksbase==NULL) return;
        for(int i=0;i<tracksbase->GetEntries();i++) eTracksBase->Add(tracksbase->At(i));
    }

◆ AddTracksPVR()

void EdbEDATrackSet::AddTracksPVR ( EdbPVRec * pvr )

inline

COPY tracks from EdbPVRec.
original PVRec is accessible through GetPVRec().

                                     {
        ePVR = pvr;
        AddTracksBase(ePVR->eTracks);
        SetTracksAll();
        eAreaSet->SetAreas(ePVR);
    }

◆ Clear()

void EdbEDATrackSet::Clear ( )

inline

Clear Tracks and TracksBase.

                 { 
        ClearTracks(); ClearTracksBase(); eAreaSet->Clear();
    }

◆ ClearComments()

void EdbEDATrackSet::ClearComments ( )

inline

476{eComments->Clear();}

◆ ClearTracks()

void EdbEDATrackSet::ClearTracks ( void )

inline

Clear Tracks to be draw.

                           {
        eTracks->Clear();
    }

◆ ClearTracksBase()

void EdbEDATrackSet::ClearTracksBase ( void )

inline

Clear eTracksBase.

                               {
        eTracksBase->Clear();
    }

◆ DoSelection()

void EdbEDATrackSet::DoSelection ( )

inline

503{ EdbEDATrackSelection::DoSelection(eTracksBase,eTracks);}

EdbEDATrackSelection::DoSelection

void DoSelection(TObjArray *tracksbase, TObjArray *tracks)

Definition: EdbEDATrackSet.C:126

◆ DoVertexing()

void EdbEDATrackSet::DoVertexing	(	EdbVertexRec *	VR = `NULL`,
		int	ntrkcut = `3`
	)

Do vertexing. if EdbVertexRec is given, use the parameter for reconstruction.

                                                             {
    if(VR==NULL){
        VR = new EdbVertexRec;
        VR->eDZmax      = 5000.;  // maximum z-gap in the track-vertex group
        VR->eProbMin    = 0.001;  // minimum acceptable probability for chi2-distance between tracks
        VR->eImpMax     = 5.;     // maximal acceptable impact parameter [microns] (for preliminary check)
        VR->eUseMom     = false;  // use or not track momentum for vertex calculations
        VR->eUseSegPar  = true;   // use only the nearest measured segments for vertex fit (as Neuchatel)
        VR->eQualityMode= 0;      // vertex quality estimation method (0:=Prob/(sigVX^2+sigVY^2); 1:= inverse average track-vertex distanc
        VR->eEdbTracks = GetTracks();
    }
    if(ePVR==NULL) ePVR = new EdbPVRec;
    
    if(ePVR->GetScanCond()==NULL) ePVR->SetScanCond(new EdbScanCond);
    
    VR->eVTX = new TObjArray;
    
    VR->SetPVRec(GetPVRec());
    int nvtx=VR->FindVertex();
    if(nvtx)VR->ProbVertexN();
    
    gEDA->GetVertexSet()->Clear();
    gEDA->GetVertexSet()->AddVertices(VR->eVTX);
    gEDA->GetVertexSet()->SetVerticesNtrk(ntrkcut);
    
    ClearTracks();
    SetTracksVertices(gEDA->GetVertexSet()->GetVertices());
 
}

◆ Draw()

void EdbEDATrackSet::Draw ( int redraw = kFALSE )

                                   {
    eAreaSet->Draw();
 
    if(eDraw==kFALSE) {
        printf("TrackSet %s Draw    0 / %4d tracks. Disabled\n", GetName(), NBase());
        return;
    }
    for(int i=0;i<N();i++){
        EdbTrackP *t = GetTrack(i);
        DrawSingleTrack(t);
    }
    
    for(int i=0;i<eComments->GetEntries();i++){
        EdbEDATrackComment *cmt = (EdbEDATrackComment *) eComments->At(i);
        DrawSingleComment(cmt);
    }
    
    
    if(redraw) gEve->Redraw3D();
    printf("TrackSet %s Draw %4d / %4d tracks\n", GetName(), N(), NBase());
}

◆ DrawSingleComment()

void EdbEDATrackSet::DrawSingleComment ( EdbEDATrackComment * tcmt )

                                                              {
    
    EdbTrackP *t = tcmt->GetTrack();
    
    // if ID, Angle are draw. use same TEveText.
    TEveCompound *cmp = EdbEDAUtil::GetTrackElement(t);
    if(cmp==NULL) return; // if the corresponding track will not be drawn, skip to draw comment.
 
    TEveText *tx = NULL;
    for(TEveElement::List_i it=cmp->BeginChildren(); it!=cmp->EndChildren();it++){
        if(strncmp("TEveText",(*it)->GetElementName(),8)==0) {
            tx = (TEveText *) (*it);
            tx->SetText(Form("%s %s", tx->GetText(), tcmt->GetComment()));
        }
    }
    
    // if ID, Angle are not drawn.
    if(tx==NULL) {
        tx=new TEveText();
        tx->SetText(tcmt->GetComment());
        // draw text 1mm downstream of the last segment.
        // ! to be selected by eTextPosition......
        EdbSegP *s = t->GetSegmentLast();
        tx->PtrMainTrans()->SetPos(
            s->X()+s->TX()*1000, 
            s->Y()+s->TY()*1000,
            (s->Z()+1000)*gEDA->GetScaleZ());
        
        tx->SetFontMode(TGLFont::kBitmap);
        tx->SetFontSize(eTextSize);
        tx->SetFontFile(eTextFont);
        tx->SetMainColor(eTextColor);
        gEve->AddElement(tx);
    }
    
}

◆ DrawSingleSegment()

void EdbEDATrackSet::DrawSingleSegment	(	EdbSegP *	s,
		char *	elname,
		TEveCompound *	cmp = `NULL`,
		int	extendup = `1`,
		int	extenddown = `1`
	)

Draw Single Segment

                                                                                                               {
    
    if(s==NULL) return;
    
    if(cmp==NULL) {
        cmp = new TEveCompound;
        gEve->AddElement(cmp);
    }
    cmp->OpenCompound();
    
        // default extention line
    TEveLine *l = new TEveLine;
    l->SetName(elname);
    l->SetLineWidth(GetTrackWidth(s));
    l->SetUserData(s);
    
    l->SetLineColor(GetTrackColor(s));
    if(extendup){
        //Auto calculation of track_line_length
        double dz = -GetTrackLength(s,-1);
        l->SetNextPoint(s->X()+dz*s->TX(), 
                        s->Y()+dz*s->TY(), 
                        (s->Z()+dz)*gEDA->GetScaleZ());
 
    } else {
        l->SetNextPoint(s->X(), s->Y(), s->Z()*gEDA->GetScaleZ());
    }
    if(extenddown){
        
        double dz = GetTrackLength(s,1);
 
        l->SetNextPoint(s->X()+dz*s->TX(), 
                        s->Y()+dz*s->TY(), 
                        (s->Z()+dz)*gEDA->GetScaleZ());
    } else {
        l->SetNextPoint(s->X(), s->Y(), s->Z()*gEDA->GetScaleZ());
    }
    cmp->AddElement(l);
 
    // sensitive layer.
    l = new TEveLine;
    l->SetName(elname);
    l->SetUserData(s);
    l->SetLineWidth(GetLayerWidth(s));
 
    l->SetLineColor(GetLayerColor(s));
    
    double dz = GetLayerLength(s);
    l->SetNextPoint( s->X()-dz*s->TX(), 
                     s->Y()-dz*s->TY(), 
                    (s->Z()-dz)*gEDA->GetScaleZ());
    l->SetNextPoint( s->X()+dz*s->TX(), 
                     s->Y()+dz*s->TY(), 
                    (s->Z()+dz)*gEDA->GetScaleZ());
 
    cmp->AddElement(l);
    
    cmp->CloseCompound();
}

◆ DrawSingleTrack()

void EdbEDATrackSet::DrawSingleTrack ( EdbTrackP * t )

                                                {
    int i;
    
    if(t==NULL) return;
    TEveCompound *cmp = new TEveCompound;
    gEve->AddElement(cmp);
    
    cmp->SetName( Form("%3s trk %4d pl %2d -> %2d %8.1f %8.1f %8.1f %7.4f %7.4f %d",
                GetName(), t->ID(), t->GetSegmentFirst()->Plate(), t->GetSegmentLast()->Plate(), t->X(),t->Y(),t->Z(),t->TX(),t->TY(), t->Flag()));
    cmp->SetUserData(t);
 
    int nseg = t->N();
    EdbSegP *last_seg=NULL;
    for(i=0;i<nseg;i++){
        EdbSegP *s = t->GetSegment(i);
        
        if(eDrawMT==kFALSE && s->Side()!=0) continue;
 
        char elname[256];
        // set name
        if(gEDA->Japanese()) sprintf(elname,
            "%3s %4d seg  itrk %4d pl %2d(%2d) id %6d %3s ph %2d %8.1f %8.1f %8.1f %7.4f %7.4f chi2 %4.2f sflag %3d", 
            GetName(), s->ScanID().eMinor, t->ID(), s->Plate(), 58-s->Plate(), (int)s->ID(), s->Side()? s->Side()==1? "MT1" : "MT2" : "BT", (int)s->W(), 
            s->X(), s->Y(), s->Z(), s->TX(), s->TY(), s->Chi2(), s->Flag());
        else sprintf(elname,
            "%3s %4d seg  itrk %4d pl %2d id %6d %3s ph %2d %8.1f %8.1f %8.1f %7.4f %7.4f chi2 %4.2f sflag %3d", 
            GetName(), s->ScanID().eMinor, t->ID(), s->Plate(), (int)s->ID(), s->Side()? s->Side()==1? "MT1" : "MT2" : "BT", (int)s->W(), 
            s->X(), s->Y(), s->Z(), s->TX(), s->TY(), s->Chi2(), s->Flag());
        if(s->MCEvt()>=0) sprintf(elname,"%s MCEvt %d P %7.4f PdgID %6d",elname,s->MCEvt(),s->P(), s->Flag());
 
        // set extend or not
        int extendup=1, extenddown=1;
        if(eExtendMode==kExtendAuto){
            if(i==0)        extendup=0;
            if(i==nseg-1)   extenddown=0;
            if(t->N()==1)   extenddown=1;
        } 
        else if (eExtendMode == kExtendUpDown) extendup=extenddown=1;
        else if (eExtendMode == kExtendDown) { extendup=0; extenddown=1;}
        else if (eExtendMode == kExtendUp)   { extendup=1; extenddown=0;}
        else if (eExtendMode == kExtendNo)     extendup=extenddown=0;
 
        DrawSingleSegment(s, elname, cmp, extendup, extenddown);
        
        // in case that there was holes, draw the interpolation line.
        // from end point of extention(down) of last_seg to that of extention(up) of s.
        if(eInterpolation&&last_seg!=NULL){
            // hole = skip of plate number
            if(abs(last_seg->PID()-s->PID())>1){
                TEveLine *l = new TEveLine;
                l->SetLineStyle(7);
                l->SetName(elname);
                l->SetUserData(last_seg);
                l->SetLineWidth(1);
                l->SetLineColor(kGray+1);
 
                double dz = -GetTrackLength(s,-1); // to upstream
 
                l->SetNextPoint(s->X()+dz*s->TX(), 
                                s->Y()+dz*s->TY(), 
                                (s->Z()+dz)*gEDA->GetScaleZ());
 
                dz = GetTrackLength(last_seg,1); // to downstream
                
                l->SetNextPoint(last_seg->X()+dz*last_seg->TX(), 
                                last_seg->Y()+dz*last_seg->TY(), 
                                (last_seg->Z()+dz)*gEDA->GetScaleZ());
                cmp->OpenCompound();
                cmp->AddElement(l);
                cmp->CloseCompound();
            }
        }
        last_seg=s;
    }
    
    if((eDrawTrackID&&eDrawTrackIDG)||(eDrawTrackAngle&&eDrawTrackAngleG)){
        char buf[256];
        strcpy(buf,"");
        if(eDrawTrackID&&eDrawTrackIDG)    sprintf(buf,"%d",t->ID());
        if(eDrawTrackAngle&&eDrawTrackAngleG) sprintf(buf,"%s (%.3lf,%.3lf)", buf, t->TX(), t->TY());
        TEveText* tx = new TEveText;
        tx->SetText(buf);
        tx->SetMainColor(eTextColor);
        tx->SetFontMode(TGLFont::kBitmap);
        tx->SetFontFile(eTextFont);
        tx->SetFontSize(eTextSize);
        
        if(eTextPosition==kTop){
            EdbSegP *s = t->GetSegmentFirst();
            tx->PtrMainTrans()->SetPos( s->X(), s->Y(), s->Z()*gEDA->GetScaleZ());
        }
        else if(eTextPosition==kMiddle){
            EdbSegP *s1 = t->GetSegmentFirst();
            EdbSegP *sl = t->GetSegmentLast();
            tx->PtrMainTrans()->SetPos( (s1->X()+sl->X())/2, (s1->Y()+sl->Y())/2, (s1->Z()+sl->Z())/2);
        }
        else {
            EdbSegP *s = t->GetSegmentLast();
            tx->PtrMainTrans()->SetPos( s->X()+s->TX()*650, s->Y()+s->TY()*650, (s->Z()+650)*gEDA->GetScaleZ());
        }
        cmp->OpenCompound();
        cmp->AddElement(tx);
        cmp->CloseCompound();
    }
}

◆ FindDownstreamPlate()

int EdbEDATrackSet::FindDownstreamPlate ( )

inline

                               {
        int ipldw = -1000;
        for(int i=0;i<NBase(); i++) {
            int ipl= GetTrackBase(i)->GetSegmentLast()->Plate();
            if(ipl>ipldw) ipldw=ipl;
        }
        return ipldw;
    }

◆ FindTrack() [1/2]

EdbTrackP * EdbEDATrackSet::FindTrack	(	EdbSegP *	s,
		double	dx = `10`,
		double	dt = `0.02`
	)

inline

                                                                       {
        EdbSegP *ss = new EdbSegP;
        for(int i=0;i<NBase();i++){
            EdbTrackP *t = GetTrackBase(i);
            if(t==NULL) continue;
            *ss = *(t->GetSegmentFirst());
            ss->PropagateTo(s->Z());
            if( fabs(s->X()-ss->X()) < dx){
            if( fabs(s->Y()-ss->Y()) < dx){
            if( fabs(s->TX()-ss->TX()) < dt) {
            if( fabs(s->TY()-ss->TY()) < dt) {
                return t;
            }}}}
            
        }
        delete ss;
        return NULL;
    }

◆ FindTrack() [2/2]

EdbTrackP * EdbEDATrackSet::FindTrack ( EdbTrackP * t )

inline

                                       {
        if(eTracks==NULL) return NULL;
        if(eTracks->FindObject(t)) return t;
        return NULL;
    }

◆ FindTrackLast()

EdbTrackP * EdbEDATrackSet::FindTrackLast	(	EdbSegP *	s,
		double	dx = `20`,
		double	dt = `0.03`
	)

inline

                                                                           {
        
        EdbSegP ss;
        for(int i=0;i<eTracksBase->GetEntries();i++){
            EdbTrackP *tt = (EdbTrackP *) eTracksBase->At(i);
            for(int j=0;j<tt->N();j++){
                ss.Copy(*tt->GetSegment(j));
                ss.PropagateTo(s->Z());
                if(fabs(s->TX()-ss.TX())<dt){
                if(fabs(s->TX()-ss.TX())<dt){
                    if( fabs(s->X()-ss.X())<dx ){
                    if( fabs(s->Y()-ss.Y())<dx ){
                        return tt;
                    }}
                }}
            }
        }
        return NULL;
    }

◆ FindUpstreamPlate()

int EdbEDATrackSet::FindUpstreamPlate ( )

inline

                             {
        if(NBase()==0) return 0;
        int iplup = 1000;
        for(int i=0;i<NBase(); i++) {
            int ipl= GetTrackBase(i)->GetSegmentFirst()->Plate();
            if(ipl<iplup) iplup=ipl;
        }
        return iplup;
    }

◆ GetAreaSet()

EdbEDAAreaSet * EdbEDATrackSet::GetAreaSet ( )

inline

602{ return eAreaSet;}

◆ GetComment()

const char * EdbEDATrackSet::GetComment ( EdbTrackP * t )

inline

                                          { 
        for(int i=0;i<eComments->GetEntries();i++){
            EdbEDATrackComment *cmt = (EdbEDATrackComment *) eComments->At(i);
            if(cmt->GetTrack()==t) {
                return cmt->GetComment();
            }
        }
        return "";
    }

◆ GetDataSet()

EdbDataSet * EdbEDATrackSet::GetDataSet ( )

inline

473{ return eDataSet;}

◆ GetDraw()

bool EdbEDATrackSet::GetDraw ( )

inline

584{ return eDraw;}

◆ GetDrawMT()

bool EdbEDATrackSet::GetDrawMT ( )

inline

586{ return eDrawMT;}

◆ GetDrawTrackAngle()

bool EdbEDATrackSet::GetDrawTrackAngle ( )

inline

592{ return eDrawTrackAngle;}

◆ GetDrawTrackID()

bool EdbEDATrackSet::GetDrawTrackID ( )

inline

591{ return eDrawTrackID;}

◆ GetExtendMode()

int EdbEDATrackSet::GetExtendMode ( )

inline

527{ return eExtendMode;}

◆ GetID()

EdbID & EdbEDATrackSet::GetID ( )

inline

464{return eID;}

◆ GetLayerColor()

int EdbEDATrackSet::GetLayerColor ( EdbSegP * s )

inline

565{ return s->Side()==0?eLayerColor:eLayerColorMT;}

EdbEDATrackSet::eLayerColorMT

int eLayerColorMT

Definition: EdbEDATrackSet.h:200

EdbEDATrackSet::eLayerColor

int eLayerColor

Definition: EdbEDATrackSet.h:191

◆ GetLayerLength()

double EdbEDATrackSet::GetLayerLength ( EdbSegP * s )

inline

567{ return eLayerLength;};

EdbEDATrackSet::eLayerLength

double eLayerLength

Definition: EdbEDATrackSet.h:193

◆ GetLayerWidth()

int EdbEDATrackSet::GetLayerWidth ( EdbSegP * s )

inline

566{ return eLayerWidth;}//eLayerWidth>=0 ? eLayerWidth : (int)s->W()/10+1;}

EdbEDATrackSet::eLayerWidth

int eLayerWidth

Definition: EdbEDATrackSet.h:192

◆ GetPVRec()

EdbPVRec * EdbEDATrackSet::GetPVRec ( )

inline

320{ return ePVR;}

◆ GetScanSet()

EdbScanSet * EdbEDATrackSet::GetScanSet ( )

inline

471{ return eScanSet;}

◆ GetTextColor()

int EdbEDATrackSet::GetTextColor ( )

inline

576{ return eTextColor;}

◆ GetTextFont()

int EdbEDATrackSet::GetTextFont ( )

inline

578{ return eTextFont;}

◆ GetTextPosition()

int EdbEDATrackSet::GetTextPosition ( )

inline

581{ return eTextPosition;}

◆ GetTextSize()

int EdbEDATrackSet::GetTextSize ( )

inline

577{ return eTextSize;}

◆ GetTrack() [1/2]

EdbTrackP * EdbEDATrackSet::GetTrack ( EdbSegP * s )

inline

                                   {
        if(IsTrack(s)) return (EdbTrackP*) s;
        if(IsSegment(s)){
            for(int i=0;i<eTracksBase->GetEntries();i++){
                EdbTrackP *t = (EdbTrackP *) eTracksBase->At(i);
                for(int j=0;j<t->N();j++) if(s==t->GetSegment(j)) return t;
            }
        }
        return NULL;
    }

◆ GetTrack() [2/2]

EdbTrackP * EdbEDATrackSet::GetTrack ( int i )

inline

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

◆ GetTrackAttribute()

void EdbEDATrackSet::GetTrackAttribute	(	int *	track_color,
		int *	track_width,
		double *	track_length,
		int *	layer_color,
		int *	layer_width,
		double *	layer_length,
		int *	layer_color_MT
	)

inline

                                                                                                                                                                     {
        *track_color  = eTrackColor ;
        *track_width  = eTrackWidth ;
        *track_length = eTrackLength;
        *layer_color  = eLayerColor ;
        *layer_width  = eLayerWidth ;
        *layer_length = eLayerLength;
        *layer_color_MT = eLayerColorMT;
    }

◆ GetTrackBase()

EdbTrackP * EdbEDATrackSet::GetTrackBase ( int i )

inline

442{ return (EdbTrackP *) eTracksBase->At(i);}

◆ GetTrackColor()

int EdbEDATrackSet::GetTrackColor ( EdbSegP * s )

return Track color. if eTrackColor==-1, calculate according to eColorMode

                                           {
    
    if(eTrackColor!=-1) return eTrackColor;
 
    if(eColorMode==kCOLOR_BY_PLATE)    { int ipl=s->Plate(); if(ipl==0) ipl=s->PID();return ((ipl+5)%13)*4+52; }
    if(eColorMode==kCOLOR_BY_PH)       { int ph = (int)s->W(); if(ph>32) ph=32; return ((ph-8)%25)*2+50;}
//  if(eColorMode==kCOLOR_BY_PH)       { int ph = (int)s->W(); if(ph>16) ph=16; return (ph-4)*4+51;}
    if(eColorMode==kBLACKWHITE)  { return kBlack; };
    if(eColorMode==kCOLOR_BY_PARTICLE) { return s->Flag();}
    if(eColorMode==kCOLOR_BY_ID)       {
        int col = s->Track()%10+1;
        if (col==5) col = kOrange;
        if (col==10) col = kGreen+3;
        return col;
    }
    if(eColorMode==kCOLOR_BY_MCID)     {
        int col = s->MCTrack()%10+1;
        if (col==5) col = kOrange;
        if (col==10) col = kGreen+3;
        if (col==1) col = kOrange+3;
        if (col<0) col = kWhite; //background
        return col;
    }
 
    return (s->Plate()%13)*4+52;
}

◆ GetTrackLength()

double EdbEDATrackSet::GetTrackLength	(	EdbSegP *	s,
		int	updown = `1`
	)

Calculate Track extrapolation length.
updon : up = -1, down = 1

                                                           {  
    if( eTrackLength>0 ) return eTrackLength;
    
    // ScanSet case
    if(eScanSet!=NULL&&eDataSet==NULL){
        EdbPlateP *pl0 = eScanSet->GetPlate(s->Plate());
        EdbPlateP *pl1 = eScanSet->GetPlate(s->Plate()+updown);
        if(pl1==NULL) {
            // in case some plates are missing.
            for(int i=1;i<eScanSet->eB.Npl();i++){
                int dpl=i*updown;
                pl1 = eScanSet->GetPlate(s->Plate()+dpl);
                if(pl1!=NULL) break;
            }
            if(pl1==NULL) pl1=pl0;
        }
        return fabs( pl0->Z() - pl1->Z() )*0.5; 
    }   
    
    // PVRec case
    // check if the next plate exist (only the case ePVR has patterns)
    //  currently SB,SF doesn't have patterns, to be done.
    if(ePVR){
        if(ePVR->Npatterns()!=0){
            for(int i=0;i<ePVR->Npatterns();i++){
                EdbPattern *pat0 = ePVR->GetPattern(i);
                if( pat0==NULL) continue;
                if( pat0->GetSegment(0)==NULL ) continue;
                if( pat0->GetSegment(0)->Plate() == s->Plate()) {
                    int pidnext = i+updown;
                    if(pidnext<0||pidnext>ePVR->Npatterns()) return 650;
                    EdbPattern *pat1 = ePVR->GetPattern(pidnext);
                    if(pat1==NULL) return 650;
                    else return fabs( pat1->Z()-pat0->Z() )*0.5;
                }
            }
        }
    }
    
    return fabs( gEDA->GetZ(s->Plate()) - gEDA->GetZ(s->Plate()+updown) )*0.5; 
} 

◆ GetTracks()

TObjArray * EdbEDATrackSet::GetTracks ( )

inline

310{ return eTracks;}

◆ GetTracksBase()

TObjArray * EdbEDATrackSet::GetTracksBase ( )

inline

275{ return eTracksBase;}

◆ GetTrackWidth()

int EdbEDATrackSet::GetTrackWidth ( EdbSegP * s )

inline

562{ return eTrackWidth;}

◆ IsMember()

bool EdbEDATrackSet::IsMember ( EdbTrackP * t )

inline

443{return (eTracksBase->FindObject(t) != NULL) ? kTRUE : kFALSE;}

◆ MicroTrackSearch() [1/2]

void EdbEDATrackSet::MicroTrackSearch ( EdbTrackP * t )

                                                 {
    //  void SetCondTrackingDefault(){
    //      eRunTracking.eDeltaRview = 400.;
    //      eRunTracking.eDeltaTheta = 0.2;
    //      eRunTracking.eDeltaR = 20.;
    //
    //      eRunTracking.ePreliminaryPulsMinMT = 7;
    //      eRunTracking.ePreliminaryChi2MaxMT = 3.0;
    //
    //      eRunTracking.ePulsMinMT       = 9;
    //      eRunTracking.ePulsMinDegradMT = 1.5;
    //      eRunTracking.eChi2MaxMT       = 1.6;
    //
    //      eRunTracking.ePulsMinBT       = 18;
    //      eRunTracking.ePulsMinDegradBT = 1.5;
    //      eRunTracking.eChi2MaxBT       = 1.8;
    //
    //      eRunTracking.eDegradPos   = 5.;
    //      eRunTracking.eDegradSlope = 0.003;
    //
    //      SetCondMTDefault( eRunTracking.eCondMT);
    //      SetCondBTDefault( eRunTracking.eCondBT);
    //  }
    //
    //  void SetCondMTDefault(EdbScanCond &cond){
    //      cond.SetSigma0( 1., 1., 0.010, 0.010 );     // sigma0 "x, y, tx, ty" at zero angle
    //      cond.SetDegrad( 5. );                       // sigma(tx) = sigma0*(1+degrad*tx)
    //      cond.SetBins(0, 0, 0, 0);  //???            // bins in [sigma] for checks
    //      cond.SetPulsRamp0(  5., 5. );               // in range (Pmin:Pmax) Signal/All is nearly linear
    //      cond.SetPulsRamp04( 5., 5. );
    //      cond.SetChi2Max( 6.5 );
    //      cond.SetChi2PMax( 6.5 );
    //      cond.SetRadX0( 5810. );
    //      cond.SetName("OPERA_microtrack");
    //  }
    //
    //  void SetCondBTDefault(EdbScanCond &cond){
    //      cond.SetSigma0( 10., 10., 0.007, 0.007 );   // sigma0 "x, y, tx, ty" at zero angle
    //      cond.SetDegrad( 2. );                       // sigma(tx) = sigma0*(1+degrad*tx)
    //      cond.SetBins(0, 0, 0, 0);                   // bins in [sigma] for checks
    //      cond.SetPulsRamp0(  5., 5. );               // in range (Pmin:Pmax) Signal/All is nearly linear
    //      cond.SetPulsRamp04( 5., 5. );
    //      cond.SetChi2Max( 6.5 );
    //      cond.SetChi2PMax( 6.5 );
    //      cond.SetRadX0( 5810. );
    //      cond.SetName("OPERA_basetrack");
    //  }
    //
    
    int ret=PrepareScanSetForMT();
    if(ret==-1) {
        printf("ScanSet error. stop.\n");
        return ;
    }
    
    // Upstream segment search
    for(;;){
        EdbSegP *s = t->GetSegmentFirst();
        int ret = MicroTrackSearch(t,s,s->Plate()-1);
        if(ret==-1) {
            ret = MicroTrackSearch(t,s,s->Plate()-2);
        }
        if (ret==-1) break;
    }
    
    // Fill holes
    for(int i=0;i<t->N()-1;i++){
        EdbSegP *s1 = t->GetSegment(i);
        EdbSegP *s2 = t->GetSegment(i+1);
 
        for(int j=1;j<=2&&i+j<t->N();j++){
            int ipl=s1->Plate()+j;
            if( ipl!=s2->Plate() ) {
                // search MT from upstream
                int ret=MicroTrackSearch(t, s1, ipl);
                if(ret!=-1) break;
                // search MT from downstream
                ret=MicroTrackSearch(t, s2, ipl);
                if(ret!=-1) break;
            }
            else{
                break;
            }
        }
    }
    
    // Downstream segment search
    for(;;){
        EdbSegP *s = t->GetSegmentLast();
        int ret = MicroTrackSearch(t,s,s->Plate()+1);
        if(ret==-1) break;
    }
}

◆ MicroTrackSearch() [2/2]

int EdbEDATrackSet::MicroTrackSearch	(	EdbTrackP *	t,
		EdbSegP *	pred,
		int	ipl
	)

Micro-track search.
Original from Napoli, modified by Frederic, impremented by Aki.
Use EdbScanProc
return -1 = not found, 0 = Basetrack found, 1 or 2 = Microtrack found.

                                                                       {
    printf("## Micro-track search ##\n");
    
    
    // Check if there is already a segment on the given ipl.
    int seg_already_exist=0;
    for(int i=0;i<t->N();i++) if( t->GetSegment(i)->Plate()==ipl) seg_already_exist++;
    if(seg_already_exist){
        printf(" A segment is already reconstructed in the track. No search is done.\n\n");
        return -1;
    }
    
    // Check if the give plate is out of brick
    if(ipl<gEDA->GetFirstPlate() || ipl>gEDA->GetLastPlate() ){
        printf("searching plate %d is out of brick. stop.\n", ipl);
        return -1;
    }
    
    int ret = PrepareScanSetForMT();
    if(ret==-1) {
        printf("ScanSet error. stop.\n");
        return -1;
    }
    EdbScanProc *sproc = gEDA->ScanProc();
    
    // get ScanSet of Total scan.
    // normally it's not filled even if TS are read via ReadTracksTree(id)
    EdbScanSet *sc = GetScanSet(); 
    
    // Check if the plate is scanned or not.
    int flag_scanned=0;
    for(int i=0;i<sc->eIDS.GetEntries();i++){
        EdbID *id = sc->GetID(i);
        if(ipl==id->ePlate) flag_scanned++;
    }
    if(flag_scanned==0) {
        //ErrorMessage(Form("Plate %d is not scanned.\n", ipl));
        printf("Plate %d is not scanned.\n", ipl);
        return -1;
    }
    // Tracking setting --> Moved in constructor
    //eRunTracking.ePredictionScan = false;
    //SetCondTrackingDefault();
 
    printf("  Segment pl=%d target_pl=%d\n",app->Plate(), ipl);
    
    // Affine parameters.
    // use main data-set affine to unify affine transformation.
    //EdbPlateP *pl0 = sc->GetPlate(app->Plate());
    //EdbPlateP *pl1 = sc->GetPlate(ipl);
 
    //EdbAffine2D *aff_vid0 = pl0->GetAffineXY();
    //EdbAffine2D *aff_vid1 = pl1->GetAffineXY();
    
    if(gEDA->GetAffine(app->Plate())==NULL||gEDA->GetAffine(ipl)==NULL) {
        printf("No affine parameters found. stop.\n");
        return -1;
    }
 
    EdbAffine2D aff_vid0 = *gEDA->GetAffine(app->Plate());
    EdbAffine2D aff_vid1 = *gEDA->GetAffine(ipl);
    
    
    aff_vid1.Print();
    aff_vid0.Print();
    
    aff_vid0.Invert();                   // invert affine
    aff_vid1.Invert();
    
    double z = gEDA->GetZ(ipl);           // z at target plate
    
    EdbSegP app_tr(*app);                 // copy of original track
    app_tr.Transform(&aff_vid0);           // from global to local
 
    EdbSegP spred(*app);                  // prediction from original track
    spred.SetPlate(ipl);
    spred.PropagateTo(z);                 // propagate to target Z
    
    spred.Transform(&aff_vid1);            // from global to local
 
//  printf("  Track id = %d\n", t->ID());
//  printf("  Original (global)  -> Plate = %d, X = %2.2f, Y = %2.2f, TX = %2.4f, TY = %2.4f\n", 
//              app->Plate(), app->X(), app->Y(), app->TX(), app->TY());
//  printf("  Original (local)   -> Plate = %d, X = %2.2f, Y = %2.2f, TX = %2.4f, TY = %2.4f\n", 
//              app_tr.Plate(), app_tr.X(), app_tr.Y(), app_tr.TX(), app_tr.TY());
//  printf("  Prediction (local) -> Plate = %d, X = %2.2f, Y = %2.2f, TX = %2.4f, TY = %2.4f\n", 
//              spred.Plate(), spred.X(), spred.Y(), spred.TX(), spred.TY());
    
    EdbID& id = GetID();
    EdbSegP fndbt,fnds1,fnds2,snewpred;
    int idp[4]={id.eBrick, ipl, id.eMajor, id.eMinor};
    sproc->InitRunAccess(eRunTracking,idp);
    
    int status = eRunTracking.FindPrediction(spred, fndbt, fnds1, fnds2, snewpred );
    if (status==-1) {
        printf(" *** MICROTRACK SEARCH ***\n");
        printf(" ***** NOTHING FOUND *****\n");
        if(gEve) gEve->SetStatusLine(Form("Nothing found on pl%02d. prediction from pl%02d", 
                                    ipl, app->Plate()));
    }
    else {
        printf("  \n");
        printf("  Status = %d, Candidate found\n", status); 
        printf("  Prediction (local) -> Plate = %2d, X = %8.1f, Y = %8.1f, TX = %7.4f, TY = %7.4f\n", 
                    spred.Plate(), spred.X(), spred.Y(), spred.TX(), spred.TY());
        printf("  Found      (local) -> Plate = %2d, X = %8.1f, Y = %8.1f, TX = %7.4f, TY = %7.4f\n", 
                    ipl, snewpred.X(), snewpred.Y(), snewpred.TX(), snewpred.TY());
        printf("  Residual                              %8.1f,     %8.1f,      %7.4f,      %7.4f\n", 
                    spred.X()-snewpred.X(), spred.Y()-snewpred.Y(), spred.TX()-snewpred.TX(), spred.TY()-snewpred.TY());
        
//      printf("  \n");
        aff_vid1.Invert();            //from local to global 
        snewpred.Transform(&aff_vid1);
        printf("  Found     (global) -> Plate = %2d, X = %8.1f, Y = %8.1f, TX = %7.4f, TY = %7.4f\n\n", 
            ipl, snewpred.X(), snewpred.Y(), snewpred.TX(), snewpred.TY()); 
    }
 
    
    if(status==0){
        EdbSegP *snewpred0 = new EdbSegP(snewpred);
 
        snewpred0->SetPID(gEDA->GetPID(ipl));
        snewpred0->SetZ(z);
        snewpred0->SetErrors(1.,1.,10.,0.002,0.002);
        snewpred0->SetDZ(-214);
 
        t->AddSegment(snewpred0);
        t->SetCounters();
        t->FitTrackKFS();
        
        printf("## BASETRACK found ##\n");
        printf(" MT Top : X = %8.1f, Y = %8.1f, TX = %7.4f, TY = %7.4f, W = %2.0f, Chi2 = %5.2f,\n",
                    fnds1.X(),fnds1.Y(),fnds1.TX(),fnds1.TY(),fnds1.W(),fnds1.Chi2());
        printf(" MT Bot : X = %8.1f, Y = %8.1f, TX = %7.4f, TY = %7.4f, W = %2.0f, Chi2 = %5.2f,\n",
                    fnds2.X(),fnds2.Y(),fnds2.TX(),fnds2.TY(),fnds2.W(),fnds2.Chi2());
        
        if(gEve) gEve->SetStatusLine(Form("Basetrack found on pl %d. (W,Chi2)= Top(%d,%.2f) Bot(%d,%.2f)", 
                                    ipl, (int)fnds1.W(), fnds1.Chi2(), (int)fnds2.W(), fnds2.Chi2()));
    }
    
    if(status==1){
        EdbSegP *snewpred1 = new EdbSegP(snewpred);
        
        snewpred1->SetPID(gEDA->GetPID(ipl));  
        snewpred1->SetErrors(1.,1.,10.,0.002,0.002);
        snewpred1->SetZ(z);
        snewpred1->SetDZ(-107);
        snewpred1->SetAid(snewpred1->Aid(0), snewpred1->Aid(1), status);
        t->AddSegment(snewpred1);
        t->SetCounters();
        t->FitTrackKFS();
 
        printf("## MICROTRACK Top found ##\n");
        printf(" MT Top : X = %8.1f, Y = %8.1f, TX = %7.4f, TY = %7.4f, W = %2.0f, Chi2 = %5.2f,\n",fnds1.X(),fnds1.Y(),fnds1.TX(),fnds1.TY(),fnds1.W(),fnds1.Chi2());
        if(gEve) gEve->SetStatusLine(Form("Microtrack Top found on pl %d. (W,Chi2)=(%d,%.2f)", 
                                    ipl,(int)fnds1.W(), fnds1.Chi2()));
    }
 
    if(status==2){
        EdbSegP *snewpred2 = new EdbSegP(snewpred);
 
        snewpred2->SetPID(gEDA->GetPID(ipl));  
        snewpred2->SetErrors(1.,1.,10.,0.002,0.002);
        snewpred2->SetZ(z);
        snewpred2->SetDZ(-107);
        snewpred2->SetAid(snewpred2->Aid(0), snewpred2->Aid(1), status);
 
        t->AddSegment(snewpred2);
        t->SetCounters();
        t->FitTrackKFS();
        printf("## MICROTRACK Bottom found ## \n");
        printf(" MT Bot : X = %8.1f, Y = %8.1f, TX = %7.4f, TY = %7.4f, W = %2.0f, Chi2 = %5.2f\n",fnds2.X(),fnds2.Y(),fnds2.TX(),fnds2.TY(),fnds2.W(),fnds2.Chi2());
        if(gEve) gEve->SetStatusLine(Form("Microtrack Bottom found on pl %d. (W,Chi2)=(%d,%.2f)", ipl, (int)fnds2.W(), fnds2.Chi2()));
    }
    
    printf("\nMicrotrack search end.\n\n");
 
    return status;
}

◆ N()

int EdbEDATrackSet::N ( )

inline

439{ return eTracks->GetEntries();}

◆ NBase()

int EdbEDATrackSet::NBase ( )

inline

440{ return eTracksBase->GetEntries();}

◆ PrepareScanSetForMT()

int EdbEDATrackSet::PrepareScanSetForMT ( )

Scan id check

                                       {
 
    EdbID& id = GetID();
    if(id.eMinor==0){
        id.eBrick = gEDA->GetBrick();
        InputID("Please input EdbID for TS.",id);
        SetID(id);
    }
    
    // get ScanSet of Total scan.
    // normally it's not filled even if TS are read via ReadTracksTree(id)
    EdbScanSet *sc = GetScanSet(); 
    
    if(sc==NULL){
        // if sc is NULL, read and assemble ScanSet. and set for TrackSet.
        // this will be executed only 1st time.
        EdbScanProc *sproc = gEDA->ScanProc();
        sc = new EdbScanSet();
        sc->MakeNominalSet(id);
        sproc->MakeScannedIDList(id, *sc, 65, -5,"cp.root"); 
        sc->eB.SetID(id.eBrick);
        int nid = sc->eIDS.GetEntries();
        if(nid==0) {
            ErrorMessage(Form("Error : Not cp files! stop. ScanID=%d.%d.%d.%d", id.eBrick, id.ePlate, id.eMajor, id.eMinor));
            return -1;
        }
        
        gEDA->ScanProc()->WriteScanSet(id, *sc);
        if(gEDA->GetScanSet()) {
            gEDA->ScanProc()->UpdateSetWithAff(id, gEDA->GetID()); 
            sc = gEDA->ScanProc()->ReadScanSet(id);
        }else {
            gEDA->ScanProc()->AssembleScanSet(*sc);
        }
        
        if(sc->eB.Npl()!=0) SetScanSet(sc); // set Scanset in TrackSet
    }
    if(sc->eB.Npl()==0){
        // if there is not plate, stop.
        ErrorMessage("No plate in ScanSet :");
        id.Print();
        return -1;
    }
    
    return 0;
}

◆ Print()

void EdbEDATrackSet::Print ( )

inline

                {
        printf("EdbEDATrackSet : %s\n", GetName());
        printf("TracksBase     : %5d tracks\n", NBase());
        printf("Tracks to Draw : %5d tracks\n", N());
        
    }

◆ ReadFile()

void EdbEDATrackSet::ReadFile	(	char *	filename = `NULL`,
		int	datatype = `100`,
		TCut	rcut = `"1"`
	)

filename : filename for "LinkDef" or "*.set.root(ScanSet)" or "*.root(linked_track.root format)"
datatype : only for "LinkDef". Data type for EdbDataProc::InitVolume(). put -1 for no InitVolume
if datatype= 100 or 1000. linked tracks will be registred to "TS".
rcut : Track selection when read.

if filename is not given. open file browser.

                                                                    {
    
    
    if(filename==NULL) {
        TGFileInfo *fi=new TGFileInfo;
        fi->fIniDir    = StrDup(".");
        const char *filetypes[] = { "LinkDef", "*.def","Linkeda Tracks", "*.root","ScanSet", "*.set.root", "Mxx file","*.all",0,0};
        fi->fFileTypes=filetypes;
        new TGFileDialog(gClient->GetRoot(), 0, kFDOpen, fi);
        filename = fi->fFilename;
    }
    
    if(filename==NULL){
        printf("Cancel EdbEDATrackSet::ReadFile\n");
        return;
    }
    
    // check the existence of the file.
    if(gSystem->AccessPathName(filename, kReadPermission)!=0) {
        printf("Error : %s is not found\n", filename);
        return;
    }
 
    // select an action for the file.
    TString s(filename);
    s.ToLower();
    if(s.EndsWith(".set.root")){
        // Scan set file
        printf("Read Scan Set : %s\n", s.Data());
        TFile *f = TFile::Open(filename);
        eScanSet = (EdbScanSet *)f->Get("set");
        eID = *((EdbID *)eScanSet->eIDS.At(0));
        eID.ePlate = 0;
        
        TString s2;
        gEDA->ScanProc()->MakeFileName(s2, eID, "trk.root", kFALSE);
        int IsExist = gSystem->AccessPathName(s2.Data(), kReadPermission);
        if( IsExist==kFALSE) {
            // linked tracks case
            ReadTracksTree(eID,rcut);
        }
        else {
            // prediction scan
            ReadPredictionScan(eScanSet);
        }
    }
    else if(s.EndsWith(".def")){
        // Link def file
        printf("Read LinkDef : %s\n", s.Data());
        EdbDataProc *dproc = new EdbDataProc(filename);
        eDataSet = dproc->GetDataSet();
        if(datatype>=0) {
            dproc->InitVolume(datatype);
            ReadLinkedTracks(dproc);
        }
    }
    else if(s.EndsWith(".root")){
        // Linked tracks file
        printf("Read Linked_track : %s\n", s.Data());
        ReadLinkedTracksFile(filename,rcut);
    }
    else if(s.EndsWith(".all")){
        // Mxx file (Nagoya style ascii)
        ReadMxxFile(filename);
    }
    
    if(NBase()!=0) SetDraw();
}

◆ ReadLinkedTracks() [1/2]

EdbDataProc * EdbEDATrackSet::ReadLinkedTracks	(	char *	lnkdef = `"lnk.def"`,
		TCut	cut = `"1"`
	)

                                                                    {
    EdbDataProc *dproc = new EdbDataProc(lnkdef);
    dproc->InitVolume(100, cut);
    ReadLinkedTracks(dproc);
    
    return dproc;
}

◆ ReadLinkedTracks() [2/2]

EdbDataProc * EdbEDATrackSet::ReadLinkedTracks ( EdbDataProc * dproc )

read tracks from linked_tracks.root for old structure.
plate number will be filled from link-list file.

                                                                {
    
    printf("EdbEDATrackSet::ReadLinkedTracks(EdbDataProc *)\n");
    
    eDataSet  = dproc->GetDataSet();
    EdbPVRec    *pvr   = dproc->PVR();
    
    // set plate number to segment.
    for(int j=0;j<pvr->Ntracks();j++){
        EdbTrackP *t = pvr->GetTrack(j);
        
        for(int k=0;k<t->N();k++){
            EdbSegP *s = t->GetSegment(k);
            int pid = s->PID();
            
            int ipl = eDataSet->GetPiece(pid)->Plate();
            s->SetPlate(ipl);
        }
        t->SetPlate(t->GetSegmentFirst()->Plate());
    }
    
    AddTracksPVR(pvr);
    
    EdbID id =pvr->GetTrack(0)->GetSegment(0)->ScanID();
    
    SetID( EdbID(id.eBrick, 0, id.eMajor, id.eMinor));
    
    return dproc;
}

◆ ReadLinkedTracksFile()

EdbDataProc * EdbEDATrackSet::ReadLinkedTracksFile	(	char *	filename = `"linked_tracks.root"`,
		TCut	cut = `"1"`
	)

Read linked_tracks.root format file.

                                                                          {
    
    // read file
    EdbDataProc *dproc = new EdbDataProc;
    ePVR = new EdbPVRec;
    dproc->ReadTracksTree(*ePVR, filename, cut);
    
    // if plate number is not set. set plate number as PID.
    int flag_plset=0;
    for(int i=0;i<ePVR->Ntracks();i++){
        EdbTrackP *t = ePVR->GetTrack(i);
        EdbSegP *s = t->GetSegmentLast();
        if(s->Plate()!=0) flag_plset++; // if plate number is set.
    }
    
    if(flag_plset==0){ // in case plate number is not set, set PID as plate number
        for(int i=0;i<ePVR->Npatterns();i++){
            EdbPattern *p = ePVR->GetPattern(i);
            if(p==NULL) continue;
            p->SetSegmentsPlate(p->ID());
        }
    }
    AddTracksPVR(ePVR);
    
    return dproc;
}

◆ ReadListFile()

void EdbEDATrackSet::ReadListFile	(	char *	filename = `NULL`,
		bool	clear_previous = `kTRUE`
	)

Read list file. Search tracks in this track set. see also EdbEDAMainTab::ReadListFile(), which try to search in BT files.

                                                                    {
    
    if(filename==NULL){
        TGFileInfo *fi = new TGFileInfo;
        fi->fIniDir    = StrDup(".");
        const char *filetypes[] = { "List file", "*.lst", "All files","*",0,0};
        fi->fFileTypes = filetypes;
        new TGFileDialog(gClient->GetRoot(), gEve->GetMainWindow(), kFDOpen, fi);
        filename=fi->fFilename;
    }
 
    printf("Read List file : %s -> TrackSet : %s\n", filename, GetName());
    FILE *fp=NULL;
    if(filename!=NULL) fp = fopen(filename,"rt");
    
    if(fp==NULL){
        printf("List file is not available.\n");
        return;
    }
 
    if(clear_previous) {
        ClearTracks();
        ClearComments();
    }
    char buf[256];
    int ipl, iseg;
    char comment[256];
    // read list, setting TObjArray *selected.
    for(int i=0;NULL!=fgets(buf,sizeof(buf),fp);i++){
        if(feof(fp)||ferror(fp)) break;
        sscanf(buf,"%d %d %s", &ipl, &iseg, comment);
        
        EdbTrackP *t=NULL;
        for(int j=0;j<NBase();j++){
            EdbTrackP *tt = GetTrackBase(j);
            if(NULL==tt) continue;
            for(int k=0;k<tt->N();k++){
                EdbSegP *s = tt->GetSegment(k);
                if(s->ID()==iseg){
                if(s->Plate()==ipl){
                    SetTrack(tt); // add tt for drawing
                    t=tt;
                    break;
                }}
            }
        }
        
        if(t==NULL) {
            // no track found in TS
            // search in BT
            
            EdbPattern *pat = gEDA->GetPatternIPL(ipl);
            for(int j=0; j<pat->N(); j++){
                EdbSegP *s = pat->GetSegment(j);
                if(s->ID()==iseg){
                    t = new EdbTrackP(s);
                    t->SetCounters();
                    t->SetPlate(s->Plate());
                    AddTrack(t);
                }
            }
            
        }
        
        if(t==NULL) continue;
        unsigned int l;
        for(l=0;l<strlen(buf);l++){
            if(buf[l]=='\"') break;
        }
        if(l<strlen(buf) ){
            strcpy(comment, buf+l+1);
            for(l=0;l<strlen(comment);l++){
                if(comment[l]=='\"') comment[l]='\0';
            }
            if(strlen(comment)!=0) {
                AddComment(t,comment);
            }
        }
    
    }
}

◆ ReadMxxFile()

void EdbEDATrackSet::ReadMxxFile ( char * filename )

                                              {
    EdbPVRec *pvr = EdbEDAUtil::ReadMxxPVR(filename);
    AddTracksPVR(pvr);
}

◆ ReadPredictionScan() [1/3]

void EdbEDATrackSet::ReadPredictionScan	(	EdbID	id,
		bool	force_update_setroot = `0`
	)

Read Prediction scan
if there is "set.root" already exist, ask whether overwrite or not.
if force_update_setroot == kTRUE, overwrite without asking.

                                                                          {
    
    if(id.eMinor==0) {
        printf("ReadPredictionScan: strange id.eMinor %d, stop\n", id.eMinor);
        ErrorMessage(Form("ReadPredictionScan: strange id.eMinor %d, stop\n", id.eMinor));
        return;
    }
    
    eID=id;
    TString s;
    gEDA->ScanProc()->MakeFileName(s, eID, "set.root", kFALSE);
    int update_setroot=1;
    if(force_update_setroot) update_setroot=1;
    else if(gSystem->AccessPathName(s.Data(), kReadPermission)==0){
        // if set.root already exist, ask whether update or not.
        update_setroot = AskYesNo(Form("%s is already exist. do you want to update?", s.Data()));
    }
    
    if(update_setroot==1){
        EdbScanSet *ss = new EdbScanSet();
        ss->MakeNominalSet(id,60);
        gEDA->ScanProc()->MakeScannedIDList(id, *ss, 60, 0,"found.root"); 
        ss->eB.SetID(id.eBrick);
        if(ss->eIDS.GetEntries()==0){
            printf("ID %d.%d.%d.%d is not scanned\n", id.eBrick, id.ePlate, id.eMajor, id.eMinor);
            return;
        }
        /*
        EdbAffine2D *aff = ss->eB.GetPlate(ss->eB.Npl()-1)->GetAffineXY();
        if(aff->A11()==1.0){
            printf("ReadPredictionScan : no affine parameters found as ScanBack. try to read as ScanForth\n");
            delete ss;
            ss = new EdbScanSet();
            ss->MakeNominalSet(id);
            gEDA->ScanProc()->MakeScannedIDList(id, *ss, 0, 60,"found.root"); 
            ss->eB.SetID(id.eBrick);
            gEDA->ScanProc()->AssembleScanSet(*ss);
        }
        */
        
        // Z shift
        int ipl = ss->eB.GetPlate(0)->ID();
        float zl = ss->eB.GetPlate(0)->Z();
        float zg = gEDA->GetZ(ipl);
        ss->ShiftBrickZ(-zl);
        ss->ShiftBrickZ(zg);
    
        gEDA->ScanProc()->WriteScanSet(id, *ss);
    
        if(gEDA->GetScanSet()) {
            EdbID idmain = gEDA->GetID();
            printf("Update geometry of %d.%d.%d.%d with %d.%d.%d.%d\n", 
                id.eBrick, id.ePlate, id.eMajor, id.eMinor,
                idmain.eBrick, idmain.ePlate, idmain.eMajor, idmain.eMinor);
            gEDA->ScanProc()->UpdateSetWithAff(id, idmain); 
            ss = gEDA->ScanProc()->ReadScanSet(id);
        }else {
            gEDA->ScanProc()->AssembleScanSet(*ss);
        }
    }
    //ReadPredictionScan(ss);
    
    ReadFile(const_cast<char*>(s.Data()),0,"1");
    
}

◆ ReadPredictionScan() [2/3]

void EdbEDATrackSet::ReadPredictionScan ( EdbScanSet * ss )

                                                     {
    EdbPVRec *ali = new EdbPVRec;
    gEDA->ScanProc()->ReadFoundTracks(*ss, *ali,-11);
 
    eScanSet = ss;
    eID = *((EdbID *)eScanSet->eIDS.At(0));
    eID.ePlate = 0;
    
    
    // to be compatible also main set by EdbDataSet
    // this is temporary solution.
    if(gEDA->GetDataSet()){
        for(int i=0;i<ali->Ntracks();i++){
            EdbTrackP *t = ali->GetTrack(i);
            for(int j=0;j<t->N();j++){
                if(t->N()==0) break;
                EdbSegP *s = t->GetSegment(j);
 
                // set Z from global calibration
                double z = gEDA->GetZ(s->Plate());
                s->SetZ(z);
                // reset affine on this ScanSet.
                EdbPlateP *pl =eScanSet->GetPlate(s->Plate());
                if(pl==NULL) continue;
                EdbAffine2D aff = *(pl->GetAffineXY());
                aff.Invert();
                s->Transform(&aff); // --> plate coordinate
 
                // apply affine of Main ScanSet (or DataSet).
                EdbAffine2D *affg = gEDA->GetAffine(s->Plate());
                if(NULL==affg) continue; // if no affine params are found in the main calibration, just leave it.
                s->Transform(affg); // --> global coordinate
            }
        }
    }
    
    AddTracksPVR(ali);
    SetDraw();
}

◆ ReadPredictionScan() [3/3]

void EdbEDATrackSet::ReadPredictionScan	(	int	BRICK,
		int	SBVERSION,
		int	RUN_PRED,
		int	UseMicrotrack = `0`
	)

this is an inferface function from old style usage.
reccoment ReadPredictionScan( EdbID ) for non-Bern people.
this force to update scanset file = "bxx.set.root".

if Brick number is not set, show message.
give command line input.

                                                                                                {
    
    if(BRICK==0){
        new TGMsgBox(gClient->GetRoot(), 0,
                    "EDA", "Follow your shell window");
        system("pwd");
        printf("Read Scanback ---------------- \n");
        printf("  Enter Brick number : ");
        scanf("%d", &BRICK);
        printf("  Enter Run number : ");
        scanf("%d", &RUN_PRED);
    }
    
    printf("Read Scanback ibrick = %d run = %d ver = %d\n", BRICK, RUN_PRED, SBVERSION);
 
    eID=EdbID(BRICK, 0, SBVERSION, RUN_PRED);
    
    ReadPredictionScan(eID, kTRUE);
    SetDrawMT(UseMicrotrack);
 
    SetDraw();
}

◆ ReadTextTracks()

void EdbEDATrackSet::ReadTextTracks ( char * filename = NULL )

Read Text file data
the format should be : itrk ipl ph x y ax ay flag_trans
flag_trans control Transformation. Affine=plate->global
flag_trans==1 (Affine)
flag_trans==2 (Affine)+(Bottom->Middle of base). For manualcheck data
flag_trans==3 (Affine)+(Top->Middle of base). For manualcheck data

                                                 {
    int i,j;
    char buf[512];
 
    FILE *fp;
 
    if(filename==NULL){
        TGFileInfo *fi = new TGFileInfo;
        fi->fIniDir    = StrDup(".");
        new TGFileDialog(gClient->GetRoot(), gEve->GetMainWindow(), kFDOpen, fi);
        filename=fi->fFilename;
    }
 
    printf(" the format should be : itrk ipl ph x y ax ay flag_trans runid\n");
    printf(" the Z value by ipl will be used\n");
    printf(" if(flag_affine==1) affine transform will be applied from plate->global\n");
    if(filename==NULL) {
        printf("Read tracks. no filename. end.\n");
        return;
    }
    printf("Read tracks from Text : %s -> TrackSet:%s\n", filename, GetName());
    if(filename!=NULL) fp = fopen(filename,"rt");
    
    if(fp==NULL){
        printf("text track is not available.\n");
        return;
    }
    
    eID=gEDA->GetID();
 
    ePVR = new EdbPVRec;
    
    EdbScanCond cond;
    for(;fgets(buf,sizeof(buf),fp)!=NULL;){
        if(feof(fp)||ferror(fp)) break;
        int itrk;
        double x,y,z,ax,ay;
        int ipl,ph,flag_affine=1;
        int runid;
        printf("%s",buf);
        int n = sscanf(buf,"%d %d %d %lf %lf %lf %lf %d %d", &itrk, &ipl, &ph, &x, &y, &ax, &ay, &flag_affine,&runid);
        if(n<9) runid=-99;
        eID.eMajor=runid%100;
        eID.eMinor=runid-runid%100;
 
        if(n==0) n=-1;
        int pid = gEDA->GetPID(ipl);
        
        // if the PID is out of volume scan, skip the segment.
        if(pid==-1) continue;
        z=gEDA->GetZ(ipl);
 
        EdbSegP *s = new EdbSegP;
        s->Set(itrk,x,y,ax,ay,0,0);
        s->SetZ(z);
        s->SetPID(pid);
        s->SetW(ph);
        s->SetTrack(itrk);
        s->SetPlate(ipl);
        s->SetAid(eID.eMajor, eID.eMinor);
 
        // fill COV for vertexing
        s->SetErrors();
        cond.FillErrorsCov(s->TX(), s->TY(), s->COV());
        
        // add segment to track
        EdbTrackP *t = NULL;
        
        // search track in sbtrk
        for(j=0;j<N();j++){
            EdbTrackP *tt = GetTrack(j);
            if(s->ID()==tt->ID()) t = tt;
        }
        
        // if not track corresponding.
        if( t==NULL){
            t = new EdbTrackP;
            t->SetID(s->ID());
            t->SetFlag(runid);
            AddTrack(t);
        }
        
        if(flag_affine==1){
            EdbAffine2D *traff = gEDA->GetAffine(ipl);
            if(NULL!=traff){
                s->Transform(traff);
            }
        }
        if(flag_affine==2){
            // in case of manualcheck data at bottom
            EdbAffine2D *traff = gEDA->GetAffine(ipl);
            if(NULL!=traff){
                s->Transform(traff);
                s->SetZ(z-102.5);
                s->PropagateTo(z);
            }
        }
        if(flag_affine==3){
            // in case of manualcheck data at top
            EdbAffine2D *traff = gEDA->GetAffine(ipl);
            if(NULL!=traff){
                s->Transform(traff);
                s->SetZ(z+102.5);
                s->PropagateTo(z);
            }
        }
        
        // add segment into track.
        t->AddSegment(s);
    }
    fclose(fp);
    
    for(i=0;i<N();i++){
        EdbTrackP* t = GetTrack(i);
        EdbSegP* s = t->GetSegmentFirst();
        t->Set(s->ID(),s->X(),s->Y(),s->TX(),s->TY(),s->W(),t->Flag());
        t->SetZ(s->Z());
        t->SetCounters();
    }
    printf("%d tracks available from text file\n", N());
}

◆ ReadTracksTree() [1/2]

void EdbEDATrackSet::ReadTracksTree	(	char *	scanset_filename,
		TCut	cut = `"1"`
	)

                                                                    {
    TFile *f = TFile::Open(scanset_filename);
    if(f==NULL) return;
    eScanSet = (EdbScanSet *)f->Get("set");
    if(eScanSet==0) {
        fprintf(stderr,"Error at ReadTracksTree : cannot find ScanSet in %s\n",scanset_filename);
        return;
    }
    EdbID id = *((EdbID *) (eScanSet->eIDS.At(0)));
    id.ePlate=0;
    ReadTracksTree(id, cut);
    f->Close();
}

◆ ReadTracksTree() [2/2]

void EdbEDATrackSet::ReadTracksTree	(	EdbID	ID,
		TCut	cut = `"1"`
	)

                                                      {
    EdbScanProc *sproc = gEDA->ScanProc();
    eScanSet = sproc->ReadScanSet(ID);
    ePVR = new EdbPVRec();
    sproc->ReadTracksTree(ID, *ePVR, cut);
    AddTracksPVR(ePVR);
    eID=ID;
}

◆ RemoveTrack()

void EdbEDATrackSet::RemoveTrack ( EdbTrackP * t )

inline

324{ if(eTracks->FindObject(t)) {eTracks->Remove(t); eTracks->Sort();}}

◆ RemoveTrackBase()

void EdbEDATrackSet::RemoveTrackBase ( EdbTrackP * t )

inline

323{ if(eTracksBase->FindObject(t)) {eTracksBase->Remove(t); eTracksBase->Sort();} RemoveTrack(t);}

EdbEDATrackSet::RemoveTrack

void RemoveTrack(EdbTrackP *t)

Definition: EdbEDATrackSet.h:324

◆ RemoveTracks()

void EdbEDATrackSet::RemoveTracks ( TObjArray * tracks )

inline

325{ for(int i=0; i<tracks->GetEntries(); i++) RemoveTrack((EdbTrackP *) tracks->At(i));}

tracks

TTree * tracks

Definition: check_tr.C:19

◆ ResetTrackAttribute()

void EdbEDATrackSet::ResetTrackAttribute ( void )

inline

558{ SetTrackAttribute(); }

◆ RestorePrevious()

void EdbEDATrackSet::RestorePrevious ( void )

inline

                               { 
        TObjArray arr = *eTracks;
        *eTracks = *eTracksPrevious;
        *eTracksPrevious = arr;
    }

◆ SearchCorrespondTrack()

EdbTrackP * EdbEDATrackSet::SearchCorrespondTrack ( EdbTrackP * t )

check if the track corresponds to the scanback track. return scanback id, if not return -1.

                                                             {
    if(t==NULL||eTracks==NULL) return NULL;
    EdbSegP *s = t->GetSegmentLast();
    for(int i=0;i<N();i++){
        EdbSegP *ss = new EdbSegP(*((EdbSegP *)GetTrack(i)));
        ss->PropagateTo(s->Z());
        if(fabs(s->TX()-ss->TX())<0.03){
        if(fabs(s->TX()-ss->TX())<0.03){
            if( fabs(s->X()-ss->X())<100 ){
            if( fabs(s->Y()-ss->Y())<100 ){
                printf("      Track: %d corresponds to scanback %d\n", t->ID(), ss->ID());
                return GetTrack(i);
            }}
        }}
        delete ss;
    }
    return NULL;
}

◆ SearchSegment()

EdbTrackP * EdbEDATrackSet::SearchSegment	(	int	ipl,
		int	iseg
	)

                                                           { 
    for(int i=0;i<eTracksBase->GetEntries(); i++) {
        EdbTrackP *t = (EdbTrackP *) eTracksBase->At(i);
        for(int j=0;j<t->N();j++){
            EdbSegP *s = t->GetSegment(j);
            if(s->Plate()!=ipl) continue;
            if(s->ID()!=iseg) continue;
            return t;
        }
    }
    return NULL;
}

◆ SearchTrack()

EdbTrackP * EdbEDATrackSet::SearchTrack ( int itrk )

inline

365{ for(int i=0;i<eTracksBase->GetEntries(); i++) {if(itrk==((EdbTrackP *) eTracksBase->At(i))->ID()) return (EdbTrackP *) eTracksBase->At(i);} return NULL;}

◆ SetAreaSet()

void EdbEDATrackSet::SetAreaSet ( EdbEDAAreaSet * set )

inline

601{ eAreaSet=set;}

set

EdbScanSet * set

Definition: emtraceback.cpp:14

◆ SetColorMode()

void EdbEDATrackSet::SetColorMode ( int mode )

                                         {
 
    if(mode==kBLACKWHITE){
        eTrackColor = kBlack;
        eLayerColor = kBlack;
        eLayerColorMT = kBlack;
        //eLayerWidth = -1;
    }
    if(eColorMode==kBLACKWHITE&&mode!=kBLACKWHITE){
        ResetTrackAttribute();
    }
    eColorMode = mode;
}

◆ SetDataSet()

void EdbEDATrackSet::SetDataSet ( EdbDataSet * dset )

inline

472{ eDataSet = dset;}

dset

EdbDataProc * dset

Definition: RecDispEX.C:9

◆ SetDraw()

void EdbEDATrackSet::SetDraw ( bool b = kTRUE )

inline

583{ eDraw = b;} // Setting Draw or not.

◆ SetDrawAreaSet()

void EdbEDATrackSet::SetDrawAreaSet ( bool draw = kTRUE )

inline

603{ eAreaSet->SetDraw(draw);}

EdbEDAAreaSet::SetDraw

void SetDraw(bool draw)

Definition: EdbEDASets.h:106

◆ SetDrawMT()

void EdbEDATrackSet::SetDrawMT ( bool b = kTRUE )

inline

585{ eDrawMT = b;} // Setting Draw or not.

◆ SetDrawTrackAngle()

void EdbEDATrackSet::SetDrawTrackAngle ( bool draw )

inline

588{ eDrawTrackAngle = draw;}

◆ SetDrawTrackAngleG()

void EdbEDATrackSet::SetDrawTrackAngleG ( bool draw )

inline

590{ eDrawTrackAngleG = draw;}

◆ SetDrawTrackID()

void EdbEDATrackSet::SetDrawTrackID ( bool draw )

inline

587{ eDrawTrackID = draw;}

◆ SetDrawTrackIDG()

void EdbEDATrackSet::SetDrawTrackIDG ( bool draw )

inline

589{ eDrawTrackIDG = draw;}

◆ SetExtendMode()

void EdbEDATrackSet::SetExtendMode ( int mode = kExtendAuto )

inline

526{ eExtendMode=mode;}

◆ SetID()

void EdbEDATrackSet::SetID ( EdbID id )

inline

463{ eID=id;}

◆ SetInterpolation()

void EdbEDATrackSet::SetInterpolation ( int interpolation = kTRUE )

inline

528{ eInterpolation = interpolation;} // kTRUE: fill hole with dashed line.

◆ SetLayerLength()

void EdbEDATrackSet::SetLayerLength ( double length )

inline

556{ eLayerLength=length;}

◆ SetPVRec()

void EdbEDATrackSet::SetPVRec ( EdbPVRec * pvr )

inline

321{ ePVR=pvr;}

◆ SetScanSet()

void EdbEDATrackSet::SetScanSet ( EdbScanSet * ss )

inline

470{ eScanSet = ss;}

◆ SetTextAttribute()

void EdbEDATrackSet::SetTextAttribute	(	int	size = `14`,
		int	color = `kWhite`,
		int	fontfile = `4`
	)

inline

                                                                        {
        eTextSize  = size;
        eTextColor = color;
        eTextFont  = fontfile;
    }

◆ SetTextPosition()

void EdbEDATrackSet::SetTextPosition ( int pos )

inline

580{ eTextPosition = pos;}

◆ SetTrack() [1/2]

void EdbEDATrackSet::SetTrack ( EdbTrackP * t )

inline

Set a track to be drawn.
the track is requiered to be already registered in eTracksBase.
if you want to simply draw the track, use AddTrack().

                                {
        if(eTracksBase->FindObject(t)&&eTracks->FindObject(t)==NULL) eTracks->Add(t);
    }

◆ SetTrack() [2/2]

void EdbEDATrackSet::SetTrack ( int itrack )

inline

Set Tracks to draw with the given track id.

                             {
        for(int i=0; i<N(); i++) {
            EdbTrackP *t = GetTrack(i);
            if(t->ID()==itrack) SetTrack(t);
        }
    }

◆ SetTrackAttribute()

void EdbEDATrackSet::SetTrackAttribute	(	int	track_color = `-1`,
		int	track_width = `1`,
		double	track_length = `-1`,
		int	layer_color = `kYellow`,
		int	layer_width = `2`,
		double	layer_length = `150`,
		int	layer_color_MT = `kCyan`
	)

inline

                                       {
        // set track attribute. -1 means automatic setting.
        eTrackColor  = track_color;
        eTrackWidth  = track_width;
        eTrackLength = track_length;
        eLayerColor  = layer_color;
        eLayerWidth  = layer_width>track_width? layer_width: track_width+1;
        eLayerLength = layer_length;
    }

◆ SetTracks()

void EdbEDATrackSet::SetTracks ( TObjArray * tracks )

inline

Set tracks to be draw.
the tracks are requiered to be already resistered in eTracksBase.

                                      {
        // if you want to simply draw the tracks, use AddTracks().
        if(NULL==tracks) return; for(int i=0; i<tracks->GetEntries(); i++) SetTrack((EdbTrackP *)tracks->At(i));
    }

◆ SetTracksAll()

void EdbEDATrackSet::SetTracksAll ( void )

inline

341{ *eTracks = *eTracksBase;}

◆ SetTracksBase()

void EdbEDATrackSet::SetTracksBase ( TObjArray * tracksbase )

inline

Copy tracks to eTracksBase. tracksbase should be an array of EdbTrackP

                                              {
        *eTracksBase = *tracksbase;
    }

◆ SetTracksNseg()

void EdbEDATrackSet::SetTracksNseg ( int nsegcut = 3 )

inline

                                        {
        eTracks->Clear();
        for(int i=0; i<NBase(); i++) {
            EdbTrackP *t = GetTrackBase(i);
            if(t->N()<nsegcut) continue;
            SetTrack(t);
        }
    }

◆ SetTracksVertex()

void EdbEDATrackSet::SetTracksVertex	(	EdbVertex *	v,
		bool	clear_previous = `kTRUE`
	)

inline

Set eTracks as the tracks which belongs to the vertex.

                                                                   {
        if(clear_previous) ClearTracks();
        for(int j=0 ; j < v->N() ; j++){
            EdbTrackP *t = v->GetTrack(j);
            if(t==NULL) continue;
            SetTrack(t);
        }
    }

◆ SetTracksVertices()

void EdbEDATrackSet::SetTracksVertices	(	TObjArray *	vertices,
		bool	clear_previous = `kTRUE`
	)

inline

Set eTracks as the tracks which belongs to the vertices.

                                                                            {
        printf("Set Tracks for %d Vertices\n", vertices->GetEntries());
        if(clear_previous) ClearTracks();
        for(int i=0;i<vertices->GetEntries();i++){
            EdbVertex *v = (EdbVertex *) vertices->At(i);
            if(v==NULL) continue;
            SetTracksVertex(v, kFALSE);
        }
    }

◆ StorePrevious()

void EdbEDATrackSet::StorePrevious ( )

inline

356{ *eTracksPrevious = *eTracks;}

◆ WriteListFile()

char * EdbEDATrackSet::WriteListFile	(	char *	filename = `NULL`,
		bool	append = `kFALSE`,
		bool	open_editor = `kFALSE`
	)

Write List file. ouput plate_number and segment_id. (track ID could change everytime after reconstruction, but segment ID doesn't change.) the result of MT search will be ignored.

                                                                                 {
    if(filename==NULL){
                TGFileInfo *fi = new TGFileInfo;
        fi->fIniDir    = StrDup(".");
        const char *filetypes[] = { "List file", "*.lst", "All files","*",0,0};
        fi->fFileTypes = filetypes;
        new TGFileDialog(gClient->GetRoot(), gEve->GetMainWindow(), kFDSave, fi);
        filename=fi->fFilename;
    }
 
    if(NULL==filename) return NULL;
    printf("Write List file : %s (%6s) <- TrackSet:%s\n", filename, append?"append":"create", GetName());
    FILE *fp;
    if(append) fp = fopen(filename,"at");
    else       fp = fopen(filename,"wt");
    
    if(fp==NULL){
        printf("Couldn't open the file.\n");
        return filename;
    }
 
    int k=0;
    for(int j=0;j<N();j++){
        EdbTrackP *t=GetTrack(j);
        if(NULL==t) continue;
        
        EdbSegP *s = 0;
        
        if(ePVR){
            // select a segment which from original reconstruction, in order to keep information after microtrack search.
            // if the segment is registered in ePVR, it's from original reconstruction.
            // if not, it's found by MT search or any.
            for(int i=0, flag=0;i<t->N();i++){
                s = t->GetSegment(i);
                for(int ipat=0;ipat<ePVR->Npatterns();ipat++){
                    EdbPattern *pat = ePVR->GetPattern(ipat);
                    TClonesArray *arr = pat->GetSegments();
                    if( arr->FindObject(s) ) {flag=1;break;}
                }
                if(flag) break;
            }
        } else s=t->GetSegmentFirst();
        
        fprintf(fp,"%2d %7d %10s itrk %5d %7.4lf %7.4lf\n", s->Plate(), s->ID(), Form("\"%s\"",GetComment(t)), t->ID(), t->TX(), t->TY());
        k++;
    }
 
    
    fclose(fp);
    printf("Write Selected : %d tracks\n", k); 
 
    // Open text editer
    if(open_editor) gEDA->OpenTextEditor(filename);
    return filename;
}

Member Data Documentation

◆ eAreaSet

EdbEDAAreaSet* EdbEDATrackSet::eAreaSet

private

◆ eColorMode

int EdbEDATrackSet::eColorMode

private

◆ eComments

TObjArray* EdbEDATrackSet::eComments

private

◆ eDataSet

EdbDataSet* EdbEDATrackSet::eDataSet

private

◆ eDraw

bool EdbEDATrackSet::eDraw

private

control of drawing

◆ eDrawMT

bool EdbEDATrackSet::eDrawMT

private

control of drawing microtrack

◆ eDrawTrackAngle

bool EdbEDATrackSet::eDrawTrackAngle

private

control of Track Angle drawing.

◆ eDrawTrackAngleG

bool EdbEDATrackSet::eDrawTrackAngleG

private

Global control of Track angle drawing by Main tab.

◆ eDrawTrackID

bool EdbEDATrackSet::eDrawTrackID

private

control of Track ID drawing

◆ eDrawTrackIDG

bool EdbEDATrackSet::eDrawTrackIDG

private

Global control of Track ID drawing by Main tab.

◆ eExtendMode

int EdbEDATrackSet::eExtendMode

private

◆ eID

EdbID EdbEDATrackSet::eID

private

◆ eInterpolation

int EdbEDATrackSet::eInterpolation

private

◆ eLayerColor

int EdbEDATrackSet::eLayerColor

private

◆ eLayerColorMT

int EdbEDATrackSet::eLayerColorMT

private

◆ eLayerLength

double EdbEDATrackSet::eLayerLength

private

◆ eLayerWidth

int EdbEDATrackSet::eLayerWidth

private

◆ ePVR

EdbPVRec* EdbEDATrackSet::ePVR

private

pointer for original EdbPVRec. tracks are copied to eTracksBase through AddTracksPVR().

◆ eScanSet

EdbScanSet* EdbEDATrackSet::eScanSet

private

◆ eTextColor

int EdbEDATrackSet::eTextColor

private

◆ eTextFont

int EdbEDATrackSet::eTextFont

private

◆ eTextPosition

int EdbEDATrackSet::eTextPosition

private

◆ eTextSize

int EdbEDATrackSet::eTextSize

private

◆ eTrackColor

int EdbEDATrackSet::eTrackColor

private

◆ eTrackLength

double EdbEDATrackSet::eTrackLength

private

◆ eTracks

TObjArray* EdbEDATrackSet::eTracks

private

array of tracks to be drawn

◆ eTracksBase

TObjArray* EdbEDATrackSet::eTracksBase

private

array of tracks, base of track search

◆ eTracksPrevious

TObjArray* EdbEDATrackSet::eTracksPrevious

private

previous array of tracks

◆ eTrackWidth

int EdbEDATrackSet::eTrackWidth

private

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

/home/antonio/fedra_doxygen/src/libEDA/EdbEDATrackSet.h
/home/antonio/fedra_doxygen/src/libEDA/EdbEDATrackSet.C

Public Types

Public Member Functions

Private Attributes

Additional Inherited Members

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ EdbEDATrackSet()

Member Function Documentation

◆ AddComment()

◆ AddSegments()

◆ AddTrack()

◆ AddTracks()

◆ AddTracksBase()

◆ AddTracksPVR()

◆ Clear()

◆ ClearComments()

◆ ClearTracks()

◆ ClearTracksBase()

◆ DoSelection()

◆ DoVertexing()

◆ Draw()

◆ DrawSingleComment()

◆ DrawSingleSegment()

◆ DrawSingleTrack()

◆ FindDownstreamPlate()

◆ FindTrack() [1/2]

◆ FindTrack() [2/2]

◆ FindTrackLast()

◆ FindUpstreamPlate()

◆ GetAreaSet()

◆ GetComment()

◆ GetDataSet()

◆ GetDraw()

◆ GetDrawMT()

◆ GetDrawTrackAngle()

◆ GetDrawTrackID()

◆ GetExtendMode()

◆ GetID()

◆ GetLayerColor()

◆ GetLayerLength()

◆ GetLayerWidth()

◆ GetPVRec()

◆ GetScanSet()

◆ GetTextColor()

◆ GetTextFont()

◆ GetTextPosition()

◆ GetTextSize()

◆ GetTrack() [1/2]

◆ GetTrack() [2/2]

◆ GetTrackAttribute()

◆ GetTrackBase()

◆ GetTrackColor()

◆ GetTrackLength()

◆ GetTracks()

◆ GetTracksBase()

◆ GetTrackWidth()

◆ IsMember()

◆ MicroTrackSearch() [1/2]

◆ MicroTrackSearch() [2/2]

◆ N()

◆ NBase()

◆ PrepareScanSetForMT()

◆ Print()

◆ ReadFile()

◆ ReadLinkedTracks() [1/2]

◆ ReadLinkedTracks() [2/2]

◆ ReadLinkedTracksFile()

◆ ReadListFile()

◆ ReadMxxFile()

◆ ReadPredictionScan() [1/3]

◆ ReadPredictionScan() [2/3]

◆ ReadPredictionScan() [3/3]

◆ ReadTextTracks()

◆ ReadTracksTree() [1/2]

◆ ReadTracksTree() [2/2]

◆ RemoveTrack()

◆ RemoveTrackBase()

◆ RemoveTracks()

◆ ResetTrackAttribute()