[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
29d11b68	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	}