FEDRA emulsion software from the OPERA Collaboration
Public Member Functions | Private Member Functions | Private Attributes | List of all members
EGraphRec Class Reference

#include <EGraphRec.h>

Collaboration diagram for EGraphRec:
Collaboration graph
[legend]

Public Member Functions

void AddCanvasFrame (TGTab *worktab)
 
void AddInfoFrame (TGVerticalFrame *workframe)
 
void AddProcBrickFrame (TGVerticalFrame *workframe)
 
void AddProcListFrame (TGVerticalFrame *workframe)
 
void AddRecOptFrame (TGTab *worktab)
 
void AddScanBackFrame (TGTab *worktab)
 
void AddVertexRecFrame (TGTab *worktab)
 
void ClearEvent ()
 
void DrawEvent ()
 
 EGraphRec ()
 
ProcBrick_t GetBrickToProc () const
 
TGTextButton * GetButtonSBStart ()
 
EdbPVRec * GetFoundTracks () const
 
EdbPattern * GetPredTracks () const
 
ProcId_t GetProcId () const
 
EdbScanProc * GetScanProc () const
 
EdbScanSet * GetScanSet () const
 
TThread * GetThSBProcess () const
 
Bool_t IsSBToAlgn () const
 
Bool_t IsSBToLink () const
 
void ProcessEvent ()
 
void ReadSBPred ()
 
void ReconstructTracks ()
 
void ResetProcess ()
 
void Set3DViewer ()
 
void SetDataDir (TString &dataDir)
 
void SetProcBrick (ProcBrick_t &procBrick)
 
void SetProcId (ProcId_t &procId)
 
void SetTree (TTree *tree)
 
void StartScanBack ()
 
void StartVertexRec ()
 
void ZoomIn ()
 
void ZoomOut ()
 
virtual ~EGraphRec ()
 

Private Member Functions

void InitDrawVariables ()
 
void InitScanSet ()
 
void InitVariables ()
 
void ReadCmdConfig ()
 
void WriteInfo ()
 

Private Attributes

ProcBrick_t fBrickToProc
 
TGTextButton * fButtonSBStart
 
TGCheckButton * fCheckProcAlgn
 
TGCheckButton * fCheckProcLink
 
TGCheckButton * fCheckProcScan
 
TGCheckButton * fCheckProcTrks
 
TGCheckButton * fCheckProcVrtx
 
TGCheckButton * fCheckSBAlgn
 
TGCheckButton * fCheckSBLink
 
TGCheckButton * fCheckSBScan
 
TGCheckButton * fCheckSBTrks
 
TGCheckButton * fCheckUseMom
 
TGCheckButton * fCheckUseSegPar
 
TString fDataDir
 
EdbDisplay * fDisplay
 
TRootEmbeddedCanvas * fDisplayFedra
 
TRootEmbeddedCanvas * fDisplayHits
 
TGNumberEntry * fEntryDZmax
 
TGNumberEntry * fEntryImpMax
 
TGNumberEntry * fEntryProbMinV
 
TGNumberEntry * fEntryProcBrickId
 
TGNumberEntry * fEntryProcVer
 
TGNumberEntry * fEntryQualityMode
 
TGNumberEntry * fEntrySBFirstPlate
 
TGNumberEntry * fEntrySBLastPlate
 
TGNumberEntry * fEntrySBStep
 
EdbView * fEvent
 
TTree * fEvtTree
 
EdbPVRec * fFoundTracks
 
TGLSAViewer * fGLViewer
 
TGLayoutHints * fLayout1
 
TGLayoutHints * fLayout2
 
TGLayoutHints * fLayout3
 
TGLayoutHints * fLayoutLeftExpY
 
TGLayoutHints * fLayoutRightExpY
 
EdbPattern * fPredTracks
 
ProcBrick_t fProcBrick
 
ProcId_t fProcId
 
EdbPVRec * fPVRec
 
TGNumberEntry * fRecOptEntry [6]
 
EGraphRecProc * fRecProc
 
EdbScanProc * fScanProc
 
EdbScanSet * fScanSet
 
TGTextView * fTextInfo
 
TGTextButton * fTextProcEvent
 
TThread * fThSBCheckProcess
 
TThread * fThSBProcess
 
VertexRecOpt_t fVertexRecOpt
 

Constructor & Destructor Documentation

◆ EGraphRec()

EGraphRec::EGraphRec ( )

◆ ~EGraphRec()

EGraphRec::~EGraphRec ( )
virtual
47 {
48  SafeDelete(fThSBProcess);
49  SafeDelete(fThSBCheckProcess);
50  SafeDelete(fPredTracks);
51  SafeDelete(fFoundTracks);
52  SafeDelete(fRecProc);
53 }
EGraphRec::fThSBProcess
TThread * fThSBProcess
Definition: EGraphRec.h:83
EGraphRec::fPredTracks
EdbPattern * fPredTracks
Definition: EGraphRec.h:75
EGraphRec::fThSBCheckProcess
TThread * fThSBCheckProcess
Definition: EGraphRec.h:84
EGraphRec::fRecProc
EGraphRecProc * fRecProc
Definition: EGraphRec.h:69
EGraphRec::fFoundTracks
EdbPVRec * fFoundTracks
Definition: EGraphRec.h:76

Member Function Documentation

◆ AddCanvasFrame()

void EGraphRec::AddCanvasFrame ( TGTab *  worktab)
540 {
541  TGCompositeFrame *tf;
542 
543  tf = worktab->AddTab("cFedra");
544  fDisplayFedra = new TRootEmbeddedCanvas("FEDRA Viewer", tf, 900, 650);
545  tf->AddFrame(fDisplayFedra, fLayout3);
546 
547  TCanvas *CanvasFedra = fDisplayFedra->GetCanvas();
548 
549  fDisplay = new EdbDisplay("FEDRA Viewer (orig)", -50000., 50000.,
550  -50000., 50000., -150., 37850., CanvasFedra);
551 
552 // tf = worktab->AddTab("GL Viewer");
553 // fDisplayHitsGL = new TRootEmbeddedCanvas("Reconstruction GL", tf, 900, 650);
554 // fGLViewer = new TGLSAViewer(tf, fDisplayHitsGL->GetCanvas());
555 
556  // tf->AddFrame(fDisplayHitsGL, fLayout3);
557 }
EGraphRec::fDisplay
EdbDisplay * fDisplay
Definition: EGraphRec.h:79
EGraphRec::fLayout3
TGLayoutHints * fLayout3
Definition: EGraphRec.h:88
EGraphRec::fDisplayFedra
TRootEmbeddedCanvas * fDisplayFedra
Definition: EGraphRec.h:124
EdbDisplay
Definition: EdbDisplay.h:21
TCanvas
new TCanvas()

