[u/mrichter/AliRoot.git] / T0 / AliT0Preprocessor.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/*
$Log: AliT0Preprocessor.cxx,v $
Revision 1.8  2007/12/07 15:22:51  alla
bug fixed by Alberto
 
Revision 1.7  2007/12/06 16:35:24  alla
new bugs fixed by Tomek

Revision 1.5  2007/11/23 19:28:52  alla
bug fixed

Version 2.1  2007/11/21 
Preprocessor storing data to OCDB (T.Malkiewicz)

Version 1.1  2006/10   
Preliminary test version (T.Malkiewicz)
*/   
// T0 preprocessor:
// 1) takes data from DCS and passes it to the class AliTOFDataDCS 
// for processing and writes the result to the Reference DB.
// 2) takes data form DAQ (both from Laser Calibration and Physics runs), 
// processes it, and stores either to OCDB or to Reference DB.


#include "AliT0Preprocessor.h"
#include "AliT0DataDCS.h"
#include "AliT0CalibWalk.h"
#include "AliT0CalibTimeEq.h"

#include "AliCDBMetaData.h"
#include "AliDCSValue.h"
#include "AliLog.h"

#include <TTimeStamp.h>
#include <TFile.h>
#include <TObjString.h>
#include <TNamed.h>
#include "AliT0Dqclass.h"


ClassImp(AliT0Preprocessor)

//____________________________________________________
AliT0Preprocessor::AliT0Preprocessor(AliShuttleInterface* shuttle) : 
  AliPreprocessor("T00", shuttle), 
  fData(0)
{
  //constructor
  AddRunType("PHYSICS");
  AddRunType("STANDALONE");
  AddRunType("LASER");
}
//____________________________________________________

AliT0Preprocessor::~AliT0Preprocessor()
{
  //destructor
  delete fData;
  fData = 0;
}
//____________________________________________________

void AliT0Preprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
{
  // Creates AliT0DataDCS object
  AliPreprocessor::Initialize(run, startTime, endTime);
  AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run, TTimeStamp(startTime).AsString(), TTimeStamp(endTime).AsString()));
  fData = new AliT0DataDCS(fRun, fStartTime, fEndTime, GetStartTimeDCSQuery(), GetEndTimeDCSQuery());
}
//____________________________________________________

Bool_t AliT0Preprocessor::ProcessDCS(){
	// Check whether DCS should be processed or not...
	TString runType = GetRunType();
	Log(Form("ProcessDCS - RunType: %s",runType.Data()));

	if((runType == "STANDALONE")||
	   (runType == "PHYSICS")||
	   (runType == "LASER")){
	  //		return kFALSE;
		return kTRUE;
	}else{
	return kFALSE;
	}
}
//____________________________________________________

UInt_t AliT0Preprocessor::ProcessDCSDataPoints(TMap* dcsAliasMap){
	// Fills data into AliT0DataDCS object
	Log("Processing DCS DP");
	Bool_t resultDCSMap=kFALSE;
	Bool_t resultDCSStore=kFALSE;

        if(!dcsAliasMap)
        {
          Log("No DCS input data");
          return 1;
        }
        else
        {
          resultDCSMap=fData->ProcessData(*dcsAliasMap);
          if(!resultDCSMap)
          {
            Log("Error when processing DCS data");
            return 2;// return error Code for processed DCS data not stored
          }
          else
          {
            AliCDBMetaData metaDataDCS;
            metaDataDCS.SetBeamPeriod(0);
            metaDataDCS.SetResponsible("Tomasz Malkiewicz");
            metaDataDCS.SetComment("This preprocessor fills an AliTODataDCS object.");
            AliInfo("Storing DCS Data");
            resultDCSStore = StoreReferenceData("Calib","DCSData",fData, &metaDataDCS);
            if (!resultDCSStore)
            {
              Log("Some problems occurred while storing DCS data results in ReferenceDB");
              return 2;// return error Code for processed DCS data not stored
            }
          }
        }
	return 0;
}
//____________________________________________________

