[u/mrichter/AliRoot.git] / ZDC / ZDCPEDESTALda.cxx

/*

This program reads the DAQ data files passed as argument using the monitoring library.

The program reports about its processing progress.

Messages on stdout are exported to DAQ log system.

DA for ZDC standalone pedestal runs

Contact: Chiara.Oppedisano@to.infn.it
Link: 
Run Type: STANDALONE_PEDESTAL_RUN
DA Type: LDC
Number of events needed: no constraint (tipically ~10^3)
Input Files: none
Output Files: ZDCPedestal.dat, ZDCChMapping.dat
Trigger Types Used: Standalone Trigger

*/
#define PEDDATA_FILE  "ZDCPedestal.dat"
#define PEDHISTO_FILE "ZDCPedHisto.root"
#define MAPDATA_FILE  "ZDCChMapping.dat"

#include <stdio.h>
#include <stdlib.h>
#include <Riostream.h>

// DATE
#include <event.h>
#include <monitor.h>
#include <daqDA.h>

//ROOT
#include <TROOT.h>
#include <TPluginManager.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TProfile.h>
#include <TF1.h>
#include <TFile.h>
#include <TFitter.h>
#include "TMinuitMinimizer.h"

//AliRoot
#include <AliRawReaderDate.h>
#include <AliRawEventHeaderBase.h>
#include <AliZDCRawStream.h>