◆ AddInfoFrame()

void EGraphRec::AddInfoFrame ( TGVerticalFrame *  workframe)
562 {
563  fTextInfo = new TGTextView(workframe, 900, 200, kFixedHeight);
564  const TGFont *font = gClient->GetFont("-*-courier-bold-r-*-*-18-*-*-*-*-*-*-*");
565  fTextInfo->SetFont(font->GetFontStruct());
566  workframe->AddFrame(fTextInfo, fLayout1);
567 
568  WriteInfo();
569 }
EGraphRec::fTextInfo
TGTextView * fTextInfo
Definition: EGraphRec.h:94
EGraphRec::fLayout1
TGLayoutHints * fLayout1
Definition: EGraphRec.h:86
EGraphRec::WriteInfo
void WriteInfo()
Definition: EGraphRec.cxx:623

◆ AddProcBrickFrame()

void EGraphRec::AddProcBrickFrame ( TGVerticalFrame *  workframe)
192 {
193  // TODO: add the scanning options window
194 
195  TGLabel *label;
196  TGHorizontalFrame *frame;
197 
198  TGVButtonGroup *GroupProcBrick = new TGVButtonGroup(workframe,
199  "Processing brick");
200 
201  // BrickId
202 
203  frame = new TGHorizontalFrame(GroupProcBrick);
204  label = new TGLabel(frame, "Brick Id");
205  fEntryProcBrickId = new TGNumberEntry(frame, fProcBrick.brickId, 7, 0,
206  TGNumberEntry::kNESInteger,
207  TGNumberEntry::kNEANonNegative,
208  TGNumberEntry::kNELLimitMin, 0, 1);
209  frame->AddFrame(label, fLayoutLeftExpY);
210  frame->AddFrame(fEntryProcBrickId, fLayoutRightExpY);
211  GroupProcBrick->AddFrame(frame, fLayout1);
212 
213  // Version
214 
215  frame = new TGHorizontalFrame(GroupProcBrick);
216  label = new TGLabel(frame, "Base version");
217  fEntryProcVer = new TGNumberEntry(frame, fProcBrick.ver, 3, 3,
218  TGNumberEntry::kNESInteger,
219  TGNumberEntry::kNEANonNegative,
220  TGNumberEntry::kNELLimitMin, 0, 1);
221  frame->AddFrame(label, fLayoutLeftExpY);
222  frame->AddFrame(fEntryProcVer, fLayoutRightExpY);
223  GroupProcBrick->AddFrame(frame, fLayout1);
224 
225  workframe->AddFrame(GroupProcBrick, fLayout1);
226 }
EGraphRec::fLayoutRightExpY
TGLayoutHints * fLayoutRightExpY
Definition: EGraphRec.h:90
EGraphRec::fEntryProcBrickId
TGNumberEntry * fEntryProcBrickId
Definition: EGraphRec.h:92
EGraphRec::fProcBrick
ProcBrick_t fProcBrick
Definition: EGraphRec.h:81
EGraphRec::fEntryProcVer
TGNumberEntry * fEntryProcVer
Definition: EGraphRec.h:93
EGraphRec::fLayoutLeftExpY
TGLayoutHints * fLayoutLeftExpY
Definition: EGraphRec.h:89
ProcBrick_t::brickId
Int_t brickId
Definition: EGraphRecProc.h:16
ProcBrick_t::ver
Int_t ver
Definition: EGraphRecProc.h:19

◆ AddProcListFrame()

void EGraphRec::AddProcListFrame ( TGVerticalFrame *  workframe)
231 {
232  TGVButtonGroup *GroupProcList = new TGVButtonGroup(workframe,"Process list");
233  fCheckProcScan = new TGCheckButton(GroupProcList, "Scanning");
234  fCheckProcLink = new TGCheckButton(GroupProcList, "Linking tracks");
235  fCheckProcAlgn = new TGCheckButton(GroupProcList, "Alignment plates");
236  fCheckProcTrks = new TGCheckButton(GroupProcList, "Reconstruct tracks");
237  fCheckProcVrtx = new TGCheckButton(GroupProcList, "Reconstruct vertex");
238 
239 // fCheckProcLink->SetState(kButtonDown);
240 // fCheckProcAlgn->SetState(kButtonDown);
241  fCheckProcScan->SetEnabled(kFALSE);
242  fCheckProcTrks->SetEnabled(kFALSE);
243  fCheckProcVrtx->SetEnabled(kFALSE);
244 
245  workframe->AddFrame(GroupProcList, fLayout1);
246 
247  // Break process
248 
249  TGTextButton *endprocess = new TGTextButton(workframe, "Reset process");
250  endprocess->Connect("Clicked()", "EGraphRec", this, "ResetProcess()");
251  // endprocess->Associate(this);
252  workframe->AddFrame(endprocess, fLayout1);
253 
254  // Running process
255 
256  fTextProcEvent = new TGTextButton(workframe, "Execute event");
257  fTextProcEvent->Connect("Clicked()", "EGraphRec", this, "ProcessEvent()");
258 
259  workframe->AddFrame(fTextProcEvent, fLayout1);
260 }
EGraphRec::fCheckProcAlgn
TGCheckButton * fCheckProcAlgn
Definition: EGraphRec.h:97
EGraphRec::fCheckProcLink
TGCheckButton * fCheckProcLink
Definition: EGraphRec.h:96
EGraphRec::fCheckProcTrks
TGCheckButton * fCheckProcTrks
Definition: EGraphRec.h:98
EGraphRec::fTextProcEvent
TGTextButton * fTextProcEvent
Definition: EGraphRec.h:100
EGraphRec::fCheckProcScan
TGCheckButton * fCheckProcScan
Definition: EGraphRec.h:95
EGraphRec::fCheckProcVrtx
TGCheckButton * fCheckProcVrtx
Definition: EGraphRec.h:99

◆ AddRecOptFrame()

