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
48{
49 SafeDelete(fThSBProcess);
50 SafeDelete(fThSBCheckProcess);
51 SafeDelete(fPredTracks);
52 SafeDelete(fFoundTracks);
53 SafeDelete(fRecProc);
54}
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)
541{
542 TGCompositeFrame *tf;
543
544 tf = worktab->AddTab("cFedra");
545 fDisplayFedra = new TRootEmbeddedCanvas("FEDRA Viewer", tf, 900, 650);
546 tf->AddFrame(fDisplayFedra, fLayout3);
547
548 TCanvas *CanvasFedra = fDisplayFedra->GetCanvas();
549
550 fDisplay = new EdbDisplay("FEDRA Viewer (orig)", -50000., 50000.,
551 -50000., 50000., -150., 37850., CanvasFedra);
552
553// tf = worktab->AddTab("GL Viewer");
554// fDisplayHitsGL = new TRootEmbeddedCanvas("Reconstruction GL", tf, 900, 650);
555// fGLViewer = new TGLSAViewer(tf, fDisplayHitsGL->GetCanvas());
556
557 // tf->AddFrame(fDisplayHitsGL, fLayout3);
558}
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
FEDRA Event Display.
Definition: EdbDisplay.h:22
TCanvas
new TCanvas()

◆ AddInfoFrame()

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

◆ AddProcBrickFrame()

void EGraphRec::AddProcBrickFrame ( TGVerticalFrame *  workframe)

TODO: add the scanning options window

193{
195
196 TGLabel *label;
197 TGHorizontalFrame *frame;
198
199 TGVButtonGroup *GroupProcBrick = new TGVButtonGroup(workframe,
200 "Processing brick");
201
202 // BrickId
203
204 frame = new TGHorizontalFrame(GroupProcBrick);
205 label = new TGLabel(frame, "Brick Id");
206 fEntryProcBrickId = new TGNumberEntry(frame, fProcBrick.brickId, 7, 0,
207 TGNumberEntry::kNESInteger,
208 TGNumberEntry::kNEANonNegative,
209 TGNumberEntry::kNELLimitMin, 0, 1);
210 frame->AddFrame(label, fLayoutLeftExpY);
211 frame->AddFrame(fEntryProcBrickId, fLayoutRightExpY);
212 GroupProcBrick->AddFrame(frame, fLayout1);
213
214 // Version
215
216 frame = new TGHorizontalFrame(GroupProcBrick);
217 label = new TGLabel(frame, "Base version");
218 fEntryProcVer = new TGNumberEntry(frame, fProcBrick.ver, 3, 3,
219 TGNumberEntry::kNESInteger,
220 TGNumberEntry::kNEANonNegative,
221 TGNumberEntry::kNELLimitMin, 0, 1);
222 frame->AddFrame(label, fLayoutLeftExpY);
223 frame->AddFrame(fEntryProcVer, fLayoutRightExpY);
224 GroupProcBrick->AddFrame(frame, fLayout1);
225
226 workframe->AddFrame(GroupProcBrick, fLayout1);
227}
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)
232{
233 TGVButtonGroup *GroupProcList = new TGVButtonGroup(workframe,"Process list");
234 fCheckProcScan = new TGCheckButton(GroupProcList, "Scanning");
235 fCheckProcLink = new TGCheckButton(GroupProcList, "Linking tracks");
236 fCheckProcAlgn = new TGCheckButton(GroupProcList, "Alignment plates");
237 fCheckProcTrks = new TGCheckButton(GroupProcList, "Reconstruct tracks");
238 fCheckProcVrtx = new TGCheckButton(GroupProcList, "Reconstruct vertex");
239
240// fCheckProcLink->SetState(kButtonDown);
241// fCheckProcAlgn->SetState(kButtonDown);
242 fCheckProcScan->SetEnabled(kFALSE);
243 fCheckProcTrks->SetEnabled(kFALSE);
244 fCheckProcVrtx->SetEnabled(kFALSE);
245
246 workframe->AddFrame(GroupProcList, fLayout1);
247
248 // Break process
249
250 TGTextButton *endprocess = new TGTextButton(workframe, "Reset process");
251 endprocess->Connect("Clicked()", "EGraphRec", this, "ResetProcess()");
252 // endprocess->Associate(this);
253 workframe->AddFrame(endprocess, fLayout1);
254
255 // Running process
256
257 fTextProcEvent = new TGTextButton(workframe, "Execute event");
258 fTextProcEvent->Connect("Clicked()", "EGraphRec", this, "ProcessEvent()");
259
260 workframe->AddFrame(fTextProcEvent, fLayout1);
261}
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)

