source: trunk/MagicSoft/Mars/macros/calibration.C@ 3324

Last change on this file since 3324 was 3323, checked in by gaug, 22 years ago
*** empty log message ***
File size: 18.6 KB
Line 
1/* ======================================================================== *\
2!
3! *
4! * This file is part of MARS, the MAGIC Analysis and Reconstruction
5! * Software. It is distributed to you in the hope that it can be a useful
6! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
7! * It is distributed WITHOUT ANY WARRANTY.
8! *
9! * Permission to use, copy, modify and distribute this software and its
10! * documentation for any purpose is hereby granted without fee,
11! * provided that the above copyright notice appear in all copies and
12! * that both that copyright notice and this permission notice appear
13! * in supporting documentation. It is provided "as is" without express
14! * or implied warranty.
15! *
16!
17!
18! Author(s): Markus Gaug, 11/2003 <mailto:markus@ifae.es>
19!
20! Copyright: MAGIC Software Development, 2000-2003
21!
22!
23\* ======================================================================== */
24#include "MAGIC.h"
25
26
27void calibration()
28{
29
30 const char *inpath = "/remote/home/pc2/operator/Crab20040214/";
31 //const TString inpath = "/mnt/Data/rootdata/CrabNebula/2004_02_10/";
32 //const TString inpath = "/mnt/Data/rootdata/CrabNebula/2004_01_26/";
33 //const TString inpath = "/mnt/Data/rootdata/Miscellaneous/2003_12_19/";
34
35 MRunIter pruns;
36 MRunIter cruns;
37
38 pruns.AddRuns(15487,15494,inpath);
39 cruns.AddRuns(15495,15508,inpath);
40
41 gStyle->SetOptStat(1111);
42 gStyle->SetOptFit();
43
44 MStatusDisplay *display = new MStatusDisplay;
45 display->SetUpdateTime(500);
46 display->Resize(850,700);
47
48 MJPedestal pedloop;
49 pedloop.SetInput(&pruns);
50 pedloop.SetDisplay(display);
51
52 if (!pedloop.Process())
53 return;
54
55 //
56 // Now the short version:
57 //
58/*
59 MJCalibration calloop;
60 calloop.SetInput(&cruns);
61 calloop.SetDisplay(display);
62 if (!calloop.Process(pedloop.GetPedestalCam()))
63 return;
64#if 0
65*/
66 //
67 // The longer version:
68 //
69
70 //
71 // Create a empty Parameter List and an empty Task List
72 //
73 MParList plist;
74 MTaskList tlist;
75 plist.AddToList(&tlist);
76 plist.AddToList(&pedloop.GetPedestalCam());
77
78 gLog << endl;;
79 gLog << "Calculate MCalibrationCam from Runs " << cruns.GetRunsAsString() << endl;
80 gLog << endl;
81
82 MReadMarsFile read("Events");
83 read.DisableAutoScheme();
84 static_cast<MRead&>(read).AddFiles(cruns);
85
86 MGeomCamMagic geomcam;
87 MExtractedSignalCam sigcam;
88 MArrivalTimeCam timecam;
89 MCalibrationChargeCam calcam;
90 MCalibrationChargePINDiode pindiode;
91 MCalibrationChargeBlindPix blindpix;
92
93 MHCalibrationRelTimeCam histtime;
94 MHCalibrationChargeCam histcharge;
95 MHCalibrationChargePINDiode histpin;
96 MHCalibrationChargeBlindPix histblind;
97 //
98 // As long, as we don't have digital modules,
99 // we have to set the color of the pulser LED by hand
100 //
101 blindpix.SetColor(kCT1);
102 pindiode.SetColor(kCT1);
103 //
104 // Get the previously created MPedestalCam into the new Parameter List
105 //
106 plist.AddToList(&geomcam);
107 plist.AddToList(&sigcam);
108 plist.AddToList(&timecam);
109 plist.AddToList(&calcam);
110 plist.AddToList(&histtime);
111 plist.AddToList(&histcharge);
112 plist.AddToList(&histpin);
113 plist.AddToList(&histblind);
114
115 //
116 // We saw that the signal jumps between slices,
117 // thus take the sliding window
118 //
119 MExtractSignal2 sigcalc2;
120 MExtractPINDiode pincalc;
121 MExtractBlindPixel blindcalc;
122 MArrivalTimeCalc2 timecalc;
123 MCalibrationChargeCalc calcalc;
124 MGeomApply geomapl;
125
126 MFillH filltime( "MHCalibrationRelTimeCam" , "MArrivalTimeCam");
127 MFillH fillpin ("MHCalibrationChargePINDiode", "MExtractedSignalPINDiode");
128 MFillH fillblind("MHCalibrationChargeBlindPix", "MExtractedSignalBlindPixel");
129 MFillH fillcam ("MHCalibrationChargeCam" , "MExtractedSignalCam");
130
131 //
132 // Skip the HiGain vs. LoGain calibration
133 //
134 calcalc.SkipHiLoGainCalibration();
135
136 //
137 // Apply a filter against cosmics
138 // (was directly in MCalibrationCalc in earlier versions)
139 //
140 MFCosmics cosmics;
141 MContinue cont(&cosmics);
142
143 tlist.AddToList(&read);
144 tlist.AddToList(&geomapl);
145 tlist.AddToList(&sigcalc2);
146 tlist.AddToList(&blindcalc);
147 tlist.AddToList(&pincalc);
148 //
149 // In case, you want to skip the cosmics rejection,
150 // uncomment the next line
151 //
152 tlist.AddToList(&cont);
153 //
154 // In case, you want to skip the somewhat lengthy calculation
155 // of the arrival times using a spline, uncomment the next two lines
156 //
157 tlist.AddToList(&timecalc);
158 tlist.AddToList(&filltime);
159 tlist.AddToList(&fillpin);
160 tlist.AddToList(&fillblind);
161 tlist.AddToList(&fillcam);
162 //
163 tlist.AddToList(&calcalc);
164 //
165 // Create and setup the eventloop
166 //
167 MEvtLoop evtloop;
168 evtloop.SetParList(&plist);
169 evtloop.SetDisplay(display);
170
171 //
172 // Execute second analysis
173 //
174 if (!evtloop.Eventloop())
175 return;
176
177 tlist.PrintStatistics();
178
179 //
180 // print the most important results of all pixels to a file
181 //
182 MLog gauglog;
183 gauglog.SetOutputFile(Form("%s%s",calcam.GetName(),".txt"),1);
184 calcam.SetLogStream(&gauglog);
185 calcam.Print();
186 calcam.SetLogStream(&gLog);
187 //
188 // just one example how to get the plots of individual pixels
189 //
190 histblind.DrawClone("all");
191 histcharge[5].DrawClone("time");
192 histtime[5].DrawClone("fourierevents");
193
194 // Create histograms to display
195 MHCamera disp1 (geomcam, "Cal;Charge", "Fitted Mean Charges");
196 MHCamera disp2 (geomcam, "Cal;SigmaCharge", "Sigma of Fitted Charges");
197 MHCamera disp3 (geomcam, "Cal;FitProb", "Probability of Fit");
198 MHCamera disp4 (geomcam, "Cal;RSigma", "Reduced Sigmas");
199 MHCamera disp5 (geomcam, "Cal;RSigma/Charge", "Reduced Sigma per Charge");
200 MHCamera disp6 (geomcam, "Cal;FFactorPh", "Nr. of Photo-electrons (F-Factor Method)");
201 MHCamera disp7 (geomcam, "Cal;FFactorConv", "Conversion Factor to photons (F-Factor Method)");
202 MHCamera disp8 (geomcam, "Cal;FFactorFFactor", "Total F-Factor (F-Factor Method)");
203 MHCamera disp9 (geomcam, "Cal;BlindPixPh", "Photon flux inside plexiglass (Blind Pixel Method)");
204 MHCamera disp10 (geomcam, "Cal;BlindPixConv", "Conversion Factor to photons (Blind Pixel Method)");
205 MHCamera disp11 (geomcam, "Cal;BlindPixFFactor","Total F-Factor (Blind Pixel Method)");
206 MHCamera disp12 (geomcam, "Cal;PINDiodePh", "Photon flux outside plexiglass (PIN Diode Method)");
207 MHCamera disp13 (geomcam, "Cal;PINDiodeConv", "Conversion Factor tp photons (PIN Diode Method)");
208 MHCamera disp14 (geomcam, "Cal;PINDiodeFFactor","Total F-Factor (PIN Diode Method)");
209 MHCamera disp15 (geomcam, "Cal;Excluded", "Pixels previously excluded");
210 MHCamera disp16 (geomcam, "Cal;NotFitted", "Pixels that could not be fitted");
211 MHCamera disp17 (geomcam, "Cal;NotFitValid", "Pixels with not valid fit results");
212 MHCamera disp18 (geomcam, "Cal;HiGainOscillating", "Oscillating Pixels HI Gain");
213 MHCamera disp19 (geomcam, "Cal;LoGainOscillating", "Oscillating Pixels LO Gain");
214 MHCamera disp20 (geomcam, "Cal;HiGainPickup", "Number Pickup events Hi Gain");
215 MHCamera disp21 (geomcam, "Cal;LoGainPickup", "Number Pickup events Lo Gain");
216 MHCamera disp22 (geomcam, "Cal;Saturation", "Pixels with saturated Hi Gain");
217 MHCamera disp23 (geomcam, "Cal;FFactorValid", "Pixels with valid F-Factor calibration");
218 MHCamera disp24 (geomcam, "Cal;BlindPixelValid", "Pixels with valid BlindPixel calibration");
219 MHCamera disp25 (geomcam, "Cal;PINdiodeFFactorValid", "Pixels with valid PINDiode calibration");
220
221 MHCamera disp26 (geomcam, "Cal;Ped", "Pedestals");
222 MHCamera disp27 (geomcam, "Cal;PedRms", "Pedestal RMS");
223
224 MHCamera disp28 (geomcam, "time;Time", "Rel. Arrival Times");
225 MHCamera disp29 (geomcam, "time;SigmaTime", "Sigma of Rel. Arrival Times");
226 MHCamera disp30 (geomcam, "time;TimeProb", "Probability of Time Fit");
227 MHCamera disp31 (geomcam, "time;NotFitValid", "Pixels with not valid fit results");
228 MHCamera disp32 (geomcam, "time;Oscillating", "Oscillating Pixels");
229
230 MHCamera disp33 (geomcam, "Cal;AbsTimeMean", "Abs. Arrival Times");
231 MHCamera disp34 (geomcam, "Cal;AbsTimeRms", "RMS of Arrival Times");
232
233 // Fitted charge means and sigmas
234 disp1.SetCamContent(calcam, 0);
235 disp1.SetCamError( calcam, 1);
236 disp2.SetCamContent(calcam, 2);
237 disp2.SetCamError( calcam, 3);
238
239 // Fit probabilities
240 disp3.SetCamContent(calcam, 4);
241
242 // Reduced Sigmas and reduced sigmas per charge
243 disp4.SetCamContent(calcam, 5);
244 disp4.SetCamError( calcam, 6);
245 disp5.SetCamContent(calcam, 7);
246 disp5.SetCamError( calcam, 8);
247
248 // F-Factor Method
249 disp6.SetCamContent(calcam, 9);
250 disp6.SetCamError( calcam, 10);
251 disp7.SetCamContent(calcam, 11);
252 disp7.SetCamError( calcam, 12);
253 disp8.SetCamContent(calcam, 13);
254 disp8.SetCamError( calcam, 14);
255
256 /// Blind Pixel Method
257 disp9.SetCamContent(calcam, 15);
258 disp9.SetCamError( calcam, 16);
259 disp10.SetCamContent(calcam,17);
260 disp10.SetCamError( calcam,18);
261 disp11.SetCamContent(calcam,19);
262 disp11.SetCamError( calcam,20);
263
264 // PIN Diode Method
265 disp12.SetCamContent(calcam,21);
266 disp12.SetCamError( calcam,22);
267 disp13.SetCamContent(calcam,23);
268 disp13.SetCamError( calcam,24);
269 disp14.SetCamContent(calcam,25);
270 disp14.SetCamError( calcam,26);
271
272 // Pixels with defects
273 disp15.SetCamContent(calcam,27);
274 disp16.SetCamContent(calcam,28);
275 disp17.SetCamContent(calcam,29);
276 disp18.SetCamContent(calcam,30);
277 disp19.SetCamContent(calcam,31);
278 disp20.SetCamContent(calcam,32);
279 disp21.SetCamContent(calcam,33);
280
281 // Lo Gain calibration
282 disp22.SetCamContent(calcam,34);
283
284 // Valid flags
285 disp23.SetCamContent(calcam,35);
286 disp24.SetCamContent(calcam,36);
287 disp25.SetCamContent(calcam,37);
288
289 // Pedestals
290 disp26.SetCamContent(calcam,38);
291 disp26.SetCamError( calcam,39);
292 disp27.SetCamContent(calcam,40);
293 disp27.SetCamError( calcam,41);
294
295 // Relative Times
296 disp28.SetCamContent(timecam,0);
297 disp28.SetCamError( timecam,1);
298 disp29.SetCamContent(timecam,2);
299 disp29.SetCamError( timecam,3);
300 disp30.SetCamContent(timecam,4);
301 disp31.SetCamContent(timecam,5);
302 disp32.SetCamContent(timecam,6);
303
304 // Absolute Times
305 disp33.SetCamContent(calcam,42);
306 disp33.SetCamError( calcam,43);
307 disp34.SetCamContent(calcam,43);
308
309 disp1.SetYTitle("Charge [FADC units]");
310 disp2.SetYTitle("\\sigma_{Charge} [FADC units]");
311 disp3.SetYTitle("P_{Charge} [1]");
312
313 disp4.SetYTitle("\\sqrt{\\sigma^{2}_{Charge} - RMS^{2}_{Ped}} [FADC Counts]");
314 disp5.SetYTitle("Reduced Sigma / Mean Charge [1]");
315
316 disp6.SetYTitle("Nr. Photo-electrons [1]");
317 disp7.SetYTitle("Conversion Factor [Ph/FADC Count]");
318 disp8.SetYTitle("\\sqrt{N_{Ph}}*\\sigma_{Charge}/\\mu_{Charge} [1] ");
319
320 disp9.SetYTitle("Photon flux [ph/mm^2]");
321 disp10.SetYTitle("Conversion Factor [Phot/FADC Count]");
322 disp11.SetYTitle("\\sqrt{N_{Ph}}*\\sigma_{Charge}/\\mu_{Charge} [1]");
323
324 disp12.SetYTitle("Photon flux [ph/mm^2]");
325 disp13.SetYTitle("Conversion Factor [Phot/FADC Count]");
326 disp14.SetYTitle("\\sqrt{N_{Ph}}*\\sigma_{Charge}/\\mu_{Charge} [1]");
327
328 disp15.SetYTitle("[1]");
329 disp16.SetYTitle("[1]");
330 disp17.SetYTitle("[1]");
331 disp18.SetYTitle("[1]");
332 disp19.SetYTitle("[1]");
333 disp20.SetYTitle("[1]");
334 disp21.SetYTitle("[1]");
335 disp22.SetYTitle("[1]");
336 disp23.SetYTitle("[1]");
337 disp24.SetYTitle("[1]");
338 disp25.SetYTitle("[1]");
339
340 disp26.SetYTitle("Ped [FADC Counts ]");
341 disp27.SetYTitle("RMS_{Ped} [FADC Counts ]");
342
343 disp28.SetYTitle("Time Offset [ns]");
344 disp29.SetYTitle("Timing resolution [ns]");
345 disp30.SetYTitle("P_{Time} [1]");
346
347 disp31.SetYTitle("[1]");
348 disp32.SetYTitle("[1]");
349
350 disp33.SetYTitle("Mean Abs. Time [FADC slice]");
351 disp34.SetYTitle("RMS Abs. Time [FADC slices]");
352
353 gStyle->SetOptStat(1111);
354 gStyle->SetOptFit();
355
356 // Charges
357 TCanvas &c1 = display->AddTab("Fit.Charge");
358 c1.Divide(2, 3);
359
360 CamDraw(c1, disp1,calcam,1, 2 , 2);
361 CamDraw(c1, disp2,calcam,2, 2 , 2);
362
363 // Fit Probability
364 TCanvas &c2 = display->AddTab("Fit.Prob");
365 c2.Divide(1,3);
366
367 CamDraw(c2, disp3,calcam,1, 1 , 4);
368
369 // Reduced Sigmas
370 TCanvas &c3 = display->AddTab("Red.Sigma");
371 c3.Divide(2,3);
372
373 CamDraw(c3, disp4,calcam,1, 2 , 2);
374 CamDraw(c3, disp5,calcam,2, 2 , 2);
375
376 // F-Factor Method
377 TCanvas &c4 = display->AddTab("F-Factor");
378 c4.Divide(3,3);
379
380 CamDraw(c4, disp6,calcam,1, 3 , 2);
381 CamDraw(c4, disp7,calcam,2, 3 , 2);
382 CamDraw(c4, disp8,calcam,3, 3 , 2);
383
384 // Blind Pixel Method
385 TCanvas &c5 = display->AddTab("BlindPix");
386 c5.Divide(3, 3);
387
388 CamDraw(c5, disp9,calcam,1, 3 , 9);
389 CamDraw(c5, disp10,calcam,2, 3 , 2);
390 CamDraw(c5, disp11,calcam,3, 3 , 2);
391
392 // PIN Diode Method
393 TCanvas &c6 = display->AddTab("PINDiode");
394 c6.Divide(3,3);
395
396 CamDraw(c6, disp12,calcam,1, 3 , 9);
397 CamDraw(c6, disp13,calcam,2, 3 , 2);
398 CamDraw(c6, disp14,calcam,3, 3 , 2);
399
400 // Defects
401 TCanvas &c7 = display->AddTab("Defects");
402 c7.Divide(7,2);
403
404 CamDraw(c7, disp15,calcam,1,7, 0);
405 CamDraw(c7, disp16,calcam,2,7, 0);
406 CamDraw(c7, disp17,calcam,3,7, 0);
407 CamDraw(c7, disp18,calcam,4,7, 0);
408 CamDraw(c7, disp19,calcam,5,7, 0);
409 CamDraw(c7, disp20,calcam,6,7, 0);
410 CamDraw(c7, disp21,calcam,7,7, 0);
411
412 // Valid flags
413 TCanvas &c8 = display->AddTab("Validity");
414 c8.Divide(4,2);
415
416 CamDraw(c8, disp22,calcam,1,4,0);
417 CamDraw(c8, disp23,calcam,2,4,0);
418 CamDraw(c8, disp24,calcam,3,4,0);
419 CamDraw(c8, disp25,calcam,4,4,0);
420
421
422 // Pedestals
423 TCanvas &c9 = display->AddTab("Pedestals");
424 c9.Divide(2,3);
425
426 CamDraw(c9,disp26,calcam,1,2,1);
427 CamDraw(c9,disp27,calcam,2,2,2);
428
429 // Rel. Times
430 TCanvas &c10 = display->AddTab("Fitted Rel. Times");
431 c10.Divide(3,3);
432
433 CamDraw(c10,disp28,calcam,1,3,2);
434 CamDraw(c10,disp29,calcam,2,3,2);
435 CamDraw(c10,disp30,calcam,3,3,4);
436
437 // Time Defects
438 TCanvas &c11 = display->AddTab("Time Def.");
439 c11.Divide(2,2);
440
441 CamDraw(c11, disp31,calcam,1,2, 0);
442 CamDraw(c11, disp32,calcam,2,2, 0);
443
444 // Abs. Times
445 TCanvas &c12 = display->AddTab("Abs. Times");
446 c12.Divide(2,3);
447
448 CamDraw(c12,disp33,calcam,1,2,2);
449 CamDraw(c12,disp34,calcam,2,2,2);
450
451#endif
452}
453
454void CamDraw(TCanvas &c, MHCamera &cam, MCamEvent &evt, Int_t i, Int_t j, Int_t fit)
455{
456
457 c.cd(i);
458 gPad->SetBorderMode(0);
459 MHCamera *obj1=(MHCamera*)cam.DrawCopy("hist");
460 // obj1->AddNotify(evt);
461
462 c.cd(i+j);
463 gPad->SetBorderMode(0);
464 obj1->Draw();
465 ((MHCamera*)obj1)->SetPrettyPalette();
466
467 if (fit != 0)
468 {
469 c.cd(i+2*j);
470 gPad->SetBorderMode(0);
471 TH1D *obj2 = (TH1D*)obj1->Projection();
472
473// obj2->Sumw2();
474 obj2->Draw();
475 obj2->SetBit(kCanDelete);
476
477 const Double_t min = obj2->GetBinCenter(obj2->GetXaxis()->GetFirst());
478 const Double_t max = obj2->GetBinCenter(obj2->GetXaxis()->GetLast());
479 const Double_t integ = obj2->Integral("width")/2.5066283;
480 const Double_t mean = obj2->GetMean();
481 const Double_t rms = obj2->GetRMS();
482 const Double_t width = max-min;
483
484 if (rms == 0. || width == 0. )
485 return;
486
487 switch (fit)
488 {
489 case 1:
490 TF1 *sgaus = new TF1("sgaus","gaus(0)",min,max);
491 sgaus->SetBit(kCanDelete);
492 sgaus->SetParNames("Area","#mu","#sigma");
493 sgaus->SetParameters(integ/rms,mean,rms);
494 sgaus->SetParLimits(0,0.,integ);
495 sgaus->SetParLimits(1,min,max);
496 sgaus->SetParLimits(2,0,width/1.5);
497 obj2->Fit("sgaus","QLR");
498 obj2->GetFunction("sgaus")->SetLineColor(kYellow);
499 break;
500
501 case 2:
502 TString dgausform = "([0]-[3])/[2]*exp(-0.5*(x-[1])*(x-[1])/[2]/[2])";
503 dgausform += "+[3]/[5]*exp(-0.5*(x-[4])*(x-[4])/[5]/[5])";
504 TF1 *dgaus = new TF1("dgaus",dgausform.Data(),min,max);
505 dgaus->SetBit(kCanDelete);
506 dgaus->SetParNames("A_{tot}","#mu_{1}","#sigma_{1}","A_{2}","#mu_{2}","#sigma_{2}");
507 dgaus->SetParameters(integ,(min+mean)/2.,width/4.,
508 integ/width/2.,(max+mean)/2.,width/4.);
509 // The left-sided Gauss
510 dgaus->SetParLimits(0,integ-1.5,integ+1.5);
511 dgaus->SetParLimits(1,min+(width/10.),mean);
512 dgaus->SetParLimits(2,0,width/2.);
513 // The right-sided Gauss
514 dgaus->SetParLimits(3,0,integ);
515 dgaus->SetParLimits(4,mean,max-(width/10.));
516 dgaus->SetParLimits(5,0,width/2.);
517 obj2->Fit("dgaus","QLRM");
518 obj2->GetFunction("dgaus")->SetLineColor(kYellow);
519 break;
520
521 case 3:
522 TString tgausform = "([0]-[3]-[6])/[2]*exp(-0.5*(x-[1])*(x-[1])/[2]/[2])";
523 tgausform += "+[3]/[5]*exp(-0.5*(x-[4])*(x-[4])/[5]/[5])";
524 tgausform += "+[6]/[8]*exp(-0.5*(x-[7])*(x-[7])/[8]/[8])";
525 TF1 *tgaus = new TF1("tgaus",tgausform.Data(),min,max);
526 tgaus->SetBit(kCanDelete);
527 tgaus->SetParNames("A_{tot}","#mu_{1}","#sigma_{1}",
528 "A_{2}","#mu_{2}","#sigma_{2}",
529 "A_{3}","#mu_{3}","#sigma_{3}");
530 tgaus->SetParameters(integ,(min+mean)/2,width/4.,
531 integ/width/3.,(max+mean)/2.,width/4.,
532 integ/width/3.,mean,width/2.);
533 // The left-sided Gauss
534 tgaus->SetParLimits(0,integ-1.5,integ+1.5);
535 tgaus->SetParLimits(1,min+(width/10.),mean);
536 tgaus->SetParLimits(2,width/15.,width/2.);
537 // The right-sided Gauss
538 tgaus->SetParLimits(3,0.,integ);
539 tgaus->SetParLimits(4,mean,max-(width/10.));
540 tgaus->SetParLimits(5,width/15.,width/2.);
541 // The Gauss describing the outliers
542 tgaus->SetParLimits(6,0.,integ);
543 tgaus->SetParLimits(7,min,max);
544 tgaus->SetParLimits(8,width/4.,width/1.5);
545 obj2->Fit("tgaus","QLRM");
546 obj2->GetFunction("tgaus")->SetLineColor(kYellow);
547 break;
548 case 4:
549 obj2->Fit("pol0","Q");
550 obj2->GetFunction("pol0")->SetLineColor(kYellow);
551 break;
552 case 9:
553 break;
554 default:
555 obj2->Fit("gaus","Q");
556 obj2->GetFunction("gaus")->SetLineColor(kYellow);
557 break;
558 }
559
560 gPad->Modified();
561 gPad->Update();
562
563 }
564}
565
566
Note: See TracBrowser for help on using the repository browser.