void EGraphRec::AddRecOptFrame ( TGTab *  worktab)
265 {
266  // Create a tab with reconstruction options buttons
267 
268  TGCompositeFrame *tf = worktab->AddTab("Reconstruction options");
269  TGLabel *label;
270  TGHorizontalFrame *frame;
271 
272  // fRecParams = fGR->GetRecParameters();
273 
274  // Momentum
275 
276  frame = new TGHorizontalFrame(tf);
277  label = new TGLabel(frame, "momentum");
278  fRecOptEntry[0] = new TGNumberEntry(frame, 1, //fRecParams->p,
279  7, 0,
280  TGNumberEntry::kNESRealTwo,
281  TGNumberEntry::kNEANonNegative,
282  TGNumberEntry::kNELLimitMin, 0, 1);
283  frame->AddFrame(label, fLayoutLeftExpY);
284  frame->AddFrame(fRecOptEntry[0], fLayoutRightExpY);
285  tf->AddFrame(frame, fLayout1);
286 
287  // Prob min
288 
289  frame = new TGHorizontalFrame(tf);
290  label = new TGLabel(frame, "probmin");
291  fRecOptEntry[1] = new TGNumberEntry(frame, 1, // fRecParams->probmin,
292  7, 1,
293  TGNumberEntry::kNESRealTwo,
294  TGNumberEntry::kNEANonNegative,
295  TGNumberEntry::kNELLimitMinMax, 0, 1);
296  frame->AddFrame(label, fLayoutLeftExpY);
297  frame->AddFrame(fRecOptEntry[1], fLayoutRightExpY);
298  tf->AddFrame(frame, fLayout1);
299 
300  // Nseg min
301 
302  frame = new TGHorizontalFrame(tf);
303  label = new TGLabel(frame, "nsegmin");
304  fRecOptEntry[2] = new TGNumberEntry(frame, 1, // fRecParams->nsegmin,
305  7, 2,
306  TGNumberEntry::kNESInteger,
307  TGNumberEntry::kNEAPositive,
308  TGNumberEntry::kNELLimitMin, 0, 1);
309  frame->AddFrame(label, fLayoutLeftExpY);
310  frame->AddFrame(fRecOptEntry[2], fLayoutRightExpY);
311  tf->AddFrame(frame, fLayout1);
312 
313  // Max gap
314 
315  frame = new TGHorizontalFrame(tf);
316  label = new TGLabel(frame, "maxgap");
317  fRecOptEntry[3] = new TGNumberEntry(frame, 1, // fRecParams->maxgap,
318  7, 3,
319  TGNumberEntry::kNESInteger,
320  TGNumberEntry::kNEAPositive,
321  TGNumberEntry::kNELLimitMin, 0, 1);
322  frame->AddFrame(label, fLayoutLeftExpY);
323  frame->AddFrame(fRecOptEntry[3], fLayoutRightExpY);
324  tf->AddFrame(frame, fLayout1);
325 
326  // Scanning conditions
327 
328  label = new TGLabel(tf,"Scanning conditions:");
329  tf->AddFrame(label, fLayout1);
330 
331  // Coords sigma
332 
333  frame = new TGHorizontalFrame(tf);
334  label = new TGLabel(frame, "Coords Sigma");
335  fRecOptEntry[4] = new TGNumberEntry(frame, 1, //fGR->GetScanCond()->SigmaX(0),
336  7, 4,
337  TGNumberEntry::kNESRealTwo,
338  TGNumberEntry::kNEANonNegative,
339  TGNumberEntry::kNELLimitMinMax, 0, 10);
340  frame->AddFrame(label, fLayoutLeftExpY);
341  frame->AddFrame(fRecOptEntry[4], fLayoutRightExpY);
342  tf->AddFrame(frame, fLayout1);
343 
344  // Tangents sigma
345 
346  frame = new TGHorizontalFrame(tf);
347  label = new TGLabel(frame, "Tangents Sigma");
348  fRecOptEntry[5] = new TGNumberEntry(frame,1, // fGR->GetScanCond()->SigmaTX(0),
349  7, 5,
350  TGNumberEntry::kNESRealFour,
351  TGNumberEntry::kNEANonNegative,
352  TGNumberEntry::kNELLimitMinMax, 0, 1);
353  frame->AddFrame(label, fLayoutLeftExpY);
354  frame->AddFrame(fRecOptEntry[5], fLayoutRightExpY);
355  tf->AddFrame(frame, fLayout1);
356 
357  // buttons
358 
359  TGHorizontalFrame *Frame1 = new TGHorizontalFrame(tf);
360 
361  TGTextButton *Apply = new TGTextButton(Frame1, "Apply", 2);
362  // Apply->Connect("Clicked()", "EGraphRec", this, "DoApplyRec()");
363  Frame1->AddFrame(Apply, fLayout1);
364 
365  TGTextButton* Reset = new TGTextButton(Frame1, "Reset", 3);
366  // Reset->Connect("Clicked()", "EGraphRec", this, "DoResetRec()");
367  Frame1->AddFrame(Reset, fLayout1);
368 
369  tf->AddFrame(Frame1, fLayout1);
370 }
EGraphRec::fRecOptEntry
TGNumberEntry * fRecOptEntry[6]
Definition: EGraphRec.h:91

◆ AddScanBackFrame()

