[u/mrichter/AliRoot.git] / ZDC / ZDCMAPPINGda.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 to write mapping for ADC modules and VME scaler

Contact: Chiara.Oppedisano@to.infn.it
Link: 
Run Type: PHYSICS
DA Type: MON
Number of events needed: at least 50% 
Input Files:  none
Output Files: ZDCChMapping.dat
Trigger Types Used: different trigger types are used

*/

#define MAPDATA_FILE  "ZDCChMapping.dat"
#define TDCDATA_FILE  "ZDCTDCCalib.dat"
#define TDCHISTO_FILE "ZDCTDCHisto.root"

#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>

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");

  //const Char_t* tableSOD[]  = {"ALL", "no", "SOD", "all", NULL, NULL};
  //monitorDeclareTable(const_cast<char**>(tableSOD));
  
  char *monitor_table[] = { "ALL", "no", "PHY", "yes", "SOD", "all", NULL };
  int err = monitorDeclareTable(monitor_table);
  if(err){
    printf("monitorDeclareTable() failed: %s\n", monitorDecodeError(err));
    return -1;
  } 
  
  int status=0, nphys=0;
  int const kNModules = 10;
  int const kNChannels = 24;
  int const kNScChannels = 32;  
  int const kZDCTDCGeo=4;
  
  int itdc=0, iprevtdc=-1, ihittdc=0;
  float tdcData[6], tdcL0=-999.;	
  for(int ij=0; ij<6; ij++) tdcData[ij]=-999.;
  
  Int_t iMod=-1;
  Int_t modGeo[kNModules], modType[kNModules],modNCh[kNModules];
  for(Int_t kl=0; kl<kNModules; kl++){
     modGeo[kl]=modType[kl]=modNCh[kl]=0;
  }
  
  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;
  }
  
  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 itdcCh=0;
  Int_t tdcMod[kNScChannels], tdcCh[kNScChannels], tdcSigCode[kNScChannels];
  Int_t tdcDet[kNScChannels], tdcSec[kNScChannels];
  for(Int_t y=0; y<kNScChannels; y++){
    tdcMod[y]=tdcCh[y]=tdcSigCode[y]=tdcDet[y]=tdcSec[y]=-1;
  }
 
  TH1F * hTDC[6];
  char ntdchist[20];
  for(Int_t it=0; it<6; it++){
    if(it==0)      hTDC[it] = new TH1F("TDCZNC", "TDC ZNC", 200, -200., 200.);
    else if(it==1) hTDC[it] = new TH1F("TDCZNA", "TDC ZNA", 200, -200., 200.);
    else if(it==2) hTDC[it] = new TH1F("TDCZPC", "TDC ZPC", 200, -200., 200.);
    else if(it==3) hTDC[it] = new TH1F("TDCZPA", "TDC ZPA", 200, -200., 200.);
    else if(it==4) hTDC[it] = new TH1F("TDCZEM1","TDC ZEM1",200, -200., 200.);
    else if(it==5) hTDC[it] = new TH1F("TDCZEM2","TDC ZEM2",200, -200., 200.);
  }
  
  /* log start of process */
  printf("\n ZDC MAPPING program started\n");  
  signal(SIGSEGV, SIG_DFL);

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

  /* 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;
    }
    
    /* declare monitoring program */
    status=monitorDeclareMp( __FILE__ );
    if (status!=0) {
      printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
      return -1;
    }
    monitorSetNowait();
    monitorSetNoWaitNetworkTimeout(1000);


    int iev = 0;
    //Bool_t sodRead = kFALSE;
    //while(!sodRead){
    
    /* loop on events (infinite) */
    for(;;) {

      struct eventHeaderStruct *event;
      eventTypeType eventT;
 
      /* check shutdown condition */
      if (daqDA_checkShutdown()) {break;}

      /* get next event */
      status=monitorGetEventDynamic((void **)&event);
      if(status==MON_ERR_EOF){
        printf ("End of File detected\n");
        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) continue;
      
      // Initalize raw-data reading and decoding
      AliRawReader *reader = new AliRawReaderDate((void*)event);
      reader->Reset();
      reader->Select("ZDC");
      // --- Reading event header
      //UInt_t evtype = reader->GetType();
      //printf("\t ZDCMAPPINGda -> run # %d\n",reader->GetRunNumber());
      //
      AliZDCRawStream *rawStreamZDC = new AliZDCRawStream(reader);
        
	
      /* use event - here, just write event id to result file */
      eventT=event->eventType;
      
      if(eventT==START_OF_DATA){
	  	
	rawStreamZDC->SetSODReading(kTRUE);
	
	// --------------------------------------------------------
	// --- Writing ascii data file for the Shuttle preprocessor
        mapFile4Shuttle = fopen(MAPDATA_FILE,"w");
	//if(rawStreamZDC->Next()){
	  while((rawStreamZDC->Next())){
            if(rawStreamZDC->IsHeaderMapping()){ // mapping header
	       iMod++;
	       modGeo[iMod]  = rawStreamZDC->GetADCModule();
	       modType[iMod] = rawStreamZDC->GetModType();
	       modNCh[iMod]  = rawStreamZDC->GetADCNChannels();
	    }
            if(rawStreamZDC->IsChMapping()){ 
	      if(modType[iMod]==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);
	        ich++;
	      }
	      else if(modType[iMod]==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);
	        iScCh++;
	      }
	      else if(modType[iMod]==6 && modGeo[iMod]==4){ // ZDC TDC mapping --------------------
	        tdcMod[itdcCh]     = rawStreamZDC->GetTDCModFromMap(itdcCh);
	        tdcCh[itdcCh]      = rawStreamZDC->GetTDCChFromMap(itdcCh);
	        tdcSigCode[itdcCh] = rawStreamZDC->GetTDCSignFromMap(itdcCh);
	        itdcCh++;
	      }
	    }
 	  }
	  // Writing data on output FXS file
	  for(Int_t is=0; is<2*kNChannels; is++){
	     fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
	       is,adcMod[is],adcCh[is],sigCode[is],det[is],sec[is]);
    	     //printf("  Mapping DA -> %d ADC: mod %d ch %d, code %d det %d, sec %d\n",
	     //  is,adcMod[is],adcCh[is],sigCode[is],det[is],sec[is]);
	  }
	  for(Int_t is=0; is<kNScChannels; is++){
	     fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
	       is,scMod[is],scCh[is],scSigCode[is],scDet[is],scSec[is]);
 	     //if(scMod[is]!=-1) printf("  Mapping DA -> %d Scaler: mod %d ch %d, code %d det %d, sec %d\n",
	     //  is,scMod[is],scCh[is],scSigCode[is],scDet[is],scSec[is]);
	  }
	  for(Int_t is=0; is<kNScChannels; is++){
	     fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\n",
	       is,tdcMod[is],tdcCh[is],tdcSigCode[is]);
 	     //if(tdcMod[is]!=-1) printf("  Mapping DA -> %d TDC: mod %d ch %d, code %d\n",
	     //  is,tdcMod[is],tdcCh[is],tdcSigCode[is]);
	  }
	  for(Int_t is=0; is<kNModules; is++){
	     fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\n",
	     modGeo[is],modType[is],modNCh[is]);
	     //printf("  Mapping DA -> Module mapping: geo %d type %d #ch %d\n",
	     //  modGeo[is],modType[is],modNCh[is]);
	  }
	  
	//} //if (rawstream)
        fclose(mapFile4Shuttle);
      }// SOD event
      else if(eventT==PHYSICS_EVENT){ 

	rawStreamZDC->SetSODReading(kTRUE);

  	// ----- Setting ch. mapping -----
	for(Int_t jk=0; jk<2*kNChannels; 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]);
	}
	
  	while(rawStreamZDC->Next()){
          if(rawStreamZDC->GetADCModule()==kZDCTDCGeo && rawStreamZDC->IsZDCTDCDatum()==kTRUE){
             //
	     itdc = rawStreamZDC->GetChannel(); 
	     if((itdc>=8 && itdc<=13) || itdc==15){
               if(itdc==iprevtdc) ihittdc++;
               else ihittdc=0;
               iprevtdc=itdc;
               if(ihittdc<1 && itdc!=15) tdcData[itdc-8] = 0.025*rawStreamZDC->GetZDCTDCDatum();
	       //
	       if(itdc==15 && ihittdc<1){
	         tdcL0 = 0.025*rawStreamZDC->GetZDCTDCDatum();
       	         for(int ic=0; ic<6; ic++){
		   if(tdcData[ic]!=-999. && tdcL0!=-999.) hTDC[ic]->Fill(tdcData[ic]-tdcL0);
		 }
	       }
	     }
	  }
        }
	
	nphys++;
	
      }//(if PHYSICS_EVENT) 
      else if(eventT==END_OF_RUN){
        printf("End Of Run detected\n");
        break;
      }
      
      delete rawStreamZDC;
      rawStreamZDC = 0x0;
      
      iev++; 

      /* free resources */
      free(event);
 
    } // event loop    
      
  }
  printf(" \n # of physics events analyzed = %d\n\n", nphys);

  /* Analysis of the histograms */
  //
  FILE *fileShuttle;
  fileShuttle = fopen(TDCDATA_FILE,"w");
  //
  Float_t xUp=0., xLow=0., deltaX=0;
  Int_t binMax=0, nBinsx=0;
  Float_t mean[6], sigma[6];
  TF1 *fitfun[6];
  for(Int_t k=0; k<6; k++){
    if(hTDC[k]->GetEntries()!=0){
       binMax = hTDC[k]->GetMaximumBin();
       if(binMax<=1){
         printf("\n WARNING! Something wrong with det %d histo \n\n", k);
         continue;
       }
       // 
       xUp = (hTDC[k]->GetXaxis())->GetXmax();
       xLow = (hTDC[k]->GetXaxis())->GetXmin();
       deltaX = xUp-xLow;
       nBinsx = (hTDC[k]->GetXaxis())->GetNbins();
       //printf(" xMax = %f\n", xLow+binMax*deltaX/nBinsx);
       hTDC[k]->Fit("gaus","Q","",xLow+binMax*deltaX/nBinsx*0.6,xLow+binMax*deltaX/nBinsx*1.24);
       fitfun[k] = hTDC[k]->GetFunction("gaus");
       mean[k] = (Float_t) (fitfun[k]->GetParameter(1));
       sigma[k] = (Float_t) (fitfun[k]->GetParameter(2));
       //printf("\t Mean value from fit = %1.2f\n", mean[k]);
       //
       fprintf(fileShuttle,"\t%f\t%f\n",mean[k], sigma[k]);
     }
     else printf("  WARNING! TDC histo %d has no entries and can't be processed!\n",k);
  }
  //						       
  fclose(fileShuttle);
  
  TFile *histofile = new TFile(TDCHISTO_FILE,"RECREATE");
  histofile->cd();
  for(int k=0; k<6; k++) hTDC[k]->Write();						       
  histofile->Close();
  //
  for(Int_t j=0; j<6; j++) delete hTDC[j];
  
  /* store the result files on FES */
  // [1] File with mapping
  status = daqDA_FES_storeFile(MAPDATA_FILE, "MAPPING");
  if(status){
    printf("Failed to export file : %d\n",status);
    return -1;
  }
  // [2] File with TDC data
  status = daqDA_FES_storeFile(TDCDATA_FILE, "TDCDATA");
  if(status){
    printf("Failed to export TDC data file to DAQ FES\n");
    return -1;
  }
  // [3] File with TDC histos
  status = daqDA_FES_storeFile(TDCHISTO_FILE, "TDCHISTOS");
  if(status){
    printf("Failed to export TDC histos file to DAQ FES\n");
    return -1;
  }

  return status;
}
Commit	Line	Data
967dda6e	1	/*
	2
	3	This program reads the DAQ data files passed as argument using the monitoring library.
	4
967dda6e	5	The program reports about its processing progress.
	6
	7	Messages on stdout are exported to DAQ log system.
	8
27afc0c8	9	DA to write mapping for ADC modules and VME scaler
967dda6e	10
	11	Contact: Chiara.Oppedisano@to.infn.it
	12	Link:
b06a579c	13	Run Type: PHYSICS
1af38adf	14	DA Type: MON
745a7cd5	15	Number of events needed: at least 50%
1af38adf	16	Input Files: none
967dda6e	17	Output Files: ZDCChMapping.dat
1af38adf	18	Trigger Types Used: different trigger types are used
967dda6e	19
967dda6e	20	*/
1af38adf	21
218f916a	22	#define MAPDATA_FILE "ZDCChMapping.dat"
b06a579c	23	#define TDCDATA_FILE "ZDCTDCCalib.dat"
b06a579c	24	#define TDCHISTO_FILE "ZDCTDCHisto.root"
967dda6e	25
	26	#include <stdio.h>
	27	#include <stdlib.h>
	28	#include <Riostream.h>
	29
	30	// DATE
	31	#include <event.h>
	32	#include <monitor.h>
	33	#include <daqDA.h>
	34
	35	//ROOT
