source: JEM-EUSO/equalization_gain/trunk/src/PlotScurvesAll-diffFit.C @ 191

#include <fstream>
#include <iostream>
#include "TH1D.h"
#include "TH2D.h"
#include "TCanvas.h"
#include "TF1.h"
#include "TPad.h"
#include "TGraphErrors.h"
#include "TGraph.h"
#include "TLine.h"
#include "PlotScurvesAll-diffFitConst.h"

// for format of EC_ASIC Scurves_all_ASIC data
// ASIC A,B,C,.... : i=0,1,2,... ch 0,1,...,63 : j=0,1,...,63
// % cat scurves_PC_inj_run5.lvm |awk '{i=2;j=37;print($1,$(i*64+j+1+1))}'
//   > scurves_PC_inj_run5-C-ch37.data
// => % cd $datadir
// => % sh $srcdir/makeDataFile.sh with assigining proper fname
// PlotScurvesAll-diffFit-v6.6.C: dac_sfit[ch]=-1; in the case of fitting failure.


void PlotScurve(
                Int_t    kDrawCh=31,
                TString  fname=kFname,
                TString  fname_ped=kFnamePed, //ASIC_D ped_file
                Double_t dac_half_spe_fix = -1,
                TString  fname_gain="gain-org.txt",
                Int_t    fit_min=kFitMin,
                Int_t    fit_max=kFitMax,
                Int_t    fit_min_scurve=kFitMinS,
                Int_t    fit_max_scurve=kFitMaxS,
                Bool_t   kBoard=1, //0:ASIC_C, 1:ASIC_D
                Int_t    kChRef=kRefCh,//ASIC_C
                Bool_t   checkAve=0 //0:use ref pix, 1:check average
                ){
                //NOTE   
                //Double_t dac_half_spe_fix = 177; //for EC_ASICb N101(asic N158). 
                //check DAC value corresponds to voltage to 160fC input 
                //(depends on DAC linearity)
                //Double_t dac_half_spe_fix = -1 //set gain to DAC average (default)

  /******************* Readout data file *********************/
  
  /*********************** SIGNAL RUN ********************/
  TString *input             = new TString[kNch];
  TString *input_ped         = new TString[kNch];
  Int_t    ch;
  Float_t  dac_half_sum      = 0;
  Float_t  dac_ped_sum       = 0;
  Float_t  dac_spe_sum       = 0;
  Float_t  dac_sfit_sum      = 0;
  Float_t  diff_sum          = 0;
  Float_t  mean_sum          = 0;
  Float_t  maxBinSum         = 0;
  Double_t dac_half[kNch];
  Double_t dac_ped[kNch];
  Double_t dac_spe[kNch];
  Double_t dac_sfit[kNch];
  Double_t mean_diff[kNch];
  Double_t gain_org[kNch];
  Double_t sfit_chiS[kNch];
  Double_t flag_fit[kNch];

  TCanvas *c1                = new TCanvas("c1","c1",200,20,1100,600);
  c1->Divide(11,6);
  TCanvas *c2                = new TCanvas("c2","c2",300,50,1100,600);
  c2->Divide(11,6);
  TCanvas *c5                = new TCanvas("c5","c5",400,70,1100,600);
  c5->Divide(11,6);
  TCanvas *c3                = new TCanvas("c3","c3",500,100,1200,300);
  c3->Divide(4,1);
  /*TCanvas *c6                = new TCanvas("c6","c6",450,150,1000,500);
  c6->Divide(4,2);
  TCanvas *c7                = new TCanvas("c7","c7",470,200,1000,500);
  c7->Divide(4,2);*/
  TCanvas *c4                = new TCanvas("c4","c4",900,400,300,300);

  TString  name_hist[kNch];
  TString  name_hist_ped[kNch];
  TString  name_hist_diff[kNch];
  TString  name_hist_diff_fit[kNch];
  TString  name_fit_diff[kNch];
  TH1D    *hist_scurve       = new TH1D[kNch];
  TH1D    *hist_scurve_ped   = new TH1D[kNch];
  TH1D    *hist_diff         = new TH1D[kNch];
  TH1D    *hist_diff_fit     = new TH1D[kNch];
  TF1     *fit_sdiff         = new TF1[kNch];

  TString input_gain(fname_gain);
  ifstream in_gain(input_gain.Data());
  if(!in_gain.good()){
    cerr << "File " << input_gain << " open failed!" << endl;
    return;
  }
  
  for(ch=0;ch<kNch;ch++){
    dac_half[ch]=0;
    dac_ped[ch]=0;
    dac_spe[ch]=0;
    dac_sfit[ch]=0;
    gain_org[ch]=0;
    mean_diff[ch]=0;
    sfit_chiS[ch]=0;
    flag_fit[ch]=0;
    name_hist[ch]           ="hist";
    name_hist[ch]          +=ch;
    name_hist_ped[ch]       ="hist_ped";
    name_hist_ped[ch]      +=ch;
    name_hist_diff[ch]      ="hist_diff";
    name_hist_diff[ch]     +=ch;
    name_hist_diff_fit[ch]  ="hist_diff_fit";
    name_hist_diff_fit[ch] +=ch;
    name_fit_diff[ch]       ="fit_diff";
    name_fit_diff[ch]      +=ch;
  }
  
  Double_t da;
  Int_t count=0;
  ch=0;
  while(in_gain >> da){
    if(!kBoard && (count>=128 && count<192)){
      gain_org[ch]=da;
      cerr << "!kBoard, count, gain_org[" << ch << "] "
           << !kBoard << " " << count << " " << gain_org[ch] << endl;
      ch++;
    }
    if(kBoard && (count>=192 && count<256)){
      gain_org[ch]=da;
      cerr << "kBoard, count, gain_org[" << ch << "] "
           << kBoard << " " << count << " " << gain_org[ch] << endl;
      ch++;
    }
    count++;
  }      
  in_gain.close();
  in_gain.clear();
  

  Int_t trigger=0, trigger_fit=0, trigger_mean=0, trigger_sfit=0;
  for(ch=0;ch<kNch;ch++){
    input[ch] += fname;
    input[ch] += "-ch";
    input[ch] += ch;
    input[ch] += ".dat";
    ifstream in(input[ch].Data());
    if(!in.good()){
      cerr << "File " << input[ch] << " open failed!" << endl;
      return;
    }

    input_ped[ch] += fname_ped;
    input_ped[ch] += "-ch";
    input_ped[ch] += ch;
    input_ped[ch] += ".dat";
    ifstream in_ped(input_ped[ch].Data());
    if(!in_ped.good()){
      cerr << "File " << input_ped[ch] << " open failed!" << endl;
      return;
    }    


    
    //10DAC~10mV

    Double_t da, dat, dac_min, dac_max, step_dac;
    count = 0;
    while (in >> da >> dat ){
      if(count==0) dac_min  = da;
      if(count==1) step_dac = da - dac_min;
      dac_max=da;
      count++;
    }      
    in.close();
    in.clear();

    /*    
    if(ch==43 || ch==47){//for T1 ASIC_C
      cerr << "CHECK " << ch << " " << fit_min_scurve << endl;
      Int_t fit_min_scurve=140;
    } else {
      Int_t fit_min_scurve=kFitMinS;
    }
    */

    if(kXmin<dac_min)kXmin=dac_min;
    const Int_t kNdata    = count;
    count = (fit_max_scurve-fit_min_scurve)/step_dac;
    const Int_t kNdataFit = count;
    if(ch==0){
      cerr << "kNdata, dac_min, dac_max, step_dac: " 
           << kNdata << " " << dac_min << " " << dac_max << " " 
           << step_dac << endl;
    }
    
    Double_t dac_min_ped, dac_max_ped, step_dac_ped;
    count = 0;
    while (in_ped >> da >> dat ){
      if(count==0) dac_min_ped  = da;
      if(count==1) step_dac_ped = da - dac_min_ped;
      dac_max_ped=da;
      count++;
    }      
    in_ped.close();
    in_ped.clear();
    

    const Int_t kNdataPed = count;
    if(ch==0){
      cerr << "kNdataPed, dac_min_ped, dac_max_ped, step_dac_ped: " 
           << kNdataPed << " " << dac_min_ped << " " << dac_max_ped 
           << " " << step_dac_ped << endl;
    }
    
    hist_scurve[ch]      = TH1D(name_hist[ch],name_hist[ch],kNdata-1,
                                dac_min,dac_max);
    hist_scurve_ped[ch]  = TH1D(name_hist_ped[ch],name_hist_ped[ch],
                                kNdataPed-1,dac_min_ped,dac_max_ped);
    hist_diff[ch]        = TH1D(name_hist_diff[ch],name_hist_diff[ch],
                                kNdata-2,dac_min,dac_max);
    hist_diff_fit[ch]    = TH1D(name_hist_diff_fit[ch],name_hist_diff_fit[ch],
                                kNdataFit,fit_min_scurve,fit_max_scurve);

    in.open(input[ch].Data());
    Double_t       data[kNdata], dac[kNdata], dac_fit[kNdataFit], data_fit[kNdataFit];
    while (in >> da >> dat ){
      hist_scurve[ch].Fill(da,dat);
    }
    in.close();
    in.clear();

    in_ped.open(input_ped[ch].Data());
    while (in_ped >> da >> dat ){
      hist_scurve_ped[ch].Fill(da,dat);
    }
    in_ped.close();
    in_ped.clear();

    //dac_ped[ch]  = hist_scurve_ped[ch].GetMaximumBin()+dac_min_ped; //absolute value
    dac_ped[ch]  = hist_scurve_ped[ch].GetBinCenter(hist_scurve_ped[ch].GetMaximumBin()); //absolute value
    dac_ped_sum += dac_ped[ch]; //absolute value
    //cerr << "dac_ped[" << ch << "] dac_ped_sum " << dac_ped[ch] 
    //<< " " << dac_ped_sum << endl;
    

    hist_scurve[ch].Smooth(3);
    Int_t binx=0;
    //hist_scurve[ch].GetBinWithContent(kHalfMax,binx,kXmin-dac_min+1,
    //                                  dac_max-dac_min+1,kHalfMax/2.);
    hist_scurve[ch].GetBinWithContent(kHalfMax,binx,kXmin-dac_min+1,
                                      dac_max-dac_min+1,2000);
    dac_half[ch] = hist_scurve[ch].GetBinCenter(binx); //absolute value
    if(dac_half[ch]<kXmin)dac_half[ch]=-1;
    
    Int_t i=0;
    for(i=0;i<kNdata;i++){
      dac[i]  = hist_scurve[ch].GetBinCenter(i+1);
      data[i] = hist_scurve[ch].GetBinContent(i+1);
    }
   
    /*** derive diff ***/
    Double_t diff[kNdata-1], dac_diff[kNdata-1];
    Int_t trigger_diff=0;
    for(i=0;i<kNdata-1;i++){
      diff[i]     = (data[i]-data[i+1])/step_dac;
      dac_diff[i] = dac[i]+step_dac/2;
      hist_diff[ch].Fill(dac_diff[i],diff[i]);
      if(dac_diff[i]>=fit_min){
        diff_sum += diff[i]*dac_diff[i];
        //cerr << "diff[" << i << "], dac_diff[" << i << "] "
        //<< diff[i] << " " << dac_diff[i] << endl;
        trigger_diff+=diff[i];
      }
    }
    //mean_diff[ch] = diff_sum/trigger_diff;
    hist_diff[ch].GetXaxis()->SetRangeUser(fit_min,fit_max);
    mean_diff[ch] = hist_diff[ch].GetMean();
    //cerr << "trigger_diff, mean_diff[" << ch << "] " 
    //<< trigger_diff << " " << mean_diff[ch] << endl;
    
   
    /******************* GRAPHICS *****************/
    c1->cd(ch+1);    
    /*** fit scurves  ***/
    cerr << "ch " << ch;
    //if(ch==43 || ch==47){
    if(ch==170){
      TF1 *fit_pol      = new TF1("fit_pol","pol4",150,fit_max_scurve);
      hist_scurve[ch].Fit(fit_pol,"","",150,fit_max_scurve);
    }else{
      TF1 *fit_pol      = new TF1("fit_pol","pol4",fit_min_scurve,fit_max_scurve);
      hist_scurve[ch].Fit(fit_pol,"","",fit_min_scurve,fit_max_scurve);
    }
    Double_t fit_par_pol4[5];
    fit_pol->GetParameters(fit_par_pol4);
    sfit_chiS[ch] =  fit_pol->GetChisquare();
    TF1 *func               = hist_scurve[ch].GetFunction("fit_pol");
    Double_t data_diff_fit;
    for(i=0;i<kNdataFit;i++){
      //if(ch==43 || ch==47){
      if(ch==170){
        dac_fit[i]  = hist_scurve[ch].GetBinCenter(i)+150-dac_min;
        data_fit[i] = func->Eval(hist_scurve[ch].GetBinCenter(i)+150-dac_min);
      }else{
        dac_fit[i]  = hist_scurve[ch].GetBinCenter(i)+fit_min_scurve-dac_min;
        data_fit[i] = func->Eval(hist_scurve[ch].GetBinCenter(i)+fit_min_scurve-dac_min);
        //cerr << "dac_fit[" << i << "], data_fit[" << i << "] "
        //<< dac_fit[i] << " " << data_fit[i] << endl;
      }
    }
    Double_t dac_diff_fit;
    for(i=0;i<kNdataFit-1;i++){
      data_diff_fit = (data_fit[i]-data_fit[i+1])/step_dac;
      hist_diff_fit[ch].Fill(dac_fit[i],data_diff_fit);
    }

    TLine *lhalf_max   = new TLine(dac[0],kHalfMax,dac[kNdata-1],kHalfMax);
    TLine *ldac_half   = new TLine(dac_half[ch],0,dac_half[ch],
                                   (Double_t)kDrawMax);
    hist_scurve[ch].SetMaximum(kDrawMax);
    hist_scurve[ch].GetXaxis()->SetRangeUser(kDrawDacMin,kDrawDacMax);
    hist_scurve[ch].Draw();
    lhalf_max->Draw("same");  
    ldac_half->Draw("same");
    if(dac_half[ch]>0){
      dac_half_sum += dac_half[ch]-dac_ped[ch]; //relative absolute value
      trigger++;
    }

    /*** Differential plot from scurve fitting function  ***/
    c5->cd(ch+1);
    hist_diff_fit[ch].GetXaxis()->SetRangeUser(fit_min_scurve,fit_max_scurve-2*step_dac);
    Double_t dac_sfit_max=hist_diff_fit[ch].GetBinCenter(hist_diff_fit[ch].GetMaximumBin());
    //if(dac_sfit_max<=fit_min_scurve+4*step_dac){
    if(dac_sfit_max<=fit_min_scurve+2*step_dac){
      hist_diff_fit[ch].GetXaxis()->SetRangeUser(fit_min_scurve+kFitSadj,fit_max_scurve-2*step_dac);
      dac_sfit[ch]  =  hist_diff_fit[ch].GetBinCenter(hist_diff_fit[ch].GetMaximumBin());
      //if(dac_sfit[ch]<=fit_min_scurve+kFitSadj+4*step_dac)dac_sfit[ch]=-1;
      if(dac_sfit[ch]<fit_min_scurve+kFitSadj+step_dac){
        dac_sfit[ch]=-1;
        //dac_sfit[ch]=dac_half[ch];
        flag_fit[ch] = -1;
        cerr << "flag_fit[" << ch << "] " << flag_fit[ch]  << endl;
      }
    }else {
      dac_sfit[ch]  =  hist_diff_fit[ch].GetBinCenter(hist_diff_fit[ch].GetMaximumBin());
    }

    if(dac_sfit[ch]>fit_min_scurve+5){
      dac_sfit_sum += dac_sfit[ch]-dac_ped[ch];
      trigger_sfit++;
    }else{
      //dac_sfit[ch] = fit_min_scurve+10;
      dac_sfit[ch] = -1;
    }
    //cerr << "dac_sfit[" << ch << "] " << dac_sfit[ch] << endl;
    TLine *ldac_sfit      = new TLine(dac_sfit[ch],0,dac_sfit[ch],kDrawMaxFit);
    TLine *ldac_sfit_copy = new TLine(dac_sfit[ch],0,dac_sfit[ch],kDrawMax);
    ldac_sfit->SetLineColor(kMagenta);
    ldac_sfit_copy->SetLineColor(kMagenta);
    hist_diff_fit[ch].SetMaximum(kDrawMaxFit);
    hist_diff_fit[ch].SetMinimum(0);
    hist_diff_fit[ch].Draw();
    ldac_sfit->Draw("same");
    
    /**** differential plot ****/
    c2->cd(ch+1);
    //hist_diff[ch].Rebin(8);
    hist_diff[ch].Rebin(3);
    fit_sdiff     = new TF1("fit_sdiff","gaus",dac_min,dac_max);
    //fit_sdiff->SetLineWidth(1);
    //if(ch==8 || ch==18 || ch==44 || ch==56)
    mean_sum += mean_diff[ch]-dac_ped[ch];
    trigger_mean++;

    Double_t fit_par[3];
    //hist_diff[ch].Fit(fit_sdiff,"RQ0","",fit_min,fit_max);
    hist_diff[ch].Fit(fit_sdiff,"","",fit_min,fit_max);
    hist_diff[ch].GetXaxis()->SetRangeUser(kDrawDacMin,kDrawDacMax);
    hist_diff[ch].SetMinimum(0);
    hist_diff[ch].SetMaximum(kDrawMaxDiff);
    //hist_diff[ch].Rebin();
    hist_diff[ch].Draw();
    fit_sdiff->GetParameters(fit_par);
    dac_spe[ch] = fit_par[1];
    if(dac_spe[ch]>fit_min){
      dac_spe_sum += dac_spe[ch]-dac_ped[ch];
      //cerr << "dac_spe[" << ch << "] " << dac_spe[ch] << endl;
      trigger_fit++;
    }else{
      dac_spe[ch] = fit_min+10;
    }
    //cerr << "dac_spe[" << ch << "] " << dac_spe[ch] << endl;
    TLine *ldac_spe    = new TLine(dac_spe[ch],0,dac_spe[ch],
                                 (Double_t)kDrawMaxDiff);
    ldac_spe->SetLineColor(kRed);
    TLine *lmean_diff  = new TLine(mean_diff[ch],0,mean_diff[ch],
                                   (Double_t)kDrawMaxDiff);
    lmean_diff->SetLineColor(kCyan);
    TLine *lfit_min    = new TLine(fit_min,0,fit_min,kDrawMaxDiff);
    lfit_min->SetLineColor(kGray);

    ldac_spe->Draw();
    lmean_diff->Draw("same");
    lfit_min->Draw("same");
    
    c3->cd(1);
    if(ch==0){
      hist_scurve[ch].SetMaximum(kDrawMax);
      hist_scurve[ch].Draw();
    }else{
    /*if(ch==8 || ch==18 || ch==44 || ch==56)*/
      hist_scurve[ch].Draw("same");
    }
    if(ch==kDrawCh){
      c3->cd(2);
      hist_scurve[ch].SetMaximum(kDrawMax);
      hist_scurve[kDrawCh].Draw();
      lhalf_max->Draw("same");  
      ldac_half->Draw("same");
      ldac_sfit_copy->Draw("same");
      c3->cd(3);
      hist_diff[kDrawCh].Draw();      
      ldac_spe->Draw();
      lmean_diff->Draw("same");
      lfit_min->Draw("same");
      c3->cd(4);
      hist_diff_fit[kDrawCh].Draw();
       ldac_sfit->Draw("same");
      }
    /*
    if(ch<32){
      c6->cd(ch/4+1);
      hist_scurve[ch].SetMaximum(kDrawMax);
      if(ch%4==0){
        hist_scurve[ch].Draw();
      }else{
        hist_scurve[ch].Draw("same");
      }
      ldac_sfit_copy->Draw("same");
    }else{
      c7->cd(ch/4-7);
      hist_scurve[ch].SetMaximum(kDrawMax);
      if(ch%4==0){
        hist_scurve[ch].Draw();
      }else{
        hist_scurve[ch].Draw("same");
      }
      ldac_sfit_copy->Draw("same");
      }
    */
    
    c4->cd();
    if(ch==0){
      hist_scurve_ped[ch].SetMaximum(kDrawMaxPed);
      hist_scurve_ped[ch].Draw("l");
    }else{
      hist_scurve_ped[ch].Draw("lsame");
    }
    
  }
  
  if(!checkAve){
    Float_t dac_ped_ave   = dac_ped[kChRef]; //absolute value
    Float_t dac_half_ave  = dac_half[kChRef];
    Float_t dac_spe_ave   = dac_spe[kChRef];
    Float_t dac_sfit_ave  = dac_sfit[kChRef];
    //Float_t dac_sfit_ave  = 252.5; //dac_sfit of ch31 of ASIC_C with the 180 for lower gain pixels
    Float_t mean_diff_ave = mean_diff[kChRef];
  }else{
    Float_t dac_ped_ave  = dac_ped_sum/(Float_t)kNch; //absolute value
    Float_t dac_half_ave = dac_half_sum/(Float_t)trigger+dac_ped_ave;
    Float_t dac_spe_ave  = dac_spe_sum/(Float_t)trigger_fit+dac_ped_ave;
    Float_t mean_diff_ave = mean_sum/(Float_t)trigger_mean+dac_ped_ave; 
    Float_t dac_sfit_ave = dac_sfit_sum/(Float_t)trigger_sfit+dac_ped_ave; 
  }
  //trigger_mean=4;
  if(dac_half_spe_fix!=-1) {
    Double_t dac_half_spe = dac_half_spe_fix;
  } else {
    //Double_t dac_half_spe = dac_half_ave;
    Double_t dac_half_spe = dac_spe_ave;
  }

  TLine *ldac_ped_ave   = new TLine(dac_ped_ave,0,dac_ped_ave,
                                   (Double_t)kDrawMax);
  TLine *ldac_ped_ave_copy = new TLine(dac_ped_ave,0,dac_ped_ave,
                                   (Double_t)kDrawMaxDiff);
  TLine *ldac_half_ave  = new TLine(dac_half_ave,0,dac_half_ave,
                                   (Double_t)kDrawMax);
  TLine *ldac_half_spe  = new TLine(dac_half_spe,0,dac_half_spe,
                                   (Double_t)kDrawMax);
  TLine *lmean_diff_ave = new TLine(mean_diff_ave,0,mean_diff_ave,
                                   (Double_t)kDrawMax);
  TLine *ldac_sfit_ave  = new TLine(dac_sfit_ave,0,dac_sfit_ave,
                                   (Double_t)kDrawMax);
  ldac_ped_ave->SetLineColor(kOrange);
  ldac_half_ave->SetLineColor(kRed);
  lmean_diff_ave->SetLineColor(kCyan);
  //ldac_half_spe->SetLineColor(kGreen);
  ldac_sfit_ave->SetLineColor(kMagenta);  

  c3->cd(1);
  ldac_ped_ave->Draw("same");
  ldac_half_ave->Draw("same");
  lhalf_max->Draw("same");
  ldac_half_spe->Draw("same");
  lmean_diff_ave->Draw("same");
  ldac_sfit_ave->Draw("same");

  c3->cd(3);
  ldac_ped_ave_copy->SetLineColor(kOrange);
  ldac_ped_ave_copy->Draw("same");

  Int_t    gain_asic_diff, gain_asic_dacHalf, gain_asic_diff_mean, gain_asic_sfit;
  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" 
       << endl;
  for(ch=0;ch<kNch;ch++){
    /*
    if(ch==8 || ch==44 || ch==56 || ch==18){
      gain_asic_diff_mean=(Int_t)((mean_diff_ave-dac_ped_ave)/
                                  (mean_diff[ch]-dac_ped[ch])*gain_org[ch]);
    }else{
      gain_asic_diff_mean=0;
    }
    */
    if(dac_half[ch]<0){
      gain_asic_dacHalf   = 0;
      gain_asic_diff      = 0;
      gain_asic_diff_mean = 0;
      gain_asic_sfit      = 0;
    }else{
      gain_asic_dacHalf  =(Int_t)((dac_half_ave-dac_ped_ave)/
                                (dac_half[ch]-dac_ped[ch])*gain_org[ch]);
      gain_asic_diff     =(Int_t)((dac_half_spe-dac_ped_ave)/
                             (dac_spe[ch]-dac_ped[ch])*gain_org[ch]);
      gain_asic_diff_mean=(Int_t)((mean_diff_ave-dac_ped_ave)/
                                  (mean_diff[ch]-dac_ped[ch])*gain_org[ch]);
      gain_asic_sfit     =(Int_t)((dac_sfit_ave-dac_ped_ave)/
                             (dac_sfit[ch]-dac_ped[ch])*gain_org[ch]);
      //cerr << ch << " " << gain_org[ch] << endl;
    }
    cout << "OUT_TABLE    "
         << ch << "    "
         << gain_asic_dacHalf   << "    "
         << gain_asic_diff      << "    "
         << gain_asic_diff_mean << "    "
         << gain_asic_sfit      << "    "
         << dac_half[ch]        << "    "
         << dac_ped[ch]         << "    "
         << (Int_t)dac_spe[ch]  << "    "
         << dac_half_ave        << "    "
         << dac_half_spe        << "    "
         << dac_ped_ave         << "    "
         << dac_sfit_ave        << "    "
         << sfit_chiS[ch]       << "    "
         << ch                  << "    "
         << flag_fit[ch]       
         << endl;
  }
  /*
    for(ch=kNch-1;ch>=0;ch--){
    cout << "OUT_TABLE_INV    "
    << (Int_t)(dac_half_ave/(dac_half[ch]-dac_ped)*64)
      << endl;
      }
  */
  
  
}