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

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// AliGRPManager class                                                    //
// The class can be used in order to access and read the Global Run       //
// Parameters entry from OCDB.                                            //
// It has a methods to set the magnetic field instanton and return        //
// the run and event info objects.                                        //
//                                                                        //
// cvetan.cheshkov@cern.ch 15/06/2009                                     //
//                                                                        //
// Usage:                                                                 //
// AliGRPManager grpMan;                                                  //
// Bool_t status = kTRUE;                                                 //
// status = grpMan.ReadGRPEntry(); // Read the corresponding OCDB entry   //
// status = grpMan.SetMagField();  // Set global field instanton          //
// AliRunInfo *runInfo = grpMan.GetRunInfo();// Get instance of run info  //
//                                                                        //
// Note: CDB manager should be initialized beforehand                     //
////////////////////////////////////////////////////////////////////////////

#include <TGeoGlobalMagField.h>
#include <TPRegexp.h>

#include "AliGRPManager.h"
#include "AliLog.h"
#include "AliRunInfo.h"
#include "AliGRPObject.h"
#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliMagF.h"

ClassImp(AliGRPManager)

//_____________________________________________________________________________
AliGRPManager::AliGRPManager() :
  TObject(),
  fGRPData(NULL)
{
  // Default constructor
}

//_____________________________________________________________________________
AliGRPManager::~AliGRPManager()
{
  // Destructor
  if (fGRPData) delete fGRPData;
}

//_____________________________________________________________________________
Bool_t AliGRPManager::ReadGRPEntry()
{
  //------------------------------------
  // Initialization of the GRP entry. 
  // Returns kTRUE in case of success.
  //------------------------------------

  AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");

  if (entry) {

    TMap* m = dynamic_cast<TMap*>(entry->GetObject());  // old GRP entry

    if (m) {
       AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
       m->Print();
       fGRPData = new AliGRPObject();
       fGRPData->ReadValuesFromMap(m);
    }

    else {
       AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
       fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject());  // new GRP entry
       entry->SetOwner(0);
    }

    AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
  }

  if (!fGRPData) {
     AliError("No GRP entry found in OCDB!");
     return kFALSE;
  }

  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliGRPManager::SetMagField()
{
  // Dealing with the magnetic field map
  // Construct the mag field map from the data in GRP
  // Set the global mag field instance

  if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
    if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
      AliInfo("ExpertMode!!! GRP information will be ignored !");
      AliInfo("ExpertMode!!! Running with the externally locked B field !");
      return kTRUE;
    }
    else {
      AliInfo("Destroying existing B field instance!");
      delete TGeoGlobalMagField::Instance();
    }
  }
  //
  // Construct the field map out of the information retrieved from GRP.
  Bool_t ok = kTRUE;
  // L3
  Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
  if (l3Current == AliGRPObject::GetInvalidFloat()) {
    AliError("GRP/GRP/Data entry:  missing value for the L3 current !");
    ok = kFALSE;
  }
  
  Char_t l3Polarity = fGRPData->GetL3Polarity();
  if (l3Polarity == AliGRPObject::GetInvalidChar()) {
    AliError("GRP/GRP/Data entry:  missing value for the L3 polarity !");
    ok = kFALSE;
  }
  
  // Dipole
  Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
  if (diCurrent == AliGRPObject::GetInvalidFloat()) {
    AliError("GRP/GRP/Data entry:  missing value for the dipole current !");
    ok = kFALSE;
  }
  
  Char_t diPolarity = fGRPData->GetDipolePolarity();
  if (diPolarity == AliGRPObject::GetInvalidChar()) {
    AliError("GRP/GRP/Data entry:  missing value for the dipole polarity !");
    ok = kFALSE;
  }
  
  TString beamType = fGRPData->GetBeamType();
  if (beamType==AliGRPObject::GetInvalidString()) {
    AliError("GRP/GRP/Data entry:  missing value for the beam type ! Using UNKNOWN");
    beamType = "UNKNOWN";
    //ok = kFALSE;  // temprorary suppressed to make read cosmics data
  }
  
  Float_t beamEnergy = fGRPData->GetBeamEnergy();
  if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
    AliError("GRP/GRP/Data entry:  missing value for the beam energy ! Using 0");
    beamEnergy = 0;
    //ok = kFALSE;  // temprorary suppressed to make read cosmics data
  }
  // LHC: "multiply by 120 to get the energy in MeV"
  beamEnergy *= 0.120;
  
  // read special bits for the polarity convention and map type
  Int_t  polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
  Bool_t uniformB = fGRPData->IsUniformBMap();
  
  if (ok) { 
    if ( !SetFieldMap(l3Current, diCurrent, l3Polarity ? -1:1, diPolarity ? -1:1, 
		      polConvention,uniformB,beamEnergy, beamType.Data())) {
      AliError("Failed to create a B field map !");
      ok = kFALSE;
    }
    else AliInfo("Running with the B field constructed out of GRP !");
  }
  else {
    AliError("B field is neither set nor constructed from GRP ! Exitig...");
  }
  
  return ok;
}