b06a579c	36	#include <TROOT.h>
	37	#include <TPluginManager.h>
	38	#include <TH1F.h>
	39	#include <TH2F.h>
	40	#include <TProfile.h>
	41	#include <TF1.h>
967dda6e	42	#include <TFile.h>
b06a579c	43	#include <TFitter.h>
b06a579c	44	#include "TMinuitMinimizer.h"
967dda6e	45
	46	//AliRoot
	47	#include <AliRawReaderDate.h>
	48	#include <AliRawEventHeaderBase.h>
	49	#include <AliZDCRawStream.h>
	50
967dda6e	51	int main(int argc, char **argv) {
1af38adf	52
b06a579c	53	gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
	54	"*",
	55	"TStreamerInfo",
	56	"RIO",
	57	"TStreamerInfo()");
	58
	59	TMinuitMinimizer m;
	60	gROOT->GetPluginManager()->AddHandler("ROOT::Math::Minimizer", "Minuit","TMinuitMinimizer",
	61	"Minuit", "TMinuitMinimizer(const char *)");
	62	TVirtualFitter::SetDefaultFitter("Minuit");
	63
745a7cd5	64	//const Char_t* tableSOD[] = {"ALL", "no", "SOD", "all", NULL, NULL};
745a7cd5	65	//monitorDeclareTable(const_cast<char**>(tableSOD));
967dda6e	66
6f0ade8b	67	char *monitor_table[] = { "ALL", "no", "PHY", "yes", "SOD", "all", NULL };
13fa523b	68	int err = monitorDeclareTable(monitor_table);
6f0ade8b	69	if(err){
	70	printf("monitorDeclareTable() failed: %s\n", monitorDecodeError(err));
	71	return -1;
	72	}
	73