/* Main routine
      Arguments: list of DATE raw data files
*/
int main(int argc, char **argv) {
  

  gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
					"*",
					"TStreamerInfo",
					"RIO",
					"TStreamerInfo()"); 

  TMinuitMinimizer m; 
  gROOT->GetPluginManager()->AddHandler("ROOT::Math::Minimizer", "Minuit","TMinuitMinimizer",
      "Minuit", "TMinuitMinimizer(const char *)");
  TVirtualFitter::SetDefaultFitter("Minuit");

  int status = 0;
  int const kNChannels = 24;
  int const kNScChannels = 32;
  
  Int_t ich=0;
  Int_t adcMod[2*kNChannels], adcCh[2*kNChannels], sigCode[2*kNChannels];
  Int_t det[2*kNChannels], sec[2*kNChannels];
  for(Int_t y=0; y<2*kNChannels; y++){
    adcMod[y]=adcCh[y]=sigCode[y]=det[y]=sec[y]=0;
  }

  /* log start of process */
  printf("\n ZDC PEDESTAL program started\n");  

  /* check that we got some arguments = list of files */
  if (argc<2){
    printf("Wrong number of arguments\n");
    return -1;
  }

  // --- Histograms for ADC pedestals 
  //     [22 signal channels + 2 reference PTMs]  x 2 gain chains
  //
  TH1F::AddDirectory(0);
  //
  TH1F *hPedhg[kNChannels], *hPedOutOfTimehg[kNChannels];
  TH2F *hPedCorrhg[kNChannels];
  TH1F *hPedlg[kNChannels], *hPedOutOfTimelg[kNChannels];
  TH2F *hPedCorrlg[kNChannels];
  //
  char namhist1hg[50], namhist2hg[50], namhist3hg[50];
  char namhist1lg[50], namhist2lg[50], namhist3lg[50];
  for(Int_t j=0; j<kNChannels; j++){
     if(j<=4){ // ZNC
       sprintf(namhist1hg,"PedZNChg_%d",j);
       sprintf(namhist2hg,"PedZNChgOutOfTime_%d",j);
       sprintf(namhist3hg,"PedCorrZNChg_%d",j);
       //
       sprintf(namhist1lg,"PedZNClg_%d",j);
       sprintf(namhist2lg,"PedZNClgOutOfTime_%d",j);
       sprintf(namhist3lg,"PedCorrZNClg_%d",j);
     }
     else if(j>=5 && j<=9){ // ZPC
       sprintf(namhist1hg,"PedZPChg_%d",j-5);
       sprintf(namhist2hg,"PedZPChgOutOfTime_%d",j-5);
       sprintf(namhist3hg,"PedCorrZPChg_%d",j-5);
       //
       sprintf(namhist1lg,"PedZPClg_%d",j-5);
       sprintf(namhist2lg,"PedZPClgOutOfTime_%d",j-5);
       sprintf(namhist3lg,"PedCorrZPClg_%d",j-5);       
     }
     else if(j==10 || j==11){ // ZEM
       sprintf(namhist1hg,"PedZEMhg_%d",j-10);
       sprintf(namhist2hg,"PedZEMhgOutOfTime_%d",j-10);
       sprintf(namhist3hg,"PedCorrZEMhg_%d",j-10);
       //
       sprintf(namhist1lg,"PedZEMlg_%d",j-10);
       sprintf(namhist2lg,"PedZEMlgOutOfTime_%d",j-10);
       sprintf(namhist3lg,"PedCorrZEMlg_%d",j-10);
     }
     else if(j>=12 && j<=16){ // ZNA
       sprintf(namhist1hg,"PedZNAhg_%d",j-12);
       sprintf(namhist2hg,"PedZNAhgOutOfTime_%d",j-12);
       sprintf(namhist3hg,"PedCorrZNAhg_%d",j-12);
       //
       sprintf(namhist1lg,"PedZNAlg_%d",j-12);
       sprintf(namhist2lg,"PedZNAlgOutOfTime_%d",j-12);
       sprintf(namhist3lg,"PedCorrZNAlg_%d",j-12);
     }
     else if(j>=17 && j<=21){ // ZPA
       sprintf(namhist1hg,"PedZPAhg_%d",j-17);
       sprintf(namhist2hg,"PedZPAhgOutOfTime_%d",j-17);
       sprintf(namhist3hg,"PedCorrZPAhg_%d",j-17);
       //
       sprintf(namhist1lg,"PedZPAlg_%d",j-17);
       sprintf(namhist2lg,"PedZPAlgOutOfTime_%d",j-17);
       sprintf(namhist3lg,"PedCorrZPAlg_%d",j-17);
     }
     else if(j==22 || j==24){ //Reference PMs
       sprintf(namhist1hg,"PedRefhg_%d",j-22);
       sprintf(namhist2hg,"PedRefhgOutOfTime_%d",j-22);
       sprintf(namhist3hg,"PedCorrRefhg_%d",j-22);
       //
       sprintf(namhist1lg,"PedReflg_%d",j-22);
       sprintf(namhist2lg,"PedReflgOutOfTime_%d",j-22);
       sprintf(namhist3lg,"PedCorrReflg_%d",j-22);
     }
     // --- High gain chain histos
     hPedhg[j] = new TH1F(namhist1hg, namhist1hg, 200, 0., 200.);
     hPedOutOfTimehg[j] = new TH1F(namhist2hg, namhist2hg, 200, 0., 200.);
     hPedCorrhg[j] = new TH2F(namhist3hg,namhist3hg,100,0.,200.,100,0.,200.);
     // --- Low gain chain histos
     hPedlg[j] = new TH1F(namhist1lg, namhist1lg, 100, 0., 1000.);
     hPedOutOfTimelg[j] = new TH1F(namhist2lg, namhist2lg, 100, 0., 1000.);
     hPedCorrlg[j] = new TH2F(namhist3lg,namhist3lg,100,0.,1000.,100,0.,1000.);
  }


  /* open result file */
  FILE *fp=NULL;
  fp=fopen("./result.txt","w");
  if (fp==NULL) {
    printf("Failed to open file\n");
    return -1;
  }
  
  FILE *mapFile4Shuttle;

  /* report progress */
  daqDA_progressReport(10);


  /* init some counters */
  int nevents_physics=0;
  int nevents_total=0;

  struct eventHeaderStruct *event;
  eventTypeType eventT;

  /* read the data files */
  int n;
  for(n=1;n<argc;n++){
   
    status=monitorSetDataSource( argv[n] );
    if (status!=0) {
      printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
      return -1;
    }

    /* report progress */
    /* in this example, indexed on the number of files */
    daqDA_progressReport(10+80*n/argc);

    /* read the file */
    for(;;) {

      /* get next event */
      status=monitorGetEventDynamic((void **)&event);
      if(status==MON_ERR_EOF) break; /* end of monitoring file has been reached */
      if(status!=0) {
        printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
        return -1;
      }

      /* retry if got no event */
      if(event==NULL) {
        break;
      }
      
      // Initalize raw-data reading and decoding
      AliRawReader *reader = new AliRawReaderDate((void*)event);
      reader->Select("ZDC");
      // --- Reading event header
      //UInt_t evtype = reader->GetType();
      //printf("\n\t ZDCPEDESTALda -> ev. type %d\n",evtype);
      //printf("\t ZDCPEDESTALda -> run # %d\n",reader->GetRunNumber());
      //
      AliZDCRawStream *rawStreamZDC = new AliZDCRawStream(reader);
        

      /* use event - here, just write event id to result file */
      eventT=event->eventType;
      
      Int_t iScCh=0;
      Int_t scMod[kNScChannels], scCh[kNScChannels], scSigCode[kNScChannels];
      Int_t scDet[kNScChannels], scSec[kNScChannels];
      for(Int_t y=0; y<kNScChannels; y++){
        scMod[y]=scCh[y]=scSigCode[y]=scDet[y]=scSec[y]=0;
      }
      //
      Int_t modNum=-1, modType=-1;
      
      if(eventT==START_OF_DATA){
	  	
	rawStreamZDC->SetSODReading(kTRUE);
	
	// --------------------------------------------------------
	// --- Writing ascii data file for the Shuttle preprocessor
        mapFile4Shuttle = fopen(MAPDATA_FILE,"w");
	if(!rawStreamZDC->Next()) printf(" \t No raw data found!! \n");
        else{
	  while((rawStreamZDC->Next())){
            if(rawStreamZDC->IsHeaderMapping()){ // mapping header
	       modNum = rawStreamZDC->GetADCModule();
	       modType = rawStreamZDC->GetModType();
	    }
            if(rawStreamZDC->IsChMapping()){ 
	      if(modType==1){ // ADC mapping ----------------------
	        adcMod[ich]  = rawStreamZDC->GetADCModFromMap(ich);
	        adcCh[ich]   = rawStreamZDC->GetADCChFromMap(ich);
	        sigCode[ich] = rawStreamZDC->GetADCSignFromMap(ich);
	        det[ich]     = rawStreamZDC->GetDetectorFromMap(ich);
	        sec[ich]     = rawStreamZDC->GetTowerFromMap(ich);
	        //
	        fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
	          ich,adcMod[ich],adcCh[ich],sigCode[ich],det[ich],sec[ich]);
	        //
	        //printf("  Mapping in DA -> %d ADC: mod %d ch %d, code %d det %d, sec %d\n",
	        //  ich,adcMod[ich],adcCh[ich],sigCode[ich],det[ich],sec[ich]);
	        //
	        ich++;
	      }
	      else if(modType==2){ //VME scaler mapping --------------------
	        scMod[iScCh]     = rawStreamZDC->GetScalerModFromMap(iScCh);
	        scCh[iScCh]      = rawStreamZDC->GetScalerChFromMap(iScCh);
	        scSigCode[iScCh] = rawStreamZDC->GetScalerSignFromMap(iScCh);
	        scDet[iScCh]     = rawStreamZDC->GetScDetectorFromMap(iScCh);
	        scSec[iScCh]    = rawStreamZDC->GetScTowerFromMap(iScCh);
	        //
	        fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
	          iScCh,scMod[iScCh],scCh[iScCh],scSigCode[iScCh],scDet[iScCh],scSec[iScCh]);
	        //
	        //printf("  Mapping in DA -> %d Scaler: mod %d ch %d, code %d det %d, sec %d\n",
	        //  iScCh,scMod[iScCh],scCh[iScCh],scSigCode[iScCh],scDet[iScCh],scSec[iScCh]);
	        //
	        iScCh++;
	      }
	    }
	  }
	}
        fclose(mapFile4Shuttle);
      }// SOD event
      
      else if(eventT==PHYSICS_EVENT){
	// --- Reading data header
        reader->ReadHeader();
        const AliRawDataHeader* header = reader->GetDataHeader();
        if(header){
         UChar_t message = header->GetAttributes();
	 //printf("   message from L1 %x\n", message);
         if(message == 0x20){ // PEDESTAL RUN
            //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
         }
         else{
            printf("ZDCPEDESTALda.cxx -> NO STANDALONE_PEDESTAL RUN raw data found\n");
            return -1;
         }
        }
        else{
           printf("\t ATTENTION! No Raw Data Header found!!!\n");
           return -1;
        }
	
	rawStreamZDC->SetSODReading(kTRUE);

  	if(!rawStreamZDC->Next()) printf(" \t No raw data found!! \n");	
	//
	// ----- Setting ch. mapping -----
	for(Int_t jk=0; jk<2*kNChannels; jk++){
	  //printf("ZDCPEDESTALDA.cxx ->  ch.%d mod %d, ch %d, code %d det %d, sec %d\n",
	  //    jk,adcMod[jk],adcCh[jk],sigCode[jk],det[jk],sec[jk]);
	  rawStreamZDC->SetMapADCMod(jk, adcMod[jk]);
	  rawStreamZDC->SetMapADCCh(jk, adcCh[jk]);
	  rawStreamZDC->SetMapADCSig(jk, sigCode[jk]);
	  rawStreamZDC->SetMapDet(jk, det[jk]);
	  rawStreamZDC->SetMapTow(jk, sec[jk]);
	}
	//
  	Int_t iraw=0;
  	Int_t RawADChg[kNChannels], RawADCoothg[kNChannels];
  	Int_t RawADClg[kNChannels], RawADCootlg[kNChannels];
  	for(Int_t j=0; j<kNChannels; j++){
  	   RawADChg[j]=0; RawADCoothg[j]=0;
  	   RawADClg[j]=0; RawADCootlg[j]=0;
  	}
	//
  	while(rawStreamZDC->Next()){
  	 Int_t index=-1;
	 Int_t detector = rawStreamZDC->GetSector(0);
	 Int_t sector = rawStreamZDC->GetSector(1);
	 
  	 if(rawStreamZDC->IsADCDataWord() && (detector!=-1)){
	  if(sector!=5){ // Physics signals
    	    if(detector==1) index = sector; // *** ZNC
	    else if(detector==2) index = sector+5; // *** ZPC
	    else if(detector==3) index = sector+9; // *** ZEM
	    else if(detector==4) index = sector+12; // *** ZNA
	    else if(detector==5) index = sector+17; // *** ZPA
	  }
	  else{ // Reference PMs
	    index = (detector-1)/3+22;
	  }
	  //
	  if(index==-1) printf("ERROR in ZDCPEDESTALda.cxx -> det %d quad %d index %d \n", 
	    detector,sector,index);
	  
	   //
	   if(iraw<2*kNChannels){ // --- In-time pedestals (1st 48 raw data)
	    if(rawStreamZDC->GetADCGain()==0){ 
	      hPedhg[index]->Fill(rawStreamZDC->GetADCValue()); 
	      RawADChg[index] = rawStreamZDC->GetADCValue();
	      //
	      //printf("\t filling histo hPedhg[%d]\n",index);
	    }
	    else{
	      hPedlg[index]->Fill(rawStreamZDC->GetADCValue()); 
	      RawADClg[index] = rawStreamZDC->GetADCValue();
	      //
	      //printf("\t filling histo hPedlg[%d]\n",index);
	    }
  	   }
  	   else{  // --- Out-of-time pedestals
  	    if(rawStreamZDC->GetADCGain()==0){
  	      hPedOutOfTimehg[index]->Fill(rawStreamZDC->GetADCValue());
  	      RawADCoothg[index] = rawStreamZDC->GetADCValue();
	      //
	      //printf("\t filling histo hPedOutOfTimehg[%d]\n",index);
  	    }
  	    else{
  	      hPedOutOfTimelg[index]->Fill(rawStreamZDC->GetADCValue());
  	      RawADCootlg[index] = rawStreamZDC->GetADCValue();
	      //
	      //printf("\t filling histo hPedOutOfTimelg[%d]\n",index);
  	    }
  	   }
  	    iraw++;
  	  }//IsADCDataWord()
  	  //
  	  if(iraw == 4*kNChannels){ // Last ADC channel -> Filling correlation histos
  	    for(Int_t k=0; k<kNChannels; k++){
  	      hPedCorrhg[k]->Fill(RawADCoothg[k], RawADChg[k]);
  	      hPedCorrlg[k]->Fill(RawADCootlg[k], RawADClg[k]);
  	    }
  	  }
        }
        nevents_physics++;
        //
	delete reader;
        delete rawStreamZDC;

      }//(if PHYSICS_EVENT) 
      
      /* exit when last event received, no need to wait for TERM signal */
      else if(eventT==END_OF_RUN) {
        printf(" -> EOR event detected\n");
        break;
      }
      
      nevents_total++;
    
    }
	  
    /* free resources */
    free(event);
  }  
  
  /* Analysis of the histograms */
  //
  FILE *fileShuttle;
  fileShuttle = fopen(PEDDATA_FILE,"w");
  //
  Float_t MeanPed[2*kNChannels], MeanPedWidth[2*kNChannels], 
   	MeanPedOOT[2*kNChannels], MeanPedWidthOOT[2*kNChannels];
  // --- In-time pedestals
  TF1 *ADCfunchg[kNChannels];
  for(Int_t i=0; i<kNChannels; i++){
     if(hPedhg[i]->GetEntries() == 0){
       printf("\n WARNING! Empty histos -> ending DA WITHOUT writing output\n\n");
       return -1;
     } 
     hPedhg[i]->Fit("gaus","Q");
     ADCfunchg[i] = hPedhg[i]->GetFunction("gaus");
     MeanPed[i] = (Double_t) ADCfunchg[i]->GetParameter(1);
     MeanPedWidth[i] = (Double_t)  ADCfunchg[i]->GetParameter(2);
     fprintf(fileShuttle,"\t%f\t%f\n",MeanPed[i],MeanPedWidth[i]);
     //printf("\t MeanPedhg[%d] = %f\n",i, MeanPed[i]);
  }
  TF1 *ADCfunclg[kNChannels];
  for(Int_t i=0; i<kNChannels; i++){
     hPedlg[i]->Fit("gaus","Q");
     ADCfunclg[i] = hPedlg[i]->GetFunction("gaus");
     MeanPed[i+kNChannels] = (Double_t)  ADCfunclg[i]->GetParameter(1);
     MeanPedWidth[i+kNChannels] = (Double_t)  ADCfunclg[i]->GetParameter(2);
     fprintf(fileShuttle,"\t%f\t%f\n",MeanPed[i+kNChannels],MeanPedWidth[i+kNChannels]);
     //printf("\t MeanPedlg[%d] = %f\n",i+kNChannels, MeanPed[i+kNChannels]);
  }
  // --- Out-of-time pedestals
  TF1 *ADCootfunchg[kNChannels];
  for(Int_t i=0; i<kNChannels; i++){
     if(hPedOutOfTimehg[i]->GetEntries() == 0){
       printf("\n WARNING! Empty histos -> ending DA WITHOUT writing output\n\n");
       return -1;
     } 
     hPedOutOfTimehg[i]->Fit("gaus","Q");
     ADCootfunchg[i] = hPedOutOfTimehg[i]->GetFunction("gaus");
     MeanPedOOT[i] = (Double_t)  ADCootfunchg[i]->GetParameter(1);
     MeanPedWidthOOT[i] = (Double_t)  ADCootfunchg[i]->GetParameter(2);
     fprintf(fileShuttle,"\t%f\t%f\n",MeanPedOOT[i],MeanPedWidthOOT[i]);
     //printf("\t MeanPedOOThg[%d] = %f\n",i, MeanPedOOT[i]);
  }
  TF1 *ADCootfunclg[kNChannels];
  for(Int_t i=0; i<kNChannels; i++){
     hPedOutOfTimelg[i]->Fit("gaus","Q");
     ADCootfunclg[i] = hPedOutOfTimelg[i]->GetFunction("gaus");
     MeanPedOOT[i+kNChannels] = (Double_t)  ADCootfunclg[i]->GetParameter(1);
     MeanPedWidthOOT[i+kNChannels] = (Double_t)  ADCootfunclg[i]->GetParameter(2);
     fprintf(fileShuttle,"\t%f\t%f\n",MeanPedOOT[i+kNChannels],MeanPedWidthOOT[i+kNChannels]);
     //printf("\t MeanPedOOTlg[%d] = %f\n",i+kNChannels, MeanPedOOT[i+kNChannels]);
  }
  
  // --- Correlations

  Float_t CorrCoeff0[2*kNChannels], CorrCoeff1[2*kNChannels];
  TProfile *hPedCorrProfhg[kNChannels], *hPedCorrProflg[kNChannels];
  TF1 *ffunchg[kNChannels], *ffunclg[kNChannels];
  char namhist4[50];
  for(int i=0;i<kNChannels;i++) {
     sprintf(namhist4,"ADCHRvsOOT%d_Prof",i);
     hPedCorrProfhg[i] = hPedCorrhg[i]->ProfileX(namhist4,-1,-1,"S");
     hPedCorrProfhg[i]->SetName(namhist4);
     hPedCorrProfhg[i]->Fit("pol1","Q");
     ffunchg[i] = hPedCorrProfhg[i]->GetFunction("pol1");
     CorrCoeff0[i] = (Double_t)  ffunchg[i]->GetParameter(0);
     CorrCoeff1[i] = (Double_t) ffunchg[i]->GetParameter(1);
     fprintf(fileShuttle,"\t%f\t%f\n",CorrCoeff0[i],CorrCoeff1[i]);
     //printf("\t CorrCoeff0[%d] = %f, CorrCoeff1[%d] = %f\n",i, CorrCoeff0[i], i, CorrCoeff1[i]);
  }    
  for(int i=0;i<kNChannels;i++) {
     sprintf(namhist4,"ADCLRvsOOT%d_Prof",i);
     hPedCorrProflg[i] = hPedCorrlg[i]->ProfileX(namhist4,-1,-1,"S");
     hPedCorrProflg[i]->SetName(namhist4);
     hPedCorrProflg[i]->Fit("pol1","Q");
     ffunclg[i] = hPedCorrProflg[i]->GetFunction("pol1");
     CorrCoeff0[i+kNChannels] =  (Double_t) ffunclg[i]->GetParameter(0);
     CorrCoeff1[i+kNChannels] =  (Double_t) ffunclg[i]->GetParameter(1);
     fprintf(fileShuttle,"\t%f\t%f\n",CorrCoeff0[i+kNChannels],CorrCoeff1[i+kNChannels]);
     //printf("\t CorrCoeff0[%d] = %f, CorrCoeff1[%d] = %f\n",
     //		i+kNChannels, CorrCoeff0[i+kNChannels], i+kNChannels, CorrCoeff1[i+kNChannels]);
  }    

  //						       
  fclose(fileShuttle);
  //
  /* report progress */
  daqDA_progressReport(80);
  //
  TFile *histofile = new TFile(PEDHISTO_FILE,"RECREATE");
  histofile->cd();
  for(int k=0; k<kNChannels; k++){
     hPedhg[k]->Write();
     hPedOutOfTimehg[k]->Write();
     hPedCorrhg[k]->Write();
     hPedlg[k]->Write();
     hPedOutOfTimelg[k]->Write();
     hPedCorrlg[k]->Write();
  }
  //						       
  histofile->Close();
  //
  for(Int_t j=0; j<kNChannels; j++){
     delete hPedhg[j];
     delete hPedOutOfTimehg[j];
     delete hPedCorrhg[j];
     delete hPedlg[j];
     delete hPedOutOfTimelg[j];
     delete hPedCorrlg[j];
  }

  /* write report */
  fprintf(fp,"Run #%s, received %d physics events out of %d\n",getenv("DATE_RUN_NUMBER"),nevents_physics,nevents_total);

  /* close result file */
  fclose(fp);
  
  /* report progress */
  daqDA_progressReport(90);

  /* store the result files on FES */
  // [1] File with mapping
  status = daqDA_FES_storeFile(MAPDATA_FILE, "MAPPING");
  if(status){
    printf("Failed to export mapping data file to DAQ FES\n");
    return -1;
  }
  // [2] File with pedestal data
  status = daqDA_FES_storeFile(PEDDATA_FILE, "PEDESTALDATA");
  if(status){
    printf("Failed to export pedestal data file to DAQ FES\n");
    return -1;
  }
  // [3] File with pedestal histos
  status = daqDA_FES_storeFile(PEDHISTO_FILE, "PEDESTALHISTOS");
  if(status){
    printf("Failed to export pedestal histos file to DAQ FES\n");
    return -1;
  }
  
  /* store the result files on DB */
  status = daqDA_DB_storeFile(PEDDATA_FILE, PEDDATA_FILE);  
  if(status){
    printf("Failed to store pedestal data file to DAQ DB\n");
    return -1;
  }

  /* report progress */
  daqDA_progressReport(100);

  return status;
}
Commit	Line	Data
f3ca8792	1	/*
f3ca8792	2
039a08c3	3	This program reads the DAQ data files passed as argument using the monitoring library.
039a08c3	4
039a08c3	5	The program reports about its processing progress.
f3ca8792	6
	7	Messages on stdout are exported to DAQ log system.
	8
b3b2b9dd	9	DA for ZDC standalone pedestal runs
ea628de7	10
b3b2b9dd	11	Contact: Chiara.Oppedisano@to.infn.it
442e1b18	12	Link:
b3b2b9dd	13	Run Type: STANDALONE_PEDESTAL_RUN
442e1b18	14	DA Type: LDC
b3b2b9dd	15	Number of events needed: no constraint (tipically ~10^3)
27afc0c8	16	Input Files: none
442e1b18	17	Output Files: ZDCPedestal.dat, ZDCChMapping.dat
b3b2b9dd	18	Trigger Types Used: Standalone Trigger
f3ca8792	19
f3ca8792	20	*/
218f916a	21	#define PEDDATA_FILE "ZDCPedestal.dat"
65448375	22	#define PEDHISTO_FILE "ZDCPedHisto.root"
218f916a	23	#define MAPDATA_FILE "ZDCChMapping.dat"
f3ca8792	24
f3ca8792	25	#include <stdio.h>
039a08c3	26	#include <stdlib.h>
f3ca8792	27	#include <Riostream.h>
	28
	29	// DATE
