[u/mrichter/AliRoot.git] / STEER / AliGRPObject.cxx

/**************************************************************************\r
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
 *                                                                        *\r
 * Author: The ALICE Off-line Project.                                    *\r
 * Contributors are mentioned in the code where appropriate.              *\r
 *                                                                        *\r
 * Permission to use, copy, modify and distribute this software and its   *\r
 * documentation strictly for non-commercial purposes is hereby granted   *\r
 * without fee, provided that the above copyright notice appears in all   *\r
 * copies and that both the copyright notice and this permission notice   *\r
 * appear in the supporting documentation. The authors make no claims     *\r
 * about the suitability of this software for any purpose. It is          *\r
 * provided "as is" without express or implied warranty.                  *\r
 **************************************************************************/\r
\r
/* $Id$ */\r
\r
// **********************\r
// Class containing the GRP data that have to be stored in the OCDB.\r
// Data come either from DAQ logbook or from DCS DB.\r
// Processing of the data can also be performed here.\r
// **********************\r
\r
#include <TMap.h>\r
#include <TObject.h>\r
#include <TObjString.h>\r
\r
#include "AliGRPObject.h"\r
#include "AliDCSSensor.h"\r
#include "AliLog.h"\r
\r
ClassImp(AliGRPObject)\r
	\r
const Float_t AliGRPObject::fgkInvalidFloat = 1E-33; // value to identify invalid data - float\r
const TString AliGRPObject::fgkInvalidString = "";  // value to identify invalid data - string\r
const Char_t AliGRPObject::fgkInvalidChar = -1;         // value to identify invalid data - uchar\r
const Int_t AliGRPObject::fgkInvalidInt = -1;  // value to identify invalid data - uint\r
const Int_t AliGRPObject::fgkInvalidUInt = 0;  // value to identify invalid data - uint\r
const Int_t AliGRPObject::fgknDCSDPHallProbes = 40;   // number of dcs dps\r
const char* AliGRPObject::fgkDCSDataPointsHallProbes[AliGRPObject::fgknDCSDPHallProbes] = {\r
		   "L3_BSF17_H1",\r
		   "L3_BSF17_H2",\r
		   "L3_BSF17_H3",\r
		   "L3_BSF17_Temperature",\r
		   "L3_BSF4_H1",\r
		   "L3_BSF4_H2",\r
		   "L3_BSF4_H3",\r
		   "L3_BSF4_Temperature",\r
		   "L3_BKF17_H1",\r
		   "L3_BKF17_H2",\r
		   "L3_BKF17_H3",\r
		   "L3_BKF17_Temperature",\r
		   "L3_BKF4_H1",\r
		   "L3_BKF4_H2",\r
		   "L3_BKF4_H3",\r
		   "L3_BKF4_Temperature",\r
		   "L3_BSF13_H1",\r
		   "L3_BSF13_H2",\r
		   "L3_BSF13_H3",\r
		   "L3_BSF13_Temperature",\r
		   "L3_BSF8_H1",\r
		   "L3_BSF8_H2",\r
		   "L3_BSF8_H3",\r
		   "L3_BSF8_Temperature",\r
		   "L3_BKF13_H1",\r
		   "L3_BKF13_H2",\r
		   "L3_BKF13_H3",\r
		   "L3_BKF13_Temperature",\r
		   "L3_BKF8_H1",\r
		   "L3_BKF8_H2",\r
		   "L3_BKF8_H3",\r
		   "L3_BKF8_Temperature",\r
		   "Dipole_Inside_H1",\r
		   "Dipole_Inside_H2",\r
		   "Dipole_Inside_H3",\r
		   "Dipole_Inside_Temperature",\r
		   "Dipole_Outside_H1",\r
		   "Dipole_Outside_H2",\r
		   "Dipole_Outside_H3",\r
		   "Dipole_Outside_Temperature",\r
                 };\r
\r
//-----------------------------------------------------------------------------\r
AliGRPObject::AliGRPObject():\r
	TObject(),\r
	fPoints(5),\r
	fDimension(0),\r
	fTimeStart((time_t)fgkInvalidFloat),\r
	fTimeEnd((time_t)fgkInvalidFloat),\r
	fBeamEnergy(fgkInvalidFloat),\r
	fBeamType(fgkInvalidString),\r
	fNumberOfDetectors(fgkInvalidChar),\r
	fDetectorMask(fgkInvalidUInt),\r
	fLHCPeriod(fgkInvalidString),\r
	fRunType(fgkInvalidString),\r
	fLHCState(fgkInvalidString),\r
	fL3Polarity(fgkInvalidChar),\r
	fDipolePolarity(fgkInvalidChar),\r
	fL3Current(new Float_t[fPoints]),\r
	fDipoleCurrent(new Float_t[fPoints]),\r
	fCavernTemperature(new Float_t[fPoints]),\r
	fCavernAtmosPressure(0x0),\r
	fCavernAtmosPressure2(0x0),\r
	fSurfaceAtmosPressure(0x0),\r
	fHallProbes(0x0),\r
	fMachineMode(fgkInvalidString),\r
	fLHCStateArray(0x0),\r
	fMachineModeArray(0x0),\r
	fMaxTimeLHCValidity(0)\r
{\r
\r
	//\r
	// AliGRPObject default ctor\r
	//\r
\r
	fDimension = fgknDCSDPHallProbes*fPoints;\r
	fHallProbes = new Float_t[fDimension];\r
\r
	for (Int_t nhp=0; nhp< fDimension; nhp++){ // setting to zero values for non working HP \r
		if ((nhp >= 0 && nhp <= 1*fPoints-1) || // L3_BSF17_H1\r
		    (nhp >= 1*fPoints && nhp <= 2*fPoints-1) || // L3_BSF17_H2\r
		    (nhp >= 2*fPoints && nhp <= 3*fPoints-1) || // L3_BSF17_H3\r
                    (nhp >= 3*fPoints && nhp <= 4*fPoints-1) || // L3_BSF17_Temperature\r
                    (nhp >= 6*fPoints && nhp <= 7*fPoints-1) ) { // L3_BSF4_H3\r
			fHallProbes[nhp] = 0; // setting to zero values for non working HP \r
			AliDebug(2,"setting hp[%d] to zero = %f", nhp, fHallProbes[nhp]);\r
		}\r
		else {\r
			fHallProbes[nhp] = fgkInvalidFloat;\r
		}\r
	}\r
\r
\r
	for (Int_t i = 0; i < fPoints; i++){\r
\r
		fL3Current[i] = fgkInvalidFloat;\r
		fDipoleCurrent[i] = fgkInvalidFloat;\r
		fCavernTemperature[i] = fgkInvalidFloat;\r
	}\r
}\r
\r
//-----------------------------------------------------------------------------\r
\r
AliGRPObject::AliGRPObject(const AliGRPObject &obj):\r
	TObject(obj),\r
	fPoints(obj.fPoints),\r
	fDimension(obj.fDimension),\r
	fTimeStart(obj.fTimeStart),\r
	fTimeEnd(obj.fTimeEnd),\r
	fBeamEnergy(obj.fBeamEnergy),\r
	fBeamType(obj.fBeamType),\r
	fNumberOfDetectors(obj.fNumberOfDetectors),\r
	fDetectorMask(obj.fDetectorMask),\r
	fLHCPeriod(obj.fLHCPeriod),\r
	fRunType(obj.fRunType),\r
	fLHCState(obj.fLHCState),\r
	fL3Polarity(obj.fL3Polarity),\r
	fDipolePolarity(obj.fDipolePolarity),\r
	fL3Current(new Float_t[fPoints]),\r
	fDipoleCurrent(new Float_t[fPoints]),\r
	fCavernTemperature(new Float_t[fPoints]),\r
	fCavernAtmosPressure(obj.fCavernAtmosPressure),\r
	fCavernAtmosPressure2(obj.fCavernAtmosPressure2),\r
	fSurfaceAtmosPressure(obj.fSurfaceAtmosPressure),\r
	fHallProbes(0x0),\r
	fMachineMode(obj.fMachineMode),\r
	fLHCStateArray(obj.fLHCStateArray),\r
	fMachineModeArray(obj.fMachineModeArray),\r
	fMaxTimeLHCValidity(obj.fMaxTimeLHCValidity)\r