ab6650a3	74	int status=0, nphys=0;
198f612a	75	int const kNModules = 10;
f9641c3b	76	int const kNChannels = 24;
745a7cd5	77	int const kNScChannels = 32;
745a7cd5	78	int const kZDCTDCGeo=4;
b06a579c	79
745a7cd5	80	int itdc=0, iprevtdc=-1, ihittdc=0;
	81	float tdcData[6], tdcL0=-999.;
	82	for(int ij=0; ij<6; ij++) tdcData[ij]=-999.;
	83
	84	Int_t iMod=-1;
	85	Int_t modGeo[kNModules], modType[kNModules],modNCh[kNModules];
	86	for(Int_t kl=0; kl<kNModules; kl++){
	87	modGeo[kl]=modType[kl]=modNCh[kl]=0;
	88	}
	89
	90	Int_t ich=0;
	91	Int_t adcMod[2kNChannels], adcCh[2kNChannels], sigCode[2*kNChannels];
	92	Int_t det[2kNChannels], sec[2kNChannels];
	93	for(Int_t y=0; y<2*kNChannels; y++){
	94	adcMod[y]=adcCh[y]=sigCode[y]=det[y]=sec[y]=0;
	95	}
	96
	97	Int_t iScCh=0;
	98	Int_t scMod[kNScChannels], scCh[kNScChannels], scSigCode[kNScChannels];
	99	Int_t scDet[kNScChannels], scSec[kNScChannels];
	100	for(Int_t y=0; y<kNScChannels; y++){
	101	scMod[y]=scCh[y]=scSigCode[y]=scDet[y]=scSec[y]=0;
	102	}
	103
	104	Int_t itdcCh=0;
	105	Int_t tdcMod[kNScChannels], tdcCh[kNScChannels], tdcSigCode[kNScChannels];
	106	Int_t tdcDet[kNScChannels], tdcSec[kNScChannels];
	107	for(Int_t y=0; y<kNScChannels; y++){
	108	tdcMod[y]=tdcCh[y]=tdcSigCode[y]=tdcDet[y]=tdcSec[y]=-1;
	109	}