f3ca8792	30	#include <event.h>
f3ca8792	31	#include <monitor.h>
039a08c3	32	#include <daqDA.h>
f3ca8792	33
f3ca8792	34	//ROOT
65448375	35	#include <TROOT.h>
65448375	36	#include <TPluginManager.h>
f3ca8792	37	#include <TH1F.h>
	38	#include <TH2F.h>
	39	#include <TProfile.h>
	40	#include <TF1.h>
	41	#include <TFile.h>
442e1b18	42	#include <TFitter.h>
65448375	43	#include "TMinuitMinimizer.h"
f3ca8792	44
	45	//AliRoot
	46	#include <AliRawReaderDate.h>
442e1b18	47	#include <AliRawEventHeaderBase.h>
f3ca8792	48	#include <AliZDCRawStream.h>
	49
	50
	51	/* Main routine
039a08c3	52	Arguments: list of DATE raw data files
f3ca8792	53	*/
f3ca8792	54	int main(int argc, char **argv) {
442e1b18	55
65448375	56
	57	gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
	58	"*",
	59	"TStreamerInfo",
	60	"RIO",
	61	"TStreamerInfo()");
	62
	63	TMinuitMinimizer m;
	64	gROOT->GetPluginManager()->AddHandler("ROOT::Math::Minimizer", "Minuit","TMinuitMinimizer",
	65	"Minuit", "TMinuitMinimizer(const char *)");
	66	TVirtualFitter::SetDefaultFitter("Minuit");