void EGraphRec::AddScanBackFrame ( TGTab *  worktab)
375 {
376  TGLabel *label;
377  TGHorizontalFrame *frame;
378 
379  // Create a tab for scan back procedure
380 
381  TGCompositeFrame *sb_tab = worktab->AddTab("Scan Back");
382 
383  // Parameters
384 
385  TGVButtonGroup *GroupSBPar = new TGVButtonGroup(sb_tab, "Parameters");
386 
387  // First plate to process
388 
389  frame = new TGHorizontalFrame(GroupSBPar);
390  label = new TGLabel(frame, "First plate");
391  fEntrySBFirstPlate = new TGNumberEntry(frame, fProcBrick.firstPlate, 3, 1,
392  TGNumberEntry::kNESInteger,
393  TGNumberEntry::kNEANonNegative,
394  TGNumberEntry::kNELLimitMinMax,0,58);
395  frame->AddFrame(label, fLayoutLeftExpY);
396  frame->AddFrame(fEntrySBFirstPlate, fLayoutRightExpY);
397  GroupSBPar->AddFrame(frame, fLayout1);
398 
399  // Last plate to process
400 
401  frame = new TGHorizontalFrame(GroupSBPar);
402  label = new TGLabel(frame, "Last plate");
403  fEntrySBLastPlate = new TGNumberEntry(frame, fProcBrick.lastPlate, 3, 2,
404  TGNumberEntry::kNESInteger,
405  TGNumberEntry::kNEANonNegative,
406  TGNumberEntry::kNELLimitMinMax,0,58);
407  frame->AddFrame(label, fLayoutLeftExpY);
408  frame->AddFrame(fEntrySBLastPlate, fLayoutRightExpY);
409  GroupSBPar->AddFrame(frame, fLayout1);
410 
411  // Step
412 
413  frame = new TGHorizontalFrame(GroupSBPar);
414  label = new TGLabel(frame, "Step");
415  fEntrySBStep = new TGNumberEntry(frame, 1, 3, 3,
416  TGNumberEntry::kNESInteger,
417  TGNumberEntry::kNEANonNegative,
418  TGNumberEntry::kNELLimitMinMax,0,58);
419  frame->AddFrame(label, fLayoutLeftExpY);
420  frame->AddFrame(fEntrySBStep, fLayoutRightExpY);
421  GroupSBPar->AddFrame(frame, fLayout1);
422 
423  sb_tab->AddFrame(GroupSBPar, fLayout1);
424 
425  // Scan back process list
426 
427  TGVButtonGroup *GroupSBProcList = new TGVButtonGroup(sb_tab, "Process list");
428  fCheckSBScan = new TGCheckButton(GroupSBProcList, "Scanning");
429  fCheckSBLink = new TGCheckButton(GroupSBProcList, "Linking");
430  fCheckSBAlgn = new TGCheckButton(GroupSBProcList, "Alignment plates");
431  fCheckSBTrks = new TGCheckButton(GroupSBProcList, "Reconstruct tracks");
432 
433 // fCheckSBLink->SetState(kButtonDown);
434 // fCheckSBAlgn->SetState(kButtonDown);
435  fCheckSBScan->SetEnabled(kFALSE);
436  fCheckSBTrks->SetEnabled(kFALSE);
437 
438  sb_tab->AddFrame(GroupSBProcList, fLayout1);
439 
440  // Read prediction
441 
442  TGTextButton *readPred = new TGTextButton(sb_tab, "Read prediction");
443  readPred->Connect("Clicked()", "EGraphRec", this, "ReadSBPred()");
444  sb_tab->AddFrame(readPred, fLayout1);
445 
446  // start process
447 
448  fButtonSBStart = new TGTextButton(sb_tab, "Start Scan Back");
449  fButtonSBStart->Connect("Clicked()","EGraphRec",this,"StartScanBack()");
450  sb_tab->AddFrame(fButtonSBStart, fLayout1);
451 }
EGraphRec::fCheckSBScan
TGCheckButton * fCheckSBScan
Definition: EGraphRec.h:108
EGraphRec::fEntrySBFirstPlate
TGNumberEntry * fEntrySBFirstPlate
Definition: EGraphRec.h:104
EGraphRec::fButtonSBStart
TGTextButton * fButtonSBStart
Definition: EGraphRec.h:107
EGraphRec::fCheckSBAlgn
TGCheckButton * fCheckSBAlgn
Definition: EGraphRec.h:110
EGraphRec::fCheckSBTrks
TGCheckButton * fCheckSBTrks
Definition: EGraphRec.h:111
EGraphRec::fCheckSBLink
TGCheckButton * fCheckSBLink
Definition: EGraphRec.h:109
EGraphRec::fEntrySBStep
TGNumberEntry * fEntrySBStep
Definition: EGraphRec.h:106
EGraphRec::fEntrySBLastPlate
TGNumberEntry * fEntrySBLastPlate
Definition: EGraphRec.h:105
ProcBrick_t::firstPlate
Int_t firstPlate
Definition: EGraphRecProc.h:17
ProcBrick_t::lastPlate
Int_t lastPlate
Definition: EGraphRecProc.h:18

◆ AddVertexRecFrame()

void EGraphRec::AddVertexRecFrame ( TGTab *  worktab)
456 {
457  // create a tab for vertex reconstruction
458 
459  TGLabel *label;
460  TGHorizontalFrame *frame;
461  TGCompositeFrame *vr_tab = worktab->AddTab("Vertex Rec");
462 
463  // use or not track momentum for vertex calculations
464 
465  fCheckUseMom = new TGCheckButton(vr_tab, "Use track momentum");
466  if (fVertexRecOpt.UseMom) fCheckUseMom->SetState(kButtonDown, kTRUE);
467  else fCheckUseMom->SetState(kButtonUp, kTRUE);
468  vr_tab->AddFrame(fCheckUseMom, fLayout1);
469 
470  // use only the nearest measured segments for vertex fit
471 
472  fCheckUseSegPar = new TGCheckButton(vr_tab, "Use nearest measured segments");
473  if (fVertexRecOpt.UseSegPar) fCheckUseSegPar->SetState(kButtonDown, kTRUE);
474  else fCheckUseSegPar->SetState(kButtonUp, kTRUE);
475  vr_tab->AddFrame(fCheckUseSegPar, fLayout1);
476 
477  // vertex quality estimation method
478 
479  frame = new TGHorizontalFrame(vr_tab);
480  label = new TGLabel(frame, "Quality Mode");
481  fEntryQualityMode = new TGNumberEntry(frame, fVertexRecOpt.QualityMode,
482  5, 0,
483  TGNumberEntry::kNESInteger,
484  TGNumberEntry::kNEANonNegative,
485  TGNumberEntry::kNELLimitMin);
486  frame->AddFrame(label, fLayoutLeftExpY);
487  frame->AddFrame(fEntryQualityMode, fLayoutRightExpY);
488  vr_tab->AddFrame(frame, fLayout1);
489 
490  // maximum z-gap in the track-vertex group
491 
492  frame = new TGHorizontalFrame(vr_tab);
493  label = new TGLabel(frame, "Maximum Z gap");
494  fEntryDZmax = new TGNumberEntry(frame, fVertexRecOpt.DZmax,
495  7, 0,
496  TGNumberEntry::kNESRealOne,
497  TGNumberEntry::kNEANonNegative,
498  TGNumberEntry::kNELLimitMin);
499  frame->AddFrame(label, fLayoutLeftExpY);
500  frame->AddFrame(fEntryDZmax, fLayoutRightExpY);
501  vr_tab->AddFrame(frame, fLayout1);
502 
503  // minimum acceptable probability for chi2-distance between tracks
504 
505  frame = new TGHorizontalFrame(vr_tab);
506  label = new TGLabel(frame, "Minimal vertex prob");
507  fEntryProbMinV = new TGNumberEntry(frame, fVertexRecOpt.ProbMinV,
508  7, 0,
509  TGNumberEntry::kNESReal,
510  TGNumberEntry::kNEANonNegative,
511  TGNumberEntry::kNELLimitMin);
512  frame->AddFrame(label, fLayoutLeftExpY);
513  frame->AddFrame(fEntryProbMinV, fLayoutRightExpY);
514  vr_tab->AddFrame(frame, fLayout1);
515 
516 
517  // maximal acceptable impact parameter
518 
519  frame = new TGHorizontalFrame(vr_tab);
520  label = new TGLabel(frame, "Maximal impact param");
521  fEntryImpMax = new TGNumberEntry(frame, fVertexRecOpt.ImpMax,
522  7, 0,
523  TGNumberEntry::kNESRealTwo,
524  TGNumberEntry::kNEANonNegative,
525  TGNumberEntry::kNELLimitMin);
526  frame->AddFrame(label, fLayoutLeftExpY);
527  frame->AddFrame(fEntryImpMax, fLayoutRightExpY);
528  vr_tab->AddFrame(frame, fLayout1);
529 
530  // start process
531 
532  TGTextButton *buttonVRStart = new TGTextButton(vr_tab, "Start Vertex Rec");
533  buttonVRStart->Connect("Clicked()","EGraphRec",this,"StartVertexRec()");
534  vr_tab->AddFrame(buttonVRStart, fLayout1);
535 }
EGraphRec::fCheckUseSegPar
TGCheckButton * fCheckUseSegPar
Definition: EGraphRec.h:116
EGraphRec::fEntryDZmax
TGNumberEntry * fEntryDZmax
Definition: EGraphRec.h:118
EGraphRec::fEntryImpMax
TGNumberEntry * fEntryImpMax
Definition: EGraphRec.h:120
EGraphRec::fEntryQualityMode
TGNumberEntry * fEntryQualityMode
Definition: EGraphRec.h:117
EGraphRec::fVertexRecOpt
VertexRecOpt_t fVertexRecOpt
Definition: EGraphRec.h:82
EGraphRec::fCheckUseMom
TGCheckButton * fCheckUseMom
Definition: EGraphRec.h:115
EGraphRec::fEntryProbMinV
TGNumberEntry * fEntryProbMinV
Definition: EGraphRec.h:119
VertexRecOpt_t::UseMom
Bool_t UseMom
Definition: EGraphRecProc.h:38
VertexRecOpt_t::ProbMinV
Float_t ProbMinV
Definition: EGraphRecProc.h:42
VertexRecOpt_t::QualityMode
Int_t QualityMode
Definition: EGraphRecProc.h:35
VertexRecOpt_t::DZmax
Float_t DZmax
Definition: EGraphRecProc.h:41
VertexRecOpt_t::ImpMax
Float_t ImpMax
Definition: EGraphRecProc.h:44
VertexRecOpt_t::UseSegPar
Bool_t UseSegPar
Definition: EGraphRecProc.h:39

