source: JEM-EUSO/equalization_gain/branches/analclass-Sylvie/src/PlotScurvesAll-diffFit.C @ 196

Last change on this file since 196 was 196, checked in by dagoret, 11 years ago

add the developpment branch of the class to avoid pertrubation on the main Plost Scurve function, this is only developpement
File size: 18.4 KB
Line 
1#include <fstream>
2#include <iostream>
3#include "TH1D.h"
4#include "TH2D.h"
5#include "TCanvas.h"
6#include "TF1.h"
7#include "TPad.h"
8#include "TGraphErrors.h"
9#include "TGraph.h"
10#include "TLine.h"
11#include "PlotScurvesAll-diffFitConst.h"
12
13// for format of EC_ASIC Scurves_all_ASIC data
14// ASIC A,B,C,.... : i=0,1,2,... ch 0,1,...,63 : j=0,1,...,63
15// % cat scurves_PC_inj_run5.lvm |awk '{i=2;j=37;print($1,$(i*64+j+1+1))}'
16//   > scurves_PC_inj_run5-C-ch37.data
17// => % cd $datadir
18// => % sh $srcdir/makeDataFile.sh with assigining proper fname
19// PlotScurvesAll-diffFit-v6.6.C: dac_sfit[ch]=-1; in the case of fitting failure.
20
21
22void PlotScurve(
23                Int_t    kDrawCh=31,
24                TString  fname=kFname,
25                TString  fname_ped=kFnamePed, //ASIC_D ped_file
26                Double_t dac_half_spe_fix = -1,
27                TString  fname_gain="gain-org.txt",
28                Int_t    fit_min=kFitMin,
29                Int_t    fit_max=kFitMax,
30                Int_t    fit_min_scurve=kFitMinS,
31                Int_t    fit_max_scurve=kFitMaxS,
32                Bool_t   kBoard=1, //0:ASIC_C, 1:ASIC_D
33                Int_t    kChRef=kRefCh,//ASIC_C
34                Bool_t   checkAve=0 //0:use ref pix, 1:check average
35                ){
36                //NOTE   
37                //Double_t dac_half_spe_fix = 177; //for EC_ASICb N101(asic N158).
38                //check DAC value corresponds to voltage to 160fC input
39                //(depends on DAC linearity)
40                //Double_t dac_half_spe_fix = -1 //set gain to DAC average (default)
41
42  /******************* Readout data file *********************/
43 
44  /*********************** SIGNAL RUN ********************/
45  TString *input             = new TString[kNch];
46  TString *input_ped         = new TString[kNch];
47  Int_t    ch;
48  Float_t  dac_half_sum      = 0;
49  Float_t  dac_ped_sum       = 0;
50  Float_t  dac_spe_sum       = 0;
51  Float_t  dac_sfit_sum      = 0;
52  Float_t  diff_sum          = 0;
53  Float_t  mean_sum          = 0;
54  Float_t  maxBinSum         = 0;
55  Double_t dac_half[kNch];
56  Double_t dac_ped[kNch];
57  Double_t dac_spe[kNch];
58  Double_t dac_sfit[kNch];
59  Double_t mean_diff[kNch];
60  Double_t gain_org[kNch];
61  Double_t sfit_chiS[kNch];
62  Double_t flag_fit[kNch];
63
64  TCanvas *c1                = new TCanvas("c1","c1",200,20,1100,600);
65  c1->Divide(11,6);
66  TCanvas *c2                = new TCanvas("c2","c2",300,50,1100,600);
67  c2->Divide(11,6);
68  TCanvas *c5                = new TCanvas("c5","c5",400,70,1100,600);
69  c5->Divide(11,6);
70  TCanvas *c3                = new TCanvas("c3","c3",500,100,1200,300);
71  c3->Divide(4,1);
72  /*TCanvas *c6                = new TCanvas("c6","c6",450,150,1000,500);
73  c6->Divide(4,2);
74  TCanvas *c7                = new TCanvas("c7","c7",470,200,1000,500);
75  c7->Divide(4,2);*/
76  TCanvas *c4                = new TCanvas("c4","c4",900,400,300,300);
77
78  TString  name_hist[kNch];
79  TString  name_hist_ped[kNch];
80  TString  name_hist_diff[kNch];
81  TString  name_hist_diff_fit[kNch];
82  TString  name_fit_diff[kNch];
83  TH1D    *hist_scurve       = new TH1D[kNch];
84  TH1D    *hist_scurve_ped   = new TH1D[kNch];
85  TH1D    *hist_diff         = new TH1D[kNch];
86  TH1D    *hist_diff_fit     = new TH1D[kNch];
87  TF1     *fit_sdiff         = new TF1[kNch];
88
89  TString input_gain(fname_gain);
90  ifstream in_gain(input_gain.Data());
91  if(!in_gain.good()){
92    cerr << "File " << input_gain << " open failed!" << endl;
93    return;
94  }
95 
96  for(ch=0;ch<kNch;ch++){
97    dac_half[ch]=0;
98    dac_ped[ch]=0;
99    dac_spe[ch]=0;
100    dac_sfit[ch]=0;
101    gain_org[ch]=0;
102    mean_diff[ch]=0;
103    sfit_chiS[ch]=0;
104    flag_fit[ch]=0;
105    name_hist[ch]           ="hist";
106    name_hist[ch]          +=ch;
107    name_hist_ped[ch]       ="hist_ped";
108    name_hist_ped[ch]      +=ch;
109    name_hist_diff[ch]      ="hist_diff";
110    name_hist_diff[ch]     +=ch;
111    name_hist_diff_fit[ch]  ="hist_diff_fit";
112    name_hist_diff_fit[ch] +=ch;
113    name_fit_diff[ch]       ="fit_diff";
114    name_fit_diff[ch]      +=ch;
115  }
116 
117  Double_t da;
118  Int_t count=0;
119  ch=0;
120  while(in_gain >> da){
121    if(!kBoard && (count>=128 && count<192)){
122      gain_org[ch]=da;
123      cerr << "!kBoard, count, gain_org[" << ch << "] "
124           << !kBoard << " " << count << " " << gain_org[ch] << endl;
125      ch++;
126    }
127    if(kBoard && (count>=192 && count<256)){
128      gain_org[ch]=da;
129      cerr << "kBoard, count, gain_org[" << ch << "] "
130           << kBoard << " " << count << " " << gain_org[ch] << endl;
131      ch++;
132    }
133    count++;
134  }     
135  in_gain.close();
136  in_gain.clear();
137 
138
139  Int_t trigger=0, trigger_fit=0, trigger_mean=0, trigger_sfit=0;
140  for(ch=0;ch<kNch;ch++){
141    input[ch] += fname;
142    input[ch] += "-ch";
143    input[ch] += ch;
144    input[ch] += ".dat";
145    ifstream in(input[ch].Data());
146    if(!in.good()){
147      cerr << "File " << input[ch] << " open failed!" << endl;
148      return;
149    }
150
151    input_ped[ch] += fname_ped;
152    input_ped[ch] += "-ch";
153    input_ped[ch] += ch;
154    input_ped[ch] += ".dat";
155    ifstream in_ped(input_ped[ch].Data());
156    if(!in_ped.good()){
157      cerr << "File " << input_ped[ch] << " open failed!" << endl;
158      return;
159    }   
160
161
162   
163    //10DAC~10mV
164
165    Double_t da, dat, dac_min, dac_max, step_dac;
166    count = 0;
167    while (in >> da >> dat ){
168      if(count==0) dac_min  = da;
169      if(count==1) step_dac = da - dac_min;
170      dac_max=da;
171      count++;
172    }     
173    in.close();
174    in.clear();
175
176    /*   
177    if(ch==43 || ch==47){//for T1 ASIC_C
178      cerr << "CHECK " << ch << " " << fit_min_scurve << endl;
179      Int_t fit_min_scurve=140;
180    } else {
181      Int_t fit_min_scurve=kFitMinS;
182    }
183    */
184
185    if(kXmin<dac_min)kXmin=dac_min;
186    const Int_t kNdata    = count;
187    count = (fit_max_scurve-fit_min_scurve)/step_dac;
188    const Int_t kNdataFit = count;
189    if(ch==0){
190      cerr << "kNdata, dac_min, dac_max, step_dac: " 
191           << kNdata << " " << dac_min << " " << dac_max << " " 
192           << step_dac << endl;
193    }
194   
195    Double_t dac_min_ped, dac_max_ped, step_dac_ped;
196    count = 0;
197    while (in_ped >> da >> dat ){
198      if(count==0) dac_min_ped  = da;
199      if(count==1) step_dac_ped = da - dac_min_ped;
200      dac_max_ped=da;
201      count++;
202    }     
203    in_ped.close();
204    in_ped.clear();
205   
206
207    const Int_t kNdataPed = count;
208    if(ch==0){
209      cerr << "kNdataPed, dac_min_ped, dac_max_ped, step_dac_ped: " 
210           << kNdataPed << " " << dac_min_ped << " " << dac_max_ped
211           << " " << step_dac_ped << endl;
212    }
213   
214    hist_scurve[ch]      = TH1D(name_hist[ch],name_hist[ch],kNdata-1,
215                                dac_min,dac_max);
216    hist_scurve_ped[ch]  = TH1D(name_hist_ped[ch],name_hist_ped[ch],
217                                kNdataPed-1,dac_min_ped,dac_max_ped);
218    hist_diff[ch]        = TH1D(name_hist_diff[ch],name_hist_diff[ch],
219                                kNdata-2,dac_min,dac_max);
220    hist_diff_fit[ch]    = TH1D(name_hist_diff_fit[ch],name_hist_diff_fit[ch],
221                                kNdataFit,fit_min_scurve,fit_max_scurve);
222
223    in.open(input[ch].Data());
224    Double_t       data[kNdata], dac[kNdata], dac_fit[kNdataFit], data_fit[kNdataFit];
225    while (in >> da >> dat ){
226      hist_scurve[ch].Fill(da,dat);
227    }
228    in.close();
229    in.clear();
230
231    in_ped.open(input_ped[ch].Data());
232    while (in_ped >> da >> dat ){
233      hist_scurve_ped[ch].Fill(da,dat);
234    }
235    in_ped.close();
236    in_ped.clear();
237
238    //dac_ped[ch]  = hist_scurve_ped[ch].GetMaximumBin()+dac_min_ped; //absolute value
239    dac_ped[ch]  = hist_scurve_ped[ch].GetBinCenter(hist_scurve_ped[ch].GetMaximumBin()); //absolute value
240    dac_ped_sum += dac_ped[ch]; //absolute value
241    //cerr << "dac_ped[" << ch << "] dac_ped_sum " << dac_ped[ch]
242    //<< " " << dac_ped_sum << endl;
243   
244
245    hist_scurve[ch].Smooth(3);
246    Int_t binx=0;
247    //hist_scurve[ch].GetBinWithContent(kHalfMax,binx,kXmin-dac_min+1,
248    //                                  dac_max-dac_min+1,kHalfMax/2.);
249    hist_scurve[ch].GetBinWithContent(kHalfMax,binx,kXmin-dac_min+1,
250                                      dac_max-dac_min+1,2000);
251    dac_half[ch] = hist_scurve[ch].GetBinCenter(binx); //absolute value
252    if(dac_half[ch]<kXmin)dac_half[ch]=-1;
253   
254    Int_t i=0;
255    for(i=0;i<kNdata;i++){
256      dac[i]  = hist_scurve[ch].GetBinCenter(i+1);
257      data[i] = hist_scurve[ch].GetBinContent(i+1);
258    }
259   
260    /*** derive diff ***/
261    Double_t diff[kNdata-1], dac_diff[kNdata-1];
262    Int_t trigger_diff=0;
263    for(i=0;i<kNdata-1;i++){
264      diff[i]     = (data[i]-data[i+1])/step_dac;
265      dac_diff[i] = dac[i]+step_dac/2;
266      hist_diff[ch].Fill(dac_diff[i],diff[i]);
267      if(dac_diff[i]>=fit_min){
268        diff_sum += diff[i]*dac_diff[i];
269        //cerr << "diff[" << i << "], dac_diff[" << i << "] "
270        //<< diff[i] << " " << dac_diff[i] << endl;
271        trigger_diff+=diff[i];
272      }
273    }
274    //mean_diff[ch] = diff_sum/trigger_diff;
275    hist_diff[ch].GetXaxis()->SetRangeUser(fit_min,fit_max);
276    mean_diff[ch] = hist_diff[ch].GetMean();
277    //cerr << "trigger_diff, mean_diff[" << ch << "] "
278    //<< trigger_diff << " " << mean_diff[ch] << endl;
279   
280   
281    /******************* GRAPHICS *****************/
282    c1->cd(ch+1);   
283    /*** fit scurves  ***/
284    cerr << "ch " << ch;
285    //if(ch==43 || ch==47){
286    if(ch==170){
287      TF1 *fit_pol      = new TF1("fit_pol","pol4",150,fit_max_scurve);
288      hist_scurve[ch].Fit(fit_pol,"","",150,fit_max_scurve);
289    }else{
290      TF1 *fit_pol      = new TF1("fit_pol","pol4",fit_min_scurve,fit_max_scurve);
291      hist_scurve[ch].Fit(fit_pol,"","",fit_min_scurve,fit_max_scurve);
292    }
293    Double_t fit_par_pol4[5];
294    fit_pol->GetParameters(fit_par_pol4);
295    sfit_chiS[ch] =  fit_pol->GetChisquare();
296    TF1 *func               = hist_scurve[ch].GetFunction("fit_pol");
297    Double_t data_diff_fit;
298    for(i=0;i<kNdataFit;i++){
299      //if(ch==43 || ch==47){
300      if(ch==170){
301        dac_fit[i]  = hist_scurve[ch].GetBinCenter(i)+150-dac_min;
302        data_fit[i] = func->Eval(hist_scurve[ch].GetBinCenter(i)+150-dac_min);
303      }else{
304        dac_fit[i]  = hist_scurve[ch].GetBinCenter(i)+fit_min_scurve-dac_min;
305        data_fit[i] = func->Eval(hist_scurve[ch].GetBinCenter(i)+fit_min_scurve-dac_min);
306        //cerr << "dac_fit[" << i << "], data_fit[" << i << "] "
307        //<< dac_fit[i] << " " << data_fit[i] << endl;
308      }
309    }
310    Double_t dac_diff_fit;
311    for(i=0;i<kNdataFit-1;i++){
312      data_diff_fit = (data_fit[i]-data_fit[i+1])/step_dac;
313      hist_diff_fit[ch].Fill(dac_fit[i],data_diff_fit);
314    }
315
316    TLine *lhalf_max   = new TLine(dac[0],kHalfMax,dac[kNdata-1],kHalfMax);
317    TLine *ldac_half   = new TLine(dac_half[ch],0,dac_half[ch],
318                                   (Double_t)kDrawMax);
319    hist_scurve[ch].SetMaximum(kDrawMax);
320    hist_scurve[ch].GetXaxis()->SetRangeUser(kDrawDacMin,kDrawDacMax);
321    hist_scurve[ch].Draw();
322    lhalf_max->Draw("same"); 
323    ldac_half->Draw("same");
324    if(dac_half[ch]>0){
325      dac_half_sum += dac_half[ch]-dac_ped[ch]; //relative absolute value
326      trigger++;
327    }
328
329    /*** Differential plot from scurve fitting function  ***/
330    c5->cd(ch+1);
331    hist_diff_fit[ch].GetXaxis()->SetRangeUser(fit_min_scurve,fit_max_scurve-2*step_dac);
332    Double_t dac_sfit_max=hist_diff_fit[ch].GetBinCenter(hist_diff_fit[ch].GetMaximumBin());
333    //if(dac_sfit_max<=fit_min_scurve+4*step_dac){
334    if(dac_sfit_max<=fit_min_scurve+2*step_dac){
335      hist_diff_fit[ch].GetXaxis()->SetRangeUser(fit_min_scurve+kFitSadj,fit_max_scurve-2*step_dac);
336      dac_sfit[ch]  =  hist_diff_fit[ch].GetBinCenter(hist_diff_fit[ch].GetMaximumBin());
337      //if(dac_sfit[ch]<=fit_min_scurve+kFitSadj+4*step_dac)dac_sfit[ch]=-1;
338      if(dac_sfit[ch]<fit_min_scurve+kFitSadj+step_dac){
339        dac_sfit[ch]=-1;
340        //dac_sfit[ch]=dac_half[ch];
341        flag_fit[ch] = -1;
342        cerr << "flag_fit[" << ch << "] " << flag_fit[ch]  << endl;
343      }
344    }else {
345      dac_sfit[ch]  =  hist_diff_fit[ch].GetBinCenter(hist_diff_fit[ch].GetMaximumBin());
346    }
347
348    if(dac_sfit[ch]>fit_min_scurve+5){
349      dac_sfit_sum += dac_sfit[ch]-dac_ped[ch];
350      trigger_sfit++;
351    }else{
352      //dac_sfit[ch] = fit_min_scurve+10;
353      dac_sfit[ch] = -1;
354    }
355    //cerr << "dac_sfit[" << ch << "] " << dac_sfit[ch] << endl;
356    TLine *ldac_sfit      = new TLine(dac_sfit[ch],0,dac_sfit[ch],kDrawMaxFit);
357    TLine *ldac_sfit_copy = new TLine(dac_sfit[ch],0,dac_sfit[ch],kDrawMax);
358    ldac_sfit->SetLineColor(kMagenta);
359    ldac_sfit_copy->SetLineColor(kMagenta);
360    hist_diff_fit[ch].SetMaximum(kDrawMaxFit);
361    hist_diff_fit[ch].SetMinimum(0);
362    hist_diff_fit[ch].Draw();
363    ldac_sfit->Draw("same");
364   
365    /**** differential plot ****/
366    c2->cd(ch+1);
367    //hist_diff[ch].Rebin(8);
368    hist_diff[ch].Rebin(3);
369    fit_sdiff     = new TF1("fit_sdiff","gaus",dac_min,dac_max);
370    //fit_sdiff->SetLineWidth(1);
371    //if(ch==8 || ch==18 || ch==44 || ch==56)
372    mean_sum += mean_diff[ch]-dac_ped[ch];
373    trigger_mean++;
374
375    Double_t fit_par[3];
376    //hist_diff[ch].Fit(fit_sdiff,"RQ0","",fit_min,fit_max);
377    hist_diff[ch].Fit(fit_sdiff,"","",fit_min,fit_max);
378    hist_diff[ch].GetXaxis()->SetRangeUser(kDrawDacMin,kDrawDacMax);
379    hist_diff[ch].SetMinimum(0);
380    hist_diff[ch].SetMaximum(kDrawMaxDiff);
381    //hist_diff[ch].Rebin();
382    hist_diff[ch].Draw();
383    fit_sdiff->GetParameters(fit_par);
384    dac_spe[ch] = fit_par[1];
385    if(dac_spe[ch]>fit_min){
386      dac_spe_sum += dac_spe[ch]-dac_ped[ch];
387      //cerr << "dac_spe[" << ch << "] " << dac_spe[ch] << endl;
388      trigger_fit++;
389    }else{
390      dac_spe[ch] = fit_min+10;
391    }
392    //cerr << "dac_spe[" << ch << "] " << dac_spe[ch] << endl;
393    TLine *ldac_spe    = new TLine(dac_spe[ch],0,dac_spe[ch],
394                                 (Double_t)kDrawMaxDiff);
395    ldac_spe->SetLineColor(kRed);
396    TLine *lmean_diff  = new TLine(mean_diff[ch],0,mean_diff[ch],
397                                   (Double_t)kDrawMaxDiff);
398    lmean_diff->SetLineColor(kCyan);
399    TLine *lfit_min    = new TLine(fit_min,0,fit_min,kDrawMaxDiff);
400    lfit_min->SetLineColor(kGray);
401
402    ldac_spe->Draw();
403    lmean_diff->Draw("same");
404    lfit_min->Draw("same");
405   
406    c3->cd(1);
407    if(ch==0){
408      hist_scurve[ch].SetMaximum(kDrawMax);
409      hist_scurve[ch].Draw();
410    }else{
411    /*if(ch==8 || ch==18 || ch==44 || ch==56)*/
412      hist_scurve[ch].Draw("same");
413    }
414    if(ch==kDrawCh){
415      c3->cd(2);
416      hist_scurve[ch].SetMaximum(kDrawMax);
417      hist_scurve[kDrawCh].Draw();
418      lhalf_max->Draw("same"); 
419      ldac_half->Draw("same");
420      ldac_sfit_copy->Draw("same");
421      c3->cd(3);
422      hist_diff[kDrawCh].Draw();     
423      ldac_spe->Draw();
424      lmean_diff->Draw("same");
425      lfit_min->Draw("same");
426      c3->cd(4);
427      hist_diff_fit[kDrawCh].Draw();
428       ldac_sfit->Draw("same");
429      }
430    /*
431    if(ch<32){
432      c6->cd(ch/4+1);
433      hist_scurve[ch].SetMaximum(kDrawMax);
434      if(ch%4==0){
435        hist_scurve[ch].Draw();
436      }else{
437        hist_scurve[ch].Draw("same");
438      }
439      ldac_sfit_copy->Draw("same");
440    }else{
441      c7->cd(ch/4-7);
442      hist_scurve[ch].SetMaximum(kDrawMax);
443      if(ch%4==0){
444        hist_scurve[ch].Draw();
445      }else{
446        hist_scurve[ch].Draw("same");
447      }
448      ldac_sfit_copy->Draw("same");
449      }
450    */
451   
452    c4->cd();
453    if(ch==0){
454      hist_scurve_ped[ch].SetMaximum(kDrawMaxPed);
455      hist_scurve_ped[ch].Draw("l");
456    }else{
457      hist_scurve_ped[ch].Draw("lsame");
458    }
459   
460  }
461 
462  if(!checkAve){
463    Float_t dac_ped_ave   = dac_ped[kChRef]; //absolute value
464    Float_t dac_half_ave  = dac_half[kChRef];
465    Float_t dac_spe_ave   = dac_spe[kChRef];
466    Float_t dac_sfit_ave  = dac_sfit[kChRef];
467    //Float_t dac_sfit_ave  = 252.5; //dac_sfit of ch31 of ASIC_C with the 180 for lower gain pixels
468    Float_t mean_diff_ave = mean_diff[kChRef];
469  }else{
470    Float_t dac_ped_ave  = dac_ped_sum/(Float_t)kNch; //absolute value
471    Float_t dac_half_ave = dac_half_sum/(Float_t)trigger+dac_ped_ave;
472    Float_t dac_spe_ave  = dac_spe_sum/(Float_t)trigger_fit+dac_ped_ave;
473    Float_t mean_diff_ave = mean_sum/(Float_t)trigger_mean+dac_ped_ave; 
474    Float_t dac_sfit_ave = dac_sfit_sum/(Float_t)trigger_sfit+dac_ped_ave; 
475  }
476  //trigger_mean=4;
477  if(dac_half_spe_fix!=-1) {
478    Double_t dac_half_spe = dac_half_spe_fix;
479  } else {
480    //Double_t dac_half_spe = dac_half_ave;
481    Double_t dac_half_spe = dac_spe_ave;
482  }
483
484  TLine *ldac_ped_ave   = new TLine(dac_ped_ave,0,dac_ped_ave,
485                                   (Double_t)kDrawMax);
486  TLine *ldac_ped_ave_copy = new TLine(dac_ped_ave,0,dac_ped_ave,
487                                   (Double_t)kDrawMaxDiff);
488  TLine *ldac_half_ave  = new TLine(dac_half_ave,0,dac_half_ave,
489                                   (Double_t)kDrawMax);
490  TLine *ldac_half_spe  = new TLine(dac_half_spe,0,dac_half_spe,
491                                   (Double_t)kDrawMax);
492  TLine *lmean_diff_ave = new TLine(mean_diff_ave,0,mean_diff_ave,
493                                   (Double_t)kDrawMax);
494  TLine *ldac_sfit_ave  = new TLine(dac_sfit_ave,0,dac_sfit_ave,
495                                   (Double_t)kDrawMax);
496  ldac_ped_ave->SetLineColor(kOrange);
497  ldac_half_ave->SetLineColor(kRed);
498  lmean_diff_ave->SetLineColor(kCyan);
499  //ldac_half_spe->SetLineColor(kGreen);
500  ldac_sfit_ave->SetLineColor(kMagenta); 
501
502  c3->cd(1);
503  ldac_ped_ave->Draw("same");
504  ldac_half_ave->Draw("same");
505  lhalf_max->Draw("same");
506  ldac_half_spe->Draw("same");
507  lmean_diff_ave->Draw("same");
508  ldac_sfit_ave->Draw("same");
509
510  c3->cd(3);
511  ldac_ped_ave_copy->SetLineColor(kOrange);
512  ldac_ped_ave_copy->Draw("same");
513
514  Int_t    gain_asic_diff, gain_asic_dacHalf, gain_asic_diff_mean, gain_asic_sfit;
515  cerr << "title  ch  g_asic_dacHalf  g_asic_diff  g_asic_diff_mean  g_asic_sfit  dac_half[ch]  dac_ped[ch]  dac_spe[ch]  dac_half_ave dac_half_spe dac_ped_ave  dac_sfit_ave" 
516       << endl;
517  for(ch=0;ch<kNch;ch++){
518    /*
519    if(ch==8 || ch==44 || ch==56 || ch==18){
520      gain_asic_diff_mean=(Int_t)((mean_diff_ave-dac_ped_ave)/
521                                  (mean_diff[ch]-dac_ped[ch])*gain_org[ch]);
522    }else{
523      gain_asic_diff_mean=0;
524    }
525    */
526    if(dac_half[ch]<0){
527      gain_asic_dacHalf   = 0;
528      gain_asic_diff      = 0;
529      gain_asic_diff_mean = 0;
530      gain_asic_sfit      = 0;
531    }else{
532      gain_asic_dacHalf  =(Int_t)((dac_half_ave-dac_ped_ave)/
533                                (dac_half[ch]-dac_ped[ch])*gain_org[ch]);
534      gain_asic_diff     =(Int_t)((dac_half_spe-dac_ped_ave)/
535                             (dac_spe[ch]-dac_ped[ch])*gain_org[ch]);
536      gain_asic_diff_mean=(Int_t)((mean_diff_ave-dac_ped_ave)/
537                                  (mean_diff[ch]-dac_ped[ch])*gain_org[ch]);
538      gain_asic_sfit     =(Int_t)((dac_sfit_ave-dac_ped_ave)/
539                             (dac_sfit[ch]-dac_ped[ch])*gain_org[ch]);
540      //cerr << ch << " " << gain_org[ch] << endl;
541    }
542    cout << "OUT_TABLE    "
543         << ch << "    "
544         << gain_asic_dacHalf   << "    "
545         << gain_asic_diff      << "    "
546         << gain_asic_diff_mean << "    "
547         << gain_asic_sfit      << "    "
548         << dac_half[ch]        << "    "
549         << dac_ped[ch]         << "    "
550         << (Int_t)dac_spe[ch]  << "    "
551         << dac_half_ave        << "    "
552         << dac_half_spe        << "    "
553         << dac_ped_ave         << "    "
554         << dac_sfit_ave        << "    "
555         << sfit_chiS[ch]       << "    "
556         << ch                  << "    "
557         << flag_fit[ch]       
558         << endl;
559  }
560  /*
561    for(ch=kNch-1;ch>=0;ch--){
562    cout << "OUT_TABLE_INV    "
563    << (Int_t)(dac_half_ave/(dac_half[ch]-dac_ped)*64)
564      << endl;
565      }
566  */
567 
568 
569}
570
571
572
573
574
575 
576
577
Note: See TracBrowser for help on using the repository browser.