f3ca8792	67
039a08c3	68	int status = 0;
9d0b658a	69	int const kNChannels = 24;
c3986754	70	int const kNScChannels = 32;
	71
	72	Int_t ich=0;
	73	Int_t adcMod[2kNChannels], adcCh[2kNChannels], sigCode[2*kNChannels];
	74	Int_t det[2kNChannels], sec[2kNChannels];
	75	for(Int_t y=0; y<2*kNChannels; y++){
	76	adcMod[y]=adcCh[y]=sigCode[y]=det[y]=sec[y]=0;
	77	}
039a08c3	78
039a08c3	79	/* log start of process */
63604324	80	printf("\n ZDC PEDESTAL program started\n");
039a08c3	81
039a08c3	82	/* check that we got some arguments = list of files */
65448375	83	if (argc<2){
039a08c3	84	printf("Wrong number of arguments\n");
	85	return -1;
	86	}
	87
f3ca8792	88	// --- Histograms for ADC pedestals
b3b2b9dd	89	// [22 signal channels + 2 reference PTMs] x 2 gain chains
f3ca8792	90	//
039a08c3	91	TH1F::AddDirectory(0);
9d0b658a	92	//
b3b2b9dd	93	TH1F hPedhg[kNChannels], hPedOutOfTimehg[kNChannels];
	94	TH2F *hPedCorrhg[kNChannels];
	95	TH1F hPedlg[kNChannels], hPedOutOfTimelg[kNChannels];
	96	TH2F *hPedCorrlg[kNChannels];