//_____________________________________________________________________________
AliRunInfo* AliGRPManager::GetRunInfo()
{
  // Constructs and returns an object
  // containing the run information
  // The user code is the owner of the object

  TString lhcState = fGRPData->GetLHCState();
  if (lhcState==AliGRPObject::GetInvalidString()) {
    AliError("GRP/GRP/Data entry:  missing value for the LHC state ! Using UNKNOWN");
    lhcState = "UNKNOWN";
  }

  TString beamType = fGRPData->GetBeamType();
  if (beamType==AliGRPObject::GetInvalidString()) {
    AliError("GRP/GRP/Data entry:  missing value for the beam type ! Using UNKNOWN");
    beamType = "UNKNOWN";
  }

  Float_t beamEnergy = fGRPData->GetBeamEnergy();
  if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
    AliError("GRP/GRP/Data entry:  missing value for the beam energy ! Using 0");
    beamEnergy = 0;
  }
  // energy is provided in MeV*120
  beamEnergy /= 120E3;

  TString runType = fGRPData->GetRunType();
  if (runType==AliGRPObject::GetInvalidString()) {
    AliError("GRP/GRP/Data entry:  missing value for the run type ! Using UNKNOWN");
    runType = "UNKNOWN";
  }

  Int_t activeDetectors = fGRPData->GetDetectorMask();
  if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
    AliError("GRP/GRP/Data entry:  missing value for the detector mask ! Using 1074790399");
    activeDetectors = 1074790399;
  }

  return new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
}