UInt_t AliT0Preprocessor::ProcessLaser(){
	// Processing data from DAQ Standalone run
	Log("Processing Laser calibration - Walk Correction");
	
	Bool_t resultLaser=kFALSE;
	//processing DAQ
        TList* list = GetFileSources(kDAQ, "LASER");
        if (list)
        {
            TIter iter(list);
            TObjString *source;
            while ((source = dynamic_cast<TObjString *> (iter.Next())))
            {
              const char *laserFile = GetFile(kDAQ, "LASER", source->GetName());
              if (laserFile)
              {
                Log(Form("File with Id LASER found in source %s!", source->GetName()));
                AliT0CalibWalk *laser = new AliT0CalibWalk();
                laser->MakeWalkCorrGraph(laserFile);
                AliCDBMetaData metaData;
                metaData.SetBeamPeriod(0);
                metaData.SetResponsible("Tomek&Michal");
                metaData.SetComment("Walk correction from laser runs.");
		resultLaser=Store("Calib","Slewing_Walk", laser, &metaData, 0, 1);
                delete laser;
		Log(Form("resultLaser = %d",resultLaser));
              }
              else
              {
                Log(Form("Could not find file with Id LASER in source %s!", source->GetName()));
                return 1;
              }
            }
            if (!resultLaser)
            {
              Log("No Laser Data stored");
              return 3;//return error code for failure in storing Laser Data
            }
          } else {
	  	Log("No sources found for id LASER!");
		return 1;
	  }
	return 0;
}
//____________________________________________________

UInt_t AliT0Preprocessor::ProcessPhysics(){
	//Processing data from DAQ Physics run
	Log("Processing Physics");

	Bool_t resultOnline=kFALSE; 
	//processing DAQ
	TList* listPhys = GetFileSources(kDAQ, "PHYSICS");
        if (listPhys)
          {
            TIter iter(listPhys);
            TObjString *sourcePhys;
            while ((sourcePhys = dynamic_cast<TObjString *> (iter.Next())))
            {
              const char *filePhys = GetFile(kDAQ, "PHYSICS", sourcePhys->GetName());
              if (filePhys)
              {
                AliT0CalibTimeEq *online = new AliT0CalibTimeEq();
                online->Reset();
                online->ComputeOnlineParams(filePhys);
                AliCDBMetaData metaData;
                metaData.SetBeamPeriod(0);
                metaData.SetResponsible("Tomek&Michal");
                metaData.SetComment("Time equalizing result.");
                resultOnline = Store("Calib","TimeDelay", online, &metaData, 0, 1);
		Log(Form("resultOnline = %d",resultOnline));
                delete online;
              }
		else
              {
                Log(Form("Could not find file with Id PHYSICS in source %s!", sourcePhys->GetName()));
                return 1;
              }
              
            }
            if (!resultOnline)
            {
              Log("No Data stored");
              return 4;//return error code for failure in storing OCDB Data
            }
          } else {
	  	Log("No sources found for id PHYSICS!");
		return 1;
	  }
	return 0;
}
//____________________________________________________

UInt_t AliT0Preprocessor::ProcessCosmic(){
	//Processing data from DAQ Physics run
	Log("Processing Laser Physics");

	Bool_t resultLaserOnline=kFALSE; 
	//processing DAQ
	TList* listLaser = GetFileSources(kDAQ, "COSMIC");
        if (listLaser)
          {
            TIter iter(listLaser);
            TObjString *sourceLaser;
            while ((sourceLaser = dynamic_cast<TObjString *> (iter.Next())))
            {
              const char *fileLaser = GetFile(kDAQ, "COSMIC", sourceLaser->GetName());
              if (fileLaser)
              {
                AliT0CalibTimeEq *onlineLaser = new AliT0CalibTimeEq();
                onlineLaser->Reset();
                onlineLaser->ComputeOnlineParams(fileLaser);
                AliCDBMetaData metaData;
                metaData.SetBeamPeriod(0);
                metaData.SetResponsible("Tomek&Michal");
                metaData.SetComment("Time equalizing result.");
                resultLaserOnline = Store("Calib","LaserTimeDelay", onlineLaser, &metaData, 0, 1);
		Log(Form("resultLaserOnline = %d",resultLaserOnline));
                delete onlineLaser;
              }
		else
              {
                Log(Form("Could not find file with Id COSMIC in source %s!", sourceLaser->GetName()));
                return 0;
              }
              
            }
            if (!resultLaserOnline)
            {
              Log("No Laser Data stored");
              return 0;//return error code for failure in storing OCDB Data
            }
          } else {
	  	Log("No sources found for id COSMIC!");
		return 0;
	  }
	return 0;
}
//____________________________________________________

UInt_t AliT0Preprocessor::Process(TMap* dcsAliasMap )
{
  // T0 preprocessor return codes:
  // return=0 : all ok
  // return=1 : no DCS input data 
  // return=2 : failed to store DCS data
  // return=3 : no Laser data (Walk correction)
  // return=4 : failed to store OCDB time equalized data
  // return=5 : no DAQ input for OCDB
  // return=6 : failed to retrieve DAQ data from OCDB
  // return=7 : failed to store T0 OCDB data
	Bool_t dcsDP = ProcessDCS();
	Log(Form("dcsDP = %d",dcsDP));	
        TString runType = GetRunType();
	Log(Form("RunType: %s",runType.Data()));
	//processing
 	if(runType == "STANDALONE"){
	  if(dcsDP==1){
	    Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
	    return iresultDCS;
	  }
	}
 	if(runType == "LASER"){
	  Int_t iresultLaser = ProcessLaser();
	  if(dcsDP==1){
            Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
            return iresultDCS;
          }
	  Log(Form("iresultLaser = %d",iresultLaser));
	  return iresultLaser;
	}
	else if(runType == "PHYSICS"){
	  Int_t iresultPhysics = ProcessPhysics();
	 //	 Int_t iresultCosmic = ProcessCosmic();
	  if(dcsDP==1){
	    Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
	    return iresultDCS;
	  }
	  Log(Form("iresultPhysics = %d",iresultPhysics));
	  return iresultPhysics; 
	  //		Log(Form("iresultPhysics =iresultCosmic %d",iresultCosmic));
	  //	return iresultCosmic; 
	}	
	
	return 0;
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/*
	17	$Log: AliT0Preprocessor.cxx,v $
	18	Revision 1.8 2007/12/07 15:22:51 alla
	19	bug fixed by Alberto
	20
	21	Revision 1.7 2007/12/06 16:35:24 alla
	22	new bugs fixed by Tomek
	23
	24	Revision 1.5 2007/11/23 19:28:52 alla
	25	bug fixed
	26
	27	Version 2.1 2007/11/21
	28	Preprocessor storing data to OCDB (T.Malkiewicz)
	29
	30	Version 1.1 2006/10
	31	Preliminary test version (T.Malkiewicz)
	32	*/
	33	// T0 preprocessor:
	34	// 1) takes data from DCS and passes it to the class AliTOFDataDCS
	35	// for processing and writes the result to the Reference DB.
	36	// 2) takes data form DAQ (both from Laser Calibration and Physics runs),
	37	// processes it, and stores either to OCDB or to Reference DB.
	38
	39
	40	#include "AliT0Preprocessor.h"
	41	#include "AliT0DataDCS.h"
	42	#include "AliT0CalibWalk.h"
	43	#include "AliT0CalibTimeEq.h"
	44
	45	#include "AliCDBMetaData.h"
	46	#include "AliDCSValue.h"
	47	#include "AliLog.h"
	48
	49	#include <TTimeStamp.h>
	50	#include <TFile.h>
	51	#include <TObjString.h>
	52	#include <TNamed.h>
	53	#include "AliT0Dqclass.h"
	54
	55
	56	ClassImp(AliT0Preprocessor)
	57
	58	//____________________________________________________
	59	AliT0Preprocessor::AliT0Preprocessor(AliShuttleInterface* shuttle) :
	60	AliPreprocessor("T00", shuttle),
	61	fData(0)
	62	{
	63	//constructor
	64	AddRunType("PHYSICS");
	65	AddRunType("STANDALONE");
	66	AddRunType("LASER");
	67	}
	68	//____________________________________________________
	69
	70	AliT0Preprocessor::~AliT0Preprocessor()
	71	{
	72	//destructor
	73	delete fData;
	74	fData = 0;
	75	}
	76	//____________________________________________________
	77
	78	void AliT0Preprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
	79	{
	80	// Creates AliT0DataDCS object
	81	AliPreprocessor::Initialize(run, startTime, endTime);
	82	AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run, TTimeStamp(startTime).AsString(), TTimeStamp(endTime).AsString()));
	83	fData = new AliT0DataDCS(fRun, fStartTime, fEndTime, GetStartTimeDCSQuery(), GetEndTimeDCSQuery());
	84	}
	85	//____________________________________________________
	86
	87	Bool_t AliT0Preprocessor::ProcessDCS(){
	88	// Check whether DCS should be processed or not...
	89	TString runType = GetRunType();
	90	Log(Form("ProcessDCS - RunType: %s",runType.Data()));
	91
	92	if((runType == "STANDALONE")\|\|
	93	(runType == "PHYSICS")\|\|
	94	(runType == "LASER")){
	95	// return kFALSE;
	96	return kTRUE;
	97	}else{
	98	return kFALSE;
	99	}
	100	}
	101	//____________________________________________________
	102
	103	UInt_t AliT0Preprocessor::ProcessDCSDataPoints(TMap* dcsAliasMap){
	104	// Fills data into AliT0DataDCS object
	105	Log("Processing DCS DP");
	106	Bool_t resultDCSMap=kFALSE;
	107	Bool_t resultDCSStore=kFALSE;
	108
	109	if(!dcsAliasMap)
	110	{
	111	Log("No DCS input data");
	112	return 1;
	113	}
	114	else
	115	{
	116	resultDCSMap=fData->ProcessData(*dcsAliasMap);
	117	if(!resultDCSMap)
	118	{
	119	Log("Error when processing DCS data");
	120	return 2;// return error Code for processed DCS data not stored
	121	}
	122	else
	123	{
	124	AliCDBMetaData metaDataDCS;
	125	metaDataDCS.SetBeamPeriod(0);
	126	metaDataDCS.SetResponsible("Tomasz Malkiewicz");
	127	metaDataDCS.SetComment("This preprocessor fills an AliTODataDCS object.");
	128	AliInfo("Storing DCS Data");
	129	resultDCSStore = StoreReferenceData("Calib","DCSData",fData, &metaDataDCS);
	130	if (!resultDCSStore)
	131	{
	132	Log("Some problems occurred while storing DCS data results in ReferenceDB");
	133	return 2;// return error Code for processed DCS data not stored
	134	}
	135	}
	136	}
	137	return 0;
	138	}
	139	//____________________________________________________
	140
	141	UInt_t AliT0Preprocessor::ProcessLaser(){
	142	// Processing data from DAQ Standalone run
	143	Log("Processing Laser calibration - Walk Correction");
	144
	145	Bool_t resultLaser=kFALSE;
	146	//processing DAQ
	147	TList* list = GetFileSources(kDAQ, "LASER");
	148	if (list)
	149	{
	150	TIter iter(list);
	151	TObjString *source;
	152	while ((source = dynamic_cast<TObjString *> (iter.Next())))
	153	{
	154	const char *laserFile = GetFile(kDAQ, "LASER", source->GetName());
	155	if (laserFile)
	156	{
	157	Log(Form("File with Id LASER found in source %s!", source->GetName()));
	158	AliT0CalibWalk *laser = new AliT0CalibWalk();
	159	laser->MakeWalkCorrGraph(laserFile);
	160	AliCDBMetaData metaData;
	161	metaData.SetBeamPeriod(0);
	162	metaData.SetResponsible("Tomek&Michal");
	163	metaData.SetComment("Walk correction from laser runs.");
	164	resultLaser=Store("Calib","Slewing_Walk", laser, &metaData, 0, 1);
	165	delete laser;
	166	Log(Form("resultLaser = %d",resultLaser));
	167	}
	168	else
	169	{
	170	Log(Form("Could not find file with Id LASER in source %s!", source->GetName()));
	171	return 1;
	172	}
	173	}
	174	if (!resultLaser)
	175	{
	176	Log("No Laser Data stored");
	177	return 3;//return error code for failure in storing Laser Data
	178	}
	179	} else {
	180	Log("No sources found for id LASER!");
	181	return 1;
	182	}
	183	return 0;
	184	}
	185	//____________________________________________________
	186
	187	UInt_t AliT0Preprocessor::ProcessPhysics(){
	188	//Processing data from DAQ Physics run
	189	Log("Processing Physics");
	190
	191	Bool_t resultOnline=kFALSE;
	192	//processing DAQ
	193	TList* listPhys = GetFileSources(kDAQ, "PHYSICS");
	194	if (listPhys)
	195	{
	196	TIter iter(listPhys);
	197	TObjString *sourcePhys;
	198	while ((sourcePhys = dynamic_cast<TObjString *> (iter.Next())))
	199	{
	200	const char *filePhys = GetFile(kDAQ, "PHYSICS", sourcePhys->GetName());
	201	if (filePhys)
	202	{
	203	AliT0CalibTimeEq *online = new AliT0CalibTimeEq();
	204	online->Reset();
	205	online->ComputeOnlineParams(filePhys);
	206	AliCDBMetaData metaData;
	207	metaData.SetBeamPeriod(0);
	208	metaData.SetResponsible("Tomek&Michal");
	209	metaData.SetComment("Time equalizing result.");
	210	resultOnline = Store("Calib","TimeDelay", online, &metaData, 0, 1);
	211	Log(Form("resultOnline = %d",resultOnline));
	212	delete online;
	213	}
	214	else
	215	{
	216	Log(Form("Could not find file with Id PHYSICS in source %s!", sourcePhys->GetName()));
	217	return 1;
	218	}
	219
	220	}
	221	if (!resultOnline)
	222	{
	223	Log("No Data stored");
	224	return 4;//return error code for failure in storing OCDB Data
	225	}
	226	} else {
	227	Log("No sources found for id PHYSICS!");
	228	return 1;
	229	}
	230	return 0;
	231	}
	232	//____________________________________________________
	233
	234	UInt_t AliT0Preprocessor::ProcessCosmic(){
	235	//Processing data from DAQ Physics run
	236	Log("Processing Laser Physics");
	237
	238	Bool_t resultLaserOnline=kFALSE;
	239	//processing DAQ
	240	TList* listLaser = GetFileSources(kDAQ, "COSMIC");
	241	if (listLaser)
	242	{
	243	TIter iter(listLaser);
	244	TObjString *sourceLaser;
	245	while ((sourceLaser = dynamic_cast<TObjString *> (iter.Next())))
	246	{
	247	const char *fileLaser = GetFile(kDAQ, "COSMIC", sourceLaser->GetName());
	248	if (fileLaser)
	249	{
	250	AliT0CalibTimeEq *onlineLaser = new AliT0CalibTimeEq();
	251	onlineLaser->Reset();
	252	onlineLaser->ComputeOnlineParams(fileLaser);
	253	AliCDBMetaData metaData;
	254	metaData.SetBeamPeriod(0);
	255	metaData.SetResponsible("Tomek&Michal");
	256	metaData.SetComment("Time equalizing result.");
	257	resultLaserOnline = Store("Calib","LaserTimeDelay", onlineLaser, &metaData, 0, 1);
	258	Log(Form("resultLaserOnline = %d",resultLaserOnline));
	259	delete onlineLaser;
	260	}
	261	else
	262	{
	263	Log(Form("Could not find file with Id COSMIC in source %s!", sourceLaser->GetName()));
	264	return 0;
	265	}
	266
	267	}
	268	if (!resultLaserOnline)
	269	{
	270	Log("No Laser Data stored");
	271	return 0;//return error code for failure in storing OCDB Data
	272	}
	273	} else {
	274	Log("No sources found for id COSMIC!");
	275	return 0;
	276	}
	277	return 0;
	278	}
	279	//____________________________________________________
	280
	281	UInt_t AliT0Preprocessor::Process(TMap* dcsAliasMap )
	282	{
	283	// T0 preprocessor return codes:
	284	// return=0 : all ok
	285	// return=1 : no DCS input data
	286	// return=2 : failed to store DCS data
	287	// return=3 : no Laser data (Walk correction)
	288	// return=4 : failed to store OCDB time equalized data
	289	// return=5 : no DAQ input for OCDB
	290	// return=6 : failed to retrieve DAQ data from OCDB
	291	// return=7 : failed to store T0 OCDB data
	292	Bool_t dcsDP = ProcessDCS();
	293	Log(Form("dcsDP = %d",dcsDP));
	294	TString runType = GetRunType();
	295	Log(Form("RunType: %s",runType.Data()));
	296	//processing
	297	if(runType == "STANDALONE"){
	298	if(dcsDP==1){
	299	Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
	300	return iresultDCS;
	301	}
	302	}
	303	if(runType == "LASER"){
	304	Int_t iresultLaser = ProcessLaser();
	305	if(dcsDP==1){
	306	Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
	307	return iresultDCS;
	308	}
	309	Log(Form("iresultLaser = %d",iresultLaser));
	310	return iresultLaser;
	311	}
	312	else if(runType == "PHYSICS"){
	313	Int_t iresultPhysics = ProcessPhysics();
	314	// Int_t iresultCosmic = ProcessCosmic();
	315	if(dcsDP==1){
	316	Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
	317	return iresultDCS;
	318	}
	319	Log(Form("iresultPhysics = %d",iresultPhysics));
	320	return iresultPhysics;
	321	// Log(Form("iresultPhysics =iresultCosmic %d",iresultCosmic));
	322	// return iresultCosmic;
	323	}
	324
	325	return 0;
	326	}