[u/mrichter/AliRoot.git] / ITS / ITSSPDda.cxx

//////////////////////////////////////////////////////////////////////////////
// This program can be run in two modes.                                    //
//                                                                          //
// 1. With the DAQ DA framework on. In Makefile: -DDA_OFF flag outcommented.//
// Call this program with the name of the executable followed by the        //
// data files to process.                                                   //
//                                                                          //
// 2. Without the DAQ DA framework on. In Makefile: with -DDA_OFF flag.     //
// Call this program with the name of the executable followed by the        //
// runNr and the data files to process.                                     //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

extern "C" {
#include "daqDA.h"
}
#include "event.h"
#include "monitor.h"
#include "AliRawReaderDate.h"
#include "AliITSRawStreamSPD.h"
#include "AliITSOnlineSPDscan.h"
#include "AliITSOnlineSPDscanSingle.h"
#include "AliITSOnlineSPDscanMultiple.h"
#include "AliITSOnlineSPDscanMeanTh.h"
#include "AliITSOnlineSPDscanAnalyzer.h"
#include "AliLog.h"
#include <iostream>
#include <fstream>
#include <TROOT.h>
#include <TPluginManager.h>


int main(int argc, char **argv) {
  if (argc<2) {
    printf("Wrong number of arguments\n");
    return -1;
  }

  char *saveDirNoisy         = "./calibResults/Noisy";       // hard wired for now!!!
#ifndef DA_OFF
  char *saveDirNoisyToFXS    = "./calibResults/NoisyToFXS";  // hard wired for now!!!
#endif
  char *saveDirParameters    = "./calibResults/Parameters";  // hard wired for now!!!
  char *saveDirRef           = "./calibResults/Reference";   // hard wired for now!!!

  // This line is needed in case of a stand-alone application w/o
  // $ROOTSYS/etc/system.rootrc file
  gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
					"*",
					"TStreamerInfo",
					"RIO",
					"TStreamerInfo()");

  // turn off annoying warning messages
  new AliLog;
  AliLog::Instance()->SetModuleDebugLevel("ROOT", -2);

  // calib scan types
  enum calib_types{MINTH,MEANTH,DAC,UNIMA,NOISE,DELAY};


  // ********* STEP 1: Produce scan container files. ***********************************
  int startSeg = 1;

#ifndef DA_OFF
  int runNr = atoi(getenv("DATE_RUN_NUMBER"));
#else
  int runNr = atoi(argv[1]);
  startSeg = 2;
#endif

  // container objects
  AliITSOnlineSPDscan *scanObj[20];
  Bool_t bScanInit[20];
  for (UInt_t eqId=0; eqId<20; eqId++) {
    scanObj[eqId]=NULL;
    bScanInit[eqId]=kFALSE;
  }
  // header data variables
  UInt_t routerNr[20];
  Bool_t halfStaveScanned[20][6];
  UInt_t type[20];
  Bool_t dataFormat[20];
  UInt_t triggers[20];
  Bool_t chipPresent[20][6][10];
  UInt_t dacStart[20];  
  UInt_t dacEnd[20];
  UInt_t dacStep[20];
  UInt_t dacId[20];
  UInt_t rowStart[20];  
  UInt_t rowEnd[20];
  UInt_t rowValue[20];
  UInt_t dacValue[20];
  UInt_t dacHigh[20][6];
  UInt_t dacLow[20][6];
  UInt_t TPAmp[20][6];
  // current scan step flag
  Int_t currentStep[20];
  for (UInt_t eqId=0; eqId<20; eqId++) currentStep[eqId] = 9999;

  // loop over run segments
  for (int segNr=startSeg; segNr<argc; segNr++) {


    int status;

    /* define data source : this is argument 1 */  
    status=monitorSetDataSource( argv[segNr] );
    if (status!=0) {
      printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
      return -1;
    }
    /* declare monitoring program */
    status=monitorDeclareMp("ITS_SPD_CAL");
    if (status!=0) {
      printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
      return -1;
    }
    /* define wait event timeout - 1s max */
    monitorSetNowait();
    monitorSetNoWaitNetworkTimeout(1000);


    struct eventHeaderStruct *event;
    eventTypeType eventT;
    UInt_t eventNr=0;


    /* main loop (infinite) */
    for(;;) {

      /* check shutdown condition */
      if (daqDA_checkShutdown()) {break;}
      /* get next event (blocking call until timeout) */
      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));
	break;
      }
      /* retry if got no event */
      if (event==NULL) {
	printf("event==NULL\n");
	continue;
      }

      eventT=event->eventType;
      if (event->eventType == PHYSICS_EVENT){


	eventNr++;
	//      printf("eventNr %d\n",eventNr);

	AliRawReader *reader = new AliRawReaderDate((void*)event);
	AliITSRawStreamSPD *str = new AliITSRawStreamSPD(reader);


	for (UInt_t eqId=0; eqId<20; eqId++) {

	  reader->Reset();
	  reader->Select("ITSSPD",eqId,eqId);

	  // Hit Event flags, specific for one event
	  Bool_t hitEventHSIncremented[6];
	  Bool_t hitEventChipIncremented[6][10];
	  for (UInt_t hs=0; hs<6; hs++) {
	    hitEventHSIncremented[hs] = kFALSE;
	    for (UInt_t chip=0; chip<10; chip++) {
	      hitEventChipIncremented[hs][chip] = kFALSE;
	    }
	  }

	  if (str->ReadCalibHeader()) {
	    // first check the type:
	    if (bScanInit[eqId] && type[eqId]!=str->GetHtype()) {
	      printf("Calib header problem. Type changed (%d -> %d)!\n",type[eqId],str->GetHtype());
	    }

	    // read calib values
	    routerNr[eqId] = str->GetHrouterNr();
	    type[eqId] = str->GetHtype();
	    dataFormat[eqId] = str->GetHdataFormat();
	    triggers[eqId] = str->GetHtriggers();
	    dacStart[eqId] = str->GetHdacStart();
	    dacEnd[eqId] = str->GetHdacEnd();
	    dacStep[eqId] = str->GetHdacStep();
	    dacId[eqId] = str->GetHdacId();
	    rowStart[eqId] = str->GetHrowStart();
	    rowEnd[eqId] = str->GetHrowEnd();
	    rowValue[eqId] = str->GetHrowValue();
	    dacValue[eqId] = str->GetHdacValue();
	    for (UInt_t hs=0; hs<6; hs++) {
	      halfStaveScanned[eqId][hs]=str->GetHhalfStaveScanned(hs);
	      dacHigh[eqId][hs] = str->GetHdacHigh(hs);
	      dacLow[eqId][hs] = str->GetHdacLow(hs);
	      TPAmp[eqId][hs] = str->GetHTPAmp(hs);
	      for (UInt_t chip=0; chip<10; chip++) {
		chipPresent[eqId][hs][chip] = str->GetHchipPresent(hs,chip);
	      }
	    }

	    currentStep[eqId] = (dacValue[eqId]-dacStart[eqId])/dacStep[eqId];
	    if (type[eqId]==DELAY) {
	      currentStep[eqId]=currentStep[eqId]*2;
	      dacValue[eqId]=dacValue[eqId]*2;
	      if (dacHigh[eqId][0]==128) { // misc_ctrl value
		currentStep[eqId]=currentStep[eqId]+1;
		dacValue[eqId]=dacValue[eqId]+1;
	      }
	    }

	    // router nr check:
	    if (routerNr[eqId]!=eqId) {
	      printf("Router nr problem? Router nr %d != EqID %d\n",routerNr[eqId],eqId);
	    }

	    if (!bScanInit[eqId]) {
	      // initialize container object
	      Char_t fileName[200];
	      sprintf(fileName,"%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
	      switch (type[eqId]) {
	      case NOISE:
	      case UNIMA:
		scanObj[eqId] = new AliITSOnlineSPDscanSingle(fileName); 
		((AliITSOnlineSPDscanSingle*)scanObj[eqId])->ClearThis();
		bScanInit[eqId]=kTRUE;
		break;
	      case MINTH:
	      case DAC:
	      case DELAY:
		scanObj[eqId] = new AliITSOnlineSPDscanMultiple(fileName);
		scanObj[eqId]->ClearThis();
		bScanInit[eqId]=kTRUE;
		break;
	      case MEANTH: 
		scanObj[eqId] = new AliITSOnlineSPDscanMeanTh(fileName);
		scanObj[eqId]->ClearThis();
		bScanInit[eqId]=kTRUE;
		break;
	      default:
		printf("Unknown scan type: %d.\n",type[eqId]);
	      }
	      // some multiple scan data
	      if (type[eqId]==MINTH || type[eqId]==MEANTH || type[eqId]==DAC || type[eqId]==DELAY) {
		((AliITSOnlineSPDscanMultiple*)scanObj[eqId])->SetDacId(dacId[eqId]);
	      }
	      // some common data
	      scanObj[eqId]->SetRunNr((UInt_t)runNr);
	      scanObj[eqId]->SetRouterNr(routerNr[eqId]);
	      for (UInt_t hs=0; hs<6; hs++) {
		scanObj[eqId]->SetHalfStaveScanned(hs,halfStaveScanned[eqId][hs]);
	      }
	      scanObj[eqId]->SetType(type[eqId]);
	      scanObj[eqId]->SetDataFormat(dataFormat[eqId]);
	      for (Int_t hs=0; hs<6; hs++) {
	      
		// remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!
		Bool_t halfStavePresent = str->GetHalfStavePresent(hs);
		// remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!

		for (UInt_t chip=0; chip<10; chip++) {
		  scanObj[eqId]->SetChipPresent(hs,chip,chipPresent[eqId][hs][chip]);

		  // remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!
		  if (halfStavePresent) scanObj[eqId]->SetChipPresent(hs,chip,kTRUE);
		  // remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!

		}
	      }
	      scanObj[eqId]->SetRowStart(rowStart[eqId]);
	      scanObj[eqId]->SetRowEnd(rowEnd[eqId]);
	      scanObj[eqId]->SetDacStart(dacStart[eqId]);
	      scanObj[eqId]->SetDacEnd(dacEnd[eqId]);
	      scanObj[eqId]->SetDacStep(dacStep[eqId]);
	    }

	    if (type[eqId]==MINTH) {
	      scanObj[eqId]->SetTriggers(currentStep[eqId],triggers[eqId]);
	    }
	    if (type[eqId]==UNIMA || type[eqId]==NOISE) {
	      if (currentStep[eqId]==9999) printf("SPDcalibratorStep1 (eq %d): single step\n",eqId);
	      currentStep[eqId]=0;
	    }
	    if (type[eqId]==MINTH || type[eqId]==MEANTH || type[eqId]==DAC || type[eqId]==DELAY) {
	      ((AliITSOnlineSPDscanMultiple*)scanObj[eqId])->SetDacValue(currentStep[eqId],dacValue[eqId]);
	      if (type[eqId]==DELAY) {
		printf("SPDcalibratorStep1 (eq %d): DAC %d/%d , step %d\n",eqId,dacValue[eqId]/2,dacHigh[eqId][0],currentStep[eqId]);
	      }
	      else {
		printf("SPDcalibratorStep1 (eq %d): DAC %d , step %d\n",eqId,dacValue[eqId],currentStep[eqId]);
	      }
	    }
	    if (type[eqId]==MEANTH) {
	      for (Int_t hs=0; hs<6; hs++) {
		((AliITSOnlineSPDscanMeanTh*)scanObj[eqId])->SetDacLow(currentStep[eqId],hs,dacLow[eqId][hs]);
		((AliITSOnlineSPDscanMeanTh*)scanObj[eqId])->SetDacHigh(currentStep[eqId],hs,dacHigh[eqId][hs]);
		((AliITSOnlineSPDscanMeanTh*)scanObj[eqId])->SetTPAmp(currentStep[eqId],hs,TPAmp[eqId][hs]);
	      }
	    }


	  }
	
	  if (bScanInit[eqId]) {
	    while (str->Next()) {
	      UInt_t hs = str->GetHalfStaveNr();
	      UInt_t chip = str->GetChipAddr();

	      if (type[eqId]!=MINTH || dacHigh[eqId][0]==chip) { // dachigh[0] holds chip scanned for minth

		scanObj[eqId]->IncrementHits(currentStep[eqId],hs,chip,str->GetChipCol(),str->GetChipRow());
	    
		if (!hitEventHSIncremented[hs]) {
		  scanObj[eqId]->IncrementHitEventsTot(currentStep[eqId],hs);
		  hitEventHSIncremented[hs]=kTRUE;
		}
	    
		if (!hitEventChipIncremented[hs][chip]) {
		  scanObj[eqId]->IncrementHitEvents(currentStep[eqId],hs,chip);
		  hitEventChipIncremented[hs][chip]=kTRUE;
		}
	      }

	    }

	    if (type[eqId]!=MINTH) { // for minth, triggers are set from header info
	      scanObj[eqId]->IncrementTriggers(currentStep[eqId]);
	    }

	  }

	}

	delete str;
	delete reader;

      }

      /* free resources */
      free(event);

    }

    status = monitorLogout();
    if (status != 0) {
      printf("monitorLogout() failed : %s\n",monitorDecodeError(status));
      return -1;
    }
    
#ifndef DA_OFF
    daqDA_progressReport((unsigned int)( ((Float_t)(segNr-startSeg+1))/(argc-startSeg)*50 ));
#else
    printf("progress: %d\n",(unsigned int)( ((Float_t)(segNr-startSeg+1))/(argc-startSeg)*50 ));
#endif

  }

  // clean up scan objects
  for (UInt_t eqId=0; eqId<20; eqId++) {
    if (scanObj[eqId]!=NULL) delete scanObj[eqId];
  }


  // ********* STEP 2: Analyze scan container files. ***********************************
#ifndef DA_OFF
  // clear noisyToFXS dir:
  Char_t command[200];
  sprintf(command,"cd %s; rm -f *",saveDirNoisyToFXS);
  system(command);
#endif

  AliITSOnlineSPDscanAnalyzer *analyzer;

  // *** *** *** start loop over equipments (eq_id)
  for (int eqId=0; eqId<20; eqId++) {

    Char_t fileName[200];
    sprintf(fileName,"%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
    analyzer = new AliITSOnlineSPDscanAnalyzer(fileName);

    Int_t type  = analyzer->GetType();
    Int_t dacId = analyzer->GetDacId();
    if (type!=99) {
      if (type==DAC) {
	printf("SPD calibrator Step2: eqId %d, type %d, dacId %d\n",eqId,type,dacId);
      }
      else printf("SPD calibrator Step2: eqId %d type %d\n",eqId,type);  
    }


    if (type==UNIMA) {
    }
    else if (type==NOISE) {
      if (analyzer->ProcessNoisyPixels(saveDirNoisy)) {
	for (UInt_t module=0; module<240; module++) {
	  if (analyzer->SaveDeadNoisyPixels(module,saveDirNoisy)) {
#ifndef DA_OFF
	    Char_t command[100];
	    sprintf(command,"cp %s/SPD_DeadNoisy_%d.root %s/.",saveDirNoisy,module,saveDirNoisyToFXS);
	    system(command);
#endif
	  }
	}
      }
    }
//    else if (type==DAC && dacId==42) {
//      Char_t ofileName[100];
//      sprintf(ofileName,"%s/delay_eq_%d.txt",saveDirParameters,eqId);
//      ofstream ofile;
//      ofile.open (ofileName);
//      for (UInt_t hs=0; hs<6; hs++) {
//	for (UInt_t chipNr=0; chipNr<10; chipNr++) {
//	  ofile << analyzer->GetDelay(hs,chipNr);
//	  ofile << "\t";
//	}
//	ofile << "\n";
//      }
//      ofile.close();
//#ifndef DA_OFF
//      Char_t id[20];
//      sprintf(id,"SPD_delay_%d",eqId);
//      Int_t status = daqDA_FES_storeFile(ofileName,id);
//      if (status) {
//	printf("Failed to export file %s , status %d\n",ofileName,status);
//      }
//#endif
//    }
    else if (type==MINTH || (type==DAC && dacId==39)) {
      Char_t ofileName[100];
      sprintf(ofileName,"%s/minth_eq_%d.txt",saveDirParameters,eqId);
      ofstream ofile;
      ofile.open (ofileName);
      for (UInt_t hs=0; hs<6; hs++) {
	for (UInt_t chipNr=0; chipNr<10; chipNr++) {
	  ofile << analyzer->GetMinTh(hs,chipNr);
	  ofile << "\t";
	}
	ofile << "\n";
      }
      ofile.close();
#ifndef DA_OFF
      Char_t id[20];
      sprintf(id,"SPD_minth_%d",eqId);
      Int_t status = daqDA_FES_storeFile(ofileName,id);
      if (status) {
	printf("Failed to export file %s , status %d\n",ofileName,status);
      }
#endif
    }
    else if (type==DELAY) {
      Char_t ofileName[100];
      sprintf(ofileName,"%s/delay_eq_%d.txt",saveDirParameters,eqId);
      ofstream ofile;
      ofile.open (ofileName);
      for (UInt_t hs=0; hs<6; hs++) {
	for (UInt_t chipNr=0; chipNr<10; chipNr++) {
	  UInt_t clockCycle = analyzer->GetDelay(hs,chipNr);
	  UInt_t delayCtrl = clockCycle/2;
	  UInt_t miscCtrl = 192;
	  if (clockCycle%2==1) miscCtrl = 128;
	  ofile << delayCtrl << "/" << miscCtrl;
	  ofile << "\t";
	}
	ofile << "\n";
      }
      ofile.close();
#ifndef DA_OFF
      Char_t id[20];
      sprintf(id,"SPD_delay_%d",eqId);
      Int_t status = daqDA_FES_storeFile(ofileName,id);
      if (status) {
	printf("Failed to export file %s , status %d\n",ofileName,status);
      }
#endif
    }


    delete analyzer;

#ifndef DA_OFF
    daqDA_progressReport((unsigned int)(50+(eqId+1)*2.5));
#else
    printf("progress: %d\n",(unsigned int)(50+(eqId+1)*2.5));
#endif

  }
  // *** *** *** end loop over equipments (eq_id)


#ifndef DA_OFF
  // send a tared file of all new noisy maps
  sprintf(command,"cd %s; tar -cf noisy.tar *",saveDirNoisyToFXS);
  printf("\n\n%s\n\n",command);
  system(command);
  Char_t fileName[200];
  sprintf(fileName,"%s/noisy.tar",saveDirNoisyToFXS);
  Char_t id[20];
  sprintf(id,"SPD_noisy");
  Int_t status = daqDA_FES_storeFile(fileName,id);
  if (status) {
    printf("Failed to export file %s , status %d\n",fileName,status);
  }
#endif


  return 0;
}
Commit	Line	Data
3ec5024c	1	//////////////////////////////////////////////////////////////////////////////
	2	// This program can be run in two modes. //
	3	// //
	4	// 1. With the DAQ DA framework on. In Makefile: -DDA_OFF flag outcommented.//
	5	// Call this program with the name of the executable followed by the //
	6	// data files to process. //
	7	// //
	8	// 2. Without the DAQ DA framework on. In Makefile: with -DDA_OFF flag. //
	9	// Call this program with the name of the executable followed by the //
	10	// runNr and the data files to process. //
	11	// //
	12	//////////////////////////////////////////////////////////////////////////////
	13
	14	extern "C" {
	15	#include "daqDA.h"
	16	}
	17	#include "event.h"
	18	#include "monitor.h"
	19	#include "AliRawReaderDate.h"
	20	#include "AliITSRawStreamSPD.h"
	21	#include "AliITSOnlineSPDscan.h"
	22	#include "AliITSOnlineSPDscanSingle.h"
	23	#include "AliITSOnlineSPDscanMultiple.h"
	24	#include "AliITSOnlineSPDscanMeanTh.h"
	25	#include "AliITSOnlineSPDscanAnalyzer.h"
	26	#include "AliLog.h"
	27	#include <iostream>
	28	#include <fstream>
	29	#include <TROOT.h>
	30	#include <TPluginManager.h>
	31
	32
	33	int main(int argc, char **argv) {
	34	if (argc<2) {
	35	printf("Wrong number of arguments\n");
	36	return -1;
	37	}
	38
	39	char *saveDirNoisy = "./calibResults/Noisy"; // hard wired for now!!!
	40	#ifndef DA_OFF
	41	char *saveDirNoisyToFXS = "./calibResults/NoisyToFXS"; // hard wired for now!!!
	42	#endif
	43	char *saveDirParameters = "./calibResults/Parameters"; // hard wired for now!!!
	44	char *saveDirRef = "./calibResults/Reference"; // hard wired for now!!!
	45
	46	// This line is needed in case of a stand-alone application w/o
	47	// $ROOTSYS/etc/system.rootrc file
	48	gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
	49	"*",
	50	"TStreamerInfo",
	51	"RIO",
	52	"TStreamerInfo()");
	53
	54	// turn off annoying warning messages
	55	new AliLog;
	56	AliLog::Instance()->SetModuleDebugLevel("ROOT", -2);
	57
	58	// calib scan types
	59	enum calib_types{MINTH,MEANTH,DAC,UNIMA,NOISE,DELAY};
	60
	61
	62	// ******* STEP 1: Produce scan container files. *********************************
	63	int startSeg = 1;
	64
65	#ifndef DA_OFF
66	int runNr = atoi(getenv("DATE_RUN_NUMBER"));
67	#else
68	int runNr = atoi(argv[1]);
69	startSeg = 2;
70	#endif
71
72	// container objects
73	AliITSOnlineSPDscan *scanObj[20];
74	Bool_t bScanInit[20];
75	for (UInt_t eqId=0; eqId<20; eqId++) {
76	scanObj[eqId]=NULL;
77	bScanInit[eqId]=kFALSE;
78	}
79	// header data variables
80	UInt_t routerNr[20];
81	Bool_t halfStaveScanned[20][6];
82	UInt_t type[20];
83	Bool_t dataFormat[20];
84	UInt_t triggers[20];
85	Bool_t chipPresent[20][6][10];
86	UInt_t dacStart[20];
87	UInt_t dacEnd[20];
88	UInt_t dacStep[20];
89	UInt_t dacId[20];
90	UInt_t rowStart[20];
91	UInt_t rowEnd[20];
92	UInt_t rowValue[20];
93	UInt_t dacValue[20];
94	UInt_t dacHigh[20][6];
95	UInt_t dacLow[20][6];
96	UInt_t TPAmp[20][6];
97	// current scan step flag
98	Int_t currentStep[20];
99	for (UInt_t eqId=0; eqId<20; eqId++) currentStep[eqId] = 9999;
100
101	// loop over run segments
102	for (int segNr=startSeg; segNr<argc; segNr++) {
103
104
105	int status;
106
107	/* define data source : this is argument 1 */
108	status=monitorSetDataSource( argv[segNr] );
109	if (status!=0) {
110	printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
111	return -1;
112	}
113	/* declare monitoring program */
114	status=monitorDeclareMp("ITS_SPD_CAL");
115	if (status!=0) {
116	printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
117	return -1;
118	}
119	/* define wait event timeout - 1s max */
120	monitorSetNowait();
121	monitorSetNoWaitNetworkTimeout(1000);
122
123
124	struct eventHeaderStruct *event;
125	eventTypeType eventT;
126	UInt_t eventNr=0;
127
128
129	/* main loop (infinite) */
130	for(;;) {
131
132	/* check shutdown condition */
133	if (daqDA_checkShutdown()) {break;}
134	/* get next event (blocking call until timeout) */
135	status=monitorGetEventDynamic((void **)&event);
136	if (status==MON_ERR_EOF) {
137	printf ("End of File detected\n");
138	break; /* end of monitoring file has been reached */
139	}
140	if (status!=0) {
141	printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
142	break;
143	}
144	/* retry if got no event */
145	if (event==NULL) {
146	printf("event==NULL\n");
147	continue;
148	}
149
150	eventT=event->eventType;
151	if (event->eventType == PHYSICS_EVENT){
152
153
154	eventNr++;
155	// printf("eventNr %d\n",eventNr);
156
157	AliRawReader reader = new AliRawReaderDate((void)event);
158	AliITSRawStreamSPD *str = new AliITSRawStreamSPD(reader);
159
160
161	for (UInt_t eqId=0; eqId<20; eqId++) {
162
163	reader->Reset();
164	reader->Select("ITSSPD",eqId,eqId);
165
166	// Hit Event flags, specific for one event
167	Bool_t hitEventHSIncremented[6];
168	Bool_t hitEventChipIncremented[6][10];
169	for (UInt_t hs=0; hs<6; hs++) {
170	hitEventHSIncremented[hs] = kFALSE;
171	for (UInt_t chip=0; chip<10; chip++) {
172	hitEventChipIncremented[hs][chip] = kFALSE;
173	}
174	}
175
176	if (str->ReadCalibHeader()) {
177	// first check the type:
178	if (bScanInit[eqId] && type[eqId]!=str->GetHtype()) {
179	printf("Calib header problem. Type changed (%d -> %d)!\n",type[eqId],str->GetHtype());
180	}
181
182	// read calib values
183	routerNr[eqId] = str->GetHrouterNr();
184	type[eqId] = str->GetHtype();
185	dataFormat[eqId] = str->GetHdataFormat();
186	triggers[eqId] = str->GetHtriggers();
187	dacStart[eqId] = str->GetHdacStart();
188	dacEnd[eqId] = str->GetHdacEnd();
189	dacStep[eqId] = str->GetHdacStep();
190	dacId[eqId] = str->GetHdacId();
191	rowStart[eqId] = str->GetHrowStart();
192	rowEnd[eqId] = str->GetHrowEnd();
193	rowValue[eqId] = str->GetHrowValue();
194	dacValue[eqId] = str->GetHdacValue();
195	for (UInt_t hs=0; hs<6; hs++) {
196	halfStaveScanned[eqId][hs]=str->GetHhalfStaveScanned(hs);
197	dacHigh[eqId][hs] = str->GetHdacHigh(hs);
198	dacLow[eqId][hs] = str->GetHdacLow(hs);
199	TPAmp[eqId][hs] = str->GetHTPAmp(hs);
200	for (UInt_t chip=0; chip<10; chip++) {
201	chipPresent[eqId][hs][chip] = str->GetHchipPresent(hs,chip);
202	}
203	}
204
205	currentStep[eqId] = (dacValue[eqId]-dacStart[eqId])/dacStep[eqId];
206	if (type[eqId]==DELAY) {
207	currentStep[eqId]=currentStep[eqId]*2;
208	dacValue[eqId]=dacValue[eqId]*2;
209	if (dacHigh[eqId][0]==128) { // misc_ctrl value
210	currentStep[eqId]=currentStep[eqId]+1;
211	dacValue[eqId]=dacValue[eqId]+1;
212	}
213	}
214
215	// router nr check:
216	if (routerNr[eqId]!=eqId) {
217	printf("Router nr problem? Router nr %d != EqID %d\n",routerNr[eqId],eqId);
218	}
219
220	if (!bScanInit[eqId]) {
221	// initialize container object
222	Char_t fileName[200];
223	sprintf(fileName,"%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
224	switch (type[eqId]) {
225	case NOISE:
226	case UNIMA:
227	scanObj[eqId] = new AliITSOnlineSPDscanSingle(fileName);
228	((AliITSOnlineSPDscanSingle*)scanObj[eqId])->ClearThis();
229	bScanInit[eqId]=kTRUE;
230	break;
231	case MINTH:
232	case DAC:
233	case DELAY:
234	scanObj[eqId] = new AliITSOnlineSPDscanMultiple(fileName);
235	scanObj[eqId]->ClearThis();
236	bScanInit[eqId]=kTRUE;
237	break;
238	case MEANTH:
239	scanObj[eqId] = new AliITSOnlineSPDscanMeanTh(fileName);
240	scanObj[eqId]->ClearThis();
241	bScanInit[eqId]=kTRUE;
242	break;
243	default:
244	printf("Unknown scan type: %d.\n",type[eqId]);
245	}
246	// some multiple scan data
247	if (type[eqId]==MINTH \|\| type[eqId]==MEANTH \|\| type[eqId]==DAC \|\| type[eqId]==DELAY) {
248	((AliITSOnlineSPDscanMultiple*)scanObj[eqId])->SetDacId(dacId[eqId]);
249	}
250	// some common data
251	scanObj[eqId]->SetRunNr((UInt_t)runNr);
252	scanObj[eqId]->SetRouterNr(routerNr[eqId]);
253	for (UInt_t hs=0; hs<6; hs++) {
254	scanObj[eqId]->SetHalfStaveScanned(hs,halfStaveScanned[eqId][hs]);
255	}
256	scanObj[eqId]->SetType(type[eqId]);
257	scanObj[eqId]->SetDataFormat(dataFormat[eqId]);
258	for (Int_t hs=0; hs<6; hs++) {
259
260	// remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!
261	Bool_t halfStavePresent = str->GetHalfStavePresent(hs);
262	// remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!
263
264	for (UInt_t chip=0; chip<10; chip++) {
265	scanObj[eqId]->SetChipPresent(hs,chip,chipPresent[eqId][hs][chip]);
266
267	// remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!
268	if (halfStavePresent) scanObj[eqId]->SetChipPresent(hs,chip,kTRUE);
269	// remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!
270
271	}
272	}
273	scanObj[eqId]->SetRowStart(rowStart[eqId]);
274	scanObj[eqId]->SetRowEnd(rowEnd[eqId]);
275	scanObj[eqId]->SetDacStart(dacStart[eqId]);
276	scanObj[eqId]->SetDacEnd(dacEnd[eqId]);
277	scanObj[eqId]->SetDacStep(dacStep[eqId]);
278	}
279
280	if (type[eqId]==MINTH) {
281	scanObj[eqId]->SetTriggers(currentStep[eqId],triggers[eqId]);
282	}
283	if (type[eqId]==UNIMA \|\| type[eqId]==NOISE) {
284	if (currentStep[eqId]==9999) printf("SPDcalibratorStep1 (eq %d): single step\n",eqId);
285	currentStep[eqId]=0;
286	}
287	if (type[eqId]==MINTH \|\| type[eqId]==MEANTH \|\| type[eqId]==DAC \|\| type[eqId]==DELAY) {
288	((AliITSOnlineSPDscanMultiple*)scanObj[eqId])->SetDacValue(currentStep[eqId],dacValue[eqId]);
289	if (type[eqId]==DELAY) {
290	printf("SPDcalibratorStep1 (eq %d): DAC %d/%d , step %d\n",eqId,dacValue[eqId]/2,dacHigh[eqId][0],currentStep[eqId]);
291	}
292	else {
293	printf("SPDcalibratorStep1 (eq %d): DAC %d , step %d\n",eqId,dacValue[eqId],currentStep[eqId]);
294	}
295	}
296	if (type[eqId]==MEANTH) {
297	for (Int_t hs=0; hs<6; hs++) {
298	((AliITSOnlineSPDscanMeanTh*)scanObj[eqId])->SetDacLow(currentStep[eqId],hs,dacLow[eqId][hs]);
299	((AliITSOnlineSPDscanMeanTh*)scanObj[eqId])->SetDacHigh(currentStep[eqId],hs,dacHigh[eqId][hs]);
300	((AliITSOnlineSPDscanMeanTh*)scanObj[eqId])->SetTPAmp(currentStep[eqId],hs,TPAmp[eqId][hs]);
301	}
302	}
303
304
305	}
306
307	if (bScanInit[eqId]) {
308	while (str->Next()) {
309	UInt_t hs = str->GetHalfStaveNr();
310	UInt_t chip = str->GetChipAddr();
311
312	if (type[eqId]!=MINTH \|\| dacHigh[eqId][0]==chip) { // dachigh[0] holds chip scanned for minth
313
314	scanObj[eqId]->IncrementHits(currentStep[eqId],hs,chip,str->GetChipCol(),str->GetChipRow());
315
316	if (!hitEventHSIncremented[hs]) {
317	scanObj[eqId]->IncrementHitEventsTot(currentStep[eqId],hs);
318	hitEventHSIncremented[hs]=kTRUE;
319	}
320
321	if (!hitEventChipIncremented[hs][chip]) {
322	scanObj[eqId]->IncrementHitEvents(currentStep[eqId],hs,chip);
323	hitEventChipIncremented[hs][chip]=kTRUE;
324	}
325	}
326
327	}
328
329	if (type[eqId]!=MINTH) { // for minth, triggers are set from header info
330	scanObj[eqId]->IncrementTriggers(currentStep[eqId]);
331	}
332
333	}
334
335	}
336
337	delete str;
338	delete reader;
339
340	}
341
342	/* free resources */
343	free(event);
344
345	}
346
347	status = monitorLogout();
348	if (status != 0) {
349	printf("monitorLogout() failed : %s\n",monitorDecodeError(status));
350	return -1;
351	}
352
353	#ifndef DA_OFF
354	daqDA_progressReport((unsigned int)( ((Float_t)(segNr-startSeg+1))/(argc-startSeg)*50 ));
355	#else
356	printf("progress: %d\n",(unsigned int)( ((Float_t)(segNr-startSeg+1))/(argc-startSeg)*50 ));
357	#endif
358
359	}
360
361	// clean up scan objects
362	for (UInt_t eqId=0; eqId<20; eqId++) {
363	if (scanObj[eqId]!=NULL) delete scanObj[eqId];
364	}
365
366
367
368
369
370	// ******* STEP 2: Analyze scan container files. *********************************
371	#ifndef DA_OFF
372	// clear noisyToFXS dir:
373	Char_t command[200];
374	sprintf(command,"cd %s; rm -f *",saveDirNoisyToFXS);
375	system(command);
376	#endif
377
378	AliITSOnlineSPDscanAnalyzer *analyzer;
379
380	// * * *** start loop over equipments (eq_id)
381	for (int eqId=0; eqId<20; eqId++) {
382
383	Char_t fileName[200];
384	sprintf(fileName,"%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
385	analyzer = new AliITSOnlineSPDscanAnalyzer(fileName);
386
387	Int_t type = analyzer->GetType();
388	Int_t dacId = analyzer->GetDacId();
389	if (type!=99) {
390	if (type==DAC) {
391	printf("SPD calibrator Step2: eqId %d, type %d, dacId %d\n",eqId,type,dacId);
392	}
393	else printf("SPD calibrator Step2: eqId %d type %d\n",eqId,type);
394	}
395
396
397
398
399	if (type==UNIMA) {
400	}
401	else if (type==NOISE) {
402	if (analyzer->ProcessNoisyPixels(saveDirNoisy)) {
403	for (UInt_t module=0; module<240; module++) {
404	if (analyzer->SaveDeadNoisyPixels(module,saveDirNoisy)) {
405	#ifndef DA_OFF
406	Char_t command[100];
407	sprintf(command,"cp %s/SPD_DeadNoisy_%d.root %s/.",saveDirNoisy,module,saveDirNoisyToFXS);
408	system(command);
409	#endif
410	}
411	}
412	}
413	}
414	// else if (type==DAC && dacId==42) {
415	// Char_t ofileName[100];
416	// sprintf(ofileName,"%s/delay_eq_%d.txt",saveDirParameters,eqId);
417	// ofstream ofile;
418	// ofile.open (ofileName);
419	// for (UInt_t hs=0; hs<6; hs++) {
420	// for (UInt_t chipNr=0; chipNr<10; chipNr++) {
421	// ofile << analyzer->GetDelay(hs,chipNr);
422	// ofile << "\t";
423	// }
424	// ofile << "\n";
425	// }
426	// ofile.close();
427	//#ifndef DA_OFF
428	// Char_t id[20];
429	// sprintf(id,"SPD_delay_%d",eqId);
430	// Int_t status = daqDA_FES_storeFile(ofileName,id);
431	// if (status) {
432	// printf("Failed to export file %s , status %d\n",ofileName,status);
433	// }
434	//#endif
435	// }
436	else if (type==MINTH \|\| (type==DAC && dacId==39)) {
437	Char_t ofileName[100];
438	sprintf(ofileName,"%s/minth_eq_%d.txt",saveDirParameters,eqId);
439	ofstream ofile;
440	ofile.open (ofileName);
441	for (UInt_t hs=0; hs<6; hs++) {
442	for (UInt_t chipNr=0; chipNr<10; chipNr++) {
443	ofile << analyzer->GetMinTh(hs,chipNr);
444	ofile << "\t";
445	}
446	ofile << "\n";
447	}
448	ofile.close();
449	#ifndef DA_OFF
450	Char_t id[20];
451	sprintf(id,"SPD_minth_%d",eqId);
452	Int_t status = daqDA_FES_storeFile(ofileName,id);
453	if (status) {
454	printf("Failed to export file %s , status %d\n",ofileName,status);
455	}
456	#endif
457	}
458	else if (type==DELAY) {
459	Char_t ofileName[100];
460	sprintf(ofileName,"%s/delay_eq_%d.txt",saveDirParameters,eqId);
461	ofstream ofile;
462	ofile.open (ofileName);
463	for (UInt_t hs=0; hs<6; hs++) {
464	for (UInt_t chipNr=0; chipNr<10; chipNr++) {
465	UInt_t clockCycle = analyzer->GetDelay(hs,chipNr);
466	UInt_t delayCtrl = clockCycle/2;
467	UInt_t miscCtrl = 192;
468	if (clockCycle%2==1) miscCtrl = 128;
469	ofile << delayCtrl << "/" << miscCtrl;
470	ofile << "\t";
471	}
472	ofile << "\n";
473	}
474	ofile.close();
475	#ifndef DA_OFF
476	Char_t id[20];
477	sprintf(id,"SPD_delay_%d",eqId);
478	Int_t status = daqDA_FES_storeFile(ofileName,id);
479	if (status) {
480	printf("Failed to export file %s , status %d\n",ofileName,status);
481	}
482	#endif
483	}
484
485
486	delete analyzer;
487
488	#ifndef DA_OFF
489	daqDA_progressReport((unsigned int)(50+(eqId+1)*2.5));
490	#else
491	printf("progress: %d\n",(unsigned int)(50+(eqId+1)*2.5));
492	#endif
493
494	}
495	// * * *** end loop over equipments (eq_id)
496
497
498	#ifndef DA_OFF
499	// send a tared file of all new noisy maps
500	sprintf(command,"cd %s; tar -cf noisy.tar *",saveDirNoisyToFXS);
501	printf("\n\n%s\n\n",command);
502	system(command);
503	Char_t fileName[200];
504	sprintf(fileName,"%s/noisy.tar",saveDirNoisyToFXS);
505	Char_t id[20];
506	sprintf(id,"SPD_noisy");
507	Int_t status = daqDA_FES_storeFile(fileName,id);
508	if (status) {
509	printf("Failed to export file %s , status %d\n",fileName,status);
510	}
511	#endif
512
513
514	return 0;
515	}