//_____________________________________________________________________________
Bool_t AliGRPManager::SetFieldMap(Float_t l3Cur, Float_t diCur, Float_t l3Pol, 
				  Float_t diPol, Int_t convention, Bool_t uniform,
				  Float_t beamenergy, const Char_t *beamtype, const Char_t *path) 
{
  //------------------------------------------------
  // The magnetic field map, defined externally...
  // L3 current 30000 A  -> 0.5 T
  // L3 current 12000 A  -> 0.2 T
  // dipole current 6000 A
  // The polarities must match the convention (LHC or DCS2008) 
  // unless the special uniform map was used for MC
  //------------------------------------------------
  const Float_t l3NominalCurrent1=30000.; // (A)
  const Float_t l3NominalCurrent2=12000.; // (A)
  const Float_t diNominalCurrent =6000. ; // (A)

  const Float_t tolerance=0.03; // relative current tolerance
  const Float_t zero=77.;       // "zero" current (A)
  //
  AliMagF::BMap_t map;
  double sclL3,sclDip;
  //
  l3Cur = TMath::Abs(l3Cur);
  diCur = TMath::Abs(diCur);
  //
  if (TMath::Abs((sclDip=diCur/diNominalCurrent)-1.) > tolerance && !uniform) {
    if (diCur <= zero) sclDip = 0.; // some small current.. -> Dipole OFF
    else {
      AliError(Form("Wrong dipole current (%f A)!",diCur));
      return kFALSE;
    }
  }
  //
  if (uniform) { 
    // special treatment of special MC with uniform mag field (normalized to 0.5 T)
    // no check for scaling/polarities are done
    map   = AliMagF::k5kGUniform;
    sclL3 = l3Cur/l3NominalCurrent1; 
  }
  else {
    if      (TMath::Abs((sclL3=l3Cur/l3NominalCurrent1)-1.) < tolerance) map  = AliMagF::k5kG;
    else if (TMath::Abs((sclL3=l3Cur/l3NominalCurrent2)-1.) < tolerance) map  = AliMagF::k2kG;
    else if (l3Cur <= zero)                                { sclL3 = 0;  map  = AliMagF::k5kGUniform;}
    else {
      AliError(Form("Wrong L3 current (%f A)!",l3Cur));
      return kFALSE;
    }
  }
  //
  if (sclDip!=0 && (map==AliMagF::k5kG || map==AliMagF::k2kG) &&
      ((convention==AliMagF::kConvLHC     && l3Pol!=diPol) ||
       (convention==AliMagF::kConvDCS2008 && l3Pol==diPol)) ) { 
    AliError(Form("Wrong combination for L3/Dipole polarities (%c/%c) for convention %d",
		  l3Pol>0?'+':'-',diPol>0?'+':'-',AliMagF::GetPolarityConvention()));
    return kFALSE;
  }
  //
  if (l3Pol<0) sclL3  = -sclL3;
  if (diPol<0) sclDip = -sclDip;
  //
  AliMagF::BeamType_t btype = AliMagF::kNoBeamField;
  TString btypestr = beamtype;
  btypestr.ToLower();
  TPRegexp protonBeam("(proton|p)\\s*-?\\s*\\1");
  TPRegexp ionBeam("(lead|pb|ion|a)\\s*-?\\s*\\1");
  if (btypestr.Contains(ionBeam)) btype = AliMagF::kBeamTypeAA;
  else if (btypestr.Contains(protonBeam)) btype = AliMagF::kBeamTypepp;
  else AliInfo(Form("Assume no LHC magnet field for the beam type %s, ",beamtype));
  char ttl[80];
  sprintf(ttl,"L3: %+5d Dip: %+4d kA; %s | Polarities in %s convention",(int)TMath::Sign(l3Cur,float(sclL3)),
	  (int)TMath::Sign(diCur,float(sclDip)),uniform ? " Constant":"",
	  convention==AliMagF::kConvLHC ? "LHC":"DCS2008");
  // LHC and DCS08 conventions have opposite dipole polarities
  if ( AliMagF::GetPolarityConvention() != convention) sclDip = -sclDip;
  AliMagF* fld = new AliMagF("MagneticFieldMap", ttl, 2, sclL3, sclDip, 10., map, path, 
			     btype,beamenergy);
  TGeoGlobalMagField::Instance()->SetField( fld );
  TGeoGlobalMagField::Instance()->Lock();
  //
  return kTRUE;
}
Commit	Line	Data
10c2f85a	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	////////////////////////////////////////////////////////////////////////////
	17	// //
	18	// AliGRPManager class //
	19	// The class can be used in order to access and read the Global Run //
	20	// Parameters entry from OCDB. //
	21	// It has a methods to set the magnetic field instanton and return //
	22	// the run and event info objects. //
	23	// //
	24	// cvetan.cheshkov@cern.ch 15/06/2009 //
	25	// //
	26	// Usage: //
	27	// AliGRPManager grpMan; //
	28	// Bool_t status = kTRUE; //
	29	// status = grpMan.ReadGRPEntry(); // Read the corresponding OCDB entry //
	30	// status = grpMan.SetMagField(); // Set global field instanton //
	31	// AliRunInfo *runInfo = grpMan.GetRunInfo();// Get instance of run info //
	32	// //
	33	// Note: CDB manager should be initialized beforehand //
	34	////////////////////////////////////////////////////////////////////////////
	35
	36	#include <TGeoGlobalMagField.h>
	37	#include <TPRegexp.h>
	38
	39	#include "AliGRPManager.h"
	40	#include "AliLog.h"
	41	#include "AliRunInfo.h"
	42	#include "AliGRPObject.h"
	43	#include "AliCDBManager.h"
	44	#include "AliCDBEntry.h"
	45	#include "AliMagF.h"
	46
	47	ClassImp(AliGRPManager)
	48
	49	//_____________________________________________________________________________
	50	AliGRPManager::AliGRPManager() :
	51	TObject(),
	52	fGRPData(NULL)
	53	{
	54	// Default constructor
	55	}
	56
	57	//_____________________________________________________________________________
	58	AliGRPManager::~AliGRPManager()
	59	{
	60	// Destructor
	61	if (fGRPData) delete fGRPData;
	62	}
	63
	64	//_____________________________________________________________________________
