[u/mrichter/AliRoot.git] / STEER / AliGRPObject.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.                  *
 **************************************************************************/

/* $Id$ */

// **********************
// Class containing the GRP data that have to be stored in the OCDB.
// Data come either from DAQ logbook or from DCS DB.
// Processing of the data can also be performed here.
// **********************

#include <TMap.h>
#include <TObject.h>
#include <TObjString.h>

#include "AliGRPObject.h"
#include "AliDCSSensor.h"
#include "AliLog.h"

ClassImp(AliGRPObject)
	
const Float_t AliGRPObject::fgkInvalidFloat = 1E-33; // value to identify invalid data - float
const TString AliGRPObject::fgkInvalidString = "";  // value to identify invalid data - string
const Char_t AliGRPObject::fgkInvalidChar = -1;         // value to identify invalid data - uchar
const Int_t AliGRPObject::fgkInvalidInt = -1;  // value to identify invalid data - uint
const Int_t AliGRPObject::fgkInvalidUInt = 0;  // value to identify invalid data - uint
const Int_t AliGRPObject::fgknDCSDPHallProbes = 40;   // number of dcs dps
const char* AliGRPObject::fgkDCSDataPointsHallProbes[AliGRPObject::fgknDCSDPHallProbes] = {
		   "L3_BSF17_H1",
		   "L3_BSF17_H2",
		   "L3_BSF17_H3",
		   "L3_BSF17_Temperature",
		   "L3_BSF4_H1",
		   "L3_BSF4_H2",
		   "L3_BSF4_H3",
		   "L3_BSF4_Temperature",
		   "L3_BKF17_H1",
		   "L3_BKF17_H2",
		   "L3_BKF17_H3",
		   "L3_BKF17_Temperature",
		   "L3_BKF4_H1",
		   "L3_BKF4_H2",
		   "L3_BKF4_H3",
		   "L3_BKF4_Temperature",
		   "L3_BSF13_H1",
		   "L3_BSF13_H2",
		   "L3_BSF13_H3",
		   "L3_BSF13_Temperature",
		   "L3_BSF8_H1",
		   "L3_BSF8_H2",
		   "L3_BSF8_H3",
		   "L3_BSF8_Temperature",
		   "L3_BKF13_H1",
		   "L3_BKF13_H2",
		   "L3_BKF13_H3",
		   "L3_BKF13_Temperature",
		   "L3_BKF8_H1",
		   "L3_BKF8_H2",
		   "L3_BKF8_H3",
		   "L3_BKF8_Temperature",
		   "Dipole_Inside_H1",
		   "Dipole_Inside_H2",
		   "Dipole_Inside_H3",
		   "Dipole_Inside_Temperature",
		   "Dipole_Outside_H1",
		   "Dipole_Outside_H2",
		   "Dipole_Outside_H3",
		   "Dipole_Outside_Temperature",
                 };

//-----------------------------------------------------------------------------
AliGRPObject::AliGRPObject():
	TObject(),
	fPoints(5),
	fDimension(0),
	fTimeStart((time_t)fgkInvalidFloat),
	fTimeEnd((time_t)fgkInvalidFloat),
	fBeamEnergy(fgkInvalidFloat),
	fBeamType(fgkInvalidString),
	fNumberOfDetectors(fgkInvalidChar),
	fDetectorMask(fgkInvalidUInt),
	fLHCPeriod(fgkInvalidString),
	fRunType(fgkInvalidString),
	fLHCState(fgkInvalidString),
	fL3Polarity(fgkInvalidChar),
	fDipolePolarity(fgkInvalidChar),
	fL3Current(new Float_t[fPoints]),
	fDipoleCurrent(new Float_t[fPoints]),
	fCavernTemperature(new Float_t[fPoints]),
	fCavernAtmosPressure(0x0),
	fCavernAtmosPressure2(0x0),
	fSurfaceAtmosPressure(0x0),
	fHallProbes(0x0),
	fMachineMode(fgkInvalidString),
	fLHCStateArray(0x0),
	fMachineModeArray(0x0),
	fMaxTimeLHCValidity(0)
{

	//
	// AliGRPObject default ctor
	//

	fDimension = fgknDCSDPHallProbes*fPoints;
	fHallProbes = new Float_t[fDimension];

	for (Int_t nhp=0; nhp< fDimension; nhp++){ // setting to zero values for non working HP 
		if ((nhp >= 0 && nhp <= 1*fPoints-1) || // L3_BSF17_H1
		    (nhp >= 1*fPoints && nhp <= 2*fPoints-1) || // L3_BSF17_H2
		    (nhp >= 2*fPoints && nhp <= 3*fPoints-1) || // L3_BSF17_H3
                    (nhp >= 3*fPoints && nhp <= 4*fPoints-1) || // L3_BSF17_Temperature
                    (nhp >= 6*fPoints && nhp <= 7*fPoints-1) ) { // L3_BSF4_H3
			fHallProbes[nhp] = 0; // setting to zero values for non working HP 
			AliDebug(2,Form("setting hp[%d] to zero = %f", 
nhp, fHallProbes[nhp]));
		}
		else {
			fHallProbes[nhp] = fgkInvalidFloat;
		}
	}


	for (Int_t i = 0; i < fPoints; i++){

		fL3Current[i] = fgkInvalidFloat;
		fDipoleCurrent[i] = fgkInvalidFloat;
		fCavernTemperature[i] = fgkInvalidFloat;
	}
}

//-----------------------------------------------------------------------------

AliGRPObject::AliGRPObject(const AliGRPObject &obj):
	TObject(obj),
	fPoints(obj.fPoints),
	fDimension(obj.fDimension),
	fTimeStart(obj.fTimeStart),
	fTimeEnd(obj.fTimeEnd),
	fBeamEnergy(obj.fBeamEnergy),
	fBeamType(obj.fBeamType),
	fNumberOfDetectors(obj.fNumberOfDetectors),
	fDetectorMask(obj.fDetectorMask),
	fLHCPeriod(obj.fLHCPeriod),
	fRunType(obj.fRunType),
	fLHCState(obj.fLHCState),
	fL3Polarity(obj.fL3Polarity),
	fDipolePolarity(obj.fDipolePolarity),
	fL3Current(new Float_t[fPoints]),
	fDipoleCurrent(new Float_t[fPoints]),
	fCavernTemperature(new Float_t[fPoints]),
	fCavernAtmosPressure(obj.fCavernAtmosPressure),
	fCavernAtmosPressure2(obj.fCavernAtmosPressure2),
	fSurfaceAtmosPressure(obj.fSurfaceAtmosPressure),
	fHallProbes(0x0),
	fMachineMode(obj.fMachineMode),
	fLHCStateArray(obj.fLHCStateArray),
	fMachineModeArray(obj.fMachineModeArray),
	fMaxTimeLHCValidity(obj.fMaxTimeLHCValidity)

{

	//
	// AliGRPObject copy ctor
	//

	fHallProbes = new Float_t[fDimension]; 

	for (Int_t nhp=0; nhp< fDimension; nhp++){
		fHallProbes[nhp] = obj.fHallProbes[nhp];
	}

	for (Int_t i = 0; i < fPoints; i++){

		fL3Current[i] = obj.fL3Current[i];
		fDipoleCurrent[i] = obj.fDipoleCurrent[i];
		fCavernTemperature[i] = obj.fCavernTemperature[i];
	}
}

//-----------------------------------------------------------------------------

AliGRPObject& AliGRPObject:: operator=(const AliGRPObject & obj) 
{

	//
	// AliGRPObject assignment operator
	//

	if (&obj == this) return *this; 

	TObject::operator=(obj);
	this->fTimeStart = obj.GetTimeStart();
	this->fTimeEnd = obj.GetTimeEnd();
	this->fBeamEnergy = obj.GetBeamEnergy();
	this->fBeamType = obj.GetBeamType();
	this->fNumberOfDetectors = obj.GetNumberOfDetectors();
	this->fDetectorMask = obj.GetDetectorMask();
	this->fLHCPeriod = obj.GetLHCPeriod();
	this->fRunType = obj.GetRunType();
	this->fLHCState = obj.GetLHCState();
	this->fL3Polarity = obj.GetL3Polarity();
	this->fDipolePolarity = obj.GetDipolePolarity();
	this->fCavernAtmosPressure = obj.GetCavernAtmosPressure();
	this->fCavernAtmosPressure2 = obj.GetCavernAtmosPressure2();
	this->fSurfaceAtmosPressure = obj.GetSurfaceAtmosPressure();
	this->fPoints = obj.GetPoints();
	this->fDimension = obj.GetDimension();

	this->fL3Current = new Float_t[fPoints];
	this->fDipoleCurrent = new Float_t[fPoints];
	this->fCavernTemperature = new Float_t[fPoints];
	
	if (this->fHallProbes==NULL) this->fHallProbes = new Float_t[this->fDimension]; 
	for (Int_t nhp=0; nhp< fDimension; nhp++){
		this->fHallProbes[nhp] = obj.GetHallProbes(nhp);

	}
	for (Int_t i = 0; i < fPoints; i++){

		this->fL3Current[i] = obj.GetL3Current((Stats)i);
		this->fDipoleCurrent[i] = obj.GetDipoleCurrent((Stats)i);
		this->fCavernTemperature[i] = obj.GetCavernTemperature((Stats)i);
	}

	this->fMachineMode = obj.fMachineMode;
	this->fLHCStateArray = obj.fLHCStateArray;
	this->fMachineModeArray = obj.fMachineModeArray;
	this->fMaxTimeLHCValidity = obj.fMaxTimeLHCValidity;
	return *this;
}

//-----------------------------------------------------------------------------

AliGRPObject::~AliGRPObject() {

	//
	// dtor
	//

	
	delete [] fHallProbes;
	delete [] fL3Current;
	delete [] fDipoleCurrent;
	delete [] fCavernTemperature;

	if (fCavernAtmosPressure){
		delete fCavernAtmosPressure;
		fCavernAtmosPressure = 0x0;
	}
	if (fCavernAtmosPressure2){
		delete fCavernAtmosPressure2;
		fCavernAtmosPressure2 = 0x0;
	}
	if (fSurfaceAtmosPressure){
		delete fSurfaceAtmosPressure;
		fSurfaceAtmosPressure = 0x0;
	}
	if (fLHCStateArray){
		delete fLHCStateArray;
		fLHCStateArray = 0x0;
	}
	if (fMachineModeArray){
		delete fMachineModeArray;
		fMachineModeArray = 0x0;
	}
}

//-----------------------------------------------------------------------------
Float_t* AliGRPObject::GetHallProbesArray(DP_HallProbes hp) const {

	//
	// method to return array of statistical
        // variables for Hall Probe hp
	//

	Float_t* array = new Float_t[fPoints];
	Int_t shift = fPoints*(Int_t)hp; 
	for (Int_t i=0;i<fPoints; i++){

		array[i] = fHallProbes[shift+i];

	}

	return array;
}
//-------------------------------------------------------------------------------

void AliGRPObject::SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe){

	//
	// method to set hall probe hp 
	// from a given array
	//

	Int_t shift = fPoints*hp;
	for (Int_t i = 0; i< fPoints; i++){

		fHallProbes[i+shift] =  hall_probe[i];
	}
	return;
}

//-------------------------------------------------------------------------------