\r
{\r
\r
	//\r
	// AliGRPObject copy ctor\r
	//\r
\r
	fHallProbes = new Float_t[fDimension]; \r
\r
	for (Int_t nhp=0; nhp< fDimension; nhp++){\r
		fHallProbes[nhp] = obj.fHallProbes[nhp];\r
	}\r
\r
	for (Int_t i = 0; i < fPoints; i++){\r
\r
		fL3Current[i] = obj.fL3Current[i];\r
		fDipoleCurrent[i] = obj.fDipoleCurrent[i];\r
		fCavernTemperature[i] = obj.fCavernTemperature[i];\r
	}\r
}\r
\r
//-----------------------------------------------------------------------------\r
\r
AliGRPObject& AliGRPObject:: operator=(const AliGRPObject & obj) \r
{\r
\r
	//\r
	// AliGRPObject assignment operator\r
	//\r
\r
	if (&obj == this) return *this; \r
\r
	TObject::operator=(obj);\r
	this->fTimeStart = obj.GetTimeStart();\r
	this->fTimeEnd = obj.GetTimeEnd();\r
	this->fBeamEnergy = obj.GetBeamEnergy();\r
	this->fBeamType = obj.GetBeamType();\r
	this->fNumberOfDetectors = obj.GetNumberOfDetectors();\r
	this->fDetectorMask = obj.GetDetectorMask();\r
	this->fLHCPeriod = obj.GetLHCPeriod();\r
	this->fRunType = obj.GetRunType();\r
	this->fLHCState = obj.GetLHCState();\r
	this->fL3Polarity = obj.GetL3Polarity();\r
	this->fDipolePolarity = obj.GetDipolePolarity();\r
	this->fCavernAtmosPressure = obj.GetCavernAtmosPressure();\r
	this->fCavernAtmosPressure2 = obj.GetCavernAtmosPressure2();\r
	this->fSurfaceAtmosPressure = obj.GetSurfaceAtmosPressure();\r
	this->fPoints = obj.GetPoints();\r
	this->fDimension = obj.GetDimension();\r
\r
	this->fL3Current = new Float_t[fPoints];\r
	this->fDipoleCurrent = new Float_t[fPoints];\r
	this->fCavernTemperature = new Float_t[fPoints];\r
	\r
	if (this->fHallProbes==NULL) this->fHallProbes = new Float_t[this->fDimension]; \r
	for (Int_t nhp=0; nhp< fDimension; nhp++){\r
		this->fHallProbes[nhp] = obj.GetHallProbes(nhp);\r
\r
	}\r
	for (Int_t i = 0; i < fPoints; i++){\r
\r
		this->fL3Current[i] = obj.GetL3Current((Stats)i);\r
		this->fDipoleCurrent[i] = obj.GetDipoleCurrent((Stats)i);\r
		this->fCavernTemperature[i] = obj.GetCavernTemperature((Stats)i);\r
	}\r
\r
	this->fMachineMode = obj.fMachineMode;\r
	this->fLHCStateArray = obj.fLHCStateArray;\r
	this->fMachineModeArray = obj.fMachineModeArray;\r
	this->fMaxTimeLHCValidity = obj.fMaxTimeLHCValidity;\r
	return *this;\r
}\r
\r
//-----------------------------------------------------------------------------\r
\r
AliGRPObject::~AliGRPObject() {\r
\r
	//\r
	// dtor\r
	//\r
\r
	\r
	delete [] fHallProbes;\r
	delete [] fL3Current;\r
	delete [] fDipoleCurrent;\r
	delete [] fCavernTemperature;\r
\r
	if (fCavernAtmosPressure){\r
		delete fCavernAtmosPressure;\r
		fCavernAtmosPressure = 0x0;\r
	}\r
	if (fCavernAtmosPressure2){\r
		delete fCavernAtmosPressure2;\r
		fCavernAtmosPressure2 = 0x0;\r
	}\r
	if (fSurfaceAtmosPressure){\r
		delete fSurfaceAtmosPressure;\r
		fSurfaceAtmosPressure = 0x0;\r
	}\r
	if (fLHCStateArray){\r
		delete fLHCStateArray;\r
		fLHCStateArray = 0x0;\r
	}\r
	if (fMachineModeArray){\r
		delete fMachineModeArray;\r
		fMachineModeArray = 0x0;\r
	}\r
}\r
\r
//-----------------------------------------------------------------------------\r
Float_t* AliGRPObject::GetHallProbesArray(DP_HallProbes hp) const {\r
\r
	//\r
	// method to return array of statistical\r
        // variables for Hall Probe hp\r
	//\r
\r
	Float_t* array = new Float_t[fPoints];\r
	Int_t shift = fPoints*(Int_t)hp; \r
	for (Int_t i=0;i<fPoints; i++){\r
\r
		array[i] = fHallProbes[shift+i];\r
\r
	}\r
\r
	return array;\r
}\r
//-------------------------------------------------------------------------------\r
\r
void AliGRPObject::SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe){\r
\r
	//\r
	// method to set hall probe hp \r
	// from a given array\r
	//\r
\r
	Int_t shift = fPoints*hp;\r
	for (Int_t i = 0; i< fPoints; i++){\r
\r
		fHallProbes[i+shift] =  hall_probe[i];\r
	}\r
	return;\r
}\r
\r
//-------------------------------------------------------------------------------\r
\r
void AliGRPObject::ReadValuesFromMap(const TMap* mapGRP){\r
\r
	//\r
	// method to set the values of the GRP parameters \r
	// reading them from the old format of the GRP \r
	// object, i.e. a TMap\r
	//\r
\r
	if (mapGRP->GetValue("fAliceStartTime")){\r
		SetTimeStart((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStartTime")))->GetString()).Atoi());\r
	}\r
	else {\r
		AliError(Form("No fAliceStartTime value found in GRP map!"));\r
	}\r
	if (mapGRP->GetValue("fAliceStopTime")){\r
		SetTimeEnd((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStopTime")))->GetString()).Atoi());\r
	}\r
	\r
	else { \r
		AliError(Form("No fAliceStopTime value found in GRP map!"));\r
	}\r
\r
	if(mapGRP->GetValue("fAliceBeamEnergy")){\r
	  double be = (((TObjString*)(mapGRP->GetValue("fAliceBeamEnergy")))->GetString()).Atof();\r
	  if (IsBeamEnergyIsSqrtSHalfGeV()) be/=2;   // old format was storig sqrt(s)\r
	  SetBeamEnergy(be);\r
	}\r
	else { \r
		AliError(Form("No fAliceBeamEnergy value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fAliceBeamType")){\r
		SetBeamType(((TObjString*)(mapGRP->GetValue("fAliceBeamType")))->GetString());\r
	}\r
	else { \r
		AliError(Form("No fAliceBeamType value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fNumberOfDetectors")){\r
		SetNumberOfDetectors((Char_t)(((TObjString*)(mapGRP->GetValue("fNumberOfDetectors")))->GetString()).Atoi()); \r
	}\r
	else { \r
		AliError(Form("No fNumberOfDetectors value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fDetectorMask")){\r
		SetDetectorMask((UInt_t)(((TObjString*)(mapGRP->GetValue("fDetectorMask")))->GetString()).Atoi());  \r
	}\r
	else { \r
		AliError(Form("No fDetectorMask value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fLHCPeriod")){\r
		SetLHCPeriod(((TObjString*)(mapGRP->GetValue("fLHCPeriod")))->GetString());\r
	}\r
	else { \r
		AliError(Form("No fLHCPeriod value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fRunType")){\r
		SetRunType(((TObjString*)(mapGRP->GetValue("fRunType")))->GetString());\r
	}\r
	else { \r
		AliError(Form("No fRunType value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fLHCState")){\r
		SetLHCState(((TObjString*)(mapGRP->GetValue("fLHCState")))->GetString());\r
	}\r
	else { \r
		AliError(Form("No fLHCState value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fLHCluminosity")){\r
		AliInfo(Form("fLHCLuminosity found, but not there anymore in the new object"));\r
	}	\r
	else { \r
		AliError(Form("No fLHCLuminosity value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fBeamIntensity")){\r
		AliInfo(Form("fBeamIntensity found, but not there anymore in the new object"));\r
	}	\r
	else { \r
		AliError(Form("No fBeamIntensity value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fL3Polarity")){\r
		SetL3Polarity((Char_t)(((TObjString*)(mapGRP->GetValue("fL3Polarity")))->GetString()).Atoi());\r
	}	\r
	else { \r
		AliError(Form("No fL3Polarity value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fDipolePolarity")){\r
		SetDipolePolarity((Char_t)(((TObjString*)(mapGRP->GetValue("fDipolePolarity")))->GetString()).Atoi());  \r
	}	\r
	else { \r
		AliError(Form("No fDipolePolarity value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fL3Current")){\r
		AliInfo(Form("fL3Current found, but porting only average to the new object, since the other values are not available in the old object"));\r
		SetL3Current((Float_t)(((TObjString*)(mapGRP->GetValue("fL3Current")))->GetString()).Atof(),(Stats)0);\r
	}	\r
	else { \r
		AliError(Form("No fL3Current value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fDipoleCurrent")){\r
		AliInfo(Form("fDipoleCurrent found, but porting only average to the new object, since the other values are not available in the old object"));\r
		SetDipoleCurrent((Float_t)(((TObjString*)(mapGRP->GetValue("fDipoleCurrent")))->GetString()).Atof(),(Stats)0);\r
	}	\r
	else { \r
		AliError(Form("No fDipoleCurrent value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fCavernTemperature")){\r
		AliInfo(Form("fCaverntemperature found, but porting only average to the new object, since the other values are not available in the old object"));\r
		SetCavernTemperature((Float_t)(((TObjString*)(mapGRP->GetValue("fCavernTemperature")))->GetString()).Atof(),(Stats)0);\r
	}	\r
	else { \r
		AliError(Form("No fCavernTemperature value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fCavernAtmosPressure")){\r
		AliInfo(Form("fCavernAtmosPressure found, but not ported to the new object since of a different type"));\r
	}	\r
	else { \r
		AliError(Form("No fCavernAtmosPressure value found in GRP map!"));\r
	}\r
	if(mapGRP->GetValue("fP2Pressure")){\r
		SetSurfaceAtmosPressure((AliDCSSensor*)((TObjString*)(mapGRP->GetValue("fP2Pressure"))));\r
	}\r
	else { \r
		AliError(Form("No fP2Pressure value found in GRP map!"));\r
	}\r
	\r
	return;\r
\r
}\r
Commit	Line	Data
39e3007b	1	/**************************************************************************\r
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
	3	* *\r
	4	* Author: The ALICE Off-line Project. *\r
	5	* Contributors are mentioned in the code where appropriate. *\r
	6	* *\r
	7	* Permission to use, copy, modify and distribute this software and its *\r
	8	* documentation strictly for non-commercial purposes is hereby granted *\r
	9	* without fee, provided that the above copyright notice appears in all *\r
	10	* copies and that both the copyright notice and this permission notice *\r
	11	* appear in the supporting documentation. The authors make no claims *\r
	12	* about the suitability of this software for any purpose. It is *\r
	13	* provided "as is" without express or implied warranty. *\r
	14	**************************************************************************/\r
	15	\r
	16	/* $Id$ */\r
	17	\r
	18	// **********************\r
	19	// Class containing the GRP data that have to be stored in the OCDB.\r
	20	// Data come either from DAQ logbook or from DCS DB.\r
	21	// Processing of the data can also be performed here.\r
	22	// **********************\r
	23	\r
	24	#include <TMap.h>\r
	25	#include <TObject.h>\r
	26	#include <TObjString.h>\r
	27	\r
	28	#include "AliGRPObject.h"\r
	29	#include "AliDCSSensor.h"\r
	30	#include "AliLog.h"\r
	31	\r
	32	ClassImp(AliGRPObject)\r
	33	\r
7e5aabd4	34	const Float_t AliGRPObject::fgkInvalidFloat = 1E-33; // value to identify invalid data - float\r
39e3007b	35	const TString AliGRPObject::fgkInvalidString = ""; // value to identify invalid data - string\r
	36	const Char_t AliGRPObject::fgkInvalidChar = -1; // value to identify invalid data - uchar\r
	37	const Int_t AliGRPObject::fgkInvalidInt = -1; // value to identify invalid data - uint\r
	38	const Int_t AliGRPObject::fgkInvalidUInt = 0; // value to identify invalid data - uint\r
	39	const Int_t AliGRPObject::fgknDCSDPHallProbes = 40; // number of dcs dps\r
	40	const char* AliGRPObject::fgkDCSDataPointsHallProbes[AliGRPObject::fgknDCSDPHallProbes] = {\r
	41	"L3_BSF17_H1",\r
	42	"L3_BSF17_H2",\r
	43	"L3_BSF17_H3",\r
	44	"L3_BSF17_Temperature",\r
	45	"L3_BSF4_H1",\r
	46	"L3_BSF4_H2",\r
	47	"L3_BSF4_H3",\r
	48	"L3_BSF4_Temperature",\r
	49	"L3_BKF17_H1",\r
	50	"L3_BKF17_H2",\r
	51	"L3_BKF17_H3",\r
	52	"L3_BKF17_Temperature",\r
	53	"L3_BKF4_H1",\r
	54	"L3_BKF4_H2",\r
	55	"L3_BKF4_H3",\r
	56	"L3_BKF4_Temperature",\r
	57	"L3_BSF13_H1",\r
	58	"L3_BSF13_H2",\r
	59	"L3_BSF13_H3",\r
	60	"L3_BSF13_Temperature",\r
	61	"L3_BSF8_H1",\r
	62	"L3_BSF8_H2",\r
	63	"L3_BSF8_H3",\r
	64	"L3_BSF8_Temperature",\r
	65	"L3_BKF13_H1",\r
	66	"L3_BKF13_H2",\r
	67	"L3_BKF13_H3",\r
	68	"L3_BKF13_Temperature",\r
	69	"L3_BKF8_H1",\r
	70	"L3_BKF8_H2",\r
	71	"L3_BKF8_H3",\r
	72	"L3_BKF8_Temperature",\r
	73	"Dipole_Inside_H1",\r
	74	"Dipole_Inside_H2",\r
	75	"Dipole_Inside_H3",\r
	76	"Dipole_Inside_Temperature",\r
	77	"Dipole_Outside_H1",\r
	78	"Dipole_Outside_H2",\r
	79	"Dipole_Outside_H3",\r
	80	"Dipole_Outside_Temperature",\r
	81	};\r
	82	\r
	83	//-----------------------------------------------------------------------------\r
	84	AliGRPObject::AliGRPObject():\r
	85	TObject(),\r
	86	fPoints(5),\r
	87	fDimension(0),\r
	88	fTimeStart((time_t)fgkInvalidFloat),\r
	89	fTimeEnd((time_t)fgkInvalidFloat),\r
	90	fBeamEnergy(fgkInvalidFloat),\r
	91	fBeamType(fgkInvalidString),\r
	92	fNumberOfDetectors(fgkInvalidChar),\r
	93	fDetectorMask(fgkInvalidUInt),\r
	94	fLHCPeriod(fgkInvalidString),\r
	95	fRunType(fgkInvalidString),\r
	96	fLHCState(fgkInvalidString),\r
39e3007b	97	fL3Polarity(fgkInvalidChar),\r
	98	fDipolePolarity(fgkInvalidChar),\r
	99	fL3Current(new Float_t[fPoints]),\r
	100	fDipoleCurrent(new Float_t[fPoints]),\r
	101	fCavernTemperature(new Float_t[fPoints]),\r
39e3007b	102	fCavernAtmosPressure(0x0),\r
ce996d13	103	fCavernAtmosPressure2(0x0),\r
39e3007b	104	fSurfaceAtmosPressure(0x0),\r
0254e751	105	fHallProbes(0x0),\r
	106	fMachineMode(fgkInvalidString),\r
	107	fLHCStateArray(0x0),\r
6b01e5fd	108	fMachineModeArray(0x0),\r
6b01e5fd	109	fMaxTimeLHCValidity(0)\r
39e3007b	110	{\r
	111	\r
	112	//\r
	113	// AliGRPObject default ctor\r
	114	//\r
	115	\r
	116	fDimension = fgknDCSDPHallProbes*fPoints;\r
	117	fHallProbes = new Float_t[fDimension];\r
	118	\r
9fae6417	119	for (Int_t nhp=0; nhp< fDimension; nhp++){ // setting to zero values for non working HP \r
	120	if ((nhp >= 0 && nhp <= 1*fPoints-1) \|\| // L3_BSF17_H1\r
	121	(nhp >= 1fPoints && nhp <= 2fPoints-1) \|\| // L3_BSF17_H2\r
	122	(nhp >= 2fPoints && nhp <= 3fPoints-1) \|\| // L3_BSF17_H3\r
	123	(nhp >= 3fPoints && nhp <= 4fPoints-1) \|\| // L3_BSF17_Temperature\r
	124	(nhp >= 6fPoints && nhp <= 7fPoints-1) ) { // L3_BSF4_H3\r
	125	fHallProbes[nhp] = 0; // setting to zero values for non working HP \r
	126	AliDebug(2,"setting hp[%d] to zero = %f", nhp, fHallProbes[nhp]);\r
	127	}\r
	128	else {\r
	129	fHallProbes[nhp] = fgkInvalidFloat;\r
	130	}\r
39e3007b	131	}\r
39e3007b	132	\r
9fae6417	133	\r
39e3007b	134	for (Int_t i = 0; i < fPoints; i++){\r
39e3007b	135	\r
39e3007b	136	fL3Current[i] = fgkInvalidFloat;\r
	137	fDipoleCurrent[i] = fgkInvalidFloat;\r
	138	fCavernTemperature[i] = fgkInvalidFloat;\r
39e3007b	139	}\r
	140	}\r
	141	\r
	142	//-----------------------------------------------------------------------------\r
	143	\r
	144	AliGRPObject::AliGRPObject(const AliGRPObject &obj):\r
7f53217d	145	TObject(obj),\r
39e3007b	146	fPoints(obj.fPoints),\r
	147	fDimension(obj.fDimension),\r
	148	fTimeStart(obj.fTimeStart),\r
	149	fTimeEnd(obj.fTimeEnd),\r
	150	fBeamEnergy(obj.fBeamEnergy),\r
	151	fBeamType(obj.fBeamType),\r
	152	fNumberOfDetectors(obj.fNumberOfDetectors),\r
	153	fDetectorMask(obj.fDetectorMask),\r
	154	fLHCPeriod(obj.fLHCPeriod),\r
	155	fRunType(obj.fRunType),\r
	156	fLHCState(obj.fLHCState),\r
39e3007b	157	fL3Polarity(obj.fL3Polarity),\r
	158	fDipolePolarity(obj.fDipolePolarity),\r
	159	fL3Current(new Float_t[fPoints]),\r
	160	fDipoleCurrent(new Float_t[fPoints]),\r
	161	fCavernTemperature(new Float_t[fPoints]),\r
39e3007b	162	fCavernAtmosPressure(obj.fCavernAtmosPressure),\r
ce996d13	163	fCavernAtmosPressure2(obj.fCavernAtmosPressure2),\r
39e3007b	164	fSurfaceAtmosPressure(obj.fSurfaceAtmosPressure),\r
0254e751	165	fHallProbes(0x0),\r
	166	fMachineMode(obj.fMachineMode),\r
	167	fLHCStateArray(obj.fLHCStateArray),\r
6b01e5fd	168	fMachineModeArray(obj.fMachineModeArray),\r
6b01e5fd	169	fMaxTimeLHCValidity(obj.fMaxTimeLHCValidity)\r
39e3007b	170	\r
	171	{\r
	172	\r
	173	//\r
	174	// AliGRPObject copy ctor\r
	175	//\r
	176	\r
7f53217d	177	fHallProbes = new Float_t[fDimension]; \r
7f53217d	178	\r
39e3007b	179	for (Int_t nhp=0; nhp< fDimension; nhp++){\r
	180	fHallProbes[nhp] = obj.fHallProbes[nhp];\r
	181	}\r
	182	\r
	183	for (Int_t i = 0; i < fPoints; i++){\r
	184	\r
39e3007b	185	fL3Current[i] = obj.fL3Current[i];\r
39e3007b	186	fDipoleCurrent[i] = obj.fDipoleCurrent[i];\r
95eb6639	187	fCavernTemperature[i] = obj.fCavernTemperature[i];\r
39e3007b	188	}\r
	189	}\r
	190	\r
	191	//-----------------------------------------------------------------------------\r
	192	\r
	193	AliGRPObject& AliGRPObject:: operator=(const AliGRPObject & obj) \r
	194	{\r
	195	\r
	196	//\r
	197	// AliGRPObject assignment operator\r
	198	//\r
	199	\r
7f53217d	200	if (&obj == this) return *this; \r
	201	\r
	202	TObject::operator=(obj);\r
39e3007b	203	this->fTimeStart = obj.GetTimeStart();\r
	204	this->fTimeEnd = obj.GetTimeEnd();\r
	205	this->fBeamEnergy = obj.GetBeamEnergy();\r
	206	this->fBeamType = obj.GetBeamType();\r
	207	this->fNumberOfDetectors = obj.GetNumberOfDetectors();\r
	208	this->fDetectorMask = obj.GetDetectorMask();\r
	209	this->fLHCPeriod = obj.GetLHCPeriod();\r
	210	this->fRunType = obj.GetRunType();\r
	211	this->fLHCState = obj.GetLHCState();\r
39e3007b	212	this->fL3Polarity = obj.GetL3Polarity();\r
	213	this->fDipolePolarity = obj.GetDipolePolarity();\r
	214	this->fCavernAtmosPressure = obj.GetCavernAtmosPressure();\r
ce996d13	215	this->fCavernAtmosPressure2 = obj.GetCavernAtmosPressure2();\r
39e3007b	216	this->fSurfaceAtmosPressure = obj.GetSurfaceAtmosPressure();\r
	217	this->fPoints = obj.GetPoints();\r
	218	this->fDimension = obj.GetDimension();\r
	219	\r
39e3007b	220	this->fL3Current = new Float_t[fPoints];\r
	221	this->fDipoleCurrent = new Float_t[fPoints];\r
	222	this->fCavernTemperature = new Float_t[fPoints];\r
39e3007b	223	\r
7f53217d	224	if (this->fHallProbes==NULL) this->fHallProbes = new Float_t[this->fDimension]; \r
39e3007b	225	for (Int_t nhp=0; nhp< fDimension; nhp++){\r
	226	this->fHallProbes[nhp] = obj.GetHallProbes(nhp);\r
	227	\r
	228	}\r
	229	for (Int_t i = 0; i < fPoints; i++){\r
	230	\r
39e3007b	231	this->fL3Current[i] = obj.GetL3Current((Stats)i);\r
	232	this->fDipoleCurrent[i] = obj.GetDipoleCurrent((Stats)i);\r
	233	this->fCavernTemperature[i] = obj.GetCavernTemperature((Stats)i);\r
39e3007b	234	}\r
39e3007b	235	\r
0254e751	236	this->fMachineMode = obj.fMachineMode;\r
	237	this->fLHCStateArray = obj.fLHCStateArray;\r
	238	this->fMachineModeArray = obj.fMachineModeArray;\r
6b01e5fd	239	this->fMaxTimeLHCValidity = obj.fMaxTimeLHCValidity;\r
39e3007b	240	return *this;\r
	241	}\r
	242	\r
	243	//-----------------------------------------------------------------------------\r
	244	\r
	245	AliGRPObject::~AliGRPObject() {\r
	246	\r
	247	//\r
	248	// dtor\r
	249	//\r
	250	\r
	251	\r
	252	delete [] fHallProbes;\r
39e3007b	253	delete [] fL3Current;\r
	254	delete [] fDipoleCurrent;\r
	255	delete [] fCavernTemperature;\r
	256	\r
39e3007b	257	if (fCavernAtmosPressure){\r
	258	delete fCavernAtmosPressure;\r
	259	fCavernAtmosPressure = 0x0;\r
	260	}\r
ce996d13	261	if (fCavernAtmosPressure2){\r
	262	delete fCavernAtmosPressure2;\r
	263	fCavernAtmosPressure2 = 0x0;\r
	264	}\r
39e3007b	265	if (fSurfaceAtmosPressure){\r
	266	delete fSurfaceAtmosPressure;\r
	267	fSurfaceAtmosPressure = 0x0;\r
	268	}\r
0254e751	269	if (fLHCStateArray){\r
	270	delete fLHCStateArray;\r
	271	fLHCStateArray = 0x0;\r
	272	}\r
	273	if (fMachineModeArray){\r
	274	delete fMachineModeArray;\r
	275	fMachineModeArray = 0x0;\r
	276	}\r
39e3007b	277	}\r
	278	\r
	279	//-----------------------------------------------------------------------------\r
a861a1ce	280	Float_t* AliGRPObject::GetHallProbesArray(DP_HallProbes hp) const {\r
39e3007b	281	\r
	282	//\r
	283	// method to return array of statistical\r
	284	// variables for Hall Probe hp\r
	285	//\r
	286	\r
a861a1ce	287	Float_t* array = new Float_t[fPoints];\r
39e3007b	288	Int_t shift = fPoints*(Int_t)hp; \r
	289	for (Int_t i=0;i<fPoints; i++){\r
	290	\r
	291	array[i] = fHallProbes[shift+i];\r
	292	\r
	293	}\r
	294	\r
	295	return array;\r
	296	}\r
39e3007b	297	//-------------------------------------------------------------------------------\r
	298	\r
	299	void AliGRPObject::SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe){\r
	300	\r
	301	//\r
	302	// method to set hall probe hp \r
	303	// from a given array\r
	304	//\r
	305	\r
	306	Int_t shift = fPoints*hp;\r
	307	for (Int_t i = 0; i< fPoints; i++){\r
	308	\r
	309	fHallProbes[i+shift] = hall_probe[i];\r
	310	}\r
	311	return;\r
	312	}\r
	313	\r
	314	//-------------------------------------------------------------------------------\r
	315	\r
	316	void AliGRPObject::ReadValuesFromMap(const TMap* mapGRP){\r
	317	\r
	318	//\r
	319	// method to set the values of the GRP parameters \r
	320	// reading them from the old format of the GRP \r
	321	// object, i.e. a TMap\r
	322	//\r
	323	\r
	324	if (mapGRP->GetValue("fAliceStartTime")){\r
	325	SetTimeStart((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStartTime")))->GetString()).Atoi());\r
	326	}\r
	327	else {\r
	328	AliError(Form("No fAliceStartTime value found in GRP map!"));\r
	329	}\r
	330	if (mapGRP->GetValue("fAliceStopTime")){\r
	331	SetTimeEnd((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStopTime")))->GetString()).Atoi());\r
	332	}\r
	333	\r
	334	else { \r
	335	AliError(Form("No fAliceStopTime value found in GRP map!"));\r
	336	}\r
	337	\r
	338	if(mapGRP->GetValue("fAliceBeamEnergy")){\r
5cf76849	339	double be = (((TObjString*)(mapGRP->GetValue("fAliceBeamEnergy")))->GetString()).Atof();\r
	340	if (IsBeamEnergyIsSqrtSHalfGeV()) be/=2; // old format was storig sqrt(s)\r
	341	SetBeamEnergy(be);\r
39e3007b	342	}\r
	343	else { \r
	344	AliError(Form("No fAliceBeamEnergy value found in GRP map!"));\r
	345	}\r
	346	if(mapGRP->GetValue("fAliceBeamType")){\r
	347	SetBeamType(((TObjString*)(mapGRP->GetValue("fAliceBeamType")))->GetString());\r
	348	}\r
	349	else { \r
	350	AliError(Form("No fAliceBeamType value found in GRP map!"));\r
	351	}\r
	352	if(mapGRP->GetValue("fNumberOfDetectors")){\r
	353	SetNumberOfDetectors((Char_t)(((TObjString*)(mapGRP->GetValue("fNumberOfDetectors")))->GetString()).Atoi()); \r
	354	}\r
	355	else { \r
	356	AliError(Form("No fNumberOfDetectors value found in GRP map!"));\r
	357	}\r
	358	if(mapGRP->GetValue("fDetectorMask")){\r
	359	SetDetectorMask((UInt_t)(((TObjString*)(mapGRP->GetValue("fDetectorMask")))->GetString()).Atoi()); \r
	360	}\r
	361	else { \r
	362	AliError(Form("No fDetectorMask value found in GRP map!"));\r
	363	}\r
	364	if(mapGRP->GetValue("fLHCPeriod")){\r
	365	SetLHCPeriod(((TObjString*)(mapGRP->GetValue("fLHCPeriod")))->GetString());\r
	366	}\r
	367	else { \r
	368	AliError(Form("No fLHCPeriod value found in GRP map!"));\r
	369	}\r
	370	if(mapGRP->GetValue("fRunType")){\r
	371	SetRunType(((TObjString*)(mapGRP->GetValue("fRunType")))->GetString());\r
	372	}\r
	373	else { \r
	374	AliError(Form("No fRunType value found in GRP map!"));\r
	375	}\r
	376	if(mapGRP->GetValue("fLHCState")){\r
	377	SetLHCState(((TObjString*)(mapGRP->GetValue("fLHCState")))->GetString());\r
	378	}\r
	379	else { \r
	380	AliError(Form("No fLHCState value found in GRP map!"));\r
	381	}\r
	382	if(mapGRP->GetValue("fLHCluminosity")){\r
f2d478f7	383	AliInfo(Form("fLHCLuminosity found, but not there anymore in the new object"));\r
39e3007b	384	} \r
	385	else { \r
	386	AliError(Form("No fLHCLuminosity value found in GRP map!"));\r
	387	}\r
	388	if(mapGRP->GetValue("fBeamIntensity")){\r
f2d478f7	389	AliInfo(Form("fBeamIntensity found, but not there anymore in the new object"));\r
39e3007b	390	} \r
	391	else { \r
	392	AliError(Form("No fBeamIntensity value found in GRP map!"));\r
	393	}\r
	394	if(mapGRP->GetValue("fL3Polarity")){\r
	395	SetL3Polarity((Char_t)(((TObjString*)(mapGRP->GetValue("fL3Polarity")))->GetString()).Atoi());\r
	396	} \r
	397	else { \r
	398	AliError(Form("No fL3Polarity value found in GRP map!"));\r
	399	}\r
	400	if(mapGRP->GetValue("fDipolePolarity")){\r
	401	SetDipolePolarity((Char_t)(((TObjString*)(mapGRP->GetValue("fDipolePolarity")))->GetString()).Atoi()); \r
	402	} \r
	403	else { \r
	404	AliError(Form("No fDipolePolarity value found in GRP map!"));\r
	405	}\r
	406	if(mapGRP->GetValue("fL3Current")){\r
	407	AliInfo(Form("fL3Current found, but porting only average to the new object, since the other values are not available in the old object"));\r
	408	SetL3Current((Float_t)(((TObjString*)(mapGRP->GetValue("fL3Current")))->GetString()).Atof(),(Stats)0);\r
	409	} \r
	410	else { \r
	411	AliError(Form("No fL3Current value found in GRP map!"));\r
	412	}\r
	413	if(mapGRP->GetValue("fDipoleCurrent")){\r
	414	AliInfo(Form("fDipoleCurrent found, but porting only average to the new object, since the other values are not available in the old object"));\r
	415	SetDipoleCurrent((Float_t)(((TObjString*)(mapGRP->GetValue("fDipoleCurrent")))->GetString()).Atof(),(Stats)0);\r
	416	} \r
	417	else { \r
	418	AliError(Form("No fDipoleCurrent value found in GRP map!"));\r
	419	}\r
	420	if(mapGRP->GetValue("fCavernTemperature")){\r
	421	AliInfo(Form("fCaverntemperature found, but porting only average to the new object, since the other values are not available in the old object"));\r
	422	SetCavernTemperature((Float_t)(((TObjString*)(mapGRP->GetValue("fCavernTemperature")))->GetString()).Atof(),(Stats)0);\r
	423	} \r
	424	else { \r
	425	AliError(Form("No fCavernTemperature value found in GRP map!"));\r
	426	}\r
39e3007b	427	if(mapGRP->GetValue("fCavernAtmosPressure")){\r
	428	AliInfo(Form("fCavernAtmosPressure found, but not ported to the new object since of a different type"));\r
	429	} \r
	430	else { \r
	431	AliError(Form("No fCavernAtmosPressure value found in GRP map!"));\r
	432	}\r
	433	if(mapGRP->GetValue("fP2Pressure")){\r
	434	SetSurfaceAtmosPressure((AliDCSSensor)((TObjString)(mapGRP->GetValue("fP2Pressure"))));\r
	435	}\r
	436	else { \r
	437	AliError(Form("No fP2Pressure value found in GRP map!"));\r
	438	}\r
	439	\r
	440	return;\r
	441	\r
	442	}\r