f3ca8792	97	//
b3b2b9dd	98	char namhist1hg[50], namhist2hg[50], namhist3hg[50];
	99	char namhist1lg[50], namhist2lg[50], namhist3lg[50];
	100	for(Int_t j=0; j<kNChannels; j++){
7f4bde92	101	if(j<=4){ // ZNC
	102	sprintf(namhist1hg,"PedZNChg_%d",j);
	103	sprintf(namhist2hg,"PedZNChgOutOfTime_%d",j);
	104	sprintf(namhist3hg,"PedCorrZNChg_%d",j);
b3b2b9dd	105	//
7f4bde92	106	sprintf(namhist1lg,"PedZNClg_%d",j);
	107	sprintf(namhist2lg,"PedZNClgOutOfTime_%d",j);
	108	sprintf(namhist3lg,"PedCorrZNClg_%d",j);
b3b2b9dd	109	}
7f4bde92	110	else if(j>=5 && j<=9){ // ZPC
	111	sprintf(namhist1hg,"PedZPChg_%d",j-5);
	112	sprintf(namhist2hg,"PedZPChgOutOfTime_%d",j-5);
	113	sprintf(namhist3hg,"PedCorrZPChg_%d",j-5);
b3b2b9dd	114	//
7f4bde92	115	sprintf(namhist1lg,"PedZPClg_%d",j-5);
	116	sprintf(namhist2lg,"PedZPClgOutOfTime_%d",j-5);
	117	sprintf(namhist3lg,"PedCorrZPClg_%d",j-5);
f3ca8792	118	}
7f4bde92	119	else if(j==10 \|\| j==11){ // ZEM
b3b2b9dd	120	sprintf(namhist1hg,"PedZEMhg_%d",j-10);
	121	sprintf(namhist2hg,"PedZEMhgOutOfTime_%d",j-10);
	122	sprintf(namhist3hg,"PedCorrZEMhg_%d",j-10);
	123	//
	124	sprintf(namhist1lg,"PedZEMlg_%d",j-10);
	125	sprintf(namhist2lg,"PedZEMlgOutOfTime_%d",j-10);
	126	sprintf(namhist3lg,"PedCorrZEMlg_%d",j-10);
f3ca8792	127	}
7f4bde92	128	else if(j>=12 && j<=16){ // ZNA
	129	sprintf(namhist1hg,"PedZNAhg_%d",j-12);
	130	sprintf(namhist2hg,"PedZNAhgOutOfTime_%d",j-12);
	131	sprintf(namhist3hg,"PedCorrZNAhg_%d",j-12);
b3b2b9dd	132	//
7f4bde92	133	sprintf(namhist1lg,"PedZNAlg_%d",j-12);
	134	sprintf(namhist2lg,"PedZNAlgOutOfTime_%d",j-12);
	135	sprintf(namhist3lg,"PedCorrZNAlg_%d",j-12);
f3ca8792	136	}
7f4bde92	137	else if(j>=17 && j<=21){ // ZPA
	138	sprintf(namhist1hg,"PedZPAhg_%d",j-17);
	139	sprintf(namhist2hg,"PedZPAhgOutOfTime_%d",j-17);
	140	sprintf(namhist3hg,"PedCorrZPAhg_%d",j-17);
b3b2b9dd	141	//
7f4bde92	142	sprintf(namhist1lg,"PedZPAlg_%d",j-17);
	143	sprintf(namhist2lg,"PedZPAlgOutOfTime_%d",j-17);
	144	sprintf(namhist3lg,"PedCorrZPAlg_%d",j-17);
f3ca8792	145	}
7f4bde92	146	else if(j==22 \|\| j==24){ //Reference PMs
b3b2b9dd	147	sprintf(namhist1hg,"PedRefhg_%d",j-22);
	148	sprintf(namhist2hg,"PedRefhgOutOfTime_%d",j-22);
	149	sprintf(namhist3hg,"PedCorrRefhg_%d",j-22);
	150	//
	151	sprintf(namhist1lg,"PedReflg_%d",j-22);
	152	sprintf(namhist2lg,"PedReflgOutOfTime_%d",j-22);
	153	sprintf(namhist3lg,"PedCorrReflg_%d",j-22);
f3ca8792	154	}
b3b2b9dd	155	// --- High gain chain histos
057ed567	156	hPedhg[j] = new TH1F(namhist1hg, namhist1hg, 200, 0., 200.);
057ed567	157	hPedOutOfTimehg[j] = new TH1F(namhist2hg, namhist2hg, 200, 0., 200.);
b3b2b9dd	158	hPedCorrhg[j] = new TH2F(namhist3hg,namhist3hg,100,0.,200.,100,0.,200.);
b3b2b9dd	159	// --- Low gain chain histos
057ed567	160	hPedlg[j] = new TH1F(namhist1lg, namhist1lg, 100, 0., 1000.);
	161	hPedOutOfTimelg[j] = new TH1F(namhist2lg, namhist2lg, 100, 0., 1000.);
	162	hPedCorrlg[j] = new TH2F(namhist3lg,namhist3lg,100,0.,1000.,100,0.,1000.);
f3ca8792	163	}
f3ca8792	164
f3ca8792	165
	166	/* open result file */
	167	FILE *fp=NULL;
9d0b658a	168	fp=fopen("./result.txt","w");
f3ca8792	169	if (fp==NULL) {
	170	printf("Failed to open file\n");
	171	return -1;
	172	}
	173
442e1b18	174	FILE *mapFile4Shuttle;
f3ca8792	175
039a08c3	176	/* report progress */
039a08c3	177	daqDA_progressReport(10);
f3ca8792	178
f3ca8792	179
f3ca8792	180	/* init some counters */
	181	int nevents_physics=0;
	182	int nevents_total=0;
	183
27afc0c8	184	struct eventHeaderStruct *event;
	185	eventTypeType eventT;
	186