65	Bool_t AliGRPManager::ReadGRPEntry()
66	{
67	//------------------------------------
68	// Initialization of the GRP entry.
69	// Returns kTRUE in case of success.
70	//------------------------------------
71
72	AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
73
74	if (entry) {
75
76	TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
77
78	if (m) {
79	AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
80	m->Print();
81	fGRPData = new AliGRPObject();
82	fGRPData->ReadValuesFromMap(m);
83	}
84
85	else {
86	AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
87	fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
88	entry->SetOwner(0);
89	}
90
91	AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
92	}
93
94	if (!fGRPData) {
95	AliError("No GRP entry found in OCDB!");
96	return kFALSE;
97	}
98
99	return kTRUE;
100	}
101
102	//_____________________________________________________________________________
103	Bool_t AliGRPManager::SetMagField()
104	{
105	// Dealing with the magnetic field map
106	// Construct the mag field map from the data in GRP
107	// Set the global mag field instance
108
109	if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
5a004fb4	110	if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
	111	AliInfo("ExpertMode!!! GRP information will be ignored !");
	112	AliInfo("ExpertMode!!! Running with the externally locked B field !");
	113	return kTRUE;
10c2f85a	114	}
5a004fb4	115	else {
	116	AliInfo("Destroying existing B field instance!");
	117	delete TGeoGlobalMagField::Instance();
99c7d495	118	}
5a004fb4	119	}
	120	//
	121	// Construct the field map out of the information retrieved from GRP.
	122	Bool_t ok = kTRUE;
	123	// L3
	124	Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
	125	if (l3Current == AliGRPObject::GetInvalidFloat()) {
	126	AliError("GRP/GRP/Data entry: missing value for the L3 current !");
	127	ok = kFALSE;
	128	}