b06a579c	110
	111	TH1F * hTDC[6];
	112	char ntdchist[20];
745a7cd5	113	for(Int_t it=0; it<6; it++){
ab6650a3	114	if(it==0) hTDC[it] = new TH1F("TDCZNC", "TDC ZNC", 200, -200., 200.);
	115	else if(it==1) hTDC[it] = new TH1F("TDCZNA", "TDC ZNA", 200, -200., 200.);
	116	else if(it==2) hTDC[it] = new TH1F("TDCZPC", "TDC ZPC", 200, -200., 200.);
	117	else if(it==3) hTDC[it] = new TH1F("TDCZPA", "TDC ZPA", 200, -200., 200.);
	118	else if(it==4) hTDC[it] = new TH1F("TDCZEM1","TDC ZEM1",200, -200., 200.);
	119	else if(it==5) hTDC[it] = new TH1F("TDCZEM2","TDC ZEM2",200, -200., 200.);
b06a579c	120	}
b06a579c	121
967dda6e	122	/* log start of process */
198f612a	123	printf("\n ZDC MAPPING program started\n");
13fa523b	124	signal(SIGSEGV, SIG_DFL);
967dda6e	125
	126	/* check that we got some arguments = list of files */
	127	if (argc<2) {
	128	printf("Wrong number of arguments\n");
	129	return -1;
	130	}