◆ ClearEvent()

void EGraphRec::ClearEvent ( )
755 {
756  SafeDelete(fEvent);
757 }
EGraphRec::fEvent
EdbView * fEvent
Definition: EGraphRec.h:73

◆ DrawEvent()

void EGraphRec::DrawEvent ( )
142 {
143  fDisplay->fCanvas->Clear("D");
144  fDisplay->fCanvas->cd();
145 
146  fDisplay->SetDrawTracks(4);
147  // fDisplay->SetDrawVertex(1);
148 
149  if (fFoundTracks) fDisplay->SetArrTr(fFoundTracks->eTracks);
150  if (fPVRec) fDisplay->SelectVertexTracks(fPVRec->eVTX);
151 
152  fDisplay->Draw();
153  fDisplay->fCanvas->Update();
154 
155 }
EGraphRec::fPVRec
EdbPVRec * fPVRec
Definition: EGraphRec.h:77
EdbDisplayBase::Draw
virtual void Draw(Option_t *option="")
Definition: EdbDisplayBase.cxx:786
EdbDisplayBase::fCanvas
TCanvas * fCanvas
Definition: EdbDisplayBase.h:123
EdbDisplay::SetArrTr
void SetArrTr(TObjArray *arr)
Definition: EdbDisplay.cxx:430
EdbDisplay::SetDrawTracks
void SetDrawTracks(int opt)
Definition: EdbDisplay.h:97
EdbDisplay::SelectVertexTracks
void SelectVertexTracks(TObjArray *vtx)
Definition: EdbDisplay.cxx:4197
EdbPVRec::eVTX
TObjArray * eVTX
Definition: EdbPVRec.h:162
EdbPVRec::eTracks
TObjArray * eTracks
Definition: EdbPVRec.h:161

◆ GetBrickToProc()

ProcBrick_t EGraphRec::GetBrickToProc ( ) const
inline
54 {return fBrickToProc;}
EGraphRec::fBrickToProc
ProcBrick_t fBrickToProc
Definition: EGraphRec.h:70

◆ GetButtonSBStart()

TGTextButton* EGraphRec::GetButtonSBStart ( )
inline
61 {return fButtonSBStart;}

◆ GetFoundTracks()

EdbPVRec* EGraphRec::GetFoundTracks ( ) const
inline
59 {return fFoundTracks;}

◆ GetPredTracks()

EdbPattern* EGraphRec::GetPredTracks ( ) const
inline
58 {return fPredTracks;}

◆ GetProcId()

ProcId_t EGraphRec::GetProcId ( ) const
inline
55 {return fProcId;}
EGraphRec::fProcId
ProcId_t fProcId
Definition: EGraphRec.h:80

◆ GetScanProc()

EdbScanProc* EGraphRec::GetScanProc ( ) const
inline
56 {return fScanProc;}
EGraphRec::fScanProc
EdbScanProc * fScanProc
Definition: EGraphRec.h:74

◆ GetScanSet()

EdbScanSet* EGraphRec::GetScanSet ( ) const
inline
57 {return fScanSet;}
EGraphRec::fScanSet
EdbScanSet * fScanSet
Definition: EGraphRec.h:78

◆ GetThSBProcess()

TThread* EGraphRec::GetThSBProcess ( ) const
inline
60 {return fThSBProcess;}

◆ InitDrawVariables()

void EGraphRec::InitDrawVariables ( )
private
693 {
694  fLayout1 = new TGLayoutHints(kLHintsExpandX, 2, 2, 2, 2);
695  fLayout2 = new TGLayoutHints(kLHintsExpandY, 2, 2, 2, 2);
696  fLayout3 = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 2, 2, 2, 2);
697  fLayoutLeftExpY = new TGLayoutHints(kLHintsLeft|kLHintsExpandY, 2, 4, 0, 0);
698  fLayoutRightExpY = new TGLayoutHints(kLHintsRight|kLHintsExpandY,4, 2, 0, 0);
699 }
EGraphRec::fLayout2
TGLayoutHints * fLayout2
Definition: EGraphRec.h:87

◆ InitScanSet()