0c976228	129
5a004fb4	130	Char_t l3Polarity = fGRPData->GetL3Polarity();
	131	if (l3Polarity == AliGRPObject::GetInvalidChar()) {
	132	AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
	133	ok = kFALSE;
	134	}
	135
	136	// Dipole
	137	Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
	138	if (diCurrent == AliGRPObject::GetInvalidFloat()) {
	139	AliError("GRP/GRP/Data entry: missing value for the dipole current !");
	140	ok = kFALSE;
	141	}
	142
	143	Char_t diPolarity = fGRPData->GetDipolePolarity();
	144	if (diPolarity == AliGRPObject::GetInvalidChar()) {
	145	AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
	146	ok = kFALSE;
	147	}
	148
	149	TString beamType = fGRPData->GetBeamType();
	150	if (beamType==AliGRPObject::GetInvalidString()) {
	151	AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
	152	beamType = "UNKNOWN";
	153	//ok = kFALSE; // temprorary suppressed to make read cosmics data
	154	}
	155
	156	Float_t beamEnergy = fGRPData->GetBeamEnergy();
	157	if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
	158	AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
	159	beamEnergy = 0;
	160	//ok = kFALSE; // temprorary suppressed to make read cosmics data
	161	}
	162	// LHC: "multiply by 120 to get the energy in MeV"
	163	beamEnergy *= 0.120;
	164
	165	// read special bits for the polarity convention and map type
	166	Int_t polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
	167	Bool_t uniformB = fGRPData->IsUniformBMap();
	168
	169	if (ok) {
	170	if ( !SetFieldMap(l3Current, diCurrent, l3Polarity ? -1:1, diPolarity ? -1:1,
	171	polConvention,uniformB,beamEnergy, beamType.Data())) {
	172	AliError("Failed to create a B field map !");
	173	ok = kFALSE;
10c2f85a	174	}
5a004fb4	175	else AliInfo("Running with the B field constructed out of GRP !");
10c2f85a	176	}
5a004fb4	177	else {
	178	AliError("B field is neither set nor constructed from GRP ! Exitig...");
	179	}
	180
	181	return ok;