967dda6e	131
967dda6e	132	FILE *mapFile4Shuttle;
967dda6e	133
	134	/* read the data files */
	135	int n;
	136	for(n=1;n<argc;n++){
	137
	138	status=monitorSetDataSource( argv[n] );
	139	if (status!=0) {
	140	printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
	141	return -1;
	142	}
1af38adf	143
	144	/* declare monitoring program */
	145	status=monitorDeclareMp( __FILE__ );
	146	if (status!=0) {
	147	printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
	148	return -1;
	149	}
	150	monitorSetNowait();
	151	monitorSetNoWaitNetworkTimeout(1000);
967dda6e	152
967dda6e	153
47c85760	154	int iev = 0;
	155	//Bool_t sodRead = kFALSE;
	156	//while(!sodRead){
	157
	158	/* loop on events (infinite) */
	159	for(;;) {
	160
	161	struct eventHeaderStruct *event;
	162	eventTypeType eventT;
1af38adf	163
	164	/* check shutdown condition */
	165	if (daqDA_checkShutdown()) {break;}
967dda6e	166
	167	/* get next event */
	168	status=monitorGetEventDynamic((void **)&event);
1af38adf	169	if(status==MON_ERR_EOF){
	170	printf ("End of File detected\n");
	171	break; /* end of monitoring file has been reached */
	172	}
967dda6e	173	if(status!=0) {
	174	printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
	175	return -1;
	176	}
	177
	178	/* retry if got no event */
ac84d2fc	179	if(event==NULL) continue;
967dda6e	180
	181	// Initalize raw-data reading and decoding
	182	AliRawReader reader = new AliRawReaderDate((void)event);
6f0ade8b	183	reader->Reset();
27afc0c8	184	reader->Select("ZDC");
967dda6e	185	// --- Reading event header
7f4bde92	186	//UInt_t evtype = reader->GetType();
ac84d2fc	187	//printf("\t ZDCMAPPINGda -> run # %d\n",reader->GetRunNumber());
967dda6e	188	//
	189	AliZDCRawStream *rawStreamZDC = new AliZDCRawStream(reader);
	190
1af38adf	191
967dda6e	192	/* use event - here, just write event id to result file */
	193	eventT=event->eventType;
	194
198f612a	195	if(eventT==START_OF_DATA){
198f612a	196
7f4bde92	197	rawStreamZDC->SetSODReading(kTRUE);
7f4bde92	198
ac84d2fc	199	// --------------------------------------------------------
	200	// --- Writing ascii data file for the Shuttle preprocessor
	201	mapFile4Shuttle = fopen(MAPDATA_FILE,"w");
47c85760	202	//if(rawStreamZDC->Next()){
27afc0c8	203	while((rawStreamZDC->Next())){
27afc0c8	204	if(rawStreamZDC->IsHeaderMapping()){ // mapping header
198f612a	205	iMod++;
	206	modGeo[iMod] = rawStreamZDC->GetADCModule();
	207	modType[iMod] = rawStreamZDC->GetModType();
	208	modNCh[iMod] = rawStreamZDC->GetADCNChannels();
27afc0c8	209	}
27afc0c8	210	if(rawStreamZDC->IsChMapping()){
198f612a	211	if(modType[iMod]==1){ // ADC mapping ----------------------
27afc0c8	212	adcMod[ich] = rawStreamZDC->GetADCModFromMap(ich);
	213	adcCh[ich] = rawStreamZDC->GetADCChFromMap(ich);
	214	sigCode[ich] = rawStreamZDC->GetADCSignFromMap(ich);
	215	det[ich] = rawStreamZDC->GetDetectorFromMap(ich);
	216	sec[ich] = rawStreamZDC->GetTowerFromMap(ich);
27afc0c8	217	ich++;
27afc0c8	218	}
82dffa48	219	else if(modType[iMod]==2){ // VME scaler mapping -------------
27afc0c8	220	scMod[iScCh] = rawStreamZDC->GetScalerModFromMap(iScCh);
	221	scCh[iScCh] = rawStreamZDC->GetScalerChFromMap(iScCh);
	222	scSigCode[iScCh] = rawStreamZDC->GetScalerSignFromMap(iScCh);
	223	scDet[iScCh] = rawStreamZDC->GetScDetectorFromMap(iScCh);
	224	scSec[iScCh] = rawStreamZDC->GetScTowerFromMap(iScCh);
27afc0c8	225	iScCh++;
27afc0c8	226	}
82dffa48	227	else if(modType[iMod]==6 && modGeo[iMod]==4){ // ZDC TDC mapping --------------------
	228	tdcMod[itdcCh] = rawStreamZDC->GetTDCModFromMap(itdcCh);
	229	tdcCh[itdcCh] = rawStreamZDC->GetTDCChFromMap(itdcCh);
	230	tdcSigCode[itdcCh] = rawStreamZDC->GetTDCSignFromMap(itdcCh);
	231	itdcCh++;
	232	}
967dda6e	233	}
198f612a	234	}
198f612a	235	// Writing data on output FXS file
198f612a	236	for(Int_t is=0; is<2*kNChannels; is++){
	237	fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
	238	is,adcMod[is],adcCh[is],sigCode[is],det[is],sec[is]);
	239	//printf(" Mapping DA -> %d ADC: mod %d ch %d, code %d det %d, sec %d\n",
	240	// is,adcMod[is],adcCh[is],sigCode[is],det[is],sec[is]);
	241	}
	242	for(Int_t is=0; is<kNScChannels; is++){
	243	fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
	244	is,scMod[is],scCh[is],scSigCode[is],scDet[is],scSec[is]);
82dffa48	245	//if(scMod[is]!=-1) printf(" Mapping DA -> %d Scaler: mod %d ch %d, code %d det %d, sec %d\n",
198f612a	246	// is,scMod[is],scCh[is],scSigCode[is],scDet[is],scSec[is]);
967dda6e	247	}
82dffa48	248	for(Int_t is=0; is<kNScChannels; is++){
	249	fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\n",
	250	is,tdcMod[is],tdcCh[is],tdcSigCode[is]);
	251	//if(tdcMod[is]!=-1) printf(" Mapping DA -> %d TDC: mod %d ch %d, code %d\n",
	252	// is,tdcMod[is],tdcCh[is],tdcSigCode[is]);
	253	}
