File: | programs/Analysis/hdview2/hdv_mainframe.cc |
Location: | line 736, column 10 |
Description: | Value stored to 'philo' during its initialization is never read |
1 | |
2 | #include <iostream> |
3 | #include <iomanip> |
4 | #include <sstream> |
5 | #include <cmath> |
6 | #include <fstream> |
7 | using namespace std; |
8 | |
9 | #include <pthread.h> |
10 | #include <sys/time.h> |
11 | |
12 | #include <TRACKING/DMCThrown.h> |
13 | #include "hdv_mainframe.h" |
14 | #include "hdview2.h" |
15 | #include "MyProcessor.h" |
16 | #include "FDC/DFDCGeometry.h" |
17 | #include "FCAL/DFCALGeometry.h" |
18 | #include "DVector2.h" |
19 | #include "HDGEOMETRY/DGeometry.h" |
20 | #include <PID/DParticleSet.h> |
21 | #include <PID/DPhysicsEvent.h> |
22 | #include <PID/DNeutralParticle.h> |
23 | |
24 | #include <TPolyMarker.h> |
25 | #include <TLine.h> |
26 | #include <TMarker.h> |
27 | #include <TBox.h> |
28 | #include <TVector3.h> |
29 | #include <TGeoVolume.h> |
30 | #include <TGeoManager.h> |
31 | #include <TGLabel.h> |
32 | #include <TGComboBox.h> |
33 | #include <TGButton.h> |
34 | #include <TGButtonGroup.h> |
35 | #include <TGTextEntry.h> |
36 | #include <TArrow.h> |
37 | #include <TLatex.h> |
38 | #include <TColor.h> |
39 | #include <TMath.h> |
40 | |
41 | extern JApplication *japp; |
42 | //TGeoVolume *MOTHER = NULL; |
43 | //TGeoCombiTrans *MotherRotTrans = NULL; |
44 | |
45 | extern int GO; |
46 | |
47 | // These values are just used to draw the detectors for visualization. |
48 | // These should be replaced by a database lookup or something similar |
49 | // at some point. |
50 | static float BCAL_Rmin=65.0; |
51 | static float BCAL_Rmax = 87.46; |
52 | static float BCAL_MIDRAD = 77.0; |
53 | static float BCAL_Zlen = 390.0; |
54 | static float BCAL_Zmin = 212.0 - BCAL_Zlen/2.0; |
55 | static float BCAL_MODS = 48; |
56 | static float BCAL_LAYS1 = 3; |
57 | //static float BCAL_LAYS2 = 4; |
58 | static float BCAL_SECS1 = 4; |
59 | static float BCAL_SECS2 = 4; |
60 | static float FCAL_Zlen = 45.0; |
61 | static float FCAL_Zmin = 622.8; |
62 | static float FCAL_Rmin = 6.0; |
63 | static float FCAL_Rmax = 212.0/2.0; |
64 | static float CDC_Rmin = 9.0; |
65 | static float CDC_Rmax = 59.0; |
66 | static float CDC_Zlen = 150.0; |
67 | static float CDC_Zmin = 17.0; |
68 | static float TOF_Rmax = 125.0; |
69 | static float TOF_Rmin = 6.0; |
70 | static float TOF_Zlen = 2.54; |
71 | static float TOF_Zmin = 618.8; |
72 | static float FDC_Rmin = 3.5; |
73 | static float FDC_Rmax = 48.5; |
74 | static float TARGET_Zmid = 65.0; |
75 | static float TARGET_Zlen = 30.0; |
76 | |
77 | // The DFCALGeometry object is not really available at the time we need it |
78 | // when the program first starts. Cretae one of our own here. |
79 | static DFCALGeometry *fcalgeom = new DFCALGeometry; |
80 | |
81 | static vector<vector <DFDCWire *> >fdcwires; |
82 | |
83 | //------------------- |
84 | // Constructor |
85 | //------------------- |
86 | hdv_mainframe::hdv_mainframe(const TGWindow *p, UInt_t w, UInt_t h):TGMainFrame(p,w,h) |
87 | { |
88 | //Get pointer to DGeometry object |
89 | DApplication* dapp=dynamic_cast<DApplication*>(japp); |
90 | const DGeometry *dgeom = dapp->GetDGeometry(9999); |
91 | |
92 | dgeom->GetFDCWires(fdcwires); |
93 | |
94 | UInt_t MainWidth = w; |
95 | |
96 | // First, define all of the of the graphics objects. Below that, make all |
97 | // of the connections to the methods so these things will work! |
98 | |
99 | // Use the "color wheel" rather than the classic palette. |
100 | //TColor::CreateColorWheel(); |
101 | |
102 | // The main GUI window is divided into three sections, top, middle, and bottom. |
103 | // Create those frames here. |
104 | TGLayoutHints *hints = new TGLayoutHints(kLHintsNormal|kLHintsExpandX|kLHintsExpandY|kLHintsLeft, 5,5,5,5); |
105 | TGLayoutHints *lhints = new TGLayoutHints(kLHintsNormal, 2,2,2,2); |
106 | TGLayoutHints *rhints = new TGLayoutHints(kLHintsCenterY|kLHintsRight, 2,2,2,2); |
107 | TGLayoutHints *chints = new TGLayoutHints(kLHintsCenterY|kLHintsCenterX, 2,2,2,2); |
108 | TGLayoutHints *bhints = new TGLayoutHints(kLHintsBottom|kLHintsCenterX, 2,2,2,2); |
109 | TGLayoutHints *xhints = new TGLayoutHints(kLHintsNormal|kLHintsExpandX, 2,2,2,2); |
110 | TGLayoutHints *yhints = new TGLayoutHints(kLHintsNormal|kLHintsExpandY, 2,2,2,2); |
111 | TGLayoutHints *dhints = new TGLayoutHints(kLHintsLeft|kLHintsCenterY, 0,0,0,0); |
112 | TGLayoutHints *ehints = new TGLayoutHints(kLHintsNormal, 2,2,0,0); |
113 | TGLayoutHints *thints = new TGLayoutHints(kLHintsTop|kLHintsCenterX, 2,2,0,0); |
114 | TGLayoutHints *lxhints = new TGLayoutHints(kLHintsLeft|kLHintsExpandX, 2,2,0,0); |
115 | TGHorizontalFrame *sourceframe = new TGHorizontalFrame(this,w,20); |
116 | TGHorizontalFrame *topframe = new TGHorizontalFrame(this, w, 200); |
117 | // TGHorizontalFrame *midframe = new TGHorizontalFrame(this, w, 200); |
118 | TGCompositeFrame *midframe = new TGCompositeFrame(this, w, 200, kHorizontalFrame); |
119 | TGHorizontalFrame *botframe = new TGHorizontalFrame(this, w, 200); |
120 | AddFrame(sourceframe, lxhints); |
121 | AddFrame(topframe, lhints); |
122 | AddFrame(midframe, lhints); |
123 | AddFrame(botframe, lhints); |
124 | |
125 | //========== Source =========== |
126 | TGLabel *sourcelab = new TGLabel(sourceframe, "Source:"); |
127 | sourceframe->AddFrame(sourcelab,ehints); |
128 | source = new TGLabel(sourceframe, "--"); |
129 | sourceframe->AddFrame(source, lxhints); |
130 | source->SetTextJustify(1); |
131 | |
132 | //========== TOP FRAME ============ |
133 | TGGroupFrame *viewcontrols = new TGGroupFrame(topframe, "View Controls", kHorizontalFrame); |
134 | TGGroupFrame *eventcontrols = new TGGroupFrame(topframe, "Event Controls", kHorizontalFrame); |
135 | TGGroupFrame *eventinfo = new TGGroupFrame(topframe, "Info", kHorizontalFrame); |
136 | TGGroupFrame *inspectors = new TGGroupFrame(topframe, "Inspectors", kVerticalFrame); |
137 | TGHorizontalFrame *programcontrols = new TGHorizontalFrame(topframe); |
138 | topframe->AddFrame(viewcontrols, lhints); |
139 | topframe->AddFrame(eventcontrols, hints); |
140 | topframe->AddFrame(eventinfo, yhints); |
141 | topframe->AddFrame(inspectors, yhints); |
142 | topframe->AddFrame(programcontrols, yhints); |
143 | |
144 | //-------------Pan buttons |
145 | TGVerticalFrame *panneg = new TGVerticalFrame(viewcontrols); |
146 | TGVerticalFrame *panpos = new TGVerticalFrame(viewcontrols); |
147 | viewcontrols->AddFrame(panneg, hints); |
148 | viewcontrols->AddFrame(panpos, hints); |
149 | TGTextButton *panxneg = new TGTextButton(panneg, "-X"); |
150 | TGTextButton *panyneg = new TGTextButton(panneg, "-Y"); |
151 | TGTextButton *panzneg = new TGTextButton(panneg, "-Z"); |
152 | panneg->AddFrame(panxneg, dhints); |
153 | panneg->AddFrame(panyneg, dhints); |
154 | panneg->AddFrame(panzneg, dhints); |
155 | |
156 | TGTextButton *panxpos = new TGTextButton(panpos, "X+"); |
157 | TGTextButton *panypos = new TGTextButton(panpos, "Y+"); |
158 | TGTextButton *panzpos = new TGTextButton(panpos, "Z+"); |
159 | panpos->AddFrame(panxpos, dhints); |
160 | panpos->AddFrame(panypos, dhints); |
161 | panpos->AddFrame(panzpos, dhints); |
162 | |
163 | panxneg->Connect("Clicked()","hdv_mainframe",this,"DoPanXneg()"); |
164 | panyneg->Connect("Clicked()","hdv_mainframe",this,"DoPanYneg()"); |
165 | panzneg->Connect("Clicked()","hdv_mainframe",this,"DoPanZneg()"); |
166 | panxpos->Connect("Clicked()","hdv_mainframe",this,"DoPanXpos()"); |
167 | panypos->Connect("Clicked()","hdv_mainframe",this,"DoPanYpos()"); |
168 | panzpos->Connect("Clicked()","hdv_mainframe",this,"DoPanZpos()"); |
169 | //------------- Zoom/Reset buttons |
170 | TGVerticalFrame *zoom = new TGVerticalFrame(viewcontrols); |
171 | viewcontrols->AddFrame(zoom, lhints); |
172 | TGGroupFrame *zoomframe = new TGGroupFrame(zoom, "ZOOM", kHorizontalFrame); |
173 | zoom->AddFrame(zoomframe, thints); |
174 | TGTextButton *zoomout = new TGTextButton(zoomframe, " - "); |
175 | TGTextButton *zoomin = new TGTextButton(zoomframe, " + "); |
176 | zoomframe->AddFrame(zoomout, thints); |
177 | zoomframe->AddFrame(zoomin, thints); |
178 | TGTextButton *reset = new TGTextButton(zoom, "Reset"); |
179 | zoom->AddFrame(reset, chints); |
180 | |
181 | //-------------- Transverse Coordinates |
182 | TGVButtonGroup *coordinates = new TGVButtonGroup(viewcontrols,"Transverse Coordinates"); |
183 | viewcontrols->AddFrame(coordinates, lhints); |
184 | TGRadioButton *xy = new TGRadioButton(coordinates, "x/y"); |
185 | new TGRadioButton(coordinates, "r/phi"); |
186 | |
187 | //-------------- Next, Previous |
188 | prev = new TGTextButton(eventcontrols, "<-- Prev"); |
189 | next = new TGTextButton(eventcontrols, "Next -->"); |
190 | TGVerticalFrame *contf = new TGVerticalFrame(eventcontrols); |
191 | eventcontrols->AddFrame(prev, chints); |
192 | eventcontrols->AddFrame(next, chints); |
193 | eventcontrols->AddFrame(contf, lhints); |
194 | |
195 | // continuous, delay |
196 | checkbuttons["continuous"] = new TGCheckButton(contf, "continuous"); |
197 | TGHorizontalFrame *delayf = new TGHorizontalFrame(contf); |
198 | contf->AddFrame(checkbuttons["continuous"], lhints); |
199 | contf->AddFrame(delayf, lhints); |
200 | TGLabel *delaylab = new TGLabel(delayf, "delay:"); |
201 | delay = new TGComboBox(delayf, "0.25"); |
202 | delay->Resize(50,20); |
203 | float delays[]={0, 0.25, 0.5, 1, 2, 3, 5, 10}; |
204 | for(int i=0; i<8; i++){ |
205 | stringstream ss; |
206 | ss<<delays[i]; |
207 | delay->AddEntry(ss.str().c_str(),i); |
208 | } |
209 | delayf->AddFrame(delaylab, lhints); |
210 | delayf->AddFrame(delay, lhints); |
211 | |
212 | //----------------- Event Info |
213 | TGVerticalFrame *eventlabs = new TGVerticalFrame(eventinfo); |
214 | TGVerticalFrame *eventvals = new TGVerticalFrame(eventinfo); |
215 | eventinfo->AddFrame(eventlabs, lhints); |
216 | eventinfo->AddFrame(eventvals, lhints); |
217 | |
218 | TGLabel *runlab = new TGLabel(eventlabs, "Run:"); |
219 | TGLabel *eventlab = new TGLabel(eventlabs, "Event:"); |
220 | run = new TGLabel(eventvals, "----------"); |
221 | event = new TGLabel(eventvals, "----------"); |
222 | eventlabs->AddFrame(runlab, rhints); |
223 | eventlabs->AddFrame(eventlab,rhints); |
224 | eventvals->AddFrame(run, lhints); |
225 | eventvals->AddFrame(event, lhints); |
226 | |
227 | //----------------- Inspectors |
228 | TGTextButton *trackinspector = new TGTextButton(inspectors, "Track Inspector"); |
229 | //TGTextButton *tofinspector = new TGTextButton(inspectors, "TOF Inspector"); |
230 | //TGTextButton *bcalinspector = new TGTextButton(inspectors, "BCAL Inspector"); |
231 | //TGTextButton *fcalinspector = new TGTextButton(inspectors, "FCAL Inspector"); |
232 | inspectors->AddFrame(trackinspector, xhints); |
233 | //inspectors->AddFrame(tofinspector, xhints); |
234 | //inspectors->AddFrame(bcalinspector, xhints); |
235 | //inspectors->AddFrame(fcalinspector, xhints); |
236 | //tofinspector->SetEnabled(kFALSE); |
237 | //bcalinspector->SetEnabled(kFALSE); |
238 | //fcalinspector->SetEnabled(kFALSE); |
239 | |
240 | //-------------- Program Controls |
241 | TGTextButton *quit = new TGTextButton(programcontrols, "&Quit"); |
242 | programcontrols->AddFrame(quit, new TGLayoutHints(kLHintsTop|kLHintsRight|kLHintsExpandX, 2,2,2,2)); |
243 | |
244 | //========== MID FRAME ============ |
245 | TGHorizontalFrame *detectorframe = new TGHorizontalFrame(midframe); |
246 | midframe->AddFrame(detectorframe, hints); |
247 | |
248 | //------ Detector Frame ------ |
249 | TGVerticalFrame *sideviews = new TGVerticalFrame(detectorframe); |
250 | TGVerticalFrame *endviews = new TGVerticalFrame(detectorframe); |
251 | TGVerticalFrame *drawopts = new TGVerticalFrame(detectorframe); |
252 | TGVerticalFrame *caloColorCodes = new TGVerticalFrame(detectorframe); |
253 | detectorframe->AddFrame(sideviews, lhints); |
254 | detectorframe->AddFrame(endviews, lhints); |
255 | detectorframe->AddFrame(caloColorCodes, lhints); |
256 | detectorframe->AddFrame(drawopts, lhints); |
257 | |
258 | // Side views |
259 | int width = MainWidth/6*2; |
260 | TGHorizontalFrame *sideviewAframe = new TGHorizontalFrame(sideviews); |
261 | TGHorizontalFrame *sideviewBframe = new TGHorizontalFrame(sideviews); |
262 | sideviews->AddFrame(sideviewAframe, lhints); |
263 | sideviews->AddFrame(sideviewBframe, lhints); |
264 | sideviewA = new TRootEmbeddedCanvas("sideviewA Canvas", sideviewAframe, width, width/2, kSunkenFrame, GetWhitePixel()); |
265 | sideviewB = new TRootEmbeddedCanvas("sideviewB Canvas", sideviewBframe, width, width/2, kSunkenFrame, GetWhitePixel()); |
266 | sideviewAframe->AddFrame(sideviewA, lhints); |
267 | sideviewBframe->AddFrame(sideviewB, lhints); |
268 | sideviewA->SetScrolling(TGCanvas::kCanvasScrollBoth); |
269 | sideviewB->SetScrolling(TGCanvas::kCanvasScrollBoth); |
270 | sideviewA->SetBackgroundColor(0xafeeee); |
271 | sideviewB->SetBackgroundColor(0xafeeee); |
272 | |
273 | // End views |
274 | endviewA = new TRootEmbeddedCanvas("endviewA Canvas", endviews, width/2, width/2, kSunkenFrame, GetWhitePixel()); |
275 | endviewB = new TRootEmbeddedCanvas("endviewB Canvas", endviews, width/2, width/2, kSunkenFrame, GetWhitePixel()); |
276 | endviews->AddFrame(endviewA, lhints); |
277 | endviews->AddFrame(endviewB, lhints); |
278 | endviewA->SetScrolling(TGCanvas::kCanvasScrollBoth); |
279 | endviewB->SetScrolling(TGCanvas::kCanvasScrollBoth); |
280 | endviewA->GetCanvas()->SetFillColor(kGray+1); |
281 | endviewB->GetCanvas()->SetFillColor(kGray+1); |
282 | |
283 | // Draw opts |
284 | TGGroupFrame *trkdrawopts = new TGGroupFrame(drawopts, "Track Draw Options", kVerticalFrame); |
285 | TGGroupFrame *hitdrawopts = new TGGroupFrame(drawopts, "Hit Draw Options", kVerticalFrame); |
286 | drawopts->AddFrame(trkdrawopts, lhints); |
287 | drawopts->AddFrame(hitdrawopts, lhints); |
288 | |
289 | // Track |
290 | TGHorizontalFrame *candidatesf = new TGHorizontalFrame(trkdrawopts); |
291 | checkbuttons["candidates"] = new TGCheckButton(candidatesf, "DTrackCandidate:"); |
292 | candidatesfactory = new TGComboBox(candidatesf, "<default>", 0); |
293 | candidatesfactory->Resize(80,20); |
294 | candidatesf->AddFrame(checkbuttons["candidates"], lhints); |
295 | for(int i=0; i<100; i++)candidatesfactory->AddEntry("a",i); |
296 | // For some reason, this is needed for ROOT >5.14 (??!!!) real entries are filled in later |
297 | candidatesf->AddFrame(candidatesfactory, lhints); |
298 | trkdrawopts->AddFrame(candidatesf, lhints); |
299 | |
300 | TGHorizontalFrame *wiretracksf = new TGHorizontalFrame(trkdrawopts); |
301 | checkbuttons["wiretracks"] = new TGCheckButton(wiretracksf, "DTrackWireBased:"); |
302 | wiretracksfactory = new TGComboBox(wiretracksf, "<default>", 0); |
303 | wiretracksfactory->Resize(80,20); |
304 | wiretracksf->AddFrame(checkbuttons["wiretracks"], lhints); |
305 | for(int i=0; i<100; i++)wiretracksfactory->AddEntry("a",i); |
306 | // For some reason, this is needed for ROOT >5.14 (??!!!) real entries are filled in later |
307 | wiretracksf->AddFrame(wiretracksfactory, lhints); |
308 | trkdrawopts->AddFrame(wiretracksf, lhints); |
309 | |
310 | TGHorizontalFrame *timetracksf = new TGHorizontalFrame(trkdrawopts); |
311 | checkbuttons["timetracks"] = new TGCheckButton(timetracksf, "DTrackTimeBased:"); |
312 | timetracksfactory = new TGComboBox(timetracksf, "<default>", 0); |
313 | timetracksfactory->Resize(80,20); |
314 | timetracksf->AddFrame(checkbuttons["timetracks"], lhints); |
315 | for(int i=0; i<100; i++)timetracksfactory->AddEntry("a",i); |
316 | // For some reason, this is needed for ROOT >5.14 (??!!!) real entries are filled in later |
317 | timetracksf->AddFrame(timetracksfactory, lhints); |
318 | trkdrawopts->AddFrame(timetracksf, lhints); |
319 | TGHorizontalFrame *chargedtracksf = new TGHorizontalFrame(trkdrawopts); |
320 | checkbuttons["chargedtracks"] = new TGCheckButton(chargedtracksf, "DChargedTrack:"); |
321 | chargedtracksfactory = new TGComboBox(chargedtracksf, "<default>", 0); |
322 | chargedtracksfactory->Resize(80,20); |
323 | chargedtracksf->AddFrame(checkbuttons["chargedtracks"], lhints); |
324 | for(int i=0; i<100; i++)chargedtracksfactory->AddEntry("a",i); |
325 | // For some reason, this is needed for ROOT >5.14 (??!!!) real entries are filled in later |
326 | chargedtracksf->AddFrame(chargedtracksfactory, lhints); |
327 | trkdrawopts->AddFrame(chargedtracksf, lhints); |
328 | |
329 | checkbuttons["neutrals"] = new TGCheckButton(trkdrawopts,"DNeutralParticle"); |
330 | checkbuttons["thrown"] = new TGCheckButton(trkdrawopts,"DMCThrown"); |
331 | checkbuttons["trajectories"] = new TGCheckButton(trkdrawopts, "DMCTrajectoryPoint"); |
332 | trkdrawopts->AddFrame(checkbuttons["neutrals"], lhints); |
333 | trkdrawopts->AddFrame(checkbuttons["thrown"], lhints); |
334 | trkdrawopts->AddFrame(checkbuttons["trajectories"], lhints); |
335 | |
336 | // Hit |
337 | checkbuttons["cdc"] = new TGCheckButton(hitdrawopts, "CDC"); |
338 | checkbuttons["cdcdrift"] = new TGCheckButton(hitdrawopts, "CDC Drift Time"); |
339 | checkbuttons["cdctruth"] = new TGCheckButton(hitdrawopts, "CDCTruth"); |
340 | checkbuttons["fdcwire"] = new TGCheckButton(hitdrawopts, "FDC Wire"); |
341 | checkbuttons["fdcpseudo"] = new TGCheckButton(hitdrawopts, "FDC Pseudo"); |
342 | checkbuttons["fdctruth"] = new TGCheckButton(hitdrawopts, "FDCTruth"); |
343 | checkbuttons["tof"] = new TGCheckButton(hitdrawopts, "TOF"); |
344 | checkbuttons["toftruth"] = new TGCheckButton(hitdrawopts, "TOFTruth"); |
345 | checkbuttons["fcal"] = new TGCheckButton(hitdrawopts, "FCAL"); |
346 | checkbuttons["bcal"] = new TGCheckButton(hitdrawopts, "BCAL"); |
347 | |
348 | hitdrawopts->AddFrame(checkbuttons["cdc"], lhints); |
349 | hitdrawopts->AddFrame(checkbuttons["cdcdrift"], lhints); |
350 | hitdrawopts->AddFrame(checkbuttons["cdctruth"], lhints); |
351 | hitdrawopts->AddFrame(checkbuttons["fdcwire"], lhints); |
352 | hitdrawopts->AddFrame(checkbuttons["fdcpseudo"], lhints); |
353 | hitdrawopts->AddFrame(checkbuttons["fdctruth"], lhints); |
354 | hitdrawopts->AddFrame(checkbuttons["tof"], lhints); |
355 | hitdrawopts->AddFrame(checkbuttons["toftruth"], lhints); |
356 | hitdrawopts->AddFrame(checkbuttons["fcal"], lhints); |
357 | hitdrawopts->AddFrame(checkbuttons["bcal"], lhints); |
358 | |
359 | TGTextButton *moreOptions = new TGTextButton(hitdrawopts, "More options"); |
360 | hitdrawopts->AddFrame(moreOptions, lhints); |
361 | |
362 | // Color codes |
363 | TGGroupFrame *bcalColorCodes = new TGGroupFrame(caloColorCodes, "BCAL colors", kVerticalFrame); |
364 | TGGroupFrame *fcalColorCodes = new TGGroupFrame(caloColorCodes, "FCAL colors", kVerticalFrame); |
365 | TGTextButton *debuger = new TGTextButton(caloColorCodes,"Debuger"); |
366 | |
367 | caloColorCodes->AddFrame(bcalColorCodes, thints); |
368 | caloColorCodes->AddFrame(debuger,lhints); |
369 | caloColorCodes->AddFrame(fcalColorCodes, bhints); |
370 | bcalColorCodes->SetWidth(30); |
371 | fcalColorCodes->SetWidth(30); |
372 | |
373 | // color lables BCAL |
374 | TGLabel* BCCLables[9]; |
375 | unsigned int ccodes[9] = {0xFF0033,0xFF2233,0xFF4433,0xFF6633,0xFF8833,0xFFaa33,0xFFcc33,0xFFee33,0xFFFFaa}; |
376 | for (int i=0;i<9;i++) { |
377 | double e = (1.-(double)i*0.11)*(1.-(double)i*0.11)*0.02; |
378 | char str1[128]; |
379 | sprintf(str1,"%4.1f MeV",e*1000.); |
380 | BCCLables[i] = new TGLabel(bcalColorCodes, (const char*)str1); |
381 | //BCCLables[i]->SetTextColor(1); |
382 | BCCLables[i]->SetBackgroundColor(ccodes[i]); |
383 | bcalColorCodes->AddFrame(BCCLables[i],lhints); |
384 | } |
385 | // color lables FCAL |
386 | TGLabel* FCCLables[9]; |
387 | for (int i=0;i<9;i++) { |
388 | double E = pow(10.,((1. - (double)i*0.11)*log10(1./0.005))); |
389 | char str1[128]; |
390 | sprintf(str1,"%5.1f MeV",E); |
391 | FCCLables[i] = new TGLabel(fcalColorCodes, (const char*)str1); |
392 | FCCLables[i]->SetBackgroundColor(ccodes[i]); |
393 | fcalColorCodes->AddFrame(FCCLables[i],lhints); |
394 | } |
395 | |
396 | //========== BOT FRAME ============ |
397 | TGGroupFrame *trackinfo = new TGGroupFrame(botframe, "Track Info", kHorizontalFrame); |
398 | botframe->AddFrame(trackinfo, xhints); |
399 | |
400 | //------ Track Info ------ |
401 | throwninfo = new TGGroupFrame(trackinfo, "Thrown", kHorizontalFrame); |
402 | reconinfo = new TGGroupFrame(trackinfo, "Reconstructed", kHorizontalFrame); |
403 | trackinfo->AddFrame(throwninfo, lhints); |
404 | trackinfo->AddFrame(reconinfo, lhints); |
405 | |
406 | // Column names |
407 | vector<string> colnames; |
408 | colnames.push_back("trk"); |
409 | colnames.push_back("type"); |
410 | colnames.push_back("p"); |
411 | colnames.push_back("theta"); |
412 | colnames.push_back("phi"); |
413 | colnames.push_back("z"); |
414 | colnames.push_back("chisq/Ndof"); |
415 | colnames.push_back("Ndof"); |
416 | colnames.push_back("FOM"); |
417 | colnames.push_back("cand"); |
418 | |
419 | // Create a vertical frame for each column and insert the label as the first item |
420 | for(unsigned int i=0; i<colnames.size(); i++){ |
421 | // create frames |
422 | TGVerticalFrame *tf = new TGVerticalFrame(throwninfo); |
423 | TGVerticalFrame *rf = new TGVerticalFrame(reconinfo); |
424 | throwninfo->AddFrame(tf, bhints); |
425 | reconinfo->AddFrame(rf, bhints); |
426 | |
427 | // create column labels |
428 | string lab = colnames[i]+":"; |
429 | TGLabel *tl = new TGLabel(tf, lab.c_str()); |
430 | TGLabel *rl = new TGLabel(rf, lab.c_str()); |
431 | if(i<6)tf->AddFrame(tl, chints); |
432 | rf->AddFrame(rl, chints); |
433 | vector<TGLabel*> tv; |
434 | vector<TGLabel*> rv; |
435 | tv.push_back(tl); |
436 | rv.push_back(rl); |
437 | |
438 | // Add 8 labels to each column |
439 | // These have to be added in reverse order so we can pack them from |
440 | // the bottom. Otherwise, it doesn't draw correctly. |
441 | for(int j=0; j<14; j++){ |
442 | stringstream ss; |
443 | ss<<(5-j); |
444 | if(i<6)tl = new TGLabel(tf, i==0 ? ss.str().c_str():"--------"); |
445 | rl = new TGLabel(rf, i==0 ? ss.str().c_str():"--------"); |
446 | if(i<6)tf->AddFrame(tl, bhints); |
447 | rf->AddFrame(rl, bhints); |
448 | tv.push_back(tl); |
449 | rv.push_back(rl); |
450 | } |
451 | |
452 | // Record the label object pointers for later use |
453 | thrownlabs[colnames[i]] = tv; |
454 | reconlabs[colnames[i]] = rv; |
455 | } |
456 | |
457 | // Reconstruction factory and full list button |
458 | TGVerticalFrame *vf = new TGVerticalFrame(reconinfo); |
459 | reconinfo->AddFrame(vf, yhints); |
460 | reconfactory = new TGComboBox(vf, "DTrackCandidate:", 0); |
461 | reconfactory->Resize(160,20); |
462 | for(int i=0; i<100; i++)reconfactory->AddEntry("a",i); // For some reason, this is needed for ROOT >5.14 (??!!!) real entries are filled in later |
463 | vf->AddFrame(reconfactory, thints); |
464 | |
465 | TGTextButton *listall = new TGTextButton(vf, "Full List"); |
466 | vf->AddFrame(listall, new TGLayoutHints(kLHintsBottom|kLHintsExpandX, 2,2,2,2)); |
467 | |
468 | // Pointers to optional daughter windows (these must be done before ReadPreferences in |
469 | // order for the options they implement to be filled into checkbuttons) |
470 | trkmf = NULL__null; |
471 | optionsmf = new hdv_optionsframe(this, NULL__null, 100, 100); |
472 | debugermf = new hdv_debugerframe(this, NULL__null, 800, 800); |
473 | fulllistmf = new hdv_fulllistframe(this, NULL__null, 100, 100); |
474 | endviewBmf = new hdv_endviewBframe(this, NULL__null, 600, 600); |
475 | |
476 | //&&&&&&&&&&&&&&&& Defaults |
477 | ReadPreferences(); |
478 | xy->SetState(kButtonDown,kTRUE); |
479 | coordinatetype = COORD_XY; |
480 | r0 = 50.0; |
481 | phi0 = M_PI3.14159265358979323846; |
482 | x0 = 0.0; |
483 | y0 = 0.0; |
484 | z0 = 350.0; |
485 | zoom_factor = 1.0; |
486 | |
487 | //&&&&&&&&&&&&&&&& Connections |
488 | zoomin->Connect("Clicked()","hdv_mainframe", this, "DoZoomIn()"); |
489 | zoomout->Connect("Clicked()","hdv_mainframe", this, "DoZoomOut()"); |
490 | reset->Connect("Clicked()","hdv_mainframe", this, "DoReset()"); |
491 | |
492 | coordinates->Connect("Clicked(Int_t)","hdv_mainframe", this, "DoSetCoordinates(Int_t)"); |
493 | coordinates->Connect("Clicked(Int_t)","hdv_mainframe", this, "DoMyRedraw()"); |
494 | |
495 | quit->Connect("Clicked()","hdv_mainframe", this, "DoQuit()"); |
496 | next->Connect("Clicked()","hdv_mainframe", this, "DoNext()"); |
497 | prev->Connect("Clicked()","hdv_mainframe", this, "DoPrev()"); |
498 | checkbuttons["continuous"]->Connect("Clicked()","hdv_mainframe", this, "DoCont()"); |
499 | delay->Connect("Selected(Int_t)","hdv_mainframe", this, "DoSetDelay(Int_t)"); |
500 | |
501 | trackinspector->Connect("Clicked()","hdv_mainframe", this, "DoOpenTrackInspector()"); |
502 | moreOptions->Connect("Clicked()","hdv_mainframe", this, "DoOpenOptionsWindow()"); |
503 | listall->Connect("Clicked()","hdv_mainframe", this, "DoOpenFullListWindow()"); |
504 | debuger->Connect("Clicked()","hdv_mainframe", this, "DoOpenDebugerWindow()"); |
505 | //tofinspector->Connect("Clicked()","hdv_mainframe", this, "DoOpenTOFInspector()"); |
506 | //fcalinspector->Connect("Clicked()","hdv_mainframe", this, "DoOpenFCALInspector()"); |
507 | //bcalinspector->Connect("Clicked()","hdv_mainframe", this, "DoOpenBCALInspector()"); |
508 | |
509 | checkbuttons["candidates"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
510 | checkbuttons["wiretracks"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
511 | checkbuttons["timetracks"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
512 | checkbuttons["chargedtracks"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
513 | checkbuttons["neutrals"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
514 | checkbuttons["thrown"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
515 | |
516 | checkbuttons["cdc"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
517 | checkbuttons["cdcdrift"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
518 | checkbuttons["cdctruth"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
519 | checkbuttons["fdcwire"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
520 | checkbuttons["fdcpseudo"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
521 | checkbuttons["fdctruth"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
522 | checkbuttons["tof"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
523 | checkbuttons["toftruth"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
524 | checkbuttons["bcal"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
525 | checkbuttons["bcaltruth"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
526 | checkbuttons["fcal"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
527 | checkbuttons["fcaltruth"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
528 | checkbuttons["trajectories"]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
529 | |
530 | for (Int_t n=1;n<debugermf->GetNTrCand();n++){ |
531 | char str1[128]; |
532 | sprintf(str1,"Candidate%d",n); |
533 | checkbuttons[str1]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
534 | } |
535 | |
536 | for (Int_t n=1;n<debugermf->GetNTrWB();n++){ |
537 | char str1[128]; |
538 | sprintf(str1,"WireBased%d",n); |
539 | checkbuttons[str1]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
540 | } |
541 | |
542 | for (Int_t n=1;n<debugermf->GetNTrTB();n++){ |
543 | char str1[128]; |
544 | sprintf(str1,"TimeBased%d",n); |
545 | checkbuttons[str1]->Connect("Clicked()","hdv_mainframe", this, "DoMyRedraw()"); |
546 | } |
547 | |
548 | candidatesfactory->Connect("Selected(Int_t)","hdv_mainframe", this, "DoMyRedraw()"); |
549 | wiretracksfactory->Connect("Selected(Int_t)","hdv_mainframe", this, "DoMyRedraw()"); |
550 | timetracksfactory->Connect("Selected(Int_t)","hdv_mainframe", this, "DoMyRedraw()"); |
551 | chargedtracksfactory->Connect("Selected(Int_t)","hdv_mainframe", this, "DoMyRedraw()"); |
552 | reconfactory->Connect("Selected(Int_t)","hdv_mainframe", this, "DoUpdateTrackLabels()"); |
553 | |
554 | endviewB->GetCanvas()->Connect("Selected(TVirtualPad*, TObject*, Int_t)", "hdv_mainframe", this, "DoEndViewBEvent(TVirtualPad*, TObject*, Int_t)"); |
555 | |
556 | // Set up timer to call the DoTimer() method repeatedly |
557 | // so events can be automatically advanced. |
558 | timer = new TTimer(); |
559 | timer->Connect("Timeout()", "hdv_mainframe", this, "DoTimer()"); |
560 | sleep_time = 250; |
561 | timer->Start(sleep_time, kFALSE); |
562 | |
563 | // Finish up and map the window |
564 | SetWindowName("Hall-D Event Viewer"); |
565 | SetIconName("HDView"); |
566 | MapSubwindows(); |
567 | Resize(GetDefaultSize()); |
568 | MapWindow(); |
569 | |
570 | // Call Resize method of some group frames to get them to shrink down to smallest size |
571 | viewcontrols->Resize(); |
572 | eventinfo->Resize(); |
573 | eventcontrols->Resize(); |
574 | inspectors->Resize(); |
575 | } |
576 | |
577 | //------------------- |
578 | // ReadPreferences |
579 | //------------------- |
580 | void hdv_mainframe::ReadPreferences(void) |
581 | { |
582 | // Preferences file is "${HOME}/.hdview2" |
583 | const char *home = getenv("HOME"); |
584 | if(!home)return; |
585 | |
586 | // Try and open file |
587 | string fname = string(home) + "/.hdview2"; |
588 | ifstream ifs(fname.c_str()); |
589 | if(!ifs.is_open())return; |
590 | cout<<"Reading preferences from \""<<fname<<"\" ..."<<endl; |
591 | |
592 | // Loop over lines |
593 | char line[1024]; |
594 | while(!ifs.eof()){ |
595 | ifs.getline(line, 1024); |
596 | if(strlen(line)==0)continue; |
597 | if(line[0] == '#')continue; |
598 | string str(line); |
599 | |
600 | // Break line into tokens |
601 | vector<string> tokens; |
602 | string buf; // Have a buffer string |
603 | stringstream ss(str); // Insert the string into a stream |
604 | while (ss >> buf)tokens.push_back(buf); |
605 | if(tokens.size()<1)continue; |
606 | |
607 | // Check first token to decide what to do |
608 | if(tokens[0] == "checkbutton"){ |
609 | if(tokens.size()!=4)continue; // should be of form "checkbutton name = value" with white space on either side of the "=" |
610 | map<string, TGCheckButton*>::iterator it = checkbuttons.find(tokens[1]); |
611 | if(it != checkbuttons.end()){ |
612 | if(tokens[3] == "on")(it->second)->SetState(kButtonDown); |
613 | } |
614 | } |
615 | |
616 | if(tokens[0] == "DTrackCandidate"){ |
617 | if(tokens.size()!=3)continue; // should be of form "DTrackCandidate = tag" with white space on either side of the "=" |
618 | default_candidate = tokens[2]; |
619 | } |
620 | |
621 | if(tokens[0] == "DTrackWireBased"){ |
622 | if(tokens.size()!=3)continue; // should be of form "DTrackWireBased = tag" with white space on either side of the "=" |
623 | default_track = tokens[2]; |
624 | } |
625 | |
626 | if(tokens[0] == "DTrackTimeBased"){ |
627 | if(tokens.size()!=3)continue; // should be of form "DTrackTimeBased = tag" with white space on either side of the "=" |
628 | default_track = tokens[2]; |
629 | } |
630 | |
631 | if(tokens[0] == "Reconstructed"){ |
632 | if(tokens.size()!=3)continue; // should be of form "Reconstructed = Factory:tag" with white space on either side of the "=" |
633 | default_reconstructed = tokens[2]; |
634 | } |
635 | |
636 | } |
637 | |
638 | // close file |
639 | ifs.close(); |
640 | } |
641 | |
642 | //------------------- |
643 | // SavePreferences |
644 | //------------------- |
645 | void hdv_mainframe::SavePreferences(void) |
646 | { |
647 | // Preferences file is "${HOME}/.hdview2" |
648 | const char *home = getenv("HOME"); |
649 | if(!home)return; |
650 | |
651 | // Try deleting old file and creating new file |
652 | string fname = string(home) + "/.hdview2"; |
653 | unlink(fname.c_str()); |
654 | ofstream ofs(fname.c_str()); |
655 | if(!ofs.is_open()){ |
656 | cout<<"Unable to create preferences file \""<<fname<<"\"!"<<endl; |
657 | return; |
658 | } |
659 | |
660 | // Write header |
661 | time_t t = time(NULL__null); |
662 | ofs<<"##### hdview2 preferences file ###"<<endl; |
663 | ofs<<"##### Auto-generated on "<<ctime(&t)<<endl; |
664 | ofs<<endl; |
665 | |
666 | // Write all checkbuttons that are "on" |
667 | map<string, TGCheckButton*>::iterator iter; |
668 | for(iter=checkbuttons.begin(); iter!=checkbuttons.end(); iter++){ |
669 | TGCheckButton *but = iter->second; |
670 | if(but->GetState() == kButtonDown){ |
671 | ofs<<"checkbutton "<<(iter->first)<<" = on"<<endl; |
672 | } |
673 | } |
674 | ofs<<endl; |
675 | |
676 | ofs<<"DTrackCandidate = "<<(candidatesfactory->GetTextEntry()->GetText())<<endl; |
677 | ofs<<"DTrackWireBased = "<<(wiretracksfactory->GetTextEntry()->GetText())<<endl; |
678 | ofs<<"DTrackTimeBased = "<<(timetracksfactory->GetTextEntry()->GetText())<<endl; |
679 | ofs<<"Reconstructed = "<<(reconfactory->GetTextEntry()->GetText())<<endl; |
680 | |
681 | ofs<<endl; |
682 | ofs.close(); |
683 | cout<<"Preferences written to \""<<fname<<"\""<<endl; |
684 | } |
685 | |
686 | //------------------- |
687 | // SetRange |
688 | //------------------- |
689 | void hdv_mainframe::SetRange(void) |
690 | { |
691 | // The following is for the bug |
692 | //endviewA->GetCanvas()->Range(-1, -1, 1, 1); |
693 | |
694 | // Set the ranges of all canvases based on |
695 | // the current units (x/y or r/phi) and the zoom,pan |
696 | // settings |
697 | |
698 | if(coordinatetype==COORD_XY){ |
699 | // define range in each direction in cm |
700 | double x_width = 350.0/zoom_factor; |
701 | double y_width = x_width; |
702 | double z_width = 2.0*x_width; |
703 | double xlo = x0 - x_width/2.0; |
704 | double xhi = x0 + x_width/2.0; |
705 | double ylo = y0 - y_width/2.0; |
706 | double yhi = y0 + y_width/2.0; |
707 | double zlo = z0 - z_width/2.0; |
708 | double zhi = z0 + z_width/2.0; |
709 | |
710 | sideviewA->GetCanvas()->cd(); |
711 | sideviewA->GetCanvas()->Range(zlo, xlo, zhi, xhi); |
712 | sideviewB->GetCanvas()->cd(); |
713 | sideviewB->GetCanvas()->Range(zlo, ylo, zhi, yhi); |
714 | |
715 | // Zoom in a little on the end views |
716 | double end_to_side_ratio=1.8; |
717 | xlo/=end_to_side_ratio; |
718 | xhi/=end_to_side_ratio; |
719 | ylo/=end_to_side_ratio; |
720 | yhi/=end_to_side_ratio; |
721 | |
722 | endviewA->GetCanvas()->cd(); |
723 | endviewA->GetCanvas()->Range(xlo, ylo, xhi, yhi); |
724 | endviewB->GetCanvas()->cd(); |
725 | endviewB->GetCanvas()->Range(xlo*1.3, ylo*1.3, xhi*1.3, yhi*1.3); |
726 | endviewBmf->SetRange(xlo*1.3, ylo*1.3, xhi*1.3, yhi*1.3); |
727 | |
728 | |
729 | }else{ |
730 | // define range in each direction in cm, radians |
731 | double r_width = 400.0/zoom_factor; |
732 | double phi_width = 2.0*M_PI3.14159265358979323846/zoom_factor; |
733 | double z_width = 2.0*r_width/zoom_factor; |
734 | double rlo = r0 - r_width/2.0; |
735 | double rhi = r0 + r_width/2.0; |
736 | double philo = phi0 - phi_width/2.0; |
Value stored to 'philo' during its initialization is never read | |
737 | double phihi = phi0 + phi_width/2.0; |
738 | double zlo = z0 - z_width/2.0; |
739 | double zhi = z0 + z_width/2.0; |
740 | |
741 | philo = -0.2; |
742 | phihi = 2.0*M_PI3.14159265358979323846+0.2; |
743 | |
744 | sideviewA->GetCanvas()->cd(); |
745 | sideviewA->GetCanvas()->Range(zlo, rlo, zhi, rhi); |
746 | sideviewB->GetCanvas()->cd(); |
747 | sideviewB->GetCanvas()->Range(zlo, philo, zhi, phihi); |
748 | |
749 | // Zoom in a little on the end views in A |
750 | endviewA->GetCanvas()->cd(); |
751 | endviewA->GetCanvas()->Range(philo, rlo/2.5, phihi, rhi/2.5); |
752 | endviewB->GetCanvas()->cd(); |
753 | endviewB->GetCanvas()->Range(philo, rlo/10.0, phihi, rhi/1.9); |
754 | endviewBmf->SetRange(philo, rlo/10.0, phihi, rhi/1.9); |
755 | } |
756 | } |
757 | |
758 | //------------------- |
759 | // DoQuit |
760 | //------------------- |
761 | void hdv_mainframe::DoQuit(void) |
762 | { |
763 | SavePreferences(); |
764 | |
765 | japp->Quit(); |
766 | japp->Fini(); |
767 | delete japp; |
768 | japp = NULL__null; |
769 | |
770 | // This is supposed to return from the Run() method in "main()" |
771 | // since we call SetReturnFromRun(true), but it doesn't seem to work. |
772 | gApplication->Terminate(0); |
773 | } |
774 | |
775 | //------------------- |
776 | // DoNext |
777 | //------------------- |
778 | void hdv_mainframe::DoNext(void) |
779 | { |
780 | if(eventloop)eventloop->OneEvent(); |
781 | } |
782 | |
783 | //------------------- |
784 | // DoPrev |
785 | //------------------- |
786 | void hdv_mainframe::DoPrev(void) |
787 | { |
788 | //eventloop->GotoEvent(current_eventnumber-1); |
789 | //eventloop->OneEvent(); |
790 | } |
791 | |
792 | //------------------- |
793 | // DoStop |
794 | //------------------- |
795 | void hdv_mainframe::DoStop(void) |
796 | { |
797 | GO = 0; |
798 | } |
799 | |
800 | //------------------- |
801 | // DoCont |
802 | //------------------- |
803 | void hdv_mainframe::DoCont(void) |
804 | { |
805 | GO = 1; |
806 | } |
807 | |
808 | //------------------- |
809 | // DoTimer |
810 | //------------------- |
811 | void hdv_mainframe::DoTimer(void) |
812 | { |
813 | /// This gets called periodically (value is set in constructor) |
814 | /// It is used to automatically call DoNext() periodically |
815 | /// so long as the global GO is set to 1. |
816 | if(GetCheckButton("continuous")){ |
817 | DoNext(); |
818 | if(sleep_time != (long)timer->GetTime())timer->SetTime(sleep_time); |
819 | }else{ |
820 | if(sleep_time == 0)timer->SetTime(10); |
821 | } |
822 | } |
823 | |
824 | //------------------- |
825 | // DoOpenTrackInspector |
826 | //------------------- |
827 | void hdv_mainframe::DoOpenTrackInspector(void) |
828 | { |
829 | if(trkmf==NULL__null){ |
830 | trkmf = new trk_mainframe(this, NULL__null, 100, 100); |
831 | if(trkmf){ |
832 | next->Connect("Clicked()","trk_mainframe", trkmf, "DoNewEvent()"); |
833 | prev->Connect("Clicked()","trk_mainframe", trkmf, "DoNewEvent()"); |
834 | } |
835 | }else{ |
836 | trkmf->RaiseWindow(); |
837 | trkmf->RequestFocus(); |
838 | } |
839 | } |
840 | |
841 | //------------------- |
842 | // DoOpenOptionsWindow |
843 | //------------------- |
844 | void hdv_mainframe::DoOpenOptionsWindow(void) |
845 | { |
846 | if(optionsmf==NULL__null){ |
847 | optionsmf = new hdv_optionsframe(this, NULL__null, 100, 100); |
848 | }else{ |
849 | optionsmf->MapWindow(); |
850 | optionsmf->RaiseWindow(); |
851 | optionsmf->RequestFocus(); |
852 | } |
853 | } |
854 | //------------------- |
855 | // DoOpenDebugerWindow |
856 | //------------------- |
857 | void hdv_mainframe::DoOpenDebugerWindow(void) |
858 | { |
859 | if(debugermf==NULL__null){ |
860 | debugermf = new hdv_debugerframe(this, NULL__null, 100, 100); |
861 | }else{ |
862 | debugermf->MapWindow(); |
863 | debugermf->RaiseWindow(); |
864 | debugermf->RequestFocus(); |
865 | DoUpdateTrackLabels(); |
866 | } |
867 | } |
868 | |
869 | //------------------- |
870 | // DoOpenFullListWindow |
871 | //------------------- |
872 | void hdv_mainframe::DoOpenFullListWindow(void) |
873 | { |
874 | if(fulllistmf==NULL__null){ |
875 | fulllistmf = new hdv_fulllistframe(this, NULL__null, 100, 100); |
876 | }else{ |
877 | fulllistmf->MapWindow(); |
878 | fulllistmf->RaiseWindow(); |
879 | fulllistmf->RequestFocus(); |
880 | DoUpdateTrackLabels(); |
881 | } |
882 | } |
883 | |
884 | //------------------- |
885 | // DoOpenTOFInspector |
886 | //------------------- |
887 | void hdv_mainframe::DoOpenTOFInspector(void) |
888 | { |
889 | |
890 | } |
891 | |
892 | //------------------- |
893 | // DoOpenFCALInspector |
894 | //------------------- |
895 | void hdv_mainframe::DoOpenFCALInspector(void) |
896 | { |
897 | |
898 | } |
899 | |
900 | //------------------- |
901 | // DoOpenBCALInspector |
902 | //------------------- |
903 | void hdv_mainframe::DoOpenBCALInspector(void) |
904 | { |
905 | |
906 | } |
907 | |
908 | //------------------- |
909 | // DoClearTrackInspectorPointer |
910 | //------------------- |
911 | void hdv_mainframe::DoClearTrackInspectorPointer(void) |
912 | { |
913 | trkmf = NULL__null; |
914 | } |
915 | |
916 | //------------------- |
917 | // DoClearOptionsWindowPointer |
918 | //------------------- |
919 | void hdv_mainframe::DoClearOptionsWindowPointer(void) |
920 | { |
921 | optionsmf = NULL__null; |
922 | } |
923 | |
924 | //------------------- |
925 | // DoClearTOFInspectorPointer |
926 | //------------------- |
927 | void hdv_mainframe::DoClearTOFInspectorPointer(void) |
928 | { |
929 | |
930 | } |
931 | |
932 | //------------------- |
933 | // DoClearFCALInspectorPointer |
934 | //------------------- |
935 | void hdv_mainframe::DoClearFCALInspectorPointer(void) |
936 | { |
937 | |
938 | } |
939 | |
940 | //------------------- |
941 | // DoClearBCALInspectorPointer |
942 | //------------------- |
943 | void hdv_mainframe::DoClearBCALInspectorPointer(void) |
944 | { |
945 | |
946 | } |
947 | |
948 | //------------------- |
949 | // DoEndViewBEvent |
950 | //------------------- |
951 | void hdv_mainframe::DoEndViewBEvent(TVirtualPad* pad, TObject* obj, Int_t event) |
952 | { |
953 | // event is the mouse button pushed (1=left, 2=center, 3=right) |
954 | // It seems we can't detect double clicks here. |
955 | if(endviewBmf==NULL__null){ |
956 | endviewBmf = new hdv_endviewBframe(this, NULL__null, 100, 100); |
957 | }else{ |
958 | endviewBmf->MapWindow(); |
959 | endviewBmf->RaiseWindow(); |
960 | endviewBmf->RequestFocus(); |
961 | DoMyRedraw(); |
962 | } |
963 | } |
964 | |
965 | //------------------- |
966 | // DoPanXpos |
967 | //------------------- |
968 | void hdv_mainframe::DoPanXpos(void) |
969 | { |
970 | x0 += 50/zoom_factor; |
971 | SetRange(); |
972 | DoMyRedraw(); |
973 | } |
974 | |
975 | //------------------- |
976 | // DoPanXneg |
977 | //------------------- |
978 | void hdv_mainframe::DoPanXneg(void) |
979 | { |
980 | x0 -= 50/zoom_factor; |
981 | SetRange(); |
982 | DoMyRedraw(); |
983 | } |
984 | |
985 | //------------------- |
986 | // DoPanYpos |
987 | //------------------- |
988 | void hdv_mainframe::DoPanYpos(void) |
989 | { |
990 | y0 += 50/zoom_factor; |
991 | SetRange(); |
992 | DoMyRedraw(); |
993 | } |
994 | |
995 | //------------------- |
996 | // DoPanYneg |
997 | //------------------- |
998 | void hdv_mainframe::DoPanYneg(void) |
999 | { |
1000 | y0 -= 50/zoom_factor; |
1001 | SetRange(); |
1002 | DoMyRedraw(); |
1003 | } |
1004 | |
1005 | //------------------- |
1006 | // DoPanZpos |
1007 | //------------------- |
1008 | void hdv_mainframe::DoPanZpos(void) |
1009 | { |
1010 | z0 += 50/zoom_factor; |
1011 | SetRange(); |
1012 | DoMyRedraw(); |
1013 | } |
1014 | |
1015 | //------------------- |
1016 | // DoPanZneg |
1017 | //------------------- |
1018 | void hdv_mainframe::DoPanZneg(void) |
1019 | { |
1020 | z0 -= 50/zoom_factor; |
1021 | SetRange(); |
1022 | DoMyRedraw(); |
1023 | } |
1024 | |
1025 | //------------------- |
1026 | // DoZoomIn |
1027 | //------------------- |
1028 | void hdv_mainframe::DoZoomIn(void) |
1029 | { |
1030 | zoom_factor*=1.25; |
1031 | SetRange(); |
1032 | DoMyRedraw(); |
1033 | //if(gMYPROC)gMYPROC->evnt(eventloop, current_eventnumber); |
1034 | } |
1035 | |
1036 | //------------------- |
1037 | // DoZoomOut |
1038 | //------------------- |
1039 | void hdv_mainframe::DoZoomOut(void) |
1040 | { |
1041 | zoom_factor/=1.25; |
1042 | SetRange(); |
1043 | DoMyRedraw(); |
1044 | //if(gMYPROC)gMYPROC->evnt(eventloop, current_eventnumber); |
1045 | } |
1046 | |
1047 | //------------------- |
1048 | // DoReset |
1049 | //------------------- |
1050 | void hdv_mainframe::DoReset(void) |
1051 | { |
1052 | x0 = 0.0; |
1053 | y0 = 0.0; |
1054 | z0 = 350.0; |
1055 | zoom_factor = 1.0; |
1056 | DoMyRedraw(); |
1057 | } |
1058 | |
1059 | |
1060 | //------------------- |
1061 | // DoMyRedraw |
1062 | //------------------- |
1063 | void hdv_mainframe::DoMyRedraw(void) |
1064 | { |
1065 | // Make sure canvases have proper ranges |
1066 | SetRange(); |
1067 | |
1068 | // Delete any existing graphics objects |
1069 | for(unsigned int i=0; i<graphics_sideA.size(); i++)delete graphics_sideA[i]; |
1070 | for(unsigned int i=0; i<graphics_sideB.size(); i++)delete graphics_sideB[i]; |
1071 | for(unsigned int i=0; i<graphics_endA.size(); i++)delete graphics_endA[i]; |
1072 | for(unsigned int i=0; i<graphics_endB.size(); i++)delete graphics_endB[i]; |
1073 | graphics_sideA.clear(); |
1074 | graphics_sideB.clear(); |
1075 | graphics_endA.clear(); |
1076 | graphics_endB.clear(); |
1077 | |
1078 | |
1079 | // Draw detectors depending on coordinate system we're using |
1080 | if(coordinatetype == COORD_XY){ |
1081 | DrawDetectorsXY(); // Draw Detectors |
1082 | }else{ |
1083 | DrawDetectorsRPhi(); // Draw Detectors |
1084 | } |
1085 | |
1086 | // Collect all hits for display |
1087 | gMYPROC->FillGraphics(); |
1088 | |
1089 | // put collected hits into appropriate views |
1090 | AddGraphicsSideA(gMYPROC->graphics_xz); |
1091 | AddGraphicsSideB(gMYPROC->graphics_yz); |
1092 | |
1093 | // Draw detector hits and tracks for the correct coordinates in all views |
1094 | vector<MyProcessor::DGraphicSet>::iterator iter = gMYPROC->graphics.begin(); |
1095 | for(; iter!=gMYPROC->graphics.end(); iter++){ |
1096 | |
1097 | if(iter->type==MyProcessor::kMarker){ |
1098 | // Markers |
1099 | TPolyMarker *sA = new TPolyMarker(); |
1100 | TPolyMarker *sB = new TPolyMarker(); |
1101 | TPolyMarker *eA = new TPolyMarker(); |
1102 | sA->SetMarkerColor(iter->color); |
1103 | sB->SetMarkerColor(iter->color); |
1104 | eA->SetMarkerColor(iter->color); |
1105 | sA->SetMarkerSize(iter->size); |
1106 | sB->SetMarkerSize(iter->size); |
1107 | eA->SetMarkerSize(iter->size); |
1108 | sA->SetMarkerStyle(iter->marker_style); |
1109 | sB->SetMarkerStyle(iter->marker_style); |
1110 | eA->SetMarkerStyle(iter->marker_style); |
1111 | FillPoly(sA, sB, eA, iter->points); // in hdv_mainframe.h |
1112 | }else{ |
1113 | // Lines |
1114 | TPolyLine *sA = new TPolyLine(); |
1115 | TPolyLine *sB = new TPolyLine(); |
1116 | TPolyLine *eA = new TPolyLine(); |
1117 | sA->SetLineColor(iter->color); |
1118 | sB->SetLineColor(iter->color); |
1119 | eA->SetLineColor(iter->color); |
1120 | sA->SetLineWidth((Width_t)iter->size); |
1121 | sB->SetLineWidth((Width_t)iter->size); |
1122 | eA->SetLineWidth((Width_t)iter->size); |
1123 | FillPoly(sA, sB, eA, iter->points); // in hdv_mainframe.h |
1124 | |
1125 | // Axial CDC wires will end up as having zero length in the end view |
1126 | // so we draw an additional marker in the end view for those cases. |
1127 | if(eA->GetN()==2){ |
1128 | double *x = eA->GetX(); |
1129 | double *y = eA->GetY(); |
1130 | if((x[0]==x[1]) && (y[0]==y[1])){ |
1131 | TMarker *m = new TMarker(x[0], y[0], 8); |
1132 | m->SetMarkerColor(iter->color); |
1133 | m->SetMarkerSize(0.5); |
1134 | graphics_endA.push_back(m); |
1135 | } |
1136 | } |
1137 | } |
1138 | } |
1139 | |
1140 | // Add in additional view-specific objects |
1141 | if(coordinatetype == COORD_XY){ |
1142 | for(unsigned int i=0; i<gMYPROC->graphics_xyA.size(); i++){ |
1143 | graphics_endA.push_back(gMYPROC->graphics_xyA[i]); |
1144 | } |
1145 | for(unsigned int i=0; i<gMYPROC->graphics_xyB.size(); i++){ |
1146 | graphics_endB.push_back(gMYPROC->graphics_xyB[i]); |
1147 | } |
1148 | } |
1149 | |
1150 | // Draw everything |
1151 | endviewA->GetCanvas()->cd(0); |
1152 | for(unsigned int i=0; i<graphics_endA.size(); i++){ |
1153 | TPolyLine *l = dynamic_cast<TPolyLine*>(graphics_endA[i]); |
1154 | if(l && l->GetFillStyle()!=1001){ |
1155 | graphics_endA[i]->Draw("f"); |
1156 | }else{ |
1157 | graphics_endA[i]->Draw(""); |
1158 | } |
1159 | } |
1160 | endviewA->GetCanvas()->Update(); |
1161 | endviewB->GetCanvas()->cd(0); |
1162 | for(unsigned int i=0; i<graphics_endB.size(); i++)graphics_endB[i]->Draw("f"); |
1163 | for(unsigned int i=0; i<graphics_endB.size(); i++)graphics_endB[i]->Draw(); |
1164 | endviewB->GetCanvas()->Update(); |
1165 | endviewBmf->DrawObjects(graphics_endB); // duplicate drawing of objects in big window |
1166 | |
1167 | sideviewA->GetCanvas()->cd(0); |
1168 | for(unsigned int i=0; i<graphics_sideA.size(); i++)graphics_sideA[i]->Draw(); |
1169 | sideviewA->GetCanvas()->Update(); |
1170 | sideviewB->GetCanvas()->cd(0); |
1171 | for(unsigned int i=0; i<graphics_sideB.size(); i++)graphics_sideB[i]->Draw(); |
1172 | sideviewB->GetCanvas()->Update(); |
1173 | |
1174 | // Update track labels |
1175 | DoUpdateTrackLabels(); |
1176 | } |
1177 | |
1178 | //------------------- |
1179 | // DoSetDelay |
1180 | //------------------- |
1181 | void hdv_mainframe::DoSetDelay(Int_t id) |
1182 | { |
1183 | stringstream ss; |
1184 | ss<<delay->GetSelectedEntry()->GetTitle(); |
1185 | double seconds; |
1186 | ss>>seconds; |
1187 | sleep_time = (int)(1000.0*seconds); |
1188 | timer->SetTime(sleep_time); |
1189 | } |
1190 | |
1191 | //------------------- |
1192 | // DoSetCoordinates |
1193 | //------------------- |
1194 | void hdv_mainframe::DoSetCoordinates(Int_t id) |
1195 | { |
1196 | coordinatetype = (coordsys_t)id; |
1197 | } |
1198 | |
1199 | //------------------- |
1200 | // DoUpdateTrackLabels |
1201 | //------------------- |
1202 | void hdv_mainframe::DoUpdateTrackLabels(void) |
1203 | { |
1204 | gMYPROC->UpdateTrackLabels(); |
1205 | |
1206 | throwninfo->Resize(); |
1207 | reconinfo->Resize(); |
1208 | } |
1209 | |
1210 | //------------------- |
1211 | // DrawDetectorsXY |
1212 | //------------------- |
1213 | void hdv_mainframe::DrawDetectorsXY(void) |
1214 | { |
1215 | //============== Side A |
1216 | { |
1217 | sideviewA->GetCanvas()->cd(0); |
1218 | sideviewA->GetCanvas()->Clear(); |
1219 | |
1220 | |
1221 | |
1222 | // ------ Target ------ |
1223 | TBox *target = new TBox(TARGET_Zmid-TARGET_Zlen/2.0, -0.5, TARGET_Zmid+TARGET_Zlen/2.0, +0.5); |
1224 | target->SetFillColor(13); |
1225 | graphics_sideA.push_back(target); |
1226 | |
1227 | // ----- BCAL ------ |
1228 | TBox *bcal1 = new TBox(BCAL_Zmin, BCAL_Rmin, BCAL_Zmin+BCAL_Zlen, BCAL_Rmax); |
1229 | TBox *bcal2 = new TBox(BCAL_Zmin, -BCAL_Rmin, BCAL_Zmin+BCAL_Zlen, -BCAL_Rmax); |
1230 | bcal1->SetFillColor(28); |
1231 | bcal2->SetFillColor(28); |
1232 | graphics_sideA.push_back(bcal1); |
1233 | graphics_sideA.push_back(bcal2); |
1234 | |
1235 | // ----- CDC ------ |
1236 | TBox *cdc1 = new TBox(CDC_Zmin, CDC_Rmin, CDC_Zmin + CDC_Zlen, CDC_Rmax); |
1237 | TBox *cdc2 = new TBox(CDC_Zmin, -CDC_Rmin, CDC_Zmin + CDC_Zlen, -CDC_Rmax); |
1238 | cdc1->SetFillColor(17); |
1239 | cdc2->SetFillColor(17); |
1240 | graphics_sideA.push_back(cdc1); |
1241 | graphics_sideA.push_back(cdc2); |
1242 | |
1243 | // ----- FDC ------ |
1244 | for(int i=0; i<4; i++){ |
1245 | // Get FDC package positions from FDC library |
1246 | float zu = fdcwires[i*6][0]->origin.z(); |
1247 | float zd = fdcwires[i*6+5][0]->origin.z(); |
1248 | TBox *fdc1 = new TBox(zu, FDC_Rmin, zd, FDC_Rmax); |
1249 | TBox *fdc2 = new TBox(zu, -FDC_Rmin, zd, -FDC_Rmax); |
1250 | fdc1->SetFillColor(21); |
1251 | fdc2->SetFillColor(21); |
1252 | graphics_sideA.push_back(fdc1); |
1253 | graphics_sideA.push_back(fdc2); |
1254 | } |
1255 | |
1256 | // ----- TOF ------ |
1257 | TBox *tof1 = new TBox(TOF_Zmin, TOF_Rmin, TOF_Zmin+TOF_Zlen, TOF_Rmax); |
1258 | TBox *tof2 = new TBox(TOF_Zmin, -TOF_Rmin, TOF_Zmin+TOF_Zlen, -TOF_Rmax); |
1259 | tof1->SetFillColor(11); |
1260 | tof2->SetFillColor(11); |
1261 | graphics_sideA.push_back(tof1); |
1262 | graphics_sideA.push_back(tof2); |
1263 | |
1264 | // ----- FCAL ------ |
1265 | TBox *fcal1 = new TBox(FCAL_Zmin, FCAL_Rmin, FCAL_Zmin+FCAL_Zlen, FCAL_Rmax); |
1266 | TBox *fcal2 = new TBox(FCAL_Zmin, -FCAL_Rmin, FCAL_Zmin+FCAL_Zlen, -FCAL_Rmax); |
1267 | fcal1->SetFillColor(40); |
1268 | fcal2->SetFillColor(40); |
1269 | graphics_sideA.push_back(fcal1); |
1270 | graphics_sideA.push_back(fcal2); |
1271 | |
1272 | // ------ scale ------ |
1273 | DrawScale(sideviewA->GetCanvas(), graphics_sideA); |
1274 | } |
1275 | |
1276 | //============== Side B |
1277 | { |
1278 | sideviewB->GetCanvas()->cd(0); |
1279 | sideviewB->GetCanvas()->Clear(); |
1280 | |
1281 | // Side B is exactly the same as side A so just copy it |
1282 | for(unsigned int i=0; i<graphics_sideA.size(); i++){ |
1283 | graphics_sideB.push_back(graphics_sideA[i]->Clone()); |
1284 | } |
1285 | } |
1286 | |
1287 | //============== End A |
1288 | { |
1289 | endviewB->GetCanvas()->cd(0); |
1290 | endviewB->GetCanvas()->Clear(); |
1291 | |
1292 | // ----- BCAL ------ |
1293 | TEllipse *bcal1 = new TEllipse(0.0, 0.0, BCAL_Rmax, BCAL_Rmax); |
1294 | TEllipse *bcal2 = new TEllipse(0.0, 0.0, BCAL_Rmin, BCAL_Rmin); |
1295 | bcal1->SetFillColor(0); |
1296 | bcal2->SetFillColor(0); |
1297 | graphics_endA.push_back(bcal1); |
1298 | graphics_endA.push_back(bcal2); |
1299 | |
1300 | double dlayer1 = 0.5*(BCAL_MIDRAD-BCAL_Rmin)/(double)BCAL_LAYS1; |
1301 | //double dlayer2 = (BCAL_Rmax-BCAL_MIDRAD)/(double)BCAL_LAYS2; |
1302 | double dmodule = (double)TMath::TwoPi()/(double)BCAL_MODS; |
1303 | double dsector1 = dmodule/(double)BCAL_SECS1; |
1304 | double dsector2 = dmodule/(double)BCAL_SECS2; |
1305 | |
1306 | // Create polygon for each readout segment for use in coloring hits |
1307 | if(GetCheckButton("bcal")){ |
1308 | for(int imod=0; imod<BCAL_MODS; imod++){ |
1309 | double mod_phi = (double)imod*dmodule; |
1310 | double r_min=BCAL_Rmin; |
1311 | for(int ilay=0; ilay<BCAL_LAYS1; ilay++){ |
1312 | r_min+=dlayer1*ilay; |
1313 | double r_max = r_min+(ilay+1)*dlayer1; |
1314 | for(int isec=0; isec<BCAL_SECS1; isec++){ |
1315 | double phimin = mod_phi + (double)isec*dsector1; |
1316 | double phimax = phimin + dsector1; |
1317 | |
1318 | double x[4], y[4]; |
1319 | x[0] = r_min*cos(phimin); |
1320 | y[0] = r_min*sin(phimin); |
1321 | x[1] = r_max*cos(phimin); |
1322 | y[1] = r_max*sin(phimin); |
1323 | x[2] = r_max*cos(phimax); |
1324 | y[2] = r_max*sin(phimax); |
1325 | x[3] = r_min*cos(phimax); |
1326 | y[3] = r_min*sin(phimax); |
1327 | |
1328 | TPolyLine *poly = new TPolyLine(4, x, y); |
1329 | poly->SetLineColor(12); |
1330 | poly->SetLineWidth(1); |
1331 | poly->SetFillColor(0); |
1332 | poly->SetFillStyle(0); |
1333 | int chan = (imod+1)*1000 + (ilay+1)*100 + (isec+1)*10; |
1334 | graphics_endA.push_back(poly); |
1335 | bcalblocks[chan] = poly; // record so we can set the color later |
1336 | } |
1337 | |
1338 | for(int isec=0; isec<BCAL_SECS2; isec++){ |
1339 | double phimin = mod_phi + (double)isec*dsector2; |
1340 | double phimax = phimin + dsector2; |
1341 | |
1342 | double x[5], y[5]; |
1343 | x[0] = BCAL_MIDRAD*cos(phimin); |
1344 | y[0] = BCAL_MIDRAD*sin(phimin); |
1345 | x[1] = BCAL_Rmax*cos(phimin); |
1346 | y[1] = BCAL_Rmax*sin(phimin); |
1347 | x[2] = BCAL_Rmax*cos(phimax); |
1348 | y[2] = BCAL_Rmax*sin(phimax); |
1349 | x[3] = BCAL_MIDRAD*cos(phimax); |
1350 | y[3] = BCAL_MIDRAD*sin(phimax); |
1351 | x[4] = x[0]; |
1352 | y[4] = y[0]; |
1353 | TPolyLine *poly = new TPolyLine(5, x, y); |
1354 | poly->SetLineColor(12); |
1355 | poly->SetLineWidth(1); |
1356 | poly->SetFillColor(0); |
1357 | poly->SetFillStyle(0); |
1358 | int chan = (int)((imod+1)*1000 + (ilay+1+BCAL_LAYS1)*100 + (isec+1)*10); |
1359 | graphics_endA.push_back(poly); |
1360 | bcalblocks[chan] = poly; // record so we can set the color later |
1361 | } |
1362 | } |
1363 | } |
1364 | } |
1365 | // Draw lines to identify boundaries of readout segments |
1366 | for(int imod=0; imod<BCAL_MODS; imod++){ |
1367 | // Vertical(sector) boundaries |
1368 | double mod_phi = (double)imod*dmodule; |
1369 | for(int isec=0; isec<BCAL_SECS1; isec++){ |
1370 | double rmin = BCAL_Rmin; |
1371 | double rmax = BCAL_MIDRAD; |
1372 | double phi = mod_phi + (double)isec*dsector1; |
1373 | |
1374 | TLine *l = new TLine(rmin*cos(phi), rmin*sin(phi), rmax*cos(phi), rmax*sin(phi)); |
1375 | l->SetLineColor(isec==0 ? kBlack:12); |
1376 | l->SetLineWidth((Width_t)(isec==0 ? 1.5:1.0)); |
1377 | graphics_endA.push_back(l); |
1378 | } |
1379 | for(int isec=0; isec<BCAL_SECS2; isec++){ |
1380 | double rmin = BCAL_MIDRAD; |
1381 | double rmax = BCAL_Rmax; |
1382 | double phi = mod_phi + (double)isec*dsector2; |
1383 | |
1384 | TLine *l = new TLine(rmin*cos(phi), rmin*sin(phi), rmax*cos(phi), rmax*sin(phi)); |
1385 | l->SetLineColor(isec==0 ? kBlack:12); |
1386 | l->SetLineWidth((Width_t)(isec==0 ? 1.5:1.0)); |
1387 | graphics_endA.push_back(l); |
1388 | } |
1389 | |
1390 | // Horizontal(layer) boundaries |
1391 | double r=BCAL_Rmin; |
1392 | for(int ilay=0; ilay<BCAL_LAYS1; ilay++){ |
1393 | r+=dlayer1*ilay; |
1394 | TLine *l = new TLine(r*cos(mod_phi), r*sin(mod_phi), r*cos(mod_phi+dmodule), r*sin(mod_phi+dmodule)); |
1395 | l->SetLineColor(ilay==0 ? kBlack:12); |
1396 | l->SetLineWidth((Width_t)(ilay==0 ? 1.0:1.0)); |
1397 | graphics_endA.push_back(l); |
1398 | } |
1399 | |
1400 | TLine *l = new TLine(BCAL_MIDRAD*cos(mod_phi), BCAL_MIDRAD*sin(mod_phi), BCAL_MIDRAD*cos(mod_phi+dmodule), BCAL_MIDRAD*sin(mod_phi+dmodule)); |
1401 | l->SetLineColor(12); |
1402 | l->SetLineWidth((Width_t)(1.0)); |
1403 | graphics_endA.push_back(l); |
1404 | } |
1405 | |
1406 | // ----- CDC ------ |
1407 | TEllipse *cdc1 = new TEllipse(0.0, 0.0, CDC_Rmax, CDC_Rmax); |
1408 | TEllipse *cdc2 = new TEllipse(0.0, 0.0, CDC_Rmin, CDC_Rmin); |
1409 | cdc1->SetFillColor(17); |
1410 | cdc1->SetLineColor(17); |
1411 | cdc2->SetFillColor(10); |
1412 | graphics_endA.push_back(cdc1); |
1413 | graphics_endA.push_back(cdc2); |
1414 | |
1415 | // ----- FDC ------ |
1416 | TEllipse *fdc1 = new TEllipse(0.0, 0.0, FDC_Rmax, FDC_Rmax); |
1417 | TEllipse *fdc2 = new TEllipse(0.0, 0.0, FDC_Rmin, FDC_Rmin); |
1418 | fdc1->SetFillColor(21); |
1419 | fdc1->SetLineColor(21); |
1420 | fdc2->SetFillColor(10); |
1421 | fdc2->SetLineColor(10); |
1422 | graphics_endA.push_back(fdc1); |
1423 | graphics_endA.push_back(fdc2); |
1424 | |
1425 | // ----- TARGET ------ |
1426 | TEllipse *target = new TEllipse(0.0, 0.0, 0.5, 0.5); |
1427 | target->SetFillColor(13); |
1428 | graphics_endA.push_back(target); |
1429 | |
1430 | // ------ scale ------ |
1431 | DrawScale(endviewA->GetCanvas(), graphics_endA); |
1432 | } |
1433 | |
1434 | //============== End B |
1435 | { |
1436 | endviewB->GetCanvas()->cd(0); |
1437 | endviewB->GetCanvas()->Clear(); |
1438 | |
1439 | // ----- FCAL ------ |
1440 | // Get list of blocks. Loop over all getting x,y coordinates of corners for all active ones. |
1441 | |
1442 | // Set up 4 2-D vectors that point from the center of a block to its |
1443 | // corners. This makes it easier to represent each corner as a vector |
1444 | // in lab corrdinate whch we can extract r, phi from. |
1445 | double blocksize = fcalgeom->blockSize(); |
1446 | DVector2 shift[4]; |
1447 | shift[0].Set(-blocksize/2, -blocksize/2); // these are ordered such that they |
1448 | shift[1].Set(-blocksize/2, +blocksize/2); // go in a clockwise manner. This |
1449 | shift[2].Set(+blocksize/2, +blocksize/2); // ensures the r/phi cooridinates also |
1450 | shift[3].Set(+blocksize/2, -blocksize/2); // define a single enclosed space |
1451 | fcalblocks.clear(); |
1452 | |
1453 | if(GetCheckButton("fcal")){ |
1454 | for(int chan=0; chan<kMaxChannels59 * 59; chan++){ |
1455 | int row = fcalgeom->row(chan); |
1456 | int col = fcalgeom->column(chan); |
1457 | if(!fcalgeom->isBlockActive(row, col))continue; |
1458 | double x[4], y[4]; |
1459 | for(int i=0; i<4; i++){ |
1460 | DVector2 pos = shift[i] + fcalgeom->positionOnFace(chan); |
1461 | x[i] = pos.X(); |
1462 | y[i] = pos.Y(); |
1463 | } |
1464 | |
1465 | TPolyLine *poly = new TPolyLine(4, x, y); |
1466 | poly->SetFillColor(0); |
1467 | poly->SetLineColor(kBlack); |
1468 | graphics_endB.push_back(poly); |
1469 | |
1470 | fcalblocks[chan] = poly; // record so we can set the color later |
1471 | } |
1472 | } |
1473 | |
1474 | // ------ scale ------ |
1475 | DrawScale(endviewB->GetCanvas(), graphics_endB); |
1476 | } |
1477 | |
1478 | //=============== Draw axes arrows |
1479 | // (this is done here since the sideB graphics are copied from sideA) |
1480 | DrawAxes(sideviewA->GetCanvas(), graphics_sideA, "Z", "X"); |
1481 | DrawAxes(sideviewB->GetCanvas(), graphics_sideB, "Z", "Y"); |
1482 | DrawAxes(endviewA->GetCanvas(), graphics_endA, "X", "Y"); |
1483 | DrawAxes(endviewB->GetCanvas(), graphics_endB, "X", "Y"); |
1484 | } |
1485 | |
1486 | //------------------- |
1487 | // DrawDetectorsRPhi |
1488 | //------------------- |
1489 | void hdv_mainframe::DrawDetectorsRPhi(void) |
1490 | { |
1491 | //============== Side A R vs. z |
1492 | { |
1493 | sideviewA->GetCanvas()->cd(0); |
1494 | sideviewA->GetCanvas()->Clear(); |
1495 | |
1496 | // ------ Target ------ |
1497 | TBox *target = new TBox(TARGET_Zmid-TARGET_Zlen/2.0, 0.0, TARGET_Zmid+TARGET_Zlen/2.0, 0.5); |
1498 | target->SetFillColor(13); |
1499 | graphics_sideA.push_back(target); |
1500 | |
1501 | // ----- BCAL ------ |
1502 | TBox *bcal1 = new TBox(BCAL_Zmin, BCAL_Rmin, BCAL_Zmin+BCAL_Zlen, BCAL_Rmax); |
1503 | bcal1->SetFillColor(28); |
1504 | graphics_sideA.push_back(bcal1); |
1505 | |
1506 | // ----- CDC ------ |
1507 | TBox *cdc1 = new TBox(CDC_Zmin, CDC_Rmin, CDC_Zmin + CDC_Zlen, CDC_Rmax); |
1508 | cdc1->SetFillColor(17); |
1509 | graphics_sideA.push_back(cdc1); |
1510 | |
1511 | // ----- FDC ------ |
1512 | for(int i=0; i<4; i++){ |
1513 | // Get FDC package positions from FDC library |
1514 | float zu = fdcwires[i*6][0]->origin.z(); |
1515 | float zd = fdcwires[i*6+5][0]->origin.z(); |
1516 | TBox *fdc1 = new TBox(zu, FDC_Rmin, zd, FDC_Rmax); |
1517 | fdc1->SetFillColor(21); |
1518 | graphics_sideA.push_back(fdc1); |
1519 | } |
1520 | |
1521 | // ----- TOF ------ |
1522 | TBox *tof1 = new TBox(TOF_Zmin, TOF_Rmin, TOF_Zmin+TOF_Zlen, TOF_Rmax); |
1523 | tof1->SetFillColor(11); |
1524 | graphics_sideA.push_back(tof1); |
1525 | |
1526 | // ----- FCAL ------ |
1527 | TBox *fcal1 = new TBox(FCAL_Zmin, FCAL_Rmin, FCAL_Zmin+FCAL_Zlen, FCAL_Rmax); |
1528 | fcal1->SetFillColor(40); |
1529 | graphics_sideA.push_back(fcal1); |
1530 | |
1531 | // ------ scale ------ |
1532 | DrawScale(endviewA->GetCanvas(), graphics_endA); |
1533 | } |
1534 | |
1535 | //============== Side B Phi vs. z |
1536 | { |
1537 | sideviewB->GetCanvas()->cd(0); |
1538 | sideviewB->GetCanvas()->Clear(); |
1539 | |
1540 | // ------ Target ------ |
1541 | TBox *target = new TBox(TARGET_Zmid-TARGET_Zlen/2.0, 0.0, TARGET_Zmid+TARGET_Zlen/2.0, 2.0*M_PI3.14159265358979323846); |
1542 | target->SetFillColor(13); |
1543 | graphics_sideB.push_back(target); |
1544 | |
1545 | // ----- BCAL ------ |
1546 | TBox *bcal1 = new TBox(BCAL_Zmin, 0.0, BCAL_Zmin+BCAL_Zlen, 2.0*M_PI3.14159265358979323846); |
1547 | bcal1->SetFillColor(28); |
1548 | graphics_sideB.push_back(bcal1); |
1549 | |
1550 | // ----- CDC ------ |
1551 | TBox *cdc1 = new TBox(CDC_Zmin, 0.0, CDC_Zmin + CDC_Zlen, 2.0*M_PI3.14159265358979323846); |
1552 | cdc1->SetFillColor(17); |
1553 | graphics_sideB.push_back(cdc1); |
1554 | |
1555 | // ----- FDC ------ |
1556 | for(int i=0; i<4; i++){ |
1557 | // Get FDC package positions from FDC library |
1558 | float zu = fdcwires[i*6][0]->origin.z(); |
1559 | float zd = fdcwires[i*6+5][0]->origin.z(); |
1560 | |
1561 | TBox *fdc1 = new TBox(zu, 0.0, zd, 2.0*M_PI3.14159265358979323846); |
1562 | fdc1->SetFillColor(21); |
1563 | graphics_sideB.push_back(fdc1); |
1564 | } |
1565 | |
1566 | // ----- TOF ------ |
1567 | TBox *tof1 = new TBox(TOF_Zmin, 0.0, TOF_Zmin+TOF_Zlen, 2.0*M_PI3.14159265358979323846); |
1568 | tof1->SetFillColor(11); |
1569 | graphics_sideB.push_back(tof1); |
1570 | |
1571 | // ----- FCAL ------ |
1572 | TBox *fcal1 = new TBox(FCAL_Zmin, 0.0, FCAL_Zmin+FCAL_Zlen, 2.0*M_PI3.14159265358979323846); |
1573 | fcal1->SetFillColor(40); |
1574 | graphics_sideB.push_back(fcal1); |
1575 | |
1576 | // ------ scale ------ |
1577 | DrawScale(endviewA->GetCanvas(), graphics_endA); |
1578 | } |
1579 | |
1580 | //============== End A R vs. phi |
1581 | { |
1582 | endviewA->GetCanvas()->cd(0); |
1583 | endviewA->GetCanvas()->Clear(); |
1584 | |
1585 | // ----- BCAL ------ |
1586 | TBox *bcal1 = new TBox(0.0, BCAL_Rmin, 2.0*M_PI3.14159265358979323846, BCAL_Rmax); |
1587 | bcal1->SetFillColor(28); |
1588 | graphics_endA.push_back(bcal1); |
1589 | |
1590 | // ----- CDC ------ |
1591 | TBox *cdc1 = new TBox(0.0, CDC_Rmin, 2.0*M_PI3.14159265358979323846, CDC_Rmax); |
1592 | cdc1->SetFillColor(17); |
1593 | graphics_endA.push_back(cdc1); |
1594 | |
1595 | // ----- FDC ------ |
1596 | TBox *fdc1 = new TBox(0.0, FDC_Rmin, 2.0*M_PI3.14159265358979323846, FDC_Rmax); |
1597 | fdc1->SetFillColor(21); |
1598 | graphics_endA.push_back(fdc1); |
1599 | |
1600 | // ----- TARGET ------ |
1601 | TBox *target = new TBox(0.0, 0.0, 2.0*M_PI3.14159265358979323846, 0.5); |
1602 | target->SetFillColor(13); |
1603 | graphics_endA.push_back(target); |
1604 | |
1605 | } |
1606 | |
1607 | //============== End B R vs. phi |
1608 | { |
1609 | endviewB->GetCanvas()->cd(0); |
1610 | endviewB->GetCanvas()->Clear(); |
1611 | |
1612 | // ----- FCAL ------ |
1613 | // Get list of blocks. Loop over all getting x,y coordinates of corners for all active ones. |
1614 | |
1615 | // Set up 4 2-D vectors that point from the center of a block to its |
1616 | // corners. This makes it easier to represent each corner as a vector |
1617 | // in lab corrdinate whch we can extract r, phi from. |
1618 | double blocksize = fcalgeom->blockSize(); |
1619 | DVector2 shift[4]; |
1620 | shift[0].Set(-blocksize/2, -blocksize/2); // these are ordered such that they |
1621 | shift[1].Set(-blocksize/2, +blocksize/2); // go in a clockwise manner. This |
1622 | shift[2].Set(+blocksize/2, +blocksize/2); // ensures the r/phi cooridinates also |
1623 | shift[3].Set(+blocksize/2, -blocksize/2); // define a single enclosed space |
1624 | fcalblocks.clear(); |
1625 | for(int chan=0; chan<kMaxChannels59 * 59; chan++){ |
1626 | int row = fcalgeom->row(chan); |
1627 | int col = fcalgeom->column(chan); |
1628 | if(!fcalgeom->isBlockActive(row, col))continue; |
1629 | double r[4], phi[4]; |
1630 | for(int i=0; i<4; i++){ |
1631 | DVector2 pos = shift[i] + fcalgeom->positionOnFace(chan); |
1632 | r[i] = pos.Mod(); |
1633 | phi[i] = pos.Phi_0_2pi(pos.Phi()); |
1634 | } |
1635 | |
1636 | TPolyLine *poly = new TPolyLine(4, phi, r); |
1637 | poly->SetFillColor(18); |
1638 | poly->SetLineColor(kBlack); |
1639 | graphics_endB.push_back(poly); |
1640 | |
1641 | fcalblocks[chan] = poly; // record so we can set the color later |
1642 | } |
1643 | } |
1644 | |
1645 | //=============== Draw axes arrows |
1646 | DrawAxes(sideviewA->GetCanvas(), graphics_sideA, "Z", "R"); |
1647 | DrawAxes(sideviewB->GetCanvas(), graphics_sideB, "Z", "#phi"); |
1648 | DrawAxes(endviewA->GetCanvas(), graphics_endA, "#phi", "R"); |
1649 | DrawAxes(endviewB->GetCanvas(), graphics_endB, "#phi", "R"); |
1650 | } |
1651 | |
1652 | //------------------- |
1653 | // DrawAxes |
1654 | //------------------- |
1655 | void hdv_mainframe::DrawAxes(TCanvas *c, vector<TObject*> &graphics, const char *xlab, const char *ylab) |
1656 | { |
1657 | /// Create arrows indicating x and y axes with labels on the specified canvas |
1658 | /// and add them to the specified container of graphics objects to be draw later. |
1659 | double x1 = c->GetX1(); |
1660 | double x2 = c->GetX2(); |
1661 | double y1 = c->GetY1(); |
1662 | double y2 = c->GetY2(); |
1663 | double deltax = x2-x1; |
1664 | deltax *= c->GetYsizeReal()/c->GetXsizeReal(); |
1665 | double deltay = y2-y1; |
1666 | double xlo = x1+0.04*deltax; |
1667 | double xhi = xlo + 0.075*deltax; |
1668 | double ylo = y1+0.04*deltay; |
1669 | double yhi = ylo + 0.075*deltay; |
1670 | TArrow *yarrow = new TArrow(xlo, ylo, xlo, yhi, 0.02, ">"); |
1671 | yarrow->SetLineWidth((Width_t)1.5); |
1672 | graphics.push_back(yarrow); |
1673 | |
1674 | TLatex *ylabel = new TLatex(xlo, yhi+0.005*deltay, ylab); |
1675 | ylabel->SetTextAlign(21); |
1676 | graphics.push_back(ylabel); |
1677 | |
1678 | TArrow *xarrow = new TArrow(xlo, ylo, xhi, ylo, 0.02, ">"); |
1679 | xarrow->SetLineWidth((Width_t)1.5); |
1680 | graphics.push_back(xarrow); |
1681 | |
1682 | TLatex *xlabel = new TLatex(xhi+0.005*deltax, ylo, xlab); |
1683 | xlabel->SetTextAlign(12); |
1684 | graphics.push_back(xlabel); |
1685 | } |
1686 | |
1687 | //------------------- |
1688 | // DrawScale |
1689 | //------------------- |
1690 | void hdv_mainframe::DrawScale(TCanvas *c, vector<TObject*> &graphics) |
1691 | { |
1692 | /// Create a scale label on the specified canvas and add it |
1693 | /// to the specified container of graphics objects to be draw later. |
1694 | double x1 = c->GetX1(); |
1695 | double x2 = c->GetX2(); |
1696 | double y1 = c->GetY1(); |
1697 | double y2 = c->GetY2(); |
1698 | double deltax = x2-x1; |
1699 | double deltay = y2-y1; |
1700 | double p = floor(log(0.1*deltax)/log(10.0)); |
1701 | double m = floor(0.1*deltax/pow(10.0, p) + 0.5); |
1702 | double xlo = x1+0.72*deltax; |
1703 | double xhi = xlo + m*pow(10.0, p); |
1704 | double y = y1+0.04*deltay; |
1705 | TArrow *arrow = new TArrow(xlo, y, xhi, y, 0.02, "|-|"); |
1706 | arrow->SetLineWidth((Width_t)1.0); |
1707 | graphics.push_back(arrow); |
1708 | |
1709 | const char *units="<out of range>"; |
1710 | switch((int)p){ |
1711 | case -5: |
1712 | units = "#mum"; |
1713 | break; |
1714 | case -4: |
1715 | units = "#mum"; |
1716 | break; |
1717 | case -3: |
1718 | m*=10.0; |
1719 | units = "#mum"; |
1720 | break; |
1721 | case -2: |
1722 | m*=100.0; |
1723 | units="#mum"; |
1724 | break; |
1725 | case -1: |
1726 | units="mm"; |
1727 | break; |
1728 | case 0: |
1729 | units = "cm"; |
1730 | break; |
1731 | case 1: |
1732 | m*=10.0; |
1733 | units = "cm"; |
1734 | break; |
1735 | case 2: |
1736 | units = "m"; |
1737 | break; |
1738 | case 3: |
1739 | m*=10.0; |
1740 | units = "m"; |
1741 | break; |
1742 | case 4: |
1743 | m*=100.0; |
1744 | units = "m"; |
1745 | break; |
1746 | case 5: |
1747 | units = "km"; |
1748 | break; |
1749 | case 6: |
1750 | m*=10.0; |
1751 | units = "km"; |
1752 | break; |
1753 | } |
1754 | char str[256]; |
1755 | sprintf(str,"%d %s", (int)m, units); |
1756 | TLatex *label = new TLatex(xhi+0.01*deltax, y, str); |
1757 | label->SetTextAlign(12); |
1758 | graphics.push_back(label); |
1759 | } |
1760 | |
1761 | //------------------- |
1762 | // SetEvent |
1763 | //------------------- |
1764 | void hdv_mainframe::SetEvent(int id) |
1765 | { |
1766 | if(!event)return; |
1767 | |
1768 | char str[256]; |
1769 | sprintf(str,"%5d", id); |
1770 | event->SetTitle(str); |
1771 | event->Draw(); |
1772 | } |
1773 | |
1774 | //------------------- |
1775 | // SetSource |
1776 | //------------------- |
1777 | void hdv_mainframe::SetSource(string source) |
1778 | { |
1779 | this->source->SetTitle(source.c_str()); |
1780 | this->source->Draw(); |
1781 | } |
1782 | |
1783 | //------------------- |
1784 | // SetCandidateFactories |
1785 | //------------------- |
1786 | void hdv_mainframe::SetCandidateFactories(vector<string> &facnames) |
1787 | { |
1788 | /// Filter out the factories that provide "DTrackCandidate" objects |
1789 | /// and add their tags to the tracksfactory combobox. |
1790 | // Erase all current entries in the combobox and add back in |
1791 | // "<default>". |
1792 | candidatesfactory->RemoveAll(); |
1793 | candidatesfactory->AddEntry("<default>", 0); |
1794 | candidatesfactory->GetTextEntry()->SetText("<default>"); |
1795 | candidatesfactory->Select(0, kFALSE); |
1796 | |
1797 | for(unsigned int i=0; i< facnames.size(); i++){ |
1798 | string name = "DTrackCandidate:"; |
1799 | string::size_type pos = facnames[i].find(name); |
1800 | if(pos==string::npos)continue; |
1801 | string tag = facnames[i]; |
1802 | tag.erase(0, name.size()); |
1803 | candidatesfactory->AddEntry(tag.c_str(), i); |
1804 | if(tag==default_candidate){ |
1805 | candidatesfactory->Select(i, kTRUE); |
1806 | candidatesfactory->GetTextEntry()->SetText(tag.c_str()); |
1807 | } |
1808 | } |
1809 | } |
1810 | |
1811 | //------------------- |
1812 | // SetWireBasedTrackFactories |
1813 | //------------------- |
1814 | void hdv_mainframe::SetWireBasedTrackFactories(vector<string> &facnames) |
1815 | { |
1816 | /// Filter out the factories that provide "DTrackWireBased" objects |
1817 | /// and add their tags to the tracksfactory combobox. |
1818 | |
1819 | // Erase all current entries in the combobox and add back in |
1820 | // "<default>". |
1821 | wiretracksfactory->RemoveAll(); |
1822 | wiretracksfactory->AddEntry("<default>", 0); |
1823 | wiretracksfactory->GetTextEntry()->SetText("<default>"); |
1824 | wiretracksfactory->Select(0, kFALSE); |
1825 | |
1826 | for(unsigned int i=0; i< facnames.size(); i++){ |
1827 | string name = "DTrackWireBased:"; |
1828 | string::size_type pos = facnames[i].find(name); |
1829 | if(pos==string::npos)continue; |
1830 | string tag = facnames[i]; |
1831 | tag.erase(0, name.size()); |
1832 | wiretracksfactory->AddEntry(tag.c_str(), i+1); |
1833 | if(tag==default_track){ |
1834 | wiretracksfactory->Select(i, kTRUE); |
1835 | wiretracksfactory->GetTextEntry()->SetText(tag.c_str()); |
1836 | } |
1837 | } |
1838 | } |
1839 | |
1840 | //------------------- |
1841 | // SetTimeBasedTrackFactories |
1842 | //------------------- |
1843 | void hdv_mainframe::SetTimeBasedTrackFactories(vector<string> &facnames) |
1844 | { |
1845 | /// Filter out the factories that provide "DTrackTimeBased" objects |
1846 | /// and add their tags to the timetracksfactory combobox. |
1847 | |
1848 | // Erase all current entries in the combobox and add back in |
1849 | // "<default>". |
1850 | timetracksfactory->RemoveAll(); |
1851 | timetracksfactory->AddEntry("<default>", 0); |
1852 | timetracksfactory->GetTextEntry()->SetText("<default>"); |
1853 | timetracksfactory->Select(0, kFALSE); |
1854 | |
1855 | for(unsigned int i=0; i< facnames.size(); i++){ |
1856 | string name = "DTrackTimeBased:"; |
1857 | string::size_type pos = facnames[i].find(name); |
1858 | if(pos==string::npos)continue; |
1859 | string tag = facnames[i]; |
1860 | tag.erase(0, name.size()); |
1861 | timetracksfactory->AddEntry(tag.c_str(), i+1); |
1862 | if(tag==default_track){ |
1863 | timetracksfactory->Select(i, kTRUE); |
1864 | timetracksfactory->GetTextEntry()->SetText(tag.c_str()); |
1865 | } |
1866 | } |
1867 | } |
1868 | |
1869 | //------------------- |
1870 | // SetChargedTrackFactories |
1871 | //------------------- |
1872 | void hdv_mainframe::SetChargedTrackFactories(vector<string> &facnames) |
1873 | { |
1874 | /// Filter out the factories that provide "DChargedTrack" objects |
1875 | /// and add their tags to the chargedtracksfactory combobox. |
1876 | |
1877 | // Erase all current entries in the combobox and add back in |
1878 | // "<default>". |
1879 | chargedtracksfactory->RemoveAll(); |
1880 | chargedtracksfactory->AddEntry("<default>", 0); |
1881 | chargedtracksfactory->GetTextEntry()->SetText("<default>"); |
1882 | chargedtracksfactory->Select(0, kFALSE); |
1883 | |
1884 | for(unsigned int i=0; i< facnames.size(); i++){ |
1885 | string name = "DChargedTrack:"; |
1886 | string::size_type pos = facnames[i].find(name); |
1887 | if(pos==string::npos)continue; |
1888 | string tag = facnames[i]; |
1889 | tag.erase(0, name.size()); |
1890 | chargedtracksfactory->AddEntry(tag.c_str(), i+1); |
1891 | if(tag==default_track){ |
1892 | chargedtracksfactory->Select(i, kTRUE); |
1893 | chargedtracksfactory->GetTextEntry()->SetText(tag.c_str()); |
1894 | } |
1895 | } |
1896 | } |
1897 | |
1898 | |
1899 | |
1900 | //------------------- |
1901 | // SetReconstructedFactories |
1902 | //------------------- |
1903 | void hdv_mainframe::SetReconstructedFactories(vector<string> &facnames) |
1904 | { |
1905 | /// Filter out the factories that provide "DTrack" objects |
1906 | /// and add them to the reconfactory combobox. |
1907 | |
1908 | // Erase all current entries in the combobox and add back in |
1909 | // "<default>". |
1910 | int id =0; |
1911 | reconfactory->RemoveAll(); |
1912 | reconfactory->AddEntry("DTrackTimeBased:", id++); |
1913 | reconfactory->Select(0, kFALSE); |
1914 | reconfactory->GetTextEntry()->SetText("DTrackTimeBased:"); |
1915 | |
1916 | // Add DTrackTimeBased factories |
1917 | for(unsigned int i=0; i< facnames.size(); i++){ |
1918 | string name = "DTrackTimeBased:"; |
1919 | string::size_type pos = facnames[i].find(name); |
1920 | if(pos==string::npos)continue; |
1921 | string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size()); |
1922 | reconfactory->AddEntry(facnames[i].c_str(), id++); |
1923 | if(facnames[i]==default_reconstructed){ |
1924 | reconfactory->Select(id-1, kTRUE); |
1925 | reconfactory->GetTextEntry()->SetText(facnames[i].c_str()); |
1926 | } |
1927 | } |
1928 | |
1929 | // Add DTrackWireBased factories |
1930 | reconfactory->AddEntry("DTrackWireBased:", id++); |
1931 | for(unsigned int i=0; i< facnames.size(); i++){ |
1932 | string name = "DTrackWireBased:"; |
1933 | string::size_type pos = facnames[i].find(name); |
1934 | if(pos==string::npos)continue; |
1935 | string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size()); |
1936 | reconfactory->AddEntry(facnames[i].c_str(), id++); |
1937 | if(facnames[i]==default_reconstructed){ |
1938 | reconfactory->Select(id-1, kTRUE); |
1939 | reconfactory->GetTextEntry()->SetText(facnames[i].c_str()); |
1940 | } |
1941 | } |
1942 | |
1943 | // Add DTrackCandidate factories |
1944 | reconfactory->AddEntry("DTrackCandidate:", id++); |
1945 | for(unsigned int i=0; i< facnames.size(); i++){ |
1946 | string name = "DTrackCandidate:"; |
1947 | string::size_type pos = facnames[i].find(name); |
1948 | if(pos==string::npos)continue; |
1949 | string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size()); |
1950 | reconfactory->AddEntry(facnames[i].c_str(), id++); |
1951 | if(facnames[i]==default_reconstructed){ |
1952 | reconfactory->Select(id-1, kTRUE); |
1953 | reconfactory->GetTextEntry()->SetText(facnames[i].c_str()); |
1954 | } |
1955 | } |
1956 | |
1957 | |
1958 | // Add DNeutralTrack factories |
1959 | reconfactory->AddEntry("DNeutralParticle:", id++); |
1960 | for(unsigned int i=0; i< facnames.size(); i++){ |
1961 | string name = "DNeutralParticle:"; |
1962 | string::size_type pos = facnames[i].find(name); |
1963 | if(pos==string::npos)continue; |
1964 | string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size()); |
1965 | reconfactory->AddEntry(facnames[i].c_str(), id++); |
1966 | if(facnames[i]==default_reconstructed){ |
1967 | reconfactory->Select(id-1, kTRUE); |
1968 | reconfactory->GetTextEntry()->SetText(facnames[i].c_str()); |
1969 | } |
1970 | } |
1971 | |
1972 | // Add DTwoGammaFit factories |
1973 | for(unsigned int i=0; i< facnames.size(); i++){ |
1974 | string name = "DTwoGammaFit:"; |
1975 | string::size_type pos = facnames[i].find(name); |
1976 | if(pos==string::npos)continue; |
1977 | string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size()); |
1978 | reconfactory->AddEntry(facnames[i].c_str(), id++); |
1979 | if(facnames[i]==default_reconstructed){ |
1980 | reconfactory->Select(id-1, kTRUE); |
1981 | reconfactory->GetTextEntry()->SetText(facnames[i].c_str()); |
1982 | } |
1983 | } |
1984 | |
1985 | // Add DChargedTrack factories |
1986 | reconfactory->AddEntry("DChargedTrack:", id++); |
1987 | for(unsigned int i=0; i< facnames.size(); i++){ |
1988 | string name = "DChargedTrack:"; |
1989 | string::size_type pos = facnames[i].find(name); |
1990 | if(pos==string::npos)continue; |
1991 | string tag = facnames[i].substr(name.size(), facnames[i].size()-name.size()); |
1992 | reconfactory->AddEntry(facnames[i].c_str(), id++); |
1993 | if(facnames[i]==default_reconstructed){ |
1994 | reconfactory->Select(id-1, kTRUE); |
1995 | reconfactory->GetTextEntry()->SetText(facnames[i].c_str()); |
1996 | } |
1997 | } |
1998 | |
1999 | |
2000 | } |
2001 | |
2002 | //------------------- |
2003 | // GetCheckButton |
2004 | //------------------- |
2005 | bool hdv_mainframe::GetCheckButton(string who) |
2006 | { |
2007 | map<string, TGCheckButton*>::iterator iter = checkbuttons.find(who); |
2008 | if(iter==checkbuttons.end())return false; |
2009 | return iter->second->GetState()==kButtonDown; |
2010 | } |
2011 | |
2012 | //------------------- |
2013 | // AddCheckButtons |
2014 | //------------------- |
2015 | void hdv_mainframe::AddCheckButtons(map<string, TGCheckButton*> &checkbuttons) |
2016 | { |
2017 | this->checkbuttons.insert(checkbuttons.begin(), checkbuttons.end()); |
2018 | } |
2019 | |
2020 | //------------------- |
2021 | // GetFactoryTag |
2022 | //------------------- |
2023 | const char* hdv_mainframe::GetFactoryTag(string who) |
2024 | { |
2025 | const char *tag = ""; |
2026 | |
2027 | if(who=="DTrackWireBased"){ |
2028 | tag = wiretracksfactory->GetTextEntry()->GetTitle(); |
2029 | //tag = wiretracksfactory->GetSelectedEntry()->GetTitle(); |
2030 | } |
2031 | if(who=="DTrackCandidate"){ |
2032 | tag = candidatesfactory->GetTextEntry()->GetTitle(); |
2033 | //tag = candidatesfactory->GetSelectedEntry()->GetTitle(); |
2034 | } |
2035 | if(who=="DTrackTimeBased"){ |
2036 | tag = timetracksfactory->GetTextEntry()->GetTitle(); |
2037 | //tag = timetracksfactory->GetSelectedEntry()->GetTitle(); |
2038 | } |
2039 | if (who=="DChargedTrack"){ |
2040 | tag=chargedtracksfactory->GetTextEntry()->GetTitle(); |
2041 | } |
2042 | if(string(tag) == "<default>")tag = ""; |
2043 | |
2044 | return tag; |
2045 | } |
2046 | |
2047 | //------------------- |
2048 | // GetReconFactory |
2049 | //------------------- |
2050 | void hdv_mainframe::GetReconFactory(string &name, string &tag) |
2051 | { |
2052 | string nametag(reconfactory->GetSelectedEntry()->GetTitle()); |
2053 | string::size_type pos = nametag.find(":"); |
2054 | name = nametag.substr(0, pos); |
2055 | tag = nametag.substr(pos+1, nametag.size()-(pos+1)); |
2056 | } |
2057 | |
2058 | //------------------- |
2059 | // GetFCALPolyLine |
2060 | //------------------- |
2061 | TPolyLine* hdv_mainframe::GetFCALPolyLine(int channel) |
2062 | { |
2063 | map<int, TPolyLine*>::iterator iter = fcalblocks.find(channel); |
2064 | if(iter==fcalblocks.end())return NULL__null; |
2065 | return iter->second; |
2066 | } |
2067 | |
2068 | //------------------- |
2069 | // GetFCALPolyLine |
2070 | //------------------- |
2071 | TPolyLine* hdv_mainframe::GetFCALPolyLine(float x, float y) |
2072 | { |
2073 | if(!fcalgeom)return NULL__null; |
2074 | int row = fcalgeom->row(y); |
2075 | int column = fcalgeom->column(x); |
2076 | return GetFCALPolyLine(fcalgeom->channel(row, column)); |
2077 | } |
2078 | |
2079 | //------------------- |
2080 | // GetBCALPolyLine |
2081 | //------------------- |
2082 | TPolyLine* hdv_mainframe::GetBCALPolyLine(int module, int layer, int sector) |
2083 | { |
2084 | int chan = module*1000 + layer*100 + sector*10; |
2085 | map<int, TPolyLine*>::iterator iter = bcalblocks.find(chan); |
2086 | if(iter==bcalblocks.end()){ |
2087 | _DBG_std::cerr<<"hdv_mainframe.cc"<<":"<<2087<< " "<<"ERROR: No BCAL readout segment display poly for module="<<module<<" layer="<<layer<<" sector="<<sector<<endl; |
2088 | return NULL__null; |
2089 | } |
2090 | return iter->second; |
2091 | } |
2092 | |
2093 | //------------------- |
2094 | // AddGraphicsSideA |
2095 | //------------------- |
2096 | void hdv_mainframe::AddGraphicsSideA(vector<TObject*> &v) |
2097 | { |
2098 | for(unsigned int i=0; i<v.size(); i++)graphics_sideA.push_back(v[i]); |
2099 | } |
2100 | |
2101 | //------------------- |
2102 | // AddGraphicsSideB |
2103 | //------------------- |
2104 | void hdv_mainframe::AddGraphicsSideB(vector<TObject*> &v) |
2105 | { |
2106 | for(unsigned int i=0; i<v.size(); i++)graphics_sideB.push_back(v[i]); |
2107 | } |
2108 | |
2109 | //------------------- |
2110 | // AddGraphicsEndA |
2111 | //------------------- |
2112 | void hdv_mainframe::AddGraphicsEndA(vector<TObject*> &v) |
2113 | { |
2114 | for(unsigned int i=0; i<v.size(); i++)graphics_endA.push_back(v[i]); |
2115 | } |
2116 | |
2117 | //------------------- |
2118 | // AddGraphicsEndB |
2119 | //------------------- |
2120 | void hdv_mainframe::AddGraphicsEndB(vector<TObject*> &v) |
2121 | { |
2122 | for(unsigned int i=0; i<v.size(); i++)graphics_endB.push_back(v[i]); |
2123 | } |