Create a tab with reconstruction options buttons

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

◆ AddScanBackFrame()

void EGraphRec::AddScanBackFrame ( TGTab *  worktab)

Create a tab for scan back procedure

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

create a tab for vertex reconstruction

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

◆ DrawEvent()

void EGraphRec::DrawEvent ( )
143{
144 fDisplay->fCanvas->Clear("D");
145 fDisplay->fCanvas->cd();
146
147 fDisplay->SetDrawTracks(4);
148 // fDisplay->SetDrawVertex(1);
149
150 if (fFoundTracks) fDisplay->SetArrTr(fFoundTracks->eTracks);
151 if (fPVRec) fDisplay->SelectVertexTracks(fPVRec->eVTX);
152
153 fDisplay->Draw();
154 fDisplay->fCanvas->Update();
155
156}
EGraphRec::fPVRec
EdbPVRec * fPVRec
Definition: EGraphRec.h:77
EdbDisplayBase::Draw
virtual void Draw(Option_t *option="")
Definition: EdbDisplayBase.cxx:787
EdbDisplayBase::fCanvas
TCanvas * fCanvas
Pointer to the display canvas.
Definition: EdbDisplayBase.h:124
EdbDisplay::SetArrTr
void SetArrTr(TObjArray *arr)
Definition: EdbDisplay.cxx:431
EdbDisplay::SetDrawTracks
void SetDrawTracks(int opt)
Definition: EdbDisplay.h:98
EdbDisplay::SelectVertexTracks
void SelectVertexTracks(TObjArray *vtx)
Definition: EdbDisplay.cxx:4198
EdbPVRec::eVTX
TObjArray * eVTX
array of vertex
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
694{
695 fLayout1 = new TGLayoutHints(kLHintsExpandX, 2, 2, 2, 2);
696 fLayout2 = new TGLayoutHints(kLHintsExpandY, 2, 2, 2, 2);
697 fLayout3 = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 2, 2, 2, 2);
698 fLayoutLeftExpY = new TGLayoutHints(kLHintsLeft|kLHintsExpandY, 2, 4, 0, 0);
699 fLayoutRightExpY = new TGLayoutHints(kLHintsRight|kLHintsExpandY,4, 2, 0, 0);
700}
EGraphRec::fLayout2
TGLayoutHints * fLayout2
Definition: EGraphRec.h:87

◆ InitScanSet()

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

◆ InitVariables()