608444fb	254	for(Int_t is=0; is<kNModules; is++){
	255	fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\n",
	256	modGeo[is],modType[is],modNCh[is]);
	257	//printf(" Mapping DA -> Module mapping: geo %d type %d #ch %d\n",
	258	// modGeo[is],modType[is],modNCh[is]);
	259	}
198f612a	260
47c85760	261	//} //if (rawstream)
967dda6e	262	fclose(mapFile4Shuttle);
27afc0c8	263	}// SOD event
745a7cd5	264	else if(eventT==PHYSICS_EVENT){
	265
	266	rawStreamZDC->SetSODReading(kTRUE);
	267
	268	// ----- Setting ch. mapping -----
	269	for(Int_t jk=0; jk<2*kNChannels; jk++){
	270	rawStreamZDC->SetMapADCMod(jk, adcMod[jk]);
	271	rawStreamZDC->SetMapADCCh(jk, adcCh[jk]);
	272	rawStreamZDC->SetMapADCSig(jk, sigCode[jk]);
	273	rawStreamZDC->SetMapDet(jk, det[jk]);
	274	rawStreamZDC->SetMapTow(jk, sec[jk]);
1af38adf	275	}
745a7cd5	276
	277	while(rawStreamZDC->Next()){
	278	if(rawStreamZDC->GetADCModule()==kZDCTDCGeo && rawStreamZDC->IsZDCTDCDatum()==kTRUE){
	279	//
	280	itdc = rawStreamZDC->GetChannel();
	281	if((itdc>=8 && itdc<=13) \|\| itdc==15){
	282	if(itdc==iprevtdc) ihittdc++;
	283	else ihittdc=0;
	284	iprevtdc=itdc;
6d64cce3	285	if(ihittdc<1 && itdc!=15) tdcData[itdc-8] = 0.025*rawStreamZDC->GetZDCTDCDatum();
745a7cd5	286	//
	287	if(itdc==15 && ihittdc<1){
	288	tdcL0 = 0.025*rawStreamZDC->GetZDCTDCDatum();
ab6650a3	289	for(int ic=0; ic<6; ic++){
	290	if(tdcData[ic]!=-999. && tdcL0!=-999.) hTDC[ic]->Fill(tdcData[ic]-tdcL0);
	291	}
745a7cd5	292	}
	293	}
	294	}
	295	}
ab6650a3	296
	297	nphys++;
	298
745a7cd5	299	}//(if PHYSICS_EVENT)
47c85760	300	else if(eventT==END_OF_RUN){
	301	printf("End Of Run detected\n");
	302	break;
	303	}
	304
	305	delete rawStreamZDC;
	306	rawStreamZDC = 0x0;
