void SetOrbitNumber(UInt_t n) {if (fHeader) fHeader->SetOrbitNumber(n);}
void SetBunchCrossNumber(UShort_t n) {if (fHeader) fHeader->SetBunchCrossNumber(n);}
void SetMagneticField(Double_t mf){if (fHeader) fHeader->SetMagneticField(mf);}
+ void SetMuonMagFieldScale(Double_t mf){if (fHeader) fHeader->SetMuonMagFieldScale(mf);}
void SetDiamond(Float_t xy[2],Float_t cov[3]){if (fHeader) fHeader->SetDiamond(xy,cov);}
Int_t GetRunNumber() const {return fHeader ? fHeader->GetRunNumber() : -999;}
UInt_t GetOrbitNumber() const {return fHeader ? fHeader->GetOrbitNumber() : 0;}
UShort_t GetBunchCrossNumber() const {return fHeader ? fHeader->GetBunchCrossNumber() : 0;}
Double_t GetMagneticField() const {return fHeader ? fHeader->GetMagneticField() : -999.;}
+ Double_t GetMuonMagFieldScale() const {return fHeader ? fHeader->GetMuonMagFieldScale() : -999.;}
Double_t GetDiamondX() const {return fHeader ? fHeader->GetDiamondX() : -999.;}
Double_t GetDiamondY() const {return fHeader ? fHeader->GetDiamondY() : -999.;}
void GetDiamondCovXY(Float_t cov[3]) const {cov[0]=-999.; if(fHeader) fHeader->GetDiamondCovXY(cov);}
const TGeoHMatrix* GetPHOSMatrix(Int_t i) const {return fESDRun->GetPHOSMatrix(i);}
void SetEMCALMatrix(TGeoHMatrix*matrix, Int_t i) {fESDRun->SetEMCALMatrix(matrix,i);}
const TGeoHMatrix* GetEMCALMatrix(Int_t i) const {return fESDRun->GetEMCALMatrix(i);}
-
+ //
+ void SetCurrentL3(Float_t cur) const {fESDRun->SetCurrentL3(cur);}
+ void SetCurrentDip(Float_t cur) const {fESDRun->SetCurrentDip(cur);}
+ void SetBeamEnergy(Float_t be) const {fESDRun->SetBeamEnergy(be);}
+ void SetBeamType(const char* bt) const {fESDRun->SetBeamType(bt);}
+ void SetUniformBMap(Bool_t val=kTRUE) const {fESDRun->SetBit(AliESDRun::kUniformBMap,val);}
+ void SetBInfoStored(Bool_t val=kTRUE) const {fESDRun->SetBit(AliESDRun::kBInfoStored,val);}
+ //
+ Float_t GetCurrentL3() const {return fESDRun->GetCurrentL3();}
+ Float_t GetCurrentDip() const {return fESDRun->GetCurrentDip();}
+ Float_t SetBeamEnergy() const {return fESDRun->GetBeamEnergy();}
+ const char* GetBeamType() const {return fESDRun->GetBeamType();}
+ Bool_t IsUniformBMap() const {return fESDRun->TestBit(AliESDRun::kUniformBMap);}
+ //
+ Bool_t InitMagneticField() const {return fESDRun->InitMagneticField();}
// HEADER
AliESDHeader* GetHeader() const {return fHeader;}
**************************************************************************/
#include <TNamed.h>
#include <TGeoMatrix.h>
+#include <TGeoGlobalMagField.h>
#include "AliESDRun.h"
#include "AliESDVertex.h"
#include "AliLog.h"
+#include "AliMagF.h"
//-------------------------------------------------------------------------
// Implementation Class AliESDRun
//______________________________________________________________________________
AliESDRun::AliESDRun() :
TObject(),
+ fCurrentL3(0),
+ fCurrentDip(0),
+ fBeamEnergy(0),
fMagneticField(0),
fPeriodNumber(0),
fRunNumber(0),
fRecoVersion(0),
+ fBeamType(""),
fTriggerClasses(kNTriggerClasses)
{
for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
//______________________________________________________________________________
AliESDRun::AliESDRun(const AliESDRun &esd) :
TObject(esd),
+ fCurrentL3(0),
+ fCurrentDip(0),
+ fBeamEnergy(0),
fMagneticField(esd.fMagneticField),
fPeriodNumber(esd.fPeriodNumber),
fRunNumber(esd.fRunNumber),
fRecoVersion(esd.fRecoVersion),
+ fBeamType(""),
fTriggerClasses(TObjArray(kNTriggerClasses))
{
// Copy constructor
fPeriodNumber=esd.fPeriodNumber;
fRecoVersion=esd.fRecoVersion;
fMagneticField=esd.fMagneticField;
+ fBeamType = esd.fBeamType;
+ fCurrentL3 = esd.fCurrentL3;
+ fCurrentDip = esd.fCurrentDip;
+ fBeamEnergy = esd.fBeamEnergy;
for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
fTriggerClasses.Clear();
// Print some data members
printf("Mean vertex in RUN %d: X=%.4f Y=%.4f cm\n",
GetRunNumber(),GetDiamondX(),GetDiamondY());
- printf("Magnetic field = %f T\n",
- GetMagneticField());
+ printf("Beam Type: %s, Energy: %.1f GeV\n",fBeamType.IsNull() ? "N/A":fBeamType.Data(),fBeamEnergy);
+ printf("Magnetic field in IP= %f T | Currents: L3:%+.1f Dipole:%+.1f %s\n",
+ GetMagneticField(),fCurrentL3,fCurrentDip,TestBit(kUniformBMap) ? "(Uniform)":"");
printf("Event from reconstruction version %d \n",fRecoVersion);
printf("List of active trigger classes: ");
else
return kFALSE;
}
+
+//_____________________________________________________________________________
+Bool_t AliESDRun::InitMagneticField() const
+{
+ // Create mag field from stored information
+ //
+ if (!TestBit(kBInfoStored)) {
+ AliError("No information on currents, cannot create field from run header");
+ return kFALSE;
+ }
+ //
+ if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
+ if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
+ AliInfo("ExpertMode!!! Information on magnet currents will be ignored !");
+ AliInfo("ExpertMode!!! Running with the externally locked B field !");
+ return kTRUE;
+ }
+ else {
+ AliInfo("Destroying existing B field instance!");
+ delete TGeoGlobalMagField::Instance();
+ }
+ }
+ //
+ AliMagF* fld = AliMagF::CreateFieldMap(fCurrentL3,fCurrentDip,AliMagF::kConvLHC,
+ TestBit(kUniformBMap),fBeamEnergy,fBeamType.Data());
+ if (fld) {
+ TGeoGlobalMagField::Instance()->SetField( fld );
+ TGeoGlobalMagField::Instance()->Lock();
+ AliInfo("Running with the B field constructed out of the Run Header !");
+ return kTRUE;
+ }
+ else {
+ AliError("Failed to create a B field map !");
+ return kFALSE;
+ }
+ //
+}
class AliESDRun: public TObject {
public:
+ enum StatusBits {kBInfoStored = BIT(14), kUniformBMap = BIT(15)};
+
AliESDRun();
AliESDRun(const AliESDRun& esd);
AliESDRun& operator=(const AliESDRun& esd);
virtual void Copy(TObject &obj) const; // Interface for using TOBject::Copy()
virtual ~AliESDRun();
+ Bool_t InitMagneticField() const;
Int_t GetRunNumber() const {return fRunNumber;}
void SetRunNumber(Int_t n) {fRunNumber=n;}
void SetMagneticField(Float_t mf){fMagneticField = mf;}
void SetPeriodNumber(Int_t n) {fPeriodNumber=n;}
void Reset();
void Print(const Option_t *opt=0) const;
- void SetDiamond(const AliESDVertex *vertex);
+ void SetDiamond(const AliESDVertex *vertex);
void SetTriggerClass(const char*name, Int_t index);
-
+ void SetCurrentL3(Float_t cur) {fCurrentL3 = cur;}
+ void SetCurrentDip(Float_t cur) {fCurrentDip = cur;}
+ void SetBeamEnergy(Float_t be) {fBeamEnergy = be;}
+ void SetBeamType(const char* bt) {fBeamType = bt;}
+
Double_t GetDiamondX() const {return fDiamondXY[0];}
Double_t GetDiamondY() const {return fDiamondXY[1];}
Double_t GetSigma2DiamondX() const {return fDiamondCovXY[0];}
TString GetActiveTriggerClasses() const;
TString GetFiredTriggerClasses(ULong64_t mask) const;
Bool_t IsTriggerClassFired(ULong64_t mask, const char *name) const;
+ Float_t GetCurrentL3() const {return fCurrentL3;}
+ Float_t GetCurrentDip() const {return fCurrentDip;}
+ Float_t GetBeamEnergy() const {return fBeamEnergy;}
+ const char* GetBeamType() const {return fBeamType.Data();}
void SetPHOSMatrix(TGeoHMatrix*matrix, Int_t i) {
if ((i >= 0) && (i < kNPHOSMatrix)) fPHOSMatrix[i] = matrix;
enum {kNEMCALMatrix = 12};
private:
+ Float_t fCurrentL3; // signed current in the L3 (LHC convention: +current -> +Bz)
+ Float_t fCurrentDip; // signed current in the Dipole (LHC convention: +current -> -Bx)
+ Float_t fBeamEnergy; // beamEnergy entry from GRP
Double32_t fMagneticField; // Solenoid Magnetic Field in kG : for compatibility with AliMagF
Double32_t fDiamondXY[2]; // Interaction diamond (x,y) in RUN
Double32_t fDiamondCovXY[3]; // Interaction diamond covariance (x,y) in RUN
UInt_t fPeriodNumber; // PeriodNumber
Int_t fRunNumber; // Run Number
- Int_t fRecoVersion; // Version of reconstruction
+ Int_t fRecoVersion; // Version of reconstruction
+ TString fBeamType; // beam type from GRP
TObjArray fTriggerClasses; // array of TNamed containing the names of the active trigger classes
TGeoHMatrix* fPHOSMatrix[kNPHOSMatrix]; //PHOS module position and orientation matrices
TGeoHMatrix* fEMCALMatrix[kNEMCALMatrix]; //EMCAL supermodule position and orientation matrices
- ClassDef(AliESDRun,5)
+ ClassDef(AliESDRun,6)
};
#endif
////////////////////////////////////////////////////////////////////////////
#include <TGeoGlobalMagField.h>
-#include <TPRegexp.h>
#include "AliGRPManager.h"
#include "AliLog.h"
Bool_t uniformB = fGRPData->IsUniformBMap();
if (ok) {
- if ( !SetFieldMap(l3Current, diCurrent, l3Polarity ? -1:1, diPolarity ? -1:1,
- polConvention,uniformB,beamEnergy, beamType.Data())) {
+ AliMagF* fld = AliMagF::CreateFieldMap(TMath::Abs(l3Current) * (l3Polarity ? -1:1),
+ TMath::Abs(diCurrent) * (diPolarity ? -1:1),
+ polConvention,uniformB,beamEnergy, beamType.Data());
+ if (fld) {
+ TGeoGlobalMagField::Instance()->SetField( fld );
+ TGeoGlobalMagField::Instance()->Lock();
+ AliInfo("Running with the B field constructed out of GRP !");
+ }
+ else {
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 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;
-}
AliRunInfo* GetRunInfo();
private:
- Bool_t SetFieldMap(Float_t l3Current=30000., Float_t diCurrent=6000.,
- Float_t l3Pol=-1., Float_t dipPol=-1.,
- Int_t convention=0, Bool_t uniform = kFALSE,
- Float_t benergy=7000., const Char_t* btype="pp",
- const Char_t* path="$(ALICE_ROOT)/data/maps/mfchebKGI_sym.root");
AliGRPObject* fGRPData; // Data from the GRP/GRP/Data CDB folder
#include <TClass.h>
#include <TFile.h>
#include <TSystem.h>
+#include <TPRegexp.h>
#include "AliMagF.h"
#include "AliMagWrapCheb.h"
default : return fFactorDip; // case kConvMap2005: return fFactorDip;
}
}
+
+//_____________________________________________________________________________
+AliMagF* AliMagF::CreateFieldMap(Float_t l3Cur, Float_t diCur, 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)
+ //
+ BMap_t map;
+ double sclL3,sclDip;
+ //
+ Float_t l3Pol = l3Cur > 0 ? 1:-1;
+ Float_t diPol = diCur > 0 ? 1:-1;
+
+ 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 {
+ AliErrorGeneral("AliMagF",Form("Wrong dipole current (%f A)!",diCur));
+ return 0;
+ }
+ }
+ //
+ if (uniform) {
+ // special treatment of special MC with uniform mag field (normalized to 0.5 T)
+ // no check for scaling/polarities are done
+ map = k5kGUniform;
+ sclL3 = l3Cur/l3NominalCurrent1;
+ }
+ else {
+ if (TMath::Abs((sclL3=l3Cur/l3NominalCurrent1)-1.) < tolerance) map = k5kG;
+ else if (TMath::Abs((sclL3=l3Cur/l3NominalCurrent2)-1.) < tolerance) map = k2kG;
+ else if (l3Cur <= zero) { sclL3 = 0; map = k5kGUniform;}
+ else {
+ AliErrorGeneral("AliMagF",Form("Wrong L3 current (%f A)!",l3Cur));
+ return 0;
+ }
+ }
+ //
+ if (sclDip!=0 && (map==k5kG || map==k2kG) &&
+ ((convention==kConvLHC && l3Pol!=diPol) ||
+ (convention==kConvDCS2008 && l3Pol==diPol)) ) {
+ AliErrorGeneral("AliMagF",Form("Wrong combination for L3/Dipole polarities (%c/%c) for convention %d",
+ l3Pol>0?'+':'-',diPol>0?'+':'-',GetPolarityConvention()));
+ return 0;
+ }
+ //
+ if (l3Pol<0) sclL3 = -sclL3;
+ if (diPol<0) sclDip = -sclDip;
+ //
+ BeamType_t btype = 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 = kBeamTypeAA;
+ else if (btypestr.Contains(protonBeam)) btype = kBeamTypepp;
+ else AliInfoGeneral("AliMagF",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==kConvLHC ? "LHC":"DCS2008");
+ // LHC and DCS08 conventions have opposite dipole polarities
+ if ( GetPolarityConvention() != convention) sclDip = -sclDip;
+ //
+ return new AliMagF("MagneticFieldMap", ttl, 2, sclL3, sclDip, 10., map, path,btype,beamenergy);
+ //
+}
+
+//_____________________________________________________________________________
+const char* AliMagF::GetBeamTypeText() const
+{
+ const char *beamNA = "No Beam";
+ const char *beamPP = "p-p";
+ const char *beamPbPb= "Pb-Pb";
+ switch ( fBeamType ) {
+ case kBeamTypepp : return beamPP;
+ case kBeamTypeAA : return beamPbPb;
+ case kNoBeamField:
+ default: return beamNA;
+ }
+}
+
{
public:
enum BMap_t {k2kG, k5kG, k5kGUniform};
- enum BeamType_t {kBeamTypeAA, kBeamTypepp, kNoBeamField};
+ enum BeamType_t {kNoBeamField, kBeamTypepp, kBeamTypeAA};
enum PolarityConvention_t {kConvLHC,kConvDCS2008,kConvMap2005};
enum {kOverrideGRP=BIT(14)}; // don't recreate from GRP if set
//
Double_t GetFactorSol() const;
Double_t GetFactorDip() const;
Double_t Factor() const {return GetFactorSol();}
+ Double_t GetCurrentSol() const {return GetFactorSol()*(fMapType==k2kG ? 12000:30000);}
+ Double_t GetCurrentDip() const {return GetFactorDip()*6000;}
Bool_t IsUniform() const {return fMapType == k5kGUniform;}
//
void MachineField(const Double_t *x, Double_t *b) const;
BMap_t GetMapType() const {return fMapType;}
BeamType_t GetBeamType() const {return fBeamType;}
+ const char* GetBeamTypeText() const;
Double_t GetBeamEnergy() const {return fBeamEnergy;}
Double_t Max() const {return fMax;}
Int_t Integ() const {return fInteg;}
//
Bool_t LoadParameterization();
static Int_t GetPolarityConvention() {return Int_t(fgkPolarityConvention);}
+ static AliMagF* CreateFieldMap(Float_t l3Current=-30000., Float_t diCurrent=-6000.,
+ Int_t convention=0, Bool_t uniform = kFALSE,
+ Float_t benergy=7000., const Char_t* btype="pp",
+ const Char_t* path="$(ALICE_ROOT)/data/maps/mfchebKGI_sym.root");
//
protected:
// not supposed to be changed during the run, set only at the initialization via constructor
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::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) in %s convention",
- l3Pol>0?'+':'-',diPol>0?'+':'-',convention==AliMagF::kConvDCS2008?"DCS2008":"LHC"));
- 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;
-}
-
Bool_t AliReconstruction::InitGRP() {
//------------------------------------
// Initialization of the GRP entry
Bool_t uniformB = fGRPData->IsUniformBMap();
if (ok) {
- if ( !SetFieldMap(l3Current, diCurrent, l3Polarity ? -1:1, diPolarity ? -1:1,
- polConvention,uniformB,beamEnergy, beamType.Data()))
- AliFatal("Failed to creat a B field map ! Exiting...");
- AliInfo("Running with the B field constructed out of GRP !");
+ AliMagF* fld = AliMagF::CreateFieldMap(TMath::Abs(l3Current) * (l3Polarity ? -1:1),
+ TMath::Abs(diCurrent) * (diPolarity ? -1:1),
+ polConvention,uniformB,beamEnergy, beamType.Data());
+ if (fld) {
+ TGeoGlobalMagField::Instance()->SetField( fld );
+ TGeoGlobalMagField::Instance()->Lock();
+ AliInfo("Running with the B field constructed out of GRP !");
+ }
+ else AliFatal("Failed to create a B field map !");
}
else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
}
// Set magnetic field from the tracker
fesd->SetMagneticField(AliTracker::GetBz());
fhltesd->SetMagneticField(AliTracker::GetBz());
-
+ //
+ AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
+ if (fld) { // set info needed for field initialization
+ fesd->SetCurrentL3(fld->GetCurrentSol());
+ fesd->SetCurrentDip(fld->GetCurrentDip());
+ fesd->SetBeamEnergy(fld->GetBeamEnergy());
+ fesd->SetBeamType(fld->GetBeamTypeText());
+ fesd->SetUniformBMap(fld->IsUniform());
+ fesd->SetBInfoStored();
+ //
+ fhltesd->SetCurrentL3(fld->GetCurrentSol());
+ fhltesd->SetCurrentDip(fld->GetCurrentDip());
+ fhltesd->SetBeamEnergy(fld->GetBeamEnergy());
+ fhltesd->SetBeamType(fld->GetBeamTypeText());
+ fhltesd->SetUniformBMap(fld->IsUniform());
+ fhltesd->SetBInfoStored();
+ }
+ //
// Set most probable pt, for B=0 tracking
// Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
void SetLoadAlignData(const char* detectors)
{fLoadAlignData = detectors;};
- //*** Magnetic field setters
- Bool_t SetFieldMap(Float_t l3Current=30000., Float_t diCurrent=6000.,
- Float_t l3Pol=-1., Float_t dipPol=-1.,
- Int_t convention=0, Bool_t uniform = kFALSE,
- Float_t benergy=7000., const Char_t* btype="pp",
- const Char_t* path="$(ALICE_ROOT)/data/maps/mfchebKGI_sym.root");
-
//*** Global reconstruction flag setters
void SetRunVertexFinder(Bool_t flag=kTRUE) {fRunVertexFinder=flag;};
void SetRunVertexFinderTracks(Bool_t flag=kTRUE) {fRunVertexFinderTracks=flag;};