039a08c3	187	/* read the data files */
039a08c3	188	int n;
442e1b18	189	for(n=1;n<argc;n++){
039a08c3	190
039a08c3	191	status=monitorSetDataSource( argv[n] );
f3ca8792	192	if (status!=0) {
039a08c3	193	printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
039a08c3	194	return -1;
f3ca8792	195	}
f3ca8792	196
039a08c3	197	/* report progress */
	198	/* in this example, indexed on the number of files */
	199	daqDA_progressReport(10+80*n/argc);
	200
	201	/* read the file */
	202	for(;;) {
039a08c3	203
	204	/* get next event */
	205	status=monitorGetEventDynamic((void **)&event);
442e1b18	206	if(status==MON_ERR_EOF) break; /* end of monitoring file has been reached */
442e1b18	207	if(status!=0) {
039a08c3	208	printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
	209	return -1;
	210	}
	211
	212	/* retry if got no event */
442e1b18	213	if(event==NULL) {
039a08c3	214	break;
039a08c3	215	}
442e1b18	216
	217	// Initalize raw-data reading and decoding
	218	AliRawReader reader = new AliRawReaderDate((void)event);
	219	reader->Select("ZDC");
	220	// --- Reading event header
	221	//UInt_t evtype = reader->GetType();
	222	//printf("\n\t ZDCPEDESTALda -> ev. type %d\n",evtype);
	223	//printf("\t ZDCPEDESTALda -> run # %d\n",reader->GetRunNumber());
	224	//
	225	AliZDCRawStream *rawStreamZDC = new AliZDCRawStream(reader);
	226
f3ca8792	227
039a08c3	228	/* use event - here, just write event id to result file */
039a08c3	229	eventT=event->eventType;
442e1b18	230
c3986754	231	Int_t iScCh=0;
27afc0c8	232	Int_t scMod[kNScChannels], scCh[kNScChannels], scSigCode[kNScChannels];
	233	Int_t scDet[kNScChannels], scSec[kNScChannels];
	234	for(Int_t y=0; y<kNScChannels; y++){
c3986754	235	scMod[y]=scCh[y]=scSigCode[y]=scDet[y]=scSec[y]=0;
	236	}
	237	//
	238	Int_t modNum=-1, modType=-1;
7f4bde92	239
442e1b18	240	if(eventT==START_OF_DATA){
442e1b18	241
7f4bde92	242	rawStreamZDC->SetSODReading(kTRUE);
7f4bde92	243
9d0b658a	244	// --------------------------------------------------------
	245	// --- Writing ascii data file for the Shuttle preprocessor
	246	mapFile4Shuttle = fopen(MAPDATA_FILE,"w");
442e1b18	247	if(!rawStreamZDC->Next()) printf(" \t No raw data found!! \n");
442e1b18	248	else{
c3986754	249	while((rawStreamZDC->Next())){
	250	if(rawStreamZDC->IsHeaderMapping()){ // mapping header
	251	modNum = rawStreamZDC->GetADCModule();
	252	modType = rawStreamZDC->GetModType();
	253	}
	254	if(rawStreamZDC->IsChMapping()){
	255	if(modType==1){ // ADC mapping ----------------------
	256	adcMod[ich] = rawStreamZDC->GetADCModFromMap(ich);
	257	adcCh[ich] = rawStreamZDC->GetADCChFromMap(ich);
	258	sigCode[ich] = rawStreamZDC->GetADCSignFromMap(ich);
	259	det[ich] = rawStreamZDC->GetDetectorFromMap(ich);
	260	sec[ich] = rawStreamZDC->GetTowerFromMap(ich);
	261	//
	262	fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
	263	ich,adcMod[ich],adcCh[ich],sigCode[ich],det[ich],sec[ich]);
	264	//
	265	//printf(" Mapping in DA -> %d ADC: mod %d ch %d, code %d det %d, sec %d\n",
	266	// ich,adcMod[ich],adcCh[ich],sigCode[ich],det[ich],sec[ich]);
	267	//
	268	ich++;
	269	}
	270	else if(modType==2){ //VME scaler mapping --------------------
	271	scMod[iScCh] = rawStreamZDC->GetScalerModFromMap(iScCh);
	272	scCh[iScCh] = rawStreamZDC->GetScalerChFromMap(iScCh);
	273	scSigCode[iScCh] = rawStreamZDC->GetScalerSignFromMap(iScCh);
	274	scDet[iScCh] = rawStreamZDC->GetScDetectorFromMap(iScCh);
	275	scSec[iScCh] = rawStreamZDC->GetScTowerFromMap(iScCh);
	276	//
	277	fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
	278	iScCh,scMod[iScCh],scCh[iScCh],scSigCode[iScCh],scDet[iScCh],scSec[iScCh]);
	279	//
	280	//printf(" Mapping in DA -> %d Scaler: mod %d ch %d, code %d det %d, sec %d\n",
	281	// iScCh,scMod[iScCh],scCh[iScCh],scSigCode[iScCh],scDet[iScCh],scSec[iScCh]);
	282	//
	283	iScCh++;
	284	}
442e1b18	285	}
	286	}
	287	}
442e1b18	288	fclose(mapFile4Shuttle);
9d0b658a	289	}// SOD event
442e1b18	290
d3f256ca	291	else if(eventT==PHYSICS_EVENT){
442e1b18	292	// --- Reading data header
442e1b18	293	reader->ReadHeader();
039a08c3	294	const AliRawDataHeader* header = reader->GetDataHeader();
442e1b18	295	if(header){
b3b2b9dd	296	UChar_t message = header->GetAttributes();
c3986754	297	//printf(" message from L1 %x\n", message);
c3986754	298	if(message == 0x20){ // PEDESTAL RUN
442e1b18	299	//printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
	300	}
	301	else{
27afc0c8	302	printf("ZDCPEDESTALda.cxx -> NO STANDALONE_PEDESTAL RUN raw data found\n");
27afc0c8	303	return -1;
442e1b18	304	}
	305	}
	306	else{
	307	printf("\t ATTENTION! No Raw Data Header found!!!\n");
	308	return -1;
	309	}
7f4bde92	310
7f4bde92	311	rawStreamZDC->SetSODReading(kTRUE);
442e1b18	312
	313	if(!rawStreamZDC->Next()) printf(" \t No raw data found!! \n");
	314	//
	315	// ----- Setting ch. mapping -----
9d0b658a	316	for(Int_t jk=0; jk<2*kNChannels; jk++){
7f4bde92	317	//printf("ZDCPEDESTALDA.cxx -> ch.%d mod %d, ch %d, code %d det %d, sec %d\n",
7f4bde92	318	// jk,adcMod[jk],adcCh[jk],sigCode[jk],det[jk],sec[jk]);
442e1b18	319	rawStreamZDC->SetMapADCMod(jk, adcMod[jk]);
	320	rawStreamZDC->SetMapADCCh(jk, adcCh[jk]);
	321	rawStreamZDC->SetMapADCSig(jk, sigCode[jk]);
	322	rawStreamZDC->SetMapDet(jk, det[jk]);
	323	rawStreamZDC->SetMapTow(jk, sec[jk]);
	324	}
	325	//
	326	Int_t iraw=0;
039a08c3	327	Int_t RawADChg[kNChannels], RawADCoothg[kNChannels];
	328	Int_t RawADClg[kNChannels], RawADCootlg[kNChannels];
	329	for(Int_t j=0; j<kNChannels; j++){
	330	RawADChg[j]=0; RawADCoothg[j]=0;
	331	RawADClg[j]=0; RawADCootlg[j]=0;
	332	}
442e1b18	333	//
039a08c3	334	while(rawStreamZDC->Next()){
442e1b18	335	Int_t index=-1;
7f4bde92	336	Int_t detector = rawStreamZDC->GetSector(0);
9d0b658a	337	Int_t sector = rawStreamZDC->GetSector(1);
9d0b658a	338
7f4bde92	339	if(rawStreamZDC->IsADCDataWord() && (detector!=-1)){
9d0b658a	340	if(sector!=5){ // Physics signals
	341	if(detector==1) index = sector; // *** ZNC
	342	else if(detector==2) index = sector+5; // *** ZPC
	343	else if(detector==3) index = sector+9; // *** ZEM
	344	else if(detector==4) index = sector+12; // *** ZNA
	345	else if(detector==5) index = sector+17; // *** ZPA
f3ca8792	346	}
b3b2b9dd	347	else{ // Reference PMs
7f4bde92	348	index = (detector-1)/3+22;
f3ca8792	349	}
b3b2b9dd	350	//
c3986754	351	if(index==-1) printf("ERROR in ZDCPEDESTALda.cxx -> det %d quad %d index %d \n",
c3986754	352	detector,sector,index);
7f4bde92	353
442e1b18	354	//
442e1b18	355	if(iraw<2*kNChannels){ // --- In-time pedestals (1st 48 raw data)
b3b2b9dd	356	if(rawStreamZDC->GetADCGain()==0){
	357	hPedhg[index]->Fill(rawStreamZDC->GetADCValue());
	358	RawADChg[index] = rawStreamZDC->GetADCValue();
442e1b18	359	//
442e1b18	360	//printf("\t filling histo hPedhg[%d]\n",index);
b3b2b9dd	361	}
	362	else{
	363	hPedlg[index]->Fill(rawStreamZDC->GetADCValue());
	364	RawADClg[index] = rawStreamZDC->GetADCValue();
442e1b18	365	//
442e1b18	366	//printf("\t filling histo hPedlg[%d]\n",index);
b3b2b9dd	367	}
442e1b18	368	}
	369	else{ // --- Out-of-time pedestals
	370	if(rawStreamZDC->GetADCGain()==0){
	371	hPedOutOfTimehg[index]->Fill(rawStreamZDC->GetADCValue());
	372	RawADCoothg[index] = rawStreamZDC->GetADCValue();
	373	//
	374	//printf("\t filling histo hPedOutOfTimehg[%d]\n",index);
039a08c3	375	}
442e1b18	376	else{
	377	hPedOutOfTimelg[index]->Fill(rawStreamZDC->GetADCValue());
	378	RawADCootlg[index] = rawStreamZDC->GetADCValue();
	379	//
	380	//printf("\t filling histo hPedOutOfTimelg[%d]\n",index);
039a08c3	381	}
442e1b18	382	}
	383	iraw++;
	384	}//IsADCDataWord()
	385	//
	386	if(iraw == 4*kNChannels){ // Last ADC channel -> Filling correlation histos
	387	for(Int_t k=0; k<kNChannels; k++){
039a08c3	388	hPedCorrhg[k]->Fill(RawADCoothg[k], RawADChg[k]);
039a08c3	389	hPedCorrlg[k]->Fill(RawADCootlg[k], RawADClg[k]);
442e1b18	390	}
442e1b18	391	}
d3f256ca	392	}
	393	nevents_physics++;
	394	//
	395	delete reader;
	396	delete rawStreamZDC;
039a08c3	397
039a08c3	398	}//(if PHYSICS_EVENT)
d3f256ca	399
	400	/* exit when last event received, no need to wait for TERM signal */
	401	else if(eventT==END_OF_RUN) {
	402	printf(" -> EOR event detected\n");
	403	break;
	404	}
	405