1af38adf	307
1af38adf	308	iev++;
d3f256ca	309
	310	/* free resources */
	311	free(event);
6f0ade8b	312
47c85760	313	} // event loop
1af38adf	314
1af38adf	315	}
ab6650a3	316	printf(" \n # of physics events analyzed = %d\n\n", nphys);
b06a579c	317
	318	/* Analysis of the histograms */
	319	//
	320	FILE *fileShuttle;
	321	fileShuttle = fopen(TDCDATA_FILE,"w");
	322	//
	323	Float_t xUp=0., xLow=0., deltaX=0;
	324	Int_t binMax=0, nBinsx=0;
	325	Float_t mean[6], sigma[6];
	326	TF1 *fitfun[6];
	327	for(Int_t k=0; k<6; k++){
	328	if(hTDC[k]->GetEntries()!=0){
	329	binMax = hTDC[k]->GetMaximumBin();
b06a579c	330	if(binMax<=1){
	331	printf("\n WARNING! Something wrong with det %d histo \n\n", k);
	332	continue;
	333	}
	334	//
	335	xUp = (hTDC[k]->GetXaxis())->GetXmax();
	336	xLow = (hTDC[k]->GetXaxis())->GetXmin();
	337	deltaX = xUp-xLow;
	338	nBinsx = (hTDC[k]->GetXaxis())->GetNbins();
	339	//printf(" xMax = %f\n", xLow+binMax*deltaX/nBinsx);
	340	hTDC[k]->Fit("gaus","Q","",xLow+binMaxdeltaX/nBinsx0.6,xLow+binMaxdeltaX/nBinsx1.24);
	341	fitfun[k] = hTDC[k]->GetFunction("gaus");
	342	mean[k] = (Float_t) (fitfun[k]->GetParameter(1));
	343	sigma[k] = (Float_t) (fitfun[k]->GetParameter(2));
	344	//printf("\t Mean value from fit = %1.2f\n", mean[k]);
	345	//
	346	fprintf(fileShuttle,"\t%f\t%f\n",mean[k], sigma[k]);
	347	}
745a7cd5	348	else printf(" WARNING! TDC histo %d has no entries and can't be processed!\n",k);
b06a579c	349	}
	350	//
	351	fclose(fileShuttle);
	352
	353	TFile *histofile = new TFile(TDCHISTO_FILE,"RECREATE");
	354	histofile->cd();
745a7cd5	355	for(int k=0; k<6; k++) hTDC[k]->Write();
b06a579c	356	histofile->Close();
	357	//
	358	for(Int_t j=0; j<6; j++) delete hTDC[j];
967dda6e	359
967dda6e	360	/* store the result files on FES */
b06a579c	361	// [1] File with mapping
a8eaff64	362	status = daqDA_FES_storeFile(MAPDATA_FILE, "MAPPING");
967dda6e	363	if(status){
	364	printf("Failed to export file : %d\n",status);
	365	return -1;
	366	}
b06a579c	367	// [2] File with TDC data
	368	status = daqDA_FES_storeFile(TDCDATA_FILE, "TDCDATA");
	369	if(status){
ab6650a3	370	printf("Failed to export TDC data file to DAQ FES\n");
b06a579c	371	return -1;
	372	}
	373	// [3] File with TDC histos
	374	status = daqDA_FES_storeFile(TDCHISTO_FILE, "TDCHISTOS");
	375	if(status){
ab6650a3	376	printf("Failed to export TDC histos file to DAQ FES\n");
b06a579c	377	return -1;
b06a579c	378	}
967dda6e	379
967dda6e	380	return status;
967dda6e	381	}