10c2f85a	182	}
	183
	184	//_____________________________________________________________________________
	185	AliRunInfo* AliGRPManager::GetRunInfo()
	186	{
	187	// Constructs and returns an object
	188	// containing the run information
	189	// The user code is the owner of the object
	190
	191	TString lhcState = fGRPData->GetLHCState();
	192	if (lhcState==AliGRPObject::GetInvalidString()) {
	193	AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
	194	lhcState = "UNKNOWN";
	195	}
	196
	197	TString beamType = fGRPData->GetBeamType();
	198	if (beamType==AliGRPObject::GetInvalidString()) {
	199	AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
	200	beamType = "UNKNOWN";
	201	}
	202
	203	Float_t beamEnergy = fGRPData->GetBeamEnergy();
	204	if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
	205	AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
	206	beamEnergy = 0;
	207	}
	208	// energy is provided in MeV*120
	209	beamEnergy /= 120E3;
	210
	211	TString runType = fGRPData->GetRunType();
	212	if (runType==AliGRPObject::GetInvalidString()) {
	213	AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
	214	runType = "UNKNOWN";
	215	}
	216
	217	Int_t activeDetectors = fGRPData->GetDetectorMask();
	218	if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
	219	AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
	220	activeDetectors = 1074790399;
	221	}
	222
	223	return new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
	224	}
	225
	226	//_____________________________________________________________________________
	227	Bool_t AliGRPManager::SetFieldMap(Float_t l3Cur, Float_t diCur, Float_t l3Pol,
99c7d495	228	Float_t diPol, Int_t convention, Bool_t uniform,
99c7d495	229	Float_t beamenergy, const Char_t beamtype, const Char_t path)
10c2f85a	230	{
	231	//------------------------------------------------
	232	// The magnetic field map, defined externally...
	233	// L3 current 30000 A -> 0.5 T
	234	// L3 current 12000 A -> 0.2 T
	235	// dipole current 6000 A
99c7d495	236	// The polarities must match the convention (LHC or DCS2008)
99c7d495	237	// unless the special uniform map was used for MC
10c2f85a	238	//------------------------------------------------
	239	const Float_t l3NominalCurrent1=30000.; // (A)
	240	const Float_t l3NominalCurrent2=12000.; // (A)
	241	const Float_t diNominalCurrent =6000. ; // (A)
	242
	243	const Float_t tolerance=0.03; // relative current tolerance
	244	const Float_t zero=77.; // "zero" current (A)
	245	//
99c7d495	246	AliMagF::BMap_t map;
99c7d495	247	double sclL3,sclDip;
10c2f85a	248	//
10c2f85a	249	l3Cur = TMath::Abs(l3Cur);
99c7d495	250	diCur = TMath::Abs(diCur);
	251	//
	252	if (TMath::Abs((sclDip=diCur/diNominalCurrent)-1.) > tolerance && !uniform) {
	253	if (diCur <= zero) sclDip = 0.; // some small current.. -> Dipole OFF
	254	else {
	255	AliError(Form("Wrong dipole current (%f A)!",diCur));
	256	return kFALSE;
	257	}
10c2f85a	258	}
10c2f85a	259	//
99c7d495	260	if (uniform) {
	261	// special treatment of special MC with uniform mag field (normalized to 0.5 T)
	262	// no check for scaling/polarities are done
	263	map = AliMagF::k5kGUniform;
	264	sclL3 = l3Cur/l3NominalCurrent1;
	265	}
	266	else {
	267	if (TMath::Abs((sclL3=l3Cur/l3NominalCurrent1)-1.) < tolerance) map = AliMagF::k5kG;
	268	else if (TMath::Abs((sclL3=l3Cur/l3NominalCurrent2)-1.) < tolerance) map = AliMagF::k2kG;
	269	else if (l3Cur <= zero) { sclL3 = 0; map = AliMagF::k5kGUniform;}
	270	else {
	271	AliError(Form("Wrong L3 current (%f A)!",l3Cur));
	272	return kFALSE;
	273	}
10c2f85a	274	}
10c2f85a	275	//
99c7d495	276	if (sclDip!=0 && (map==AliMagF::k5kG \|\| map==AliMagF::k2kG) &&
	277	((convention==AliMagF::kConvLHC && l3Pol!=diPol) \|\|
	278	(convention==AliMagF::kConvDCS2008 && l3Pol==diPol)) ) {
1dd3d90e	279	AliError(Form("Wrong combination for L3/Dipole polarities (%c/%c) for convention %d",
1dd3d90e	280	l3Pol>0?'+':'-',diPol>0?'+':'-',AliMagF::GetPolarityConvention()));
10c2f85a	281	return kFALSE;
	282	}
	283	//
99c7d495	284	if (l3Pol<0) sclL3 = -sclL3;
99c7d495	285	if (diPol<0) sclDip = -sclDip;
10c2f85a	286	//
	287	AliMagF::BeamType_t btype = AliMagF::kNoBeamField;
	288	TString btypestr = beamtype;
	289	btypestr.ToLower();
	290	TPRegexp protonBeam("(proton\|p)\\s-?\\s\\1");
	291	TPRegexp ionBeam("(lead\|pb\|ion\|a)\\s-?\\s\\1");
	292	if (btypestr.Contains(ionBeam)) btype = AliMagF::kBeamTypeAA;
	293	else if (btypestr.Contains(protonBeam)) btype = AliMagF::kBeamTypepp;
e86708b3	294	else AliInfo(Form("Assume no LHC magnet field for the beam type %s, ",beamtype));
	295	char ttl[80];
	296	sprintf(ttl,"L3: %+5d Dip: %+4d kA; %s \| Polarities in %s convention",(int)TMath::Sign(l3Cur,float(sclL3)),
	297	(int)TMath::Sign(diCur,float(sclDip)),uniform ? " Constant":"",
	298	convention==AliMagF::kConvLHC ? "LHC":"DCS2008");
	299	// LHC and DCS08 conventions have opposite dipole polarities
	300	if ( AliMagF::GetPolarityConvention() != convention) sclDip = -sclDip;
99c7d495	301	AliMagF* fld = new AliMagF("MagneticFieldMap", ttl, 2, sclL3, sclDip, 10., map, path,
10c2f85a	302	btype,beamenergy);
	303	TGeoGlobalMagField::Instance()->SetField( fld );
	304	TGeoGlobalMagField::Instance()->Lock();
	305	//
	306	return kTRUE;
	307	}