void EGraphRec::InitScanSet ( )
private
633 {
634  fScanProc->eProcDirClient = fDataDir; // brick directory initialization
635 
636  // Scan set initialization
637 
638 // if (fScanSet && fScanSet->Brick().ID() != fBrickToProc.brickId)
639 // SafeDelete(fScanSet);
640 
641 // if (!fScanSet) {
642 // fScanSet = new EdbScanSet();
643 // fScanSet->Brick().SetID(fBrickToProc.brickId);
644 // }
645 
646  SafeDelete(fScanSet);
647  fScanSet = new EdbScanSet();
648  fScanSet->Brick().SetID(fBrickToProc.brickId);
649 }
EGraphRec::fDataDir
TString fDataDir
Definition: EGraphRec.h:72
EdbLayer::SetID
void SetID(int id)
Definition: EdbLayer.h:95
EdbScanProc::eProcDirClient
TString eProcDirClient
Definition: EdbScanProc.h:14
EdbScanSet
Definition: EdbScanSet.h:11
EdbScanSet::Brick
const EdbBrickP & Brick() const
Definition: EdbScanSet.h:50

◆ InitVariables()

void EGraphRec::InitVariables ( )
private
654 {
655  fEvent = NULL;
656  fFoundTracks = NULL;
657  fPVRec = NULL;
658  fThSBProcess = NULL;
659  fThSBCheckProcess = NULL;
660  fScanSet = NULL;
661  fThSBProcess = NULL;
662  fDataDir = "";
663 
664  fProcBrick.brickId = fProcBrick.firstPlate = fProcBrick.lastPlate =
665  fProcBrick.ver = -1;
666  fProcId.interCalib = fProcId.volumeScan = fProcId.predScan =
667  fProcId.scanForth = -1;
668 
669  // init default vertex reconstruction options
670 
671  fVertexRecOpt.QualityMode = 0;
672  fVertexRecOpt.UseMom = kTRUE;
673  fVertexRecOpt.UseSegPar = kFALSE;
674  fVertexRecOpt.DZmax = 3000.;
675  fVertexRecOpt.ProbMinV = 0.001;
676  fVertexRecOpt.ImpMax = 20.;
677 
678  fScanProc = new EdbScanProc();
679  fPredTracks = new EdbPattern();
680  fRecProc = new EGraphRecProc();
681 
682  // TThread functions
683 
684  // fThSBProcess = new TThread("ThSBProcess", ThSBProcess, (void*) this);
685  fThSBCheckProcess = new TThread("ThSBCheckProcess",
686  ThSBCheckProcess, (void*) this);
687 
688  gEDBDEBUGLEVEL = 2;
689 }
ThSBCheckProcess
void * ThSBCheckProcess(void *ptr)
Definition: EGraphRecProc.cxx:138
EGraphRecProc
Definition: EGraphRecProc.h:54
EdbPattern
Definition: EdbPattern.h:280
EdbScanProc
Definition: EdbScanProc.h:12
gEDBDEBUGLEVEL
gEDBDEBUGLEVEL
Definition: energy.C:7
NULL
#define NULL
Definition: nidaqmx.h:84
ProcId_t::volumeScan
Int_t volumeScan
Definition: EGraphRecProc.h:27
ProcId_t::predScan
Int_t predScan
Definition: EGraphRecProc.h:28
ProcId_t::interCalib
Int_t interCalib
Definition: EGraphRecProc.h:26
ProcId_t::scanForth
Int_t scanForth
Definition: EGraphRecProc.h:29

◆ IsSBToAlgn()

Bool_t EGraphRec::IsSBToAlgn ( ) const
inline
53 {return fCheckSBAlgn->IsDown();}

◆ IsSBToLink()

Bool_t EGraphRec::IsSBToLink ( ) const
inline
52 {return fCheckSBLink->IsDown();}

◆ ProcessEvent()

void EGraphRec::ProcessEvent ( )
58 {
59  // DrawEvent(nentries);
60  // InitScanSet();
61 }

◆ ReadCmdConfig()

void EGraphRec::ReadCmdConfig ( )
private
704 {
705  TString configDir = (TString)getenv("FEDRA_ROOT") + "/config/";
706  TString configFile = configDir + "EGraphRec";
707 
708  if (gEnv->ReadFile(configFile + ".cfg", kEnvChange) == -1)
709  if (gEnv->ReadFile(configFile + "_default.cfg", kEnvChange) == -1) return;
710 
711  if (fDataDir == "")
712  fDataDir = gEnv->GetValue("EGraphRec.DataDir", "");
713 
714  // brick Id
715 
716  if (fProcBrick.brickId < 0)
717  fProcBrick.brickId = gEnv->GetValue("EGraphRec.ProcBrick.brickId", 0);
718  if (fProcBrick.firstPlate < 0)
719  fProcBrick.firstPlate = gEnv->GetValue("EGraphRec.ProcBrick.firstPlate", 0);
720  if (fProcBrick.lastPlate < 0)
721  fProcBrick.lastPlate = gEnv->GetValue("EGraphRec.ProcBrick.lastPlate", 0);
722  if (fProcBrick.ver < 0)
723  fProcBrick.ver = gEnv->GetValue("EGraphRec.ProcBrick.ver", 0);
724 
725  // processes Ids
726 
727  if (fProcId.interCalib < 0)
728  fProcId.interCalib = gEnv->GetValue("EGraphRec.ProcId.interCalib", 0);
729  if (fProcId.volumeScan < 0)
730  fProcId.volumeScan = gEnv->GetValue("EGraphRec.ProcId.volumeScan", 0);
731  if (fProcId.predScan < 0)
732  fProcId.predScan = gEnv->GetValue("EGraphRec.ProcId.predScan", 0);
733  if (fProcId.scanForth < 0)
734  fProcId.scanForth = gEnv->GetValue("EGraphRec.ProcId.scanForth", 0);
735 
736  // vertex reconstruction options
737 
738  fVertexRecOpt.QualityMode = gEnv->GetValue("VertexRecOpt.QualityMode",
739  fVertexRecOpt.QualityMode);
740  fVertexRecOpt.UseMom = gEnv->GetValue("VertexRecOpt.UseMom",
741  fVertexRecOpt.UseMom);
742  fVertexRecOpt.UseSegPar = gEnv->GetValue("VertexRecOpt.UseSegPar",
743  fVertexRecOpt.UseSegPar);
744  fVertexRecOpt.DZmax = gEnv->GetValue("VertexRecOpt.DZmax",
745  fVertexRecOpt.DZmax);
746  fVertexRecOpt.ProbMinV = gEnv->GetValue("VertexRecOpt.ProbMinV",
747  fVertexRecOpt.ProbMinV);
748  fVertexRecOpt.ImpMax = gEnv->GetValue("VertexRecOpt.ImpMax",
749  fVertexRecOpt.ImpMax);
750 }

◆ ReadSBPred()