void AliGRPObject::ReadValuesFromMap(const TMap* mapGRP){

	//
	// method to set the values of the GRP parameters 
	// reading them from the old format of the GRP 
	// object, i.e. a TMap
	//

	if (mapGRP->GetValue("fAliceStartTime")){
		SetTimeStart((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStartTime")))->GetString()).Atoi());
	}
	else {
		AliError(Form("No fAliceStartTime value found in GRP map!"));
	}
	if (mapGRP->GetValue("fAliceStopTime")){
		SetTimeEnd((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStopTime")))->GetString()).Atoi());
	}
	
	else { 
		AliError(Form("No fAliceStopTime value found in GRP map!"));
	}

	if(mapGRP->GetValue("fAliceBeamEnergy")){
	  double be = (((TObjString*)(mapGRP->GetValue("fAliceBeamEnergy")))->GetString()).Atof();
	  if (IsBeamEnergyIsSqrtSHalfGeV()) be/=2;   // old format was storig sqrt(s)
	  SetBeamEnergy(be);
	}
	else { 
		AliError(Form("No fAliceBeamEnergy value found in GRP map!"));
	}
	if(mapGRP->GetValue("fAliceBeamType")){
		SetBeamType(((TObjString*)(mapGRP->GetValue("fAliceBeamType")))->GetString());
	}
	else { 
		AliError(Form("No fAliceBeamType value found in GRP map!"));
	}
	if(mapGRP->GetValue("fNumberOfDetectors")){
		SetNumberOfDetectors((Char_t)(((TObjString*)(mapGRP->GetValue("fNumberOfDetectors")))->GetString()).Atoi()); 
	}
	else { 
		AliError(Form("No fNumberOfDetectors value found in GRP map!"));
	}
	if(mapGRP->GetValue("fDetectorMask")){
		SetDetectorMask((UInt_t)(((TObjString*)(mapGRP->GetValue("fDetectorMask")))->GetString()).Atoi());  
	}
	else { 
		AliError(Form("No fDetectorMask value found in GRP map!"));
	}
	if(mapGRP->GetValue("fLHCPeriod")){
		SetLHCPeriod(((TObjString*)(mapGRP->GetValue("fLHCPeriod")))->GetString());
	}
	else { 
		AliError(Form("No fLHCPeriod value found in GRP map!"));
	}
	if(mapGRP->GetValue("fRunType")){
		SetRunType(((TObjString*)(mapGRP->GetValue("fRunType")))->GetString());
	}
	else { 
		AliError(Form("No fRunType value found in GRP map!"));
	}
	if(mapGRP->GetValue("fLHCState")){
		SetLHCState(((TObjString*)(mapGRP->GetValue("fLHCState")))->GetString());
	}
	else { 
		AliError(Form("No fLHCState value found in GRP map!"));
	}
	if(mapGRP->GetValue("fLHCluminosity")){
		AliInfo(Form("fLHCLuminosity found, but not there anymore in the new object"));
	}	
	else { 
		AliError(Form("No fLHCLuminosity value found in GRP map!"));
	}
	if(mapGRP->GetValue("fBeamIntensity")){
		AliInfo(Form("fBeamIntensity found, but not there anymore in the new object"));
	}	
	else { 
		AliError(Form("No fBeamIntensity value found in GRP map!"));
	}
	if(mapGRP->GetValue("fL3Polarity")){
		SetL3Polarity((Char_t)(((TObjString*)(mapGRP->GetValue("fL3Polarity")))->GetString()).Atoi());
	}	
	else { 
		AliError(Form("No fL3Polarity value found in GRP map!"));
	}
	if(mapGRP->GetValue("fDipolePolarity")){
		SetDipolePolarity((Char_t)(((TObjString*)(mapGRP->GetValue("fDipolePolarity")))->GetString()).Atoi());  
	}	
	else { 
		AliError(Form("No fDipolePolarity value found in GRP map!"));
	}
	if(mapGRP->GetValue("fL3Current")){
		AliInfo(Form("fL3Current found, but porting only average to the new object, since the other values are not available in the old object"));
		SetL3Current((Float_t)(((TObjString*)(mapGRP->GetValue("fL3Current")))->GetString()).Atof(),(Stats)0);
	}	
	else { 
		AliError(Form("No fL3Current value found in GRP map!"));
	}
	if(mapGRP->GetValue("fDipoleCurrent")){
		AliInfo(Form("fDipoleCurrent found, but porting only average to the new object, since the other values are not available in the old object"));
		SetDipoleCurrent((Float_t)(((TObjString*)(mapGRP->GetValue("fDipoleCurrent")))->GetString()).Atof(),(Stats)0);
	}	
	else { 
		AliError(Form("No fDipoleCurrent value found in GRP map!"));
	}
	if(mapGRP->GetValue("fCavernTemperature")){
		AliInfo(Form("fCaverntemperature found, but porting only average to the new object, since the other values are not available in the old object"));
		SetCavernTemperature((Float_t)(((TObjString*)(mapGRP->GetValue("fCavernTemperature")))->GetString()).Atof(),(Stats)0);
	}	
	else { 
		AliError(Form("No fCavernTemperature value found in GRP map!"));
	}
	if(mapGRP->GetValue("fCavernAtmosPressure")){
		AliInfo(Form("fCavernAtmosPressure found, but not ported to the new object since of a different type"));
	}	
	else { 
		AliError(Form("No fCavernAtmosPressure value found in GRP map!"));
	}
	if(mapGRP->GetValue("fP2Pressure")){
		SetSurfaceAtmosPressure((AliDCSSensor*)((TObjString*)(mapGRP->GetValue("fP2Pressure"))));
	}
	else { 
		AliError(Form("No fP2Pressure value found in GRP map!"));
	}
	
	return;

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