void EGraphRec::InitVariables ( )
private
655{
656 fEvent = NULL;
657 fFoundTracks = NULL;
658 fPVRec = NULL;
659 fThSBProcess = NULL;
660 fThSBCheckProcess = NULL;
661 fScanSet = NULL;
662 fThSBProcess = NULL;
663 fDataDir = "";
664
665 fProcBrick.brickId = fProcBrick.firstPlate = fProcBrick.lastPlate =
666 fProcBrick.ver = -1;
667 fProcId.interCalib = fProcId.volumeScan = fProcId.predScan =
668 fProcId.scanForth = -1;
669
670 // init default vertex reconstruction options
671
672 fVertexRecOpt.QualityMode = 0;
673 fVertexRecOpt.UseMom = kTRUE;
674 fVertexRecOpt.UseSegPar = kFALSE;
675 fVertexRecOpt.DZmax = 3000.;
676 fVertexRecOpt.ProbMinV = 0.001;
677 fVertexRecOpt.ImpMax = 20.;
678
679 fScanProc = new EdbScanProc();
680 fPredTracks = new EdbPattern();
681 fRecProc = new EGraphRecProc();
682
683 // TThread functions
684
685 // fThSBProcess = new TThread("ThSBProcess", ThSBProcess, (void*) this);
686 fThSBCheckProcess = new TThread("ThSBCheckProcess",
687 ThSBCheckProcess, (void*) this);
688
689 gEDBDEBUGLEVEL = 2;
690}
ThSBCheckProcess
void * ThSBCheckProcess(void *ptr)
Definition: EGraphRecProc.cxx:139
EGraphRecProc
Definition: EGraphRecProc.h:54
EdbPattern
Definition: EdbPattern.h:273
EdbScanProc
scanned data processing
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 ( )
59{
60 // DrawEvent(nentries);
61 // InitScanSet();
62}

◆ ReadCmdConfig()

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

◆ ReadSBPred()

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

◆ ReconstructTracks()

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

◆ ResetProcess()

void EGraphRec::ResetProcess ( )

Reset process

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

◆ Set3DViewer()

void EGraphRec::Set3DViewer ( )
598{
599 fGLViewer = (TGLSAViewer*)fDisplay->fPad->GetViewer3D("ogl");
600 fGLViewer->SetClearColor(38);
601}
EGraphRec::fGLViewer
TGLSAViewer * fGLViewer
Definition: EGraphRec.h:125
EdbDisplayBase::fPad
TPad * fPad
Pointer to the event display main pad.
Definition: EdbDisplayBase.h:127

◆ 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)
168{
169 fEvent = new EdbView();
170 fEvtTree = tree;
171
172 TBranch *headerBranch = fEvtTree->GetBranch("headers");
173 TBranchClones *clustersBranch = (TBranchClones*)(fEvtTree->GetBranch("clusters"));
174 TBranchClones *segmentsBranch = (TBranchClones*)(fEvtTree->GetBranch("segments"));
175 TBranchClones *tracksBranch = (TBranchClones*)(fEvtTree->GetBranch("tracks"));
176 TBranchClones *framesBranch = (TBranchClones*)(fEvtTree->GetBranch("frames"));
177
178 clustersBranch->ResetReadEntry();
179 segmentsBranch->ResetReadEntry();
180 tracksBranch->ResetReadEntry();
181 framesBranch->ResetReadEntry();
182
183 headerBranch->SetAddress(fEvent->GetHeaderAddr());
184 clustersBranch->SetAddress(fEvent->GetClustersAddr());
185 segmentsBranch->SetAddress(fEvent->GetSegmentsAddr());
186 tracksBranch->SetAddress(fEvent->GetTracksAddr());
187 framesBranch->SetAddress(fEvent->GetFramesAddr());
188}
EGraphRec::fEvtTree
TTree * fEvtTree
Definition: EGraphRec.h:71
EdbView
Base scanning data object: entry into Run tree.
Definition: EdbView.h:134
EdbView::GetSegmentsAddr
void * GetSegmentsAddr()
Definition: EdbView.h:171
EdbView::GetClustersAddr
void * GetClustersAddr()
Definition: EdbView.h:170
EdbView::GetTracksAddr
void * GetTracksAddr()
Definition: EdbView.h:172
EdbView::GetHeaderAddr
void * GetHeaderAddr()
Definition: EdbView.h:169
EdbView::GetFramesAddr
void * GetFramesAddr()
Definition: EdbView.h:173

◆ StartScanBack()

void EGraphRec::StartScanBack ( )

start scan back

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

◆ StartVertexRec()

void EGraphRec::StartVertexRec ( )

start vertex reconstruction

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

◆ WriteInfo()

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

◆ ZoomIn()

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

◆ ZoomOut()

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

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: