[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 Double_t kCavernCut = 1.0;           // tolerable difference between cavern pressure sensors
const Double_t kSurfaceDifference = 4.5;   //  offset between surface and cavern pressure sensors
	
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;

}
//-------------------------------------------------------------------------------

Float_t AliGRPObject::GetBeamEnergy() const {

	//
	// Getting the energy
	// in case of BeamType = A-A, multiplying by 82/208 (for PbPb)
	//

	Float_t energy = fBeamEnergy;
	if (fBeamType=="A-A"){
		energy = energy*82./208;
	}
	return IsBeamEnergyIsSqrtSHalfGeV() ? energy : energy/2;
}

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

Double_t AliGRPObject::EvalCavernPressure(const TTimeStamp& time, Bool_t& inside) const { 
//
//  Return current pressure value from 'best' cavern sensor
//    (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
//     use sensor most compatible with surface sensor

  return EvalCavernPressure(fCavernAtmosPressure,fCavernAtmosPressure2,
             fSurfaceAtmosPressure,time,inside);
	     			
}

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

Double_t AliGRPObject::EvalCavernPressure(AliDCSSensor* cavern1, 
	              AliDCSSensor* cavern2, AliDCSSensor* surface, 
		      const TTimeStamp& time, Bool_t& inside)  {
//
//  Return current pressure value from 'best' cavern sensor
//    (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
//     use sensor most compatible with surface sensor

     
    Double_t valueSensor2 = cavern2->Eval(time,inside);
    Double_t valueSensor1 = cavern1->Eval(time,inside);
    if (TMath::Abs(valueSensor2-valueSensor1)<kCavernCut) {
        return valueSensor2;
    } else { 
        Double_t valueSurface = surface->Eval(time,inside);
        Double_t diff1 = TMath::Abs(valueSensor1-valueSurface-kSurfaceDifference);
        Double_t diff2 = TMath::Abs(valueSensor2-valueSurface-kSurfaceDifference);
	if (TMath::Abs(diff1)<TMath::Abs(diff2) ) {
	    return valueSensor1;
	} else {
	    return valueSensor2;
	}
     }
}

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

AliDCSSensor* AliGRPObject::GetBestCavernAtmosPressure(AliDCSSensor* cavern1, 
	     AliDCSSensor* cavern2, AliDCSSensor* surface, const TTimeStamp& time) {

//
//  Return pointer to 'best' cavern sensor
//    (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
//     use sensor most compatible with surface sensor
//    Pressure measuread at time specified by TTimestamp


    Bool_t inside; 
    Double_t valueSensor2 = cavern2->Eval(time,inside);
    Double_t valueSensor1 = cavern1->Eval(time,inside);
    if (TMath::Abs(valueSensor2-valueSensor1)<kCavernCut) {
        return cavern2;
    } else { 
        Double_t valueSurface = surface->Eval(time,inside);
        Double_t diff1 = TMath::Abs(valueSensor1-valueSurface-kSurfaceDifference);
        Double_t diff2 = TMath::Abs(valueSensor2-valueSurface-kSurfaceDifference);
	if (TMath::Abs(diff1)<TMath::Abs(diff2) ) {
	    return cavern1;
	} else {
	    return cavern2;
	}
     }
}

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

AliDCSSensor*   AliGRPObject::GetBestCavernAtmosPressure(const TTimeStamp& time) const {
//
//  Return pointer to 'best' cavern sensor
//    (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
//     use sensor most compatible with surface sensor
//    Pressure measuread at time specified by TTimestamp


   return GetBestCavernAtmosPressure(fCavernAtmosPressure,
        fCavernAtmosPressure2, fSurfaceAtmosPressure, time);

}
    
//-------------------------------------------------------------------------------

AliDCSSensor*   AliGRPObject::GetBestCavernAtmosPressure() const {
//
//  Return pointer to 'best' cavern sensor
//    (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
//     use sensor most compatible with surface sensor
//    Pressure measuread at start-of-run

   return GetBestCavernAtmosPressure(TTimeStamp(fTimeStart));
}
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)
de67dd6b	33
	34	const Double_t kCavernCut = 1.0; // tolerable difference between cavern pressure sensors
	35	const Double_t kSurfaceDifference = 4.5; // offset between surface and cavern pressure sensors
29d11b68	36
	37	const Float_t AliGRPObject::fgkInvalidFloat = 1E-33; // value to identify invalid data - float
	38	const TString AliGRPObject::fgkInvalidString = ""; // value to identify invalid data - string
	39	const Char_t AliGRPObject::fgkInvalidChar = -1; // value to identify invalid data - uchar
	40	const Int_t AliGRPObject::fgkInvalidInt = -1; // value to identify invalid data - uint
	41	const Int_t AliGRPObject::fgkInvalidUInt = 0; // value to identify invalid data - uint
	42	const Int_t AliGRPObject::fgknDCSDPHallProbes = 40; // number of dcs dps
	43	const char* AliGRPObject::fgkDCSDataPointsHallProbes[AliGRPObject::fgknDCSDPHallProbes] = {
	44	"L3_BSF17_H1",
	45	"L3_BSF17_H2",
	46	"L3_BSF17_H3",
	47	"L3_BSF17_Temperature",
	48	"L3_BSF4_H1",
	49	"L3_BSF4_H2",
	50	"L3_BSF4_H3",
	51	"L3_BSF4_Temperature",
	52	"L3_BKF17_H1",
	53	"L3_BKF17_H2",
	54	"L3_BKF17_H3",
	55	"L3_BKF17_Temperature",
	56	"L3_BKF4_H1",
	57	"L3_BKF4_H2",
	58	"L3_BKF4_H3",
	59	"L3_BKF4_Temperature",
	60	"L3_BSF13_H1",
	61	"L3_BSF13_H2",
	62	"L3_BSF13_H3",
	63	"L3_BSF13_Temperature",
	64	"L3_BSF8_H1",
	65	"L3_BSF8_H2",
	66	"L3_BSF8_H3",
	67	"L3_BSF8_Temperature",
	68	"L3_BKF13_H1",
	69	"L3_BKF13_H2",
	70	"L3_BKF13_H3",
	71	"L3_BKF13_Temperature",
	72	"L3_BKF8_H1",
	73	"L3_BKF8_H2",
	74	"L3_BKF8_H3",
	75	"L3_BKF8_Temperature",
	76	"Dipole_Inside_H1",
	77	"Dipole_Inside_H2",
	78	"Dipole_Inside_H3",
	79	"Dipole_Inside_Temperature",
	80	"Dipole_Outside_H1",
	81	"Dipole_Outside_H2",
	82	"Dipole_Outside_H3",
	83	"Dipole_Outside_Temperature",
	84	};
	85
	86	//-----------------------------------------------------------------------------
	87	AliGRPObject::AliGRPObject():
	88	TObject(),
	89	fPoints(5),
	90	fDimension(0),
	91	fTimeStart((time_t)fgkInvalidFloat),
	92	fTimeEnd((time_t)fgkInvalidFloat),
	93	fBeamEnergy(fgkInvalidFloat),
	94	fBeamType(fgkInvalidString),
	95	fNumberOfDetectors(fgkInvalidChar),
	96	fDetectorMask(fgkInvalidUInt),
	97	fLHCPeriod(fgkInvalidString),
	98	fRunType(fgkInvalidString),
	99	fLHCState(fgkInvalidString),