void EGraphRec::ReadSBPred ( )
574 {
575  // const char *filetypes[] = {"ROOT files", "*.root", 0, 0};
576 
577  static TString dir(".");
578  TGFileInfo fi;
579  // fi.fFileTypes = filetypes;
580  fi.fIniDir = StrDup(dir.Data());
581  new TGFileDialog(gClient->GetRoot(), 0, kFDOpen, &fi);
582  dir = fi.fIniDir;
583 
584  fPredTracks->Reset();
585 
586  // open file with predictions
587 
588  if (fi.fFilename) fScanProc->ReadPatTXT(fi.fFilename, *fPredTracks);
589 
590  // Create directory and write the predictions to the root file
591 
592 }
EdbPattern::Reset
void Reset()
Definition: EdbPattern.cxx:1632
EdbScanProc::ReadPatTXT
int ReadPatTXT(EdbPattern &pred, EdbID id, const char *suffix, int flag=-1)
Definition: EdbScanProc.h:61

◆ ReconstructTracks()

void EGraphRec::ReconstructTracks ( )
160 {
161 
162 }

◆ ResetProcess()

void EGraphRec::ResetProcess ( )
66 {
67  // Reset process
68 
69 // cout << "Reset Process" << endl;
70 
71 // if (fThProcessEvent) {
72 // TThread::Delete(fThProcessEvent);
73 // SafeDelete(fThProcessEvent);
74 // fThProcessEvent = new TThread("ThProcessEvent",
75 // ThProcessEvent, (void*) this);
76 // }
77 }

◆ Set3DViewer()

void EGraphRec::Set3DViewer ( )
597 {
598  fGLViewer = (TGLSAViewer*)fDisplay->fPad->GetViewer3D("ogl");
599  fGLViewer->SetClearColor(38);
600 }
EGraphRec::fGLViewer
TGLSAViewer * fGLViewer
Definition: EGraphRec.h:125
EdbDisplayBase::fPad
TPad * fPad
Definition: EdbDisplayBase.h:126

◆ SetDataDir()

void EGraphRec::SetDataDir ( TString &  dataDir)
inline
63 {fDataDir = dataDir;}

◆ SetProcBrick()

void EGraphRec::SetProcBrick ( ProcBrick_t &  procBrick)
inline
65 {fProcBrick = procBrick;}

◆ SetProcId()

void EGraphRec::SetProcId ( ProcId_t &  procId)
inline
64 {fProcId = procId;}

◆ SetTree()

void EGraphRec::SetTree ( TTree *  tree)
167 {
168  fEvent = new EdbView();
169  fEvtTree = tree;
170 
171  TBranch *headerBranch = fEvtTree->GetBranch("headers");
172  TBranchClones *clustersBranch = (TBranchClones*)(fEvtTree->GetBranch("clusters"));
173  TBranchClones *segmentsBranch = (TBranchClones*)(fEvtTree->GetBranch("segments"));
174  TBranchClones *tracksBranch = (TBranchClones*)(fEvtTree->GetBranch("tracks"));
175  TBranchClones *framesBranch = (TBranchClones*)(fEvtTree->GetBranch("frames"));
176 
177  clustersBranch->ResetReadEntry();
178  segmentsBranch->ResetReadEntry();
179  tracksBranch->ResetReadEntry();
180  framesBranch->ResetReadEntry();
181 
182  headerBranch->SetAddress(fEvent->GetHeaderAddr());
183  clustersBranch->SetAddress(fEvent->GetClustersAddr());
184  segmentsBranch->SetAddress(fEvent->GetSegmentsAddr());
185  tracksBranch->SetAddress(fEvent->GetTracksAddr());
186  framesBranch->SetAddress(fEvent->GetFramesAddr());
187 }
EGraphRec::fEvtTree
TTree * fEvtTree
Definition: EGraphRec.h:71
EdbView
Definition: EdbView.h:134
EdbView::GetClustersAddr
void * GetClustersAddr()
Definition: EdbView.h:170
EdbView::GetSegmentsAddr
void * GetSegmentsAddr()
Definition: EdbView.h:171
EdbView::GetTracksAddr
void * GetTracksAddr()
Definition: EdbView.h:172
EdbView::GetFramesAddr
void * GetFramesAddr()
Definition: EdbView.h:173
EdbView::GetHeaderAddr
void * GetHeaderAddr()
Definition: EdbView.h:169

◆ StartScanBack()

void EGraphRec::StartScanBack ( )
82 {
83  // start scan back
84 
85  // Initialization of brick to be processed
86 
87  fBrickToProc.brickId = fEntryProcBrickId->GetIntNumber();
88  fBrickToProc.ver = fEntryProcVer->GetIntNumber();
89  fBrickToProc.firstPlate = fEntrySBFirstPlate->GetIntNumber();
90  fBrickToProc.lastPlate = fEntrySBLastPlate->GetIntNumber();
91  fBrickToProc.step = fEntrySBStep->GetIntNumber();
92 
93  InitScanSet();
94 
95  SafeDelete(fFoundTracks);
96  fFoundTracks = new EdbPVRec();
97  fThSBProcess = new TThread("ThSBProcess", ThSBProcess, (void*) this);
98 
99  fThSBProcess->Run(); // Run scan back Process in Thread mode
100  fThSBCheckProcess->Run(); // Check the end of job
101  fButtonSBStart->SetEnabled(kFALSE); // Disable Execution button
102 }
ThSBProcess
void * ThSBProcess(void *ptr)
EGraphRec::InitScanSet
void InitScanSet()
Definition: EGraphRec.cxx:632
EdbPVRec
Definition: EdbPVRec.h:148
ProcBrick_t::step
Int_t step
Definition: EGraphRecProc.h:20

◆ StartVertexRec()

void EGraphRec::StartVertexRec ( )
107 {
108  // start vertex reconstruction
109 
110  // Initialization of brick to be processed
111 
112  fBrickToProc.brickId = fEntryProcBrickId->GetIntNumber();
113  fBrickToProc.ver = fEntryProcVer->GetIntNumber();
114  fBrickToProc.firstPlate = fEntrySBFirstPlate->GetIntNumber();
115  fBrickToProc.lastPlate = fEntrySBLastPlate->GetIntNumber();
116  fBrickToProc.step = fEntrySBStep->GetIntNumber();
117 
118  fVertexRecOpt.QualityMode = fEntryQualityMode->GetIntNumber();
119  fVertexRecOpt.UseMom = fCheckUseMom->IsDown();
120  fVertexRecOpt.UseSegPar = fCheckUseSegPar->IsDown();
121  fVertexRecOpt.DZmax = fEntryDZmax->GetNumber();
122  fVertexRecOpt.ProbMinV = fEntryProbMinV->GetNumber();
123  fVertexRecOpt.ImpMax = fEntryImpMax->GetNumber();
124 
125  fScanProc->eProcDirClient = fDataDir; // brick directory initialization
126 
127  fRecProc->SetScanProc(fScanProc); // Scan Proc
128  fRecProc->SetBrickToProc(fBrickToProc); // Brick to process
129  fRecProc->SetProcId(fProcId); // Process Ids
130  fRecProc->SetVertexRecOpt(fVertexRecOpt); // vertex reconstruction options
131 
132  fPVRec = fRecProc->VertexRec();
133 
134  DrawEvent();
135 
136  // delete recProc;
137 }
EGraphRecProc::SetBrickToProc
void SetBrickToProc(ProcBrick_t &brickToProc)
Definition: EGraphRecProc.h:61
EGraphRecProc::VertexRec
EdbPVRec * VertexRec()
Definition: EGraphRecProc.cxx:177
EGraphRecProc::SetVertexRecOpt
void SetVertexRecOpt(VertexRecOpt_t &recOpt)
Definition: EGraphRecProc.h:63
EGraphRecProc::SetProcId
void SetProcId(ProcId_t &procId)
Definition: EGraphRecProc.h:62
EGraphRecProc::SetScanProc
void SetScanProc(EdbScanProc *scanProc)
Definition: EGraphRecProc.h:60
EGraphRec::DrawEvent
void DrawEvent()
Definition: EGraphRec.cxx:141

