[u/mrichter/AliRoot.git] / VZERO / AliVZEROPreprocessor.cxx

#include "AliVZEROPreprocessor.h"
#include "AliVZEROCalibData.h"
#include "AliVZEROTriggerData.h"
#include "AliCDBMetaData.h"
#include "AliCDBEntry.h"
#include "AliDCSValue.h"
#include "AliLog.h"
#include "AliShuttleInterface.h"
#include "AliVZERODataFEE.h"
#include "AliVZERODataDCS.h"

#include <TFile.h>
#include <TTimeStamp.h>
#include <TObjString.h>
#include <TSystem.h>
#include <TH1F.h>


class Tlist;

//
//  This class is  a simple preprocessor for VZERO detector.
//
//  It gets High Voltage values for a given run from DCS and Pedestal values from DAQ 
//  and writes them as Calibration MetaData into OCDB/VZERO/Calib/Data
//  It also retrieves FEE parameters from DCS archive   
//  and writes them as Trigger MetaData into OCDB/VZERO/Trigger/Data 
//  (to be used for trigger simulation)
//

ClassImp(AliVZEROPreprocessor)

//______________________________________________________________________________________________
AliVZEROPreprocessor::AliVZEROPreprocessor(AliShuttleInterface* shuttle) :
	AliPreprocessor("V00", shuttle),
	fData(0),
	fFEEData(0)
 
{
  // constructor  
  
  AddRunType("STANDALONE_PULSER");
  AddRunType("STANDALONE_BC");
  AddRunType("PHYSICS");
    
}

//______________________________________________________________________________________________
AliVZEROPreprocessor::~AliVZEROPreprocessor()
{
  // destructor
	delete fFEEData;
	delete fData;
	
}

//______________________________________________________________________________________________
void AliVZEROPreprocessor::Initialize(Int_t run, UInt_t startTime,
	UInt_t endTime)
{
  // Creates AliVZERODataDCS object

   AliPreprocessor::Initialize(run, startTime, endTime);
  
   Log(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run,
		TTimeStamp(startTime).AsString(),
		TTimeStamp(endTime).AsString()));

   fRun       = run;
   // fStartTime = startTime;
   // fEndTime   = endTime;
   fStartTime = GetStartTimeDCSQuery ();
   fEndTime   = GetEndTimeDCSQuery ();
   time_t daqStart = (time_t) (((TString)GetRunParameter("DAQ_time_start")).Atoi());
   time_t daqEnd   = (time_t) (((TString)GetRunParameter("DAQ_time_end")).Atoi());
   time_t ctpStart = (time_t) (((TString)GetRunParameter("TRGTimeStart")).Atoi());
   time_t ctpEnd   = (time_t) (((TString)GetRunParameter("TRGTimeEnd")).Atoi());
   
	fData      = new AliVZERODataDCS(fRun, fStartTime, fEndTime,(UInt_t)daqStart, (UInt_t)daqEnd,(UInt_t)ctpStart, (UInt_t)ctpEnd);
	fFEEData   = new AliVZERODataFEE(fRun, fStartTime, fEndTime);		
   
}

//______________________________________________________________________________________________
UInt_t AliVZEROPreprocessor::Process(TMap* dcsAliasMap)
{
  // Fills data retrieved from DCS and DAQ into a AliVZEROCalibData object and 
  // stores it into CalibrationDB


  // *** GET RUN TYPE ***
  TString runType = GetRunType();


  // *** REFERENCE DATA *** 
  
  TString fileName; 
  AliVZEROCalibData *calibData = new AliVZEROCalibData();
  
  // *************** HV From DCS ******************
  // Fills data into a AliVZERODataDCS object
  if(!dcsAliasMap) return 1;

 	// The Processing of the DCS input data is forwarded to AliVZERODataDCS
  if (!fData->ProcessData(*dcsAliasMap)) return 1;

	// Writes VZERO PMs HV values into VZERO calibration object and Timing resolution parameters
  	calibData->FillDCSData(fData);
	   
   // *************** From DAQ ******************
   
	TString sourcesId = "V00da_results";

	TList* sourceList = GetFileSources(kDAQ, sourcesId.Data());
  	if (!sourceList)  {
		Log(Form("No sources found for id %s", sourcesId.Data()));      		
      		return 1; }
	Log(Form("The following sources produced files with the id %s",sourcesId.Data()));
	sourceList->Print();    

  	TIter iter(sourceList);
  	TObjString *source;
		
	while((source=dynamic_cast<TObjString*> (iter.Next()))){
  		fileName = GetFile(kDAQ, sourcesId.Data(), source->GetName());
  		if (fileName.Length() > 0)
    		Log(Form("Got the file %s, now we can extract some values.", fileName.Data()));
		FILE *file;
		if((file = fopen(fileName.Data(),"r")) == NULL){
            	                   Log(Form("Cannot open file %s",fileName.Data()));
	    	  	           return 1;}
		Float_t pedMean[128], pedSigma[128], adcMean[128], adcSigma[128] ;
		for(Int_t j=0; j<128; j++) {
		  Int_t resScan = fscanf(file,"%f %f %f %f",
					 &pedMean[j], &pedSigma[j], &adcMean[j], &adcSigma[j]);
		  if (resScan != 4) Log(Form("Bad data in file %s !",fileName.Data()));
		}
		fclose(file);
	    	
		calibData->SetPedestal(pedMean);
		calibData->SetSigma(pedSigma);			
		calibData->SetADCsigma(adcSigma);
		}				

	delete source;      
  
  // Check that everything was properly transmitted

//   for(Int_t j=0; j<128; j++){printf("Pedestal[%d] -> %f \n",j,calibData->GetPedestal(j));}
//   for(Int_t j=0; j<128; j++){printf("pedSigma[%d] -> %f \n",j,calibData->GetSigma(j));}
//   for(Int_t j=0; j<128; j++){printf("Gain[%d] -> %f \n",j,calibData->GetGain(j));}
//   for(Int_t j=0; j<128; j++){printf("adcSigma[%d] -> %f \n",j,calibData->GetADCsigma(j));}
//   for(Int_t j=0; j<64; j++){printf("MeanHV[%d] -> %f \n",j,calibData->GetMeanHV(j));}
//   for(Int_t j=0; j<64; j++){printf("WidthHV[%d] -> %f \n",j,calibData->GetWidthHV(j));}
  
  // Now we store the VZERO Calibration Object into CalibrationDB

  Bool_t resECal=kTRUE;
  
  Bool_t result = 0;
//  if(sourceList && sourceList->GetEntries()>0)
//  {
  AliCDBMetaData metaData;
  metaData.SetBeamPeriod(0);
  metaData.SetResponsible("Brigitte Cheynis");
  metaData.SetComment("This preprocessor fills an AliVZEROCalibData object");

  resECal = Store("Calib", "Data", calibData, &metaData, 0, kTRUE);
//  }
  if(resECal==kFALSE ) result = 1;
  

  delete calibData;
  delete sourceList; 

 // -----------------------------------------------------------------------
 // Retrieves Front End Electronics Parameters from  DCS archive
 // -----------------------------------------------------------------------
	AliVZEROTriggerData *triggerData = new AliVZEROTriggerData();

 	// The processing of the DCS input data is forwarded to AliVZERODataFEE
	fFEEData->ProcessData(*dcsAliasMap);

	// Writes VZERO FEE parameters values into VZERO  Trigger parametrization object
	triggerData->FillData(fFEEData);

	// Stores the VZERO Trigger Object into TriggerDB
	
	resECal=kTRUE;
	
	metaData.SetBeamPeriod(0);
	metaData.SetResponsible("Brigitte Cheynis");
	metaData.SetComment("This preprocessor fills an AliVZEROTriggerData object");
	
	resECal = Store("Trigger", "Data", triggerData, &metaData, 0, kTRUE);
	if(resECal==kFALSE ) result = 1;
	

   // *************** From DAQ DA - Equalization factors ******************
  
  TH1F *eqFactors = new TH1F("VZEROEqualizationFactors","VZERO Equalization Factors for Pb-Pb",64,-0.5,63.5);
  sourcesId = "V00DAEqualFactors";

  TList* sourceList2 = GetFileSources(kDAQ, sourcesId.Data());
  if (!sourceList2)  {
    Log(Form("No sources found for id %s", sourcesId.Data()));      		
    return 1; }
  Log(Form("The following sources produced files with the id %s",sourcesId.Data()));
  sourceList2->Print();

  TIter iter2(sourceList2);
  TObjString *source2;
		
  while((source2=dynamic_cast<TObjString*> (iter2.Next()))){
    fileName = GetFile(kDAQ, sourcesId.Data(), source2->GetName());
    if (fileName.Length() > 0)
      Log(Form("Got the file %s, now we can extract some values.", fileName.Data()));
    FILE *file2;
    if((file2 = fopen(fileName.Data(),"r")) == NULL){
      Log(Form("Cannot open file %s",fileName.Data()));
      return 1;}

    Double_t alpha[66];
    alpha[0] = alpha[65] = 0;
    Int_t tempCh;
    Float_t tempAlpha;
    for(Int_t j=0; j<64; ++j) {
      Int_t resScan = fscanf(file2,"%d %f", &tempCh, &tempAlpha);
      if (resScan != 2) Log(Form("Bad data in file %s !",fileName.Data()));
      alpha[tempCh+1] = tempAlpha;
    }
    fclose(file2);

    // Check that everything was properly transmitted
    printf("Equalization factors (0->64): ");
    for(Int_t j=0; j<64; ++j) printf("%.5f ",alpha[j+1]);
    printf("\n");

    eqFactors->SetContent(alpha);
  }

  delete source2;      
  
  // Now we store the VZERO Equalization Factors Object into OCDB

  resECal=kTRUE;
  
  AliCDBMetaData metaData2;
  metaData2.SetBeamPeriod(0);
  metaData2.SetResponsible("Brigitte Cheynis");
  metaData2.SetComment("VZERO Equalization Factors object filled by VZERO preprocessor");

  resECal = Store("Calib", "EqualizationFactors", eqFactors, &metaData2, 0, kTRUE);

  if(resECal==kFALSE ) result = 1;

  delete eqFactors;
  delete sourceList2; 

	
  return result;
}
Commit	Line	Data
	1	#include "AliVZEROPreprocessor.h"
	2	#include "AliVZEROCalibData.h"
	3	#include "AliVZEROTriggerData.h"
	4	#include "AliCDBMetaData.h"
	5	#include "AliCDBEntry.h"
	6	#include "AliDCSValue.h"
	7	#include "AliLog.h"
	8	#include "AliShuttleInterface.h"
	9	#include "AliVZERODataFEE.h"
	10	#include "AliVZERODataDCS.h"
	11
	12	#include <TFile.h>
	13	#include <TTimeStamp.h>
	14	#include <TObjString.h>
	15	#include <TSystem.h>
	16	#include <TH1F.h>
	17
	18
	19	class Tlist;
	20
	21	//
	22	// This class is a simple preprocessor for VZERO detector.
	23	//
	24	// It gets High Voltage values for a given run from DCS and Pedestal values from DAQ
	25	// and writes them as Calibration MetaData into OCDB/VZERO/Calib/Data
	26	// It also retrieves FEE parameters from DCS archive
	27	// and writes them as Trigger MetaData into OCDB/VZERO/Trigger/Data
	28	// (to be used for trigger simulation)
	29	//
	30
	31	ClassImp(AliVZEROPreprocessor)
	32
	33	//______________________________________________________________________________________________
	34	AliVZEROPreprocessor::AliVZEROPreprocessor(AliShuttleInterface* shuttle) :
	35	AliPreprocessor("V00", shuttle),
	36	fData(0),
	37	fFEEData(0)
	38
	39	{
	40	// constructor
	41
	42	AddRunType("STANDALONE_PULSER");
	43	AddRunType("STANDALONE_BC");
	44	AddRunType("PHYSICS");
	45
	46	}
	47
	48	//______________________________________________________________________________________________
	49	AliVZEROPreprocessor::~AliVZEROPreprocessor()
	50	{
	51	// destructor
	52	delete fFEEData;
	53	delete fData;
	54
	55	}
	56
	57	//______________________________________________________________________________________________
	58	void AliVZEROPreprocessor::Initialize(Int_t run, UInt_t startTime,
	59	UInt_t endTime)
	60	{
	61	// Creates AliVZERODataDCS object
	62
	63	AliPreprocessor::Initialize(run, startTime, endTime);
	64
	65	Log(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run,
	66	TTimeStamp(startTime).AsString(),
	67	TTimeStamp(endTime).AsString()));
	68
	69	fRun = run;
	70	// fStartTime = startTime;
	71	// fEndTime = endTime;
	72	fStartTime = GetStartTimeDCSQuery ();
	73	fEndTime = GetEndTimeDCSQuery ();
	74	time_t daqStart = (time_t) (((TString)GetRunParameter("DAQ_time_start")).Atoi());
	75	time_t daqEnd = (time_t) (((TString)GetRunParameter("DAQ_time_end")).Atoi());
	76	time_t ctpStart = (time_t) (((TString)GetRunParameter("TRGTimeStart")).Atoi());
	77	time_t ctpEnd = (time_t) (((TString)GetRunParameter("TRGTimeEnd")).Atoi());
	78
	79	fData = new AliVZERODataDCS(fRun, fStartTime, fEndTime,(UInt_t)daqStart, (UInt_t)daqEnd,(UInt_t)ctpStart, (UInt_t)ctpEnd);
	80	fFEEData = new AliVZERODataFEE(fRun, fStartTime, fEndTime);
	81
	82	}
	83
	84	//______________________________________________________________________________________________
	85	UInt_t AliVZEROPreprocessor::Process(TMap* dcsAliasMap)
	86	{
	87	// Fills data retrieved from DCS and DAQ into a AliVZEROCalibData object and
	88	// stores it into CalibrationDB
	89
	90
	91	// * GET RUN TYPE *
	92	TString runType = GetRunType();
	93
	94
	95	// * REFERENCE DATA *
	96
	97	TString fileName;
	98	AliVZEROCalibData *calibData = new AliVZEROCalibData();
	99
	100	// ************* HV From DCS ****************
	101	// Fills data into a AliVZERODataDCS object
	102	if(!dcsAliasMap) return 1;
	103
	104	// The Processing of the DCS input data is forwarded to AliVZERODataDCS
	105	if (!fData->ProcessData(*dcsAliasMap)) return 1;
	106
	107	// Writes VZERO PMs HV values into VZERO calibration object and Timing resolution parameters
	108	calibData->FillDCSData(fData);
	109
	110	// ************* From DAQ ****************
	111
	112	TString sourcesId = "V00da_results";
	113
	114	TList* sourceList = GetFileSources(kDAQ, sourcesId.Data());
	115	if (!sourceList) {
	116	Log(Form("No sources found for id %s", sourcesId.Data()));
	117	return 1; }
	118	Log(Form("The following sources produced files with the id %s",sourcesId.Data()));
	119	sourceList->Print();
	120
	121	TIter iter(sourceList);
	122	TObjString *source;
	123
	124	while((source=dynamic_cast<TObjString*> (iter.Next()))){
	125	fileName = GetFile(kDAQ, sourcesId.Data(), source->GetName());
	126	if (fileName.Length() > 0)
	127	Log(Form("Got the file %s, now we can extract some values.", fileName.Data()));
	128	FILE *file;
	129	if((file = fopen(fileName.Data(),"r")) == NULL){
	130	Log(Form("Cannot open file %s",fileName.Data()));
	131	return 1;}
	132	Float_t pedMean[128], pedSigma[128], adcMean[128], adcSigma[128] ;
	133	for(Int_t j=0; j<128; j++) {
	134	Int_t resScan = fscanf(file,"%f %f %f %f",
	135	&pedMean[j], &pedSigma[j], &adcMean[j], &adcSigma[j]);
	136	if (resScan != 4) Log(Form("Bad data in file %s !",fileName.Data()));
	137	}
	138	fclose(file);
	139
	140	calibData->SetPedestal(pedMean);
	141	calibData->SetSigma(pedSigma);
	142	calibData->SetADCsigma(adcSigma);
	143	}
	144
	145	delete source;
	146
	147	// Check that everything was properly transmitted
	148
	149	// for(Int_t j=0; j<128; j++){printf("Pedestal[%d] -> %f \n",j,calibData->GetPedestal(j));}
	150	// for(Int_t j=0; j<128; j++){printf("pedSigma[%d] -> %f \n",j,calibData->GetSigma(j));}
	151	// for(Int_t j=0; j<128; j++){printf("Gain[%d] -> %f \n",j,calibData->GetGain(j));}
	152	// for(Int_t j=0; j<128; j++){printf("adcSigma[%d] -> %f \n",j,calibData->GetADCsigma(j));}
	153	// for(Int_t j=0; j<64; j++){printf("MeanHV[%d] -> %f \n",j,calibData->GetMeanHV(j));}
	154	// for(Int_t j=0; j<64; j++){printf("WidthHV[%d] -> %f \n",j,calibData->GetWidthHV(j));}
	155
	156	// Now we store the VZERO Calibration Object into CalibrationDB
	157
	158	Bool_t resECal=kTRUE;
	159
	160	Bool_t result = 0;
	161	// if(sourceList && sourceList->GetEntries()>0)
	162	// {
	163	AliCDBMetaData metaData;
	164	metaData.SetBeamPeriod(0);
	165	metaData.SetResponsible("Brigitte Cheynis");
	166	metaData.SetComment("This preprocessor fills an AliVZEROCalibData object");
	167
	168	resECal = Store("Calib", "Data", calibData, &metaData, 0, kTRUE);
	169	// }
	170	if(resECal==kFALSE ) result = 1;
	171
	172
	173	delete calibData;
	174	delete sourceList;
	175
	176	// -----------------------------------------------------------------------
	177	// Retrieves Front End Electronics Parameters from DCS archive
	178	// -----------------------------------------------------------------------
	179	AliVZEROTriggerData *triggerData = new AliVZEROTriggerData();
	180
	181	// The processing of the DCS input data is forwarded to AliVZERODataFEE
	182	fFEEData->ProcessData(*dcsAliasMap);
	183
	184	// Writes VZERO FEE parameters values into VZERO Trigger parametrization object
	185	triggerData->FillData(fFEEData);
	186
	187	// Stores the VZERO Trigger Object into TriggerDB
	188
	189	resECal=kTRUE;
	190
	191	metaData.SetBeamPeriod(0);
	192	metaData.SetResponsible("Brigitte Cheynis");
	193	metaData.SetComment("This preprocessor fills an AliVZEROTriggerData object");
	194
	195	resECal = Store("Trigger", "Data", triggerData, &metaData, 0, kTRUE);
	196	if(resECal==kFALSE ) result = 1;
	197
	198
	199	// ************* From DAQ DA - Equalization factors ****************
	200
	201	TH1F *eqFactors = new TH1F("VZEROEqualizationFactors","VZERO Equalization Factors for Pb-Pb",64,-0.5,63.5);
	202	sourcesId = "V00DAEqualFactors";
	203
	204	TList* sourceList2 = GetFileSources(kDAQ, sourcesId.Data());
	205	if (!sourceList2) {
	206	Log(Form("No sources found for id %s", sourcesId.Data()));
	207	return 1; }
	208	Log(Form("The following sources produced files with the id %s",sourcesId.Data()));
	209	sourceList2->Print();
	210
	211	TIter iter2(sourceList2);
	212	TObjString *source2;
	213
	214	while((source2=dynamic_cast<TObjString*> (iter2.Next()))){
	215	fileName = GetFile(kDAQ, sourcesId.Data(), source2->GetName());
	216	if (fileName.Length() > 0)
	217	Log(Form("Got the file %s, now we can extract some values.", fileName.Data()));
	218	FILE *file2;
	219	if((file2 = fopen(fileName.Data(),"r")) == NULL){
	220	Log(Form("Cannot open file %s",fileName.Data()));
	221	return 1;}
	222
	223	Double_t alpha[66];
	224	alpha[0] = alpha[65] = 0;
	225	Int_t tempCh;
	226	Float_t tempAlpha;
	227	for(Int_t j=0; j<64; ++j) {
	228	Int_t resScan = fscanf(file2,"%d %f", &tempCh, &tempAlpha);
	229	if (resScan != 2) Log(Form("Bad data in file %s !",fileName.Data()));
	230	alpha[tempCh+1] = tempAlpha;
	231	}
	232	fclose(file2);
	233
	234	// Check that everything was properly transmitted
	235	printf("Equalization factors (0->64): ");
	236	for(Int_t j=0; j<64; ++j) printf("%.5f ",alpha[j+1]);
	237	printf("\n");
	238
	239	eqFactors->SetContent(alpha);
	240	}
	241
	242	delete source2;
	243
	244	// Now we store the VZERO Equalization Factors Object into OCDB
	245
	246	resECal=kTRUE;
	247
	248	AliCDBMetaData metaData2;
	249	metaData2.SetBeamPeriod(0);
	250	metaData2.SetResponsible("Brigitte Cheynis");
	251	metaData2.SetComment("VZERO Equalization Factors object filled by VZERO preprocessor");
	252
	253	resECal = Store("Calib", "EqualizationFactors", eqFactors, &metaData2, 0, kTRUE);
	254
	255	if(resECal==kFALSE ) result = 1;
	256
	257	delete eqFactors;
	258	delete sourceList2;
	259
	260
	261	return result;
	262	}
	263