100	fL3Polarity(fgkInvalidChar),
101	fDipolePolarity(fgkInvalidChar),
102	fL3Current(new Float_t[fPoints]),
103	fDipoleCurrent(new Float_t[fPoints]),
104	fCavernTemperature(new Float_t[fPoints]),
105	fCavernAtmosPressure(0x0),
106	fCavernAtmosPressure2(0x0),
107	fSurfaceAtmosPressure(0x0),
108	fHallProbes(0x0),
109	fMachineMode(fgkInvalidString),
110	fLHCStateArray(0x0),
111	fMachineModeArray(0x0),
112	fMaxTimeLHCValidity(0)
113	{
114
115	//
116	// AliGRPObject default ctor
117	//
118
119	fDimension = fgknDCSDPHallProbes*fPoints;
120	fHallProbes = new Float_t[fDimension];
121
122	for (Int_t nhp=0; nhp< fDimension; nhp++){ // setting to zero values for non working HP
123	if ((nhp >= 0 && nhp <= 1*fPoints-1) \|\| // L3_BSF17_H1
124	(nhp >= 1fPoints && nhp <= 2fPoints-1) \|\| // L3_BSF17_H2
125	(nhp >= 2fPoints && nhp <= 3fPoints-1) \|\| // L3_BSF17_H3
126	(nhp >= 3fPoints && nhp <= 4fPoints-1) \|\| // L3_BSF17_Temperature
127	(nhp >= 6fPoints && nhp <= 7fPoints-1) ) { // L3_BSF4_H3
128	fHallProbes[nhp] = 0; // setting to zero values for non working HP
129	AliDebug(2,Form("setting hp[%d] to zero = %f",
130	nhp, fHallProbes[nhp]));
131	}
132	else {
133	fHallProbes[nhp] = fgkInvalidFloat;
134	}
135	}
136
137
138	for (Int_t i = 0; i < fPoints; i++){
139
140	fL3Current[i] = fgkInvalidFloat;
141	fDipoleCurrent[i] = fgkInvalidFloat;
142	fCavernTemperature[i] = fgkInvalidFloat;
143	}
144	}
145
146	//-----------------------------------------------------------------------------
147
148	AliGRPObject::AliGRPObject(const AliGRPObject &obj):
149	TObject(obj),
150	fPoints(obj.fPoints),
151	fDimension(obj.fDimension),
152	fTimeStart(obj.fTimeStart),
153	fTimeEnd(obj.fTimeEnd),
154	fBeamEnergy(obj.fBeamEnergy),
155	fBeamType(obj.fBeamType),
156	fNumberOfDetectors(obj.fNumberOfDetectors),
157	fDetectorMask(obj.fDetectorMask),
158	fLHCPeriod(obj.fLHCPeriod),
159	fRunType(obj.fRunType),
160	fLHCState(obj.fLHCState),
161	fL3Polarity(obj.fL3Polarity),
162	fDipolePolarity(obj.fDipolePolarity),
163	fL3Current(new Float_t[fPoints]),
164	fDipoleCurrent(new Float_t[fPoints]),
165	fCavernTemperature(new Float_t[fPoints]),
166	fCavernAtmosPressure(obj.fCavernAtmosPressure),
167	fCavernAtmosPressure2(obj.fCavernAtmosPressure2),
168	fSurfaceAtmosPressure(obj.fSurfaceAtmosPressure),
169	fHallProbes(0x0),
170	fMachineMode(obj.fMachineMode),
171	fLHCStateArray(obj.fLHCStateArray),
172	fMachineModeArray(obj.fMachineModeArray),
173	fMaxTimeLHCValidity(obj.fMaxTimeLHCValidity)
174
175	{
176
177	//
178	// AliGRPObject copy ctor
179	//
180
181	fHallProbes = new Float_t[fDimension];
182
183	for (Int_t nhp=0; nhp< fDimension; nhp++){
184	fHallProbes[nhp] = obj.fHallProbes[nhp];
185	}
186
187	for (Int_t i = 0; i < fPoints; i++){
188
189	fL3Current[i] = obj.fL3Current[i];
190	fDipoleCurrent[i] = obj.fDipoleCurrent[i];
191	fCavernTemperature[i] = obj.fCavernTemperature[i];
192	}
193	}
194
195	//-----------------------------------------------------------------------------
196
197	AliGRPObject& AliGRPObject:: operator=(const AliGRPObject & obj)
198	{
199
200	//
201	// AliGRPObject assignment operator
202	//
203
204	if (&obj == this) return *this;
205
206	TObject::operator=(obj);
207	this->fTimeStart = obj.GetTimeStart();
208	this->fTimeEnd = obj.GetTimeEnd();
209	this->fBeamEnergy = obj.GetBeamEnergy();
210	this->fBeamType = obj.GetBeamType();
211	this->fNumberOfDetectors = obj.GetNumberOfDetectors();
212	this->fDetectorMask = obj.GetDetectorMask();
213	this->fLHCPeriod = obj.GetLHCPeriod();
214	this->fRunType = obj.GetRunType();
215	this->fLHCState = obj.GetLHCState();
216	this->fL3Polarity = obj.GetL3Polarity();
217	this->fDipolePolarity = obj.GetDipolePolarity();
218	this->fCavernAtmosPressure = obj.GetCavernAtmosPressure();
219	this->fCavernAtmosPressure2 = obj.GetCavernAtmosPressure2();
220	this->fSurfaceAtmosPressure = obj.GetSurfaceAtmosPressure();
221	this->fPoints = obj.GetPoints();
222	this->fDimension = obj.GetDimension();
223
224	this->fL3Current = new Float_t[fPoints];
225	this->fDipoleCurrent = new Float_t[fPoints];
226	this->fCavernTemperature = new Float_t[fPoints];
227
228	if (this->fHallProbes==NULL) this->fHallProbes = new Float_t[this->fDimension];
229	for (Int_t nhp=0; nhp< fDimension; nhp++){
230	this->fHallProbes[nhp] = obj.GetHallProbes(nhp);
231
232	}
233	for (Int_t i = 0; i < fPoints; i++){
234
235	this->fL3Current[i] = obj.GetL3Current((Stats)i);
236	this->fDipoleCurrent[i] = obj.GetDipoleCurrent((Stats)i);
237	this->fCavernTemperature[i] = obj.GetCavernTemperature((Stats)i);
238	}
239
240	this->fMachineMode = obj.fMachineMode;
241	this->fLHCStateArray = obj.fLHCStateArray;
242	this->fMachineModeArray = obj.fMachineModeArray;
243	this->fMaxTimeLHCValidity = obj.fMaxTimeLHCValidity;
244	return *this;
245	}
246
247	//-----------------------------------------------------------------------------
248
249	AliGRPObject::~AliGRPObject() {
250
251	//
252	// dtor
253	//
254
255
256	delete [] fHallProbes;
257	delete [] fL3Current;
258	delete [] fDipoleCurrent;
259	delete [] fCavernTemperature;
260
261	if (fCavernAtmosPressure){
262	delete fCavernAtmosPressure;
263	fCavernAtmosPressure = 0x0;
264	}
265	if (fCavernAtmosPressure2){
266	delete fCavernAtmosPressure2;
267	fCavernAtmosPressure2 = 0x0;
268	}
269	if (fSurfaceAtmosPressure){
270	delete fSurfaceAtmosPressure;
271	fSurfaceAtmosPressure = 0x0;
272	}
273	if (fLHCStateArray){
274	delete fLHCStateArray;
275	fLHCStateArray = 0x0;
276	}
277	if (fMachineModeArray){
278	delete fMachineModeArray;
279	fMachineModeArray = 0x0;
280	}
281	}
282
283	//-----------------------------------------------------------------------------
284	Float_t* AliGRPObject::GetHallProbesArray(DP_HallProbes hp) const {
285
286	//
287	// method to return array of statistical
288	// variables for Hall Probe hp
289	//
290
291	Float_t* array = new Float_t[fPoints];
292	Int_t shift = fPoints*(Int_t)hp;
293	for (Int_t i=0;i<fPoints; i++){
294
295	array[i] = fHallProbes[shift+i];
296
297	}
298
299	return array;
300	}
301	//-------------------------------------------------------------------------------
302
303	void AliGRPObject::SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe){
304
305	//
306	// method to set hall probe hp
307	// from a given array
308	//
309
310	Int_t shift = fPoints*hp;
311	for (Int_t i = 0; i< fPoints; i++){
312
313	fHallProbes[i+shift] = hall_probe[i];
314	}
315	return;
316	}
317
318	//-------------------------------------------------------------------------------
319
320	void AliGRPObject::ReadValuesFromMap(const TMap* mapGRP){
321
322	//
323	// method to set the values of the GRP parameters
324	// reading them from the old format of the GRP
325	// object, i.e. a TMap
326	//
327
328	if (mapGRP->GetValue("fAliceStartTime")){
329	SetTimeStart((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStartTime")))->GetString()).Atoi());
330	}
331	else {
332	AliError(Form("No fAliceStartTime value found in GRP map!"));
333	}
334	if (mapGRP->GetValue("fAliceStopTime")){
335	SetTimeEnd((time_t)(((TObjString*)(mapGRP->GetValue("fAliceStopTime")))->GetString()).Atoi());
336	}
337
338	else {
339	AliError(Form("No fAliceStopTime value found in GRP map!"));
340	}
341
342	if(mapGRP->GetValue("fAliceBeamEnergy")){
343	double be = (((TObjString*)(mapGRP->GetValue("fAliceBeamEnergy")))->GetString()).Atof();
344	if (IsBeamEnergyIsSqrtSHalfGeV()) be/=2; // old format was storig sqrt(s)
345	SetBeamEnergy(be);
346	}
347	else {
348	AliError(Form("No fAliceBeamEnergy value found in GRP map!"));
349	}
350	if(mapGRP->GetValue("fAliceBeamType")){
351	SetBeamType(((TObjString*)(mapGRP->GetValue("fAliceBeamType")))->GetString());
352	}
353	else {
354	AliError(Form("No fAliceBeamType value found in GRP map!"));
355	}
356	if(mapGRP->GetValue("fNumberOfDetectors")){
357	SetNumberOfDetectors((Char_t)(((TObjString*)(mapGRP->GetValue("fNumberOfDetectors")))->GetString()).Atoi());
358	}
359	else {
360	AliError(Form("No fNumberOfDetectors value found in GRP map!"));
361	}
362	if(mapGRP->GetValue("fDetectorMask")){
363	SetDetectorMask((UInt_t)(((TObjString*)(mapGRP->GetValue("fDetectorMask")))->GetString()).Atoi());
364	}
365	else {
366	AliError(Form("No fDetectorMask value found in GRP map!"));
367	}
368	if(mapGRP->GetValue("fLHCPeriod")){
369	SetLHCPeriod(((TObjString*)(mapGRP->GetValue("fLHCPeriod")))->GetString());
370	}
371	else {
372	AliError(Form("No fLHCPeriod value found in GRP map!"));
373	}
374	if(mapGRP->GetValue("fRunType")){
375	SetRunType(((TObjString*)(mapGRP->GetValue("fRunType")))->GetString());
376	}
377	else {
378	AliError(Form("No fRunType value found in GRP map!"));
379	}
380	if(mapGRP->GetValue("fLHCState")){
381	SetLHCState(((TObjString*)(mapGRP->GetValue("fLHCState")))->GetString());
382	}
383	else {
384	AliError(Form("No fLHCState value found in GRP map!"));
385	}
386	if(mapGRP->GetValue("fLHCluminosity")){
387	AliInfo(Form("fLHCLuminosity found, but not there anymore in the new object"));
388	}
389	else {
390	AliError(Form("No fLHCLuminosity value found in GRP map!"));
391	}
392	if(mapGRP->GetValue("fBeamIntensity")){
393	AliInfo(Form("fBeamIntensity found, but not there anymore in the new object"));
394	}
395	else {
396	AliError(Form("No fBeamIntensity value found in GRP map!"));
397	}
398	if(mapGRP->GetValue("fL3Polarity")){
399	SetL3Polarity((Char_t)(((TObjString*)(mapGRP->GetValue("fL3Polarity")))->GetString()).Atoi());
400	}
401	else {
402	AliError(Form("No fL3Polarity value found in GRP map!"));
403	}
404	if(mapGRP->GetValue("fDipolePolarity")){
405	SetDipolePolarity((Char_t)(((TObjString*)(mapGRP->GetValue("fDipolePolarity")))->GetString()).Atoi());
406	}
407	else {
408	AliError(Form("No fDipolePolarity value found in GRP map!"));
409	}
410	if(mapGRP->GetValue("fL3Current")){
411	AliInfo(Form("fL3Current found, but porting only average to the new object, since the other values are not available in the old object"));
412	SetL3Current((Float_t)(((TObjString*)(mapGRP->GetValue("fL3Current")))->GetString()).Atof(),(Stats)0);
413	}
414	else {
415	AliError(Form("No fL3Current value found in GRP map!"));
416	}
417	if(mapGRP->GetValue("fDipoleCurrent")){
418	AliInfo(Form("fDipoleCurrent found, but porting only average to the new object, since the other values are not available in the old object"));
419	SetDipoleCurrent((Float_t)(((TObjString*)(mapGRP->GetValue("fDipoleCurrent")))->GetString()).Atof(),(Stats)0);
420	}
421	else {
422	AliError(Form("No fDipoleCurrent value found in GRP map!"));
423	}
424	if(mapGRP->GetValue("fCavernTemperature")){
425	AliInfo(Form("fCaverntemperature found, but porting only average to the new object, since the other values are not available in the old object"));
426	SetCavernTemperature((Float_t)(((TObjString*)(mapGRP->GetValue("fCavernTemperature")))->GetString()).Atof(),(Stats)0);
427	}
428	else {
429	AliError(Form("No fCavernTemperature value found in GRP map!"));
430	}
431	if(mapGRP->GetValue("fCavernAtmosPressure")){
432	AliInfo(Form("fCavernAtmosPressure found, but not ported to the new object since of a different type"));
433	}
434	else {
435	AliError(Form("No fCavernAtmosPressure value found in GRP map!"));
436	}
437	if(mapGRP->GetValue("fP2Pressure")){
438	SetSurfaceAtmosPressure((AliDCSSensor)((TObjString)(mapGRP->GetValue("fP2Pressure"))));
439	}
440	else {
441	AliError(Form("No fP2Pressure value found in GRP map!"));
442	}
443
444	return;
445
446	}
549ab3c2	447	//-------------------------------------------------------------------------------
	448
	449	Float_t AliGRPObject::GetBeamEnergy() const {
	450
	451	//
	452	// Getting the energy
	453	// in case of BeamType = A-A, multiplying by 82/208 (for PbPb)
	454	//
	455
	456	Float_t energy = fBeamEnergy;
	457	if (fBeamType=="A-A"){
	458	energy = energy*82./208;
	459	}
	460	return IsBeamEnergyIsSqrtSHalfGeV() ? energy : energy/2;
	461	}
de67dd6b	462
	463	//-------------------------------------------------------------------------------
	464
	465	Double_t AliGRPObject::EvalCavernPressure(const TTimeStamp& time, Bool_t& inside) const {
	466	//
	467	// Return current pressure value from 'best' cavern sensor
	468	// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
	469	// use sensor most compatible with surface sensor
	470
	471	return EvalCavernPressure(fCavernAtmosPressure,fCavernAtmosPressure2,
	472	fSurfaceAtmosPressure,time,inside);
	473
	474	}
	475
	476	//-------------------------------------------------------------------------------
	477
	478	Double_t AliGRPObject::EvalCavernPressure(AliDCSSensor* cavern1,
	479	AliDCSSensor* cavern2, AliDCSSensor* surface,
	480	const TTimeStamp& time, Bool_t& inside) {
	481	//
	482	// Return current pressure value from 'best' cavern sensor
	483	// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
	484	// use sensor most compatible with surface sensor
	485
	486
	487	Double_t valueSensor2 = cavern2->Eval(time,inside);
	488	Double_t valueSensor1 = cavern1->Eval(time,inside);
	489	if (TMath::Abs(valueSensor2-valueSensor1)<kCavernCut) {
	490	return valueSensor2;
	491	} else {
	492	Double_t valueSurface = surface->Eval(time,inside);
	493	Double_t diff1 = TMath::Abs(valueSensor1-valueSurface-kSurfaceDifference);
	494	Double_t diff2 = TMath::Abs(valueSensor2-valueSurface-kSurfaceDifference);
	495	if (TMath::Abs(diff1)<TMath::Abs(diff2) ) {
	496	return valueSensor1;
	497	} else {
	498	return valueSensor2;
	499	}
	500	}
	501	}
	502
	503	//-------------------------------------------------------------------------------
	504
	505	AliDCSSensor* AliGRPObject::GetBestCavernAtmosPressure(AliDCSSensor* cavern1,
	506	AliDCSSensor* cavern2, AliDCSSensor* surface, const TTimeStamp& time) {
	507
	508	//
	509	// Return pointer to 'best' cavern sensor
	510	// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
	511	// use sensor most compatible with surface sensor
	512	// Pressure measuread at time specified by TTimestamp
	513
	514
	515	Bool_t inside;
	516	Double_t valueSensor2 = cavern2->Eval(time,inside);
	517	Double_t valueSensor1 = cavern1->Eval(time,inside);
	518	if (TMath::Abs(valueSensor2-valueSensor1)<kCavernCut) {
	519	return cavern2;
	520	} else {
	521	Double_t valueSurface = surface->Eval(time,inside);
	522	Double_t diff1 = TMath::Abs(valueSensor1-valueSurface-kSurfaceDifference);
	523	Double_t diff2 = TMath::Abs(valueSensor2-valueSurface-kSurfaceDifference);
	524	if (TMath::Abs(diff1)<TMath::Abs(diff2) ) {
	525	return cavern1;
526	} else {
527	return cavern2;
528	}
529	}
530	}
531
532	//-------------------------------------------------------------------------------
533
534	AliDCSSensor* AliGRPObject::GetBestCavernAtmosPressure(const TTimeStamp& time) const {
535	//
536	// Return pointer to 'best' cavern sensor
537	// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
538	// use sensor most compatible with surface sensor
539	// Pressure measuread at time specified by TTimestamp
540
541
542	return GetBestCavernAtmosPressure(fCavernAtmosPressure,
543	fCavernAtmosPressure2, fSurfaceAtmosPressure, time);
544
545	}
546
547	//-------------------------------------------------------------------------------
548
549	AliDCSSensor* AliGRPObject::GetBestCavernAtmosPressure() const {
550	//
551	// Return pointer to 'best' cavern sensor
552	// (default sensor 2. If sensor 1 and sensor 2 are sufficiently different,
553	// use sensor most compatible with surface sensor
554	// Pressure measuread at start-of-run
555
556	return GetBestCavernAtmosPressure(TTimeStamp(fTimeStart));
557	}
558