◆ WriteInfo()

void EGraphRec::WriteInfo ( )
private
624 {
625  fTextInfo->Clear();
626  fTextInfo->AddLine("");
627  fTextInfo->AddLine(" Brick data directory: " + fDataDir);
628 }

◆ ZoomIn()

void EGraphRec::ZoomIn ( )
604 {
605 // fDisplayHits->GetCanvas()->cd();
606 // fDisplayHits->GetCanvas()->GetView()->Zoom();
607 // fDisplayHits->GetCanvas()->Modified();
608 // fDisplayHits->GetCanvas()->Update();
609 }

◆ ZoomOut()

void EGraphRec::ZoomOut ( )
614 {
615 // fDisplayHits->GetCanvas()->cd();
616 // fDisplayHits->GetCanvas()->GetView()->UnZoom();
617 // fDisplayHits->GetCanvas()->Modified();
618 // fDisplayHits->GetCanvas()->Update();
619 }

Member Data Documentation

◆ fBrickToProc

ProcBrick_t EGraphRec::fBrickToProc
private

◆ fButtonSBStart

TGTextButton* EGraphRec::fButtonSBStart
private

◆ fCheckProcAlgn

TGCheckButton* EGraphRec::fCheckProcAlgn
private

◆ fCheckProcLink

TGCheckButton* EGraphRec::fCheckProcLink
private

◆ fCheckProcScan

TGCheckButton* EGraphRec::fCheckProcScan
private

◆ fCheckProcTrks

TGCheckButton* EGraphRec::fCheckProcTrks
private

◆ fCheckProcVrtx

TGCheckButton* EGraphRec::fCheckProcVrtx
private

◆ fCheckSBAlgn

TGCheckButton* EGraphRec::fCheckSBAlgn
private

◆ fCheckSBLink

TGCheckButton* EGraphRec::fCheckSBLink
private

◆ fCheckSBScan

TGCheckButton* EGraphRec::fCheckSBScan
private

◆ fCheckSBTrks

TGCheckButton* EGraphRec::fCheckSBTrks
private

◆ fCheckUseMom

TGCheckButton* EGraphRec::fCheckUseMom
private

◆ fCheckUseSegPar

TGCheckButton* EGraphRec::fCheckUseSegPar
private

◆ fDataDir

TString EGraphRec::fDataDir
private

◆ fDisplay

EdbDisplay* EGraphRec::fDisplay
private

◆ fDisplayFedra

TRootEmbeddedCanvas* EGraphRec::fDisplayFedra
private

◆ fDisplayHits

TRootEmbeddedCanvas* EGraphRec::fDisplayHits
private

◆ fEntryDZmax

TGNumberEntry* EGraphRec::fEntryDZmax
private

◆ fEntryImpMax

TGNumberEntry* EGraphRec::fEntryImpMax
private

◆ fEntryProbMinV

TGNumberEntry* EGraphRec::fEntryProbMinV
private

◆ fEntryProcBrickId

TGNumberEntry* EGraphRec::fEntryProcBrickId
private

◆ fEntryProcVer

TGNumberEntry* EGraphRec::fEntryProcVer
private

◆ fEntryQualityMode

TGNumberEntry* EGraphRec::fEntryQualityMode
private

◆ fEntrySBFirstPlate

TGNumberEntry* EGraphRec::fEntrySBFirstPlate
private

◆ fEntrySBLastPlate

TGNumberEntry* EGraphRec::fEntrySBLastPlate
private

◆ fEntrySBStep

TGNumberEntry* EGraphRec::fEntrySBStep
private

◆ fEvent

EdbView* EGraphRec::fEvent
private

◆ fEvtTree

TTree* EGraphRec::fEvtTree
private

◆ fFoundTracks

EdbPVRec* EGraphRec::fFoundTracks
private

◆ fGLViewer

TGLSAViewer* EGraphRec::fGLViewer
private

◆ fLayout1

TGLayoutHints* EGraphRec::fLayout1
private

◆ fLayout2

TGLayoutHints* EGraphRec::fLayout2
private

◆ fLayout3

TGLayoutHints* EGraphRec::fLayout3
private

◆ fLayoutLeftExpY

TGLayoutHints* EGraphRec::fLayoutLeftExpY
private

◆ fLayoutRightExpY

TGLayoutHints* EGraphRec::fLayoutRightExpY
private

◆ fPredTracks

EdbPattern* EGraphRec::fPredTracks
private

◆ fProcBrick

ProcBrick_t EGraphRec::fProcBrick
private

◆ fProcId

ProcId_t EGraphRec::fProcId
private

◆ fPVRec

EdbPVRec* EGraphRec::fPVRec
private

◆ fRecOptEntry

TGNumberEntry* EGraphRec::fRecOptEntry[6]
private

◆ fRecProc

EGraphRecProc* EGraphRec::fRecProc
private

◆ fScanProc

EdbScanProc* EGraphRec::fScanProc
private

◆ fScanSet

EdbScanSet* EGraphRec::fScanSet
private

◆ fTextInfo

TGTextView* EGraphRec::fTextInfo
private

◆ fTextProcEvent

TGTextButton* EGraphRec::fTextProcEvent
private

◆ fThSBCheckProcess

TThread* EGraphRec::fThSBCheckProcess
private

◆ fThSBProcess

TThread* EGraphRec::fThSBProcess
private

◆ fVertexRecOpt

VertexRecOpt_t EGraphRec::fVertexRecOpt
private
The documentation for this class was generated from the following files: