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