// _ can be given a set of run numbers
// _ loads the adc pedestal datafiles data/L20-adc-ped-####.dat and displays pedestals vs run# for each ADC channel
// _ enters the data into database
// _ sets channels with known negative pedestals to -1
// _ if pedestal=0 (e.g. flasher run) or datafiles missing, pedestal is assumed to stay constant

// Revisions:
// _ Original code updated (4/23/04)

//  raw_adc()
{
  gROOT->Reset();
 
  // read in the data file numbers, put them in list[]
  int i, j, n1, n2, list[3000], nl;
  int arc=gApplication->Argc(); 
  char** arv=gApplication->Argv(); 

  for (i=0;i<arc;i++){ // scan command line
    TString arg(arv[i]);
    int k = sscanf(arv[i],"%d-%d",&n1,&n2);

    if (k == 1 && n1 > 0) list[nl++] = n1;
    if (k == 2 && n1 > 0 && n2>n1)
      for (int j=n1;j<n2+1;j++) {
	if (j<301) { cout<<"Do not use this script for run numbers < 301"<<endl; exit(0);}
	list[nl++] = j;
      }
  }

  int min_runno = list[nl-1];
  int max_runno = list[0];
  // int dist_runno = max_runno - min_runno;

  gSystem->Load("/usr/lib/libz.so");
  gSystem->Load("/usr/local/root/lib/libMySQL.so");
  TSQLServer *db = TSQLServer::Connect("mysql://blast05.lns.mit.edu:3306/BLAST_physics","ANALYSIS", "BLana02");
  TSQLResult *res;

  char table[15];
  sprintf(table, "LAD_ADC_RUN");
  char detector[3];
  sprintf(detector, "L20");

  // **************************
  // **  negative Pedestals  **
  // **************************

  int pedneg[2][16][2]=0;
  pedneg[1][10][0]=1;  // L20_R10T
  pedneg[1][12][0]=1;  // L20_R12T
  pedneg[1][08][1]=1;  // L20_R08B
  pedneg[1][11][1]=1;  // L20_R11B
  pedneg[1][12][1]=1;  // L20_R12B

  // **************************

  char batchName[25];
  char query[250];

  sprintf(batchName, "pro2003");

  gSystem.Load("libBlast.so");
  Setup();

  char title[125];
  int k,il,mean;
  int nullflag=0;
  char data[100];

  // make array for the pedestals of different runs
  int ped[2][16][2][nl];  //  [sect][pad][tb][il]  /  run# = list[il]  
  int pedmin[2][16][2];
  int pedmax[2][16][2];

  // loop over datafiles
  for (il=0;il<gOpt->nList();il++) {
    char pedfilename[100];
    sprintf(pedfilename,"data/%s-adc-ped-%d\.dat",detector,list[il]);
    cout<<"Processing pedestal file "<<pedfilename<<" ..."<<endl;

    if (!(gSystem->AccessPathName(pedfilename, kReadPermission))) 
    {
      Long_t myId, mySize, myFlags, myModtime;
      gSystem->GetPathInfo(pedfilename,&myId,&mySize,&myFlags,&myModtime);
      
      if (mySize!=0)
      {
        char run_number[4];
        sprintf(run_number,"%d",list[il]);
        // delete this run's info from db
        sprintf(query, "DELETE FROM %s WHERE BatchName='%s' AND RunNumber=%s AND LadAdcId LIKE '%s%%'", table, batchName, run_number, detector);
        res = db->Query(query);
        // ************** change this to non-destructive check of existence ******************

        char hardware[25];

        if (min_runno>list[il]) min_runno=list[il];
        if (max_runno<list[il]) max_runno=list[il];

        ifstream pedfile(pedfilename, ios::in);

        int lr,tb,bar,p;
        while(!pedfile.eof())
	{
	  pedfile.getline(data,100);
	  if (data[0]!=33 && data[0]!=NULL)  // filter comment lines (starting with "!")
	  {
	    sscanf(data,"%d\t%d\t%d\t%d",&lr,&tb,&bar,&p);
            if (pedneg[lr][bar][tb]==1)  ped[lr][bar][tb][il]=-1;  // negative pedestal -> -1
              else if (p>0 || il==0)  ped[lr][bar][tb][il]=p;
                else  ped[lr][bar][tb][il]=ped[lr][bar][tb][il-1];  //  pedestal is assumed to stay constant -> take value of last run
            if ((pedmin[lr][bar][tb]>p || pedmin[lr][bar][tb]==0) && p>0)  pedmin[lr][bar][tb] = p;
            if (pedmax[lr][bar][tb]<p)  pedmax[lr][bar][tb] = p;

            // enter into database
	    sprintf(hardware, "%s_%s%02d%s_adc", detector,(lr==0)?"L":"R",bar,(tb==0)?"T":"B");
	    sprintf(query, "INSERT INTO %s SET LadAdcId='%s',BatchName='%s',RunNumber=%s,MeanADC=NULL,WidthADC=NULL,Pedestal=%d", table, hardware, batchName, run_number, p);
            // ************** change this to conditional INSERT / UPDATE command (depending on existence) ******************
            // sprintf(query, "UPDATE %s SET Pedestal=%d WHERE LadAdcId='%s' AND BatchName='%s' AND RunNumber=%s", table, p, hardware, batchName, run_number);
            
 	    res = db->Query(query);

	  }  //  end of comment line filter
	}  //  end of "eof check" while loop
        
        pedfile.close();

      }
      else  // file has length 0
      {
        cerr<<"file "<<pedfilename<<" does not contain any data\n";
        nullflag=1;
      }  // check if file has length 0
	  
    }
    else  // file doesn't exist
    {
      cerr<<"file "<<pedfilename<<" does not exist or is not readable\n";
      nullflag=1;
    }  // check if file exists 

    if (nullflag==1)
    {
      for (lr=0;lr<=1;lr++)
      {
        for (bar=0;bar<=13;bar++)
        {
          for (tb=0;tb<=1;tb++)
          {
            if (pedneg[lr][bar][tb]==1)  ped[lr][bar][tb][il]=-1;  // negative pedestal -> -1
              else  ped[lr][bar][tb][il]=(il==0)?0:ped[lr][bar][tb][il-1];    
          }    
        }
      }
      nullflag=0;
    }

  } // loop on files

  //  display pedestal array

  if (min_runno>max_runno)
    cerr<<"no datafiles found"<<endl;
  else
  {
    char txt[100];
    TCanvas *c1 = new TCanvas("l20.LEFT.top.adcped.run","l20.LEFT_top_adcped_run", 10, 10, 960, 720);
    c1->Divide(4,4);
    c1->Iconify();
    for (k=0; k<16; k++) {
      c1->cd(k+1);
      TGraph *gr1 = new TGraph(nl,list,ped[0][k][0]);
      gr1->SetMarkerStyle(6);
      gr1->SetMarkerSize(1);
      gr1->SetMinimum(pedmin[0][k][0]-2);
      gr1->SetMaximum(pedmax[0][k][0]+2);
      gr1->GetXaxis()->SetRangeUser(min_runno-1,max_runno+1);
      sprintf(txt,"%s left %d top",detector,k);
      gr1->SetTitle(txt);
      gr1->Draw("AP");
   }
    TCanvas *c2 = new TCanvas("l20.LEFT.bot.adcped.run","l20.LEFT_bot_adcped_run", 10, 10, 960, 720);
    c2->Divide(4,4);
    c2->Iconify();
    for (k=0; k<16; k++) {
      c2->cd(k+1);
      TGraph *gr2 = new TGraph(nl,list,ped[0][k][1]);
      gr2->SetMarkerStyle(6);
      gr2->SetMarkerSize(1);
      gr2->SetMinimum(pedmin[0][k][1]-2);
      gr2->SetMaximum(pedmax[0][k][1]+2);
      gr2->GetXaxis()->SetRangeUser(min_runno-1,max_runno+1);
      sprintf(txt,"%s left %d bottom",detector,k);
      gr2->SetTitle(txt);
      gr2->Draw("AP");
    }
    TCanvas *c3 = new TCanvas("l20.RIGHT.top.adcped.run","l20.RIGHT_top_adcped_run", 10, 10, 960, 720);
    c3->Divide(4,4);
    c3->Iconify();
    for (k=0; k<16; k++) {
      c3->cd(k+1);
      TGraph *gr3 = new TGraph(nl,list,ped[1][k][0]);
      gr3->SetMarkerStyle(6);
      gr3->SetMarkerSize(1);
      gr3->SetMinimum(pedmin[1][k][0]-2);
      gr3->SetMaximum(pedmax[1][k][0]+2);
      gr3->GetXaxis()->SetRangeUser(min_runno-1,max_runno+1);
      sprintf(txt,"%s right %d top",detector,k);
      gr3->SetTitle(txt);
      gr3->Draw("AP");
    }
    TCanvas *c4 = new TCanvas("l20.RIGHT.bot.adcped.run","l20.RIGHT_bot_adcped_run", 10, 10, 960, 720);
    c4->Divide(4,4);
    c4->Iconify();
    for (k=0; k<16; k++) {
      c4->cd(k+1);
      TGraph *gr4 = new TGraph(nl,list,ped[1][k][1]);
      gr4->SetMarkerStyle(6);
      gr4->SetMarkerSize(1);
      gr4->SetMinimum(pedmin[1][k][1]-2);
      gr4->SetMaximum(pedmax[1][k][1]+2);
      gr4->GetXaxis()->SetRangeUser(min_runno-1,max_runno+1);
      sprintf(txt,"%s right %d bottom",detector,k);
      gr4->SetTitle(txt);
      gr4->Draw("AP");
    }
  }
}