039a08c3	406	nevents_total++;
f3ca8792	407
f3ca8792	408	}
d3f256ca	409
	410	/* free resources */
	411	free(event);
039a08c3	412	}
f3ca8792	413
	414	/* Analysis of the histograms */
	415	//
	416	FILE *fileShuttle;
218f916a	417	fileShuttle = fopen(PEDDATA_FILE,"w");
f3ca8792	418	//
b3b2b9dd	419	Float_t MeanPed[2kNChannels], MeanPedWidth[2kNChannels],
63604324	420	MeanPedOOT[2kNChannels], MeanPedWidthOOT[2kNChannels];
b3b2b9dd	421	// --- In-time pedestals
	422	TF1 *ADCfunchg[kNChannels];
	423	for(Int_t i=0; i<kNChannels; i++){
f9641c3b	424	if(hPedhg[i]->GetEntries() == 0){
	425	printf("\n WARNING! Empty histos -> ending DA WITHOUT writing output\n\n");
	426	return -1;
	427	}
b3b2b9dd	428	hPedhg[i]->Fit("gaus","Q");
b3b2b9dd	429	ADCfunchg[i] = hPedhg[i]->GetFunction("gaus");
442e1b18	430	MeanPed[i] = (Double_t) ADCfunchg[i]->GetParameter(1);
442e1b18	431	MeanPedWidth[i] = (Double_t) ADCfunchg[i]->GetParameter(2);
218f916a	432	fprintf(fileShuttle,"\t%f\t%f\n",MeanPed[i],MeanPedWidth[i]);
057ed567	433	//printf("\t MeanPedhg[%d] = %f\n",i, MeanPed[i]);
b3b2b9dd	434	}
	435	TF1 *ADCfunclg[kNChannels];
	436	for(Int_t i=0; i<kNChannels; i++){
	437	hPedlg[i]->Fit("gaus","Q");
	438	ADCfunclg[i] = hPedlg[i]->GetFunction("gaus");
442e1b18	439	MeanPed[i+kNChannels] = (Double_t) ADCfunclg[i]->GetParameter(1);
442e1b18	440	MeanPedWidth[i+kNChannels] = (Double_t) ADCfunclg[i]->GetParameter(2);
218f916a	441	fprintf(fileShuttle,"\t%f\t%f\n",MeanPed[i+kNChannels],MeanPedWidth[i+kNChannels]);
057ed567	442	//printf("\t MeanPedlg[%d] = %f\n",i+kNChannels, MeanPed[i+kNChannels]);
f3ca8792	443	}
f3ca8792	444	// --- Out-of-time pedestals
b3b2b9dd	445	TF1 *ADCootfunchg[kNChannels];
b3b2b9dd	446	for(Int_t i=0; i<kNChannels; i++){
3d155339	447	if(hPedOutOfTimehg[i]->GetEntries() == 0){
	448	printf("\n WARNING! Empty histos -> ending DA WITHOUT writing output\n\n");
	449	return -1;
	450	}
b3b2b9dd	451	hPedOutOfTimehg[i]->Fit("gaus","Q");
b3b2b9dd	452	ADCootfunchg[i] = hPedOutOfTimehg[i]->GetFunction("gaus");
442e1b18	453	MeanPedOOT[i] = (Double_t) ADCootfunchg[i]->GetParameter(1);
442e1b18	454	MeanPedWidthOOT[i] = (Double_t) ADCootfunchg[i]->GetParameter(2);
218f916a	455	fprintf(fileShuttle,"\t%f\t%f\n",MeanPedOOT[i],MeanPedWidthOOT[i]);
057ed567	456	//printf("\t MeanPedOOThg[%d] = %f\n",i, MeanPedOOT[i]);
b3b2b9dd	457	}
	458	TF1 *ADCootfunclg[kNChannels];
	459	for(Int_t i=0; i<kNChannels; i++){
	460	hPedOutOfTimelg[i]->Fit("gaus","Q");
	461	ADCootfunclg[i] = hPedOutOfTimelg[i]->GetFunction("gaus");
442e1b18	462	MeanPedOOT[i+kNChannels] = (Double_t) ADCootfunclg[i]->GetParameter(1);
442e1b18	463	MeanPedWidthOOT[i+kNChannels] = (Double_t) ADCootfunclg[i]->GetParameter(2);
218f916a	464	fprintf(fileShuttle,"\t%f\t%f\n",MeanPedOOT[i+kNChannels],MeanPedWidthOOT[i+kNChannels]);
057ed567	465	//printf("\t MeanPedOOTlg[%d] = %f\n",i+kNChannels, MeanPedOOT[i+kNChannels]);
f3ca8792	466	}
63604324	467
b3b2b9dd	468	// --- Correlations
9d0b658a	469
27afc0c8	470	Float_t CorrCoeff0[2kNChannels], CorrCoeff1[2kNChannels];
b3b2b9dd	471	TProfile hPedCorrProfhg[kNChannels], hPedCorrProflg[kNChannels];
b3b2b9dd	472	TF1 ffunchg[kNChannels], ffunclg[kNChannels];
f3ca8792	473	char namhist4[50];
b3b2b9dd	474	for(int i=0;i<kNChannels;i++) {
	475	sprintf(namhist4,"ADCHRvsOOT%d_Prof",i);
	476	hPedCorrProfhg[i] = hPedCorrhg[i]->ProfileX(namhist4,-1,-1,"S");
	477	hPedCorrProfhg[i]->SetName(namhist4);
	478	hPedCorrProfhg[i]->Fit("pol1","Q");
	479	ffunchg[i] = hPedCorrProfhg[i]->GetFunction("pol1");
442e1b18	480	CorrCoeff0[i] = (Double_t) ffunchg[i]->GetParameter(0);
442e1b18	481	CorrCoeff1[i] = (Double_t) ffunchg[i]->GetParameter(1);
9d0b658a	482	fprintf(fileShuttle,"\t%f\t%f\n",CorrCoeff0[i],CorrCoeff1[i]);
ea628de7	483	//printf("\t CorrCoeff0[%d] = %f, CorrCoeff1[%d] = %f\n",i, CorrCoeff0[i], i, CorrCoeff1[i]);
b3b2b9dd	484	}
	485	for(int i=0;i<kNChannels;i++) {
	486	sprintf(namhist4,"ADCLRvsOOT%d_Prof",i);
	487	hPedCorrProflg[i] = hPedCorrlg[i]->ProfileX(namhist4,-1,-1,"S");
	488	hPedCorrProflg[i]->SetName(namhist4);
	489	hPedCorrProflg[i]->Fit("pol1","Q");
	490	ffunclg[i] = hPedCorrProflg[i]->GetFunction("pol1");
442e1b18	491	CorrCoeff0[i+kNChannels] = (Double_t) ffunclg[i]->GetParameter(0);
442e1b18	492	CorrCoeff1[i+kNChannels] = (Double_t) ffunclg[i]->GetParameter(1);
9d0b658a	493	fprintf(fileShuttle,"\t%f\t%f\n",CorrCoeff0[i+kNChannels],CorrCoeff1[i+kNChannels]);
ea628de7	494	//printf("\t CorrCoeff0[%d] = %f, CorrCoeff1[%d] = %f\n",
ea628de7	495	// i+kNChannels, CorrCoeff0[i+kNChannels], i+kNChannels, CorrCoeff1[i+kNChannels]);
f3ca8792	496	}
27afc0c8	497
f3ca8792	498	//
f3ca8792	499	fclose(fileShuttle);
b3b2b9dd	500	//
65448375	501	/* report progress */
	502	daqDA_progressReport(80);
	503	//
	504	TFile *histofile = new TFile(PEDHISTO_FILE,"RECREATE");
	505	histofile->cd();
	506	for(int k=0; k<kNChannels; k++){
	507	hPedhg[k]->Write();
	508	hPedOutOfTimehg[k]->Write();
	509	hPedCorrhg[k]->Write();
	510	hPedlg[k]->Write();
	511	hPedOutOfTimelg[k]->Write();
	512	hPedCorrlg[k]->Write();
	513	}
	514	//
	515	histofile->Close();
	516	//
039a08c3	517	for(Int_t j=0; j<kNChannels; j++){
	518	delete hPedhg[j];
	519	delete hPedOutOfTimehg[j];
	520	delete hPedCorrhg[j];
	521	delete hPedlg[j];
	522	delete hPedOutOfTimelg[j];
	523	delete hPedCorrlg[j];
	524	}
f3ca8792	525
	526	/* write report */
	527	fprintf(fp,"Run #%s, received %d physics events out of %d\n",getenv("DATE_RUN_NUMBER"),nevents_physics,nevents_total);
	528
	529	/* close result file */
	530	fclose(fp);
039a08c3	531
	532	/* report progress */
	533	daqDA_progressReport(90);
	534
442e1b18	535	/* store the result files on FES */
63604324	536	// [1] File with mapping
a8eaff64	537	status = daqDA_FES_storeFile(MAPDATA_FILE, "MAPPING");
442e1b18	538	if(status){
65448375	539	printf("Failed to export mapping data file to DAQ FES\n");
442e1b18	540	return -1;
442e1b18	541	}
63604324	542	// [2] File with pedestal data
a8eaff64	543	status = daqDA_FES_storeFile(PEDDATA_FILE, "PEDESTALDATA");
039a08c3	544	if(status){
65448375	545	printf("Failed to export pedestal data file to DAQ FES\n");
	546	return -1;
	547	}
	548	// [3] File with pedestal histos
a8eaff64	549	status = daqDA_FES_storeFile(PEDHISTO_FILE, "PEDESTALHISTOS");
65448375	550	if(status){
65448375	551	printf("Failed to export pedestal histos file to DAQ FES\n");
63604324	552	return -1;
	553	}
	554
	555	/* store the result files on DB */
a8eaff64	556	status = daqDA_DB_storeFile(PEDDATA_FILE, PEDDATA_FILE);
63604324	557	if(status){
65448375	558	printf("Failed to store pedestal data file to DAQ DB\n");
039a08c3	559	return -1;
	560	}
	561
	562	/* report progress */
	563	daqDA_progressReport(100);
f3ca8792	564
f3ca8792	565	return status;
f3ca8792	566	}