STEER/AliGRPManager.cxx

   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() ) {
 110     AliInfo("Running with the externally locked B field !");
 111   }
 112   else {
 113     // Construct the field map out of the information retrieved from GRP.
 114     Bool_t ok = kTRUE;
 115     // L3
 116     Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
 117     if (l3Current == AliGRPObject::GetInvalidFloat()) {
 118       AliError("GRP/GRP/Data entry:  missing value for the L3 current !");
 119       ok = kFALSE;
 120     }
 121
 122     Char_t l3Polarity = fGRPData->GetL3Polarity();
 123     if (l3Polarity == AliGRPObject::GetInvalidChar()) {
 124       AliError("GRP/GRP/Data entry:  missing value for the L3 polarity !");
 125       ok = kFALSE;
 126     }
 127
 128     // Dipole
 129     Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
 130     if (diCurrent == AliGRPObject::GetInvalidFloat()) {
 131       AliError("GRP/GRP/Data entry:  missing value for the dipole current !");
 132       ok = kFALSE;
 133     }
 134
 135     Char_t diPolarity = fGRPData->GetDipolePolarity();
 136     if (diPolarity == AliGRPObject::GetInvalidChar()) {
 137       AliError("GRP/GRP/Data entry:  missing value for the dipole polarity !");
 138       ok = kFALSE;
 139     }
 140
 141     TString beamType = fGRPData->GetBeamType();
 142     if (beamType==AliGRPObject::GetInvalidString()) {
 143       AliError("GRP/GRP/Data entry:  missing value for the beam type ! Using UNKNOWN");
 144       beamType = "UNKNOWN";
 145       ok = kFALSE;
 146     }
 147
 148     Float_t beamEnergy = fGRPData->GetBeamEnergy();
 149     if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
 150       AliError("GRP/GRP/Data entry:  missing value for the beam energy ! Using 0");
 151       beamEnergy = 0;
 152       ok = kFALSE;
 153     }
 154     beamEnergy /= 120E3;       // energy is provided in MeV*120
 155
 156     // read special bits for the polarity convention and map type
 157     Int_t  polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
 158     Bool_t uniformB = fGRPData->IsUniformBMap();
 159
 160     if (ok) {
 161       if ( !SetFieldMap(l3Current, diCurrent, l3Polarity ? -1:1, diPolarity ? -1:1,
 162                         polConvention,uniformB,beamEnergy, beamType.Data())) {
 163         AliError("Failed to create a B field map !");
 164         ok = kFALSE;
 165       }
 166       AliInfo("Running with the B field constructed out of GRP !");
 167     }
 168     else {
 169       AliError("B field is neither set nor constructed from GRP ! Exitig...");
 170     }
 171     return ok;
 172   }
 173
 174   return kTRUE;
 175 }
 176
 177 //_____________________________________________________________________________
 178 AliRunInfo* AliGRPManager::GetRunInfo()
 179 {
 180   // Constructs and returns an object
 181   // containing the run information
 182   // The user code is the owner of the object
 183
 184   TString lhcState = fGRPData->GetLHCState();
 185   if (lhcState==AliGRPObject::GetInvalidString()) {
 186     AliError("GRP/GRP/Data entry:  missing value for the LHC state ! Using UNKNOWN");
 187     lhcState = "UNKNOWN";
 188   }
 189
 190   TString beamType = fGRPData->GetBeamType();
 191   if (beamType==AliGRPObject::GetInvalidString()) {
 192     AliError("GRP/GRP/Data entry:  missing value for the beam type ! Using UNKNOWN");
 193     beamType = "UNKNOWN";
 194   }
 195
 196   Float_t beamEnergy = fGRPData->GetBeamEnergy();
 197   if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
 198     AliError("GRP/GRP/Data entry:  missing value for the beam energy ! Using 0");
 199     beamEnergy = 0;
 200   }
 201   // energy is provided in MeV*120
 202   beamEnergy /= 120E3;
 203
 204   TString runType = fGRPData->GetRunType();
 205   if (runType==AliGRPObject::GetInvalidString()) {
 206     AliError("GRP/GRP/Data entry:  missing value for the run type ! Using UNKNOWN");
 207     runType = "UNKNOWN";
 208   }
 209
 210   Int_t activeDetectors = fGRPData->GetDetectorMask();
 211   if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
 212     AliError("GRP/GRP/Data entry:  missing value for the detector mask ! Using 1074790399");
 213     activeDetectors = 1074790399;
 214   }
 215
 216   return new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
 217 }
 218
 219 //_____________________________________________________________________________
 220 Bool_t AliGRPManager::SetFieldMap(Float_t l3Cur, Float_t diCur, Float_t l3Pol,
 221                                   Float_t diPol, Int_t convention, Bool_t uniform,
 222                                   Float_t beamenergy, const Char_t *beamtype, const Char_t *path)
 223 {
 224   //------------------------------------------------
 225   // The magnetic field map, defined externally...
 226   // L3 current 30000 A  -> 0.5 T
 227   // L3 current 12000 A  -> 0.2 T
 228   // dipole current 6000 A
 229   // The polarities must match the convention (LHC or DCS2008)
 230   // unless the special uniform map was used for MC
 231   //------------------------------------------------
 232   const Float_t l3NominalCurrent1=30000.; // (A)
 233   const Float_t l3NominalCurrent2=12000.; // (A)
 234   const Float_t diNominalCurrent =6000. ; // (A)
 235
 236   const Float_t tolerance=0.03; // relative current tolerance
 237   const Float_t zero=77.;       // "zero" current (A)
 238   //
 239   AliMagF::BMap_t map;
 240   double sclL3,sclDip;
 241   //
 242   l3Cur = TMath::Abs(l3Cur);
 243   diCur = TMath::Abs(diCur);
 244   //
 245   if (TMath::Abs((sclDip=diCur/diNominalCurrent)-1.) > tolerance && !uniform) {
 246     if (diCur <= zero) sclDip = 0.; // some small current.. -> Dipole OFF
 247     else {
 248       AliError(Form("Wrong dipole current (%f A)!",diCur));
 249       return kFALSE;
 250     }
 251   }
 252   //
 253   if (uniform) {
 254     // special treatment of special MC with uniform mag field (normalized to 0.5 T)
 255     // no check for scaling/polarities are done
 256     map   = AliMagF::k5kGUniform;
 257     sclL3 = l3Cur/l3NominalCurrent1;
 258   }
 259   else {
 260     if      (TMath::Abs((sclL3=l3Cur/l3NominalCurrent1)-1.) < tolerance) map  = AliMagF::k5kG;
 261     else if (TMath::Abs((sclL3=l3Cur/l3NominalCurrent2)-1.) < tolerance) map  = AliMagF::k2kG;
 262     else if (l3Cur <= zero)                                { sclL3 = 0;  map  = AliMagF::k5kGUniform;}
 263     else {
 264       AliError(Form("Wrong L3 current (%f A)!",l3Cur));
 265       return kFALSE;
 266     }
 267   }
 268   //
 269   if (sclDip!=0 && (map==AliMagF::k5kG || map==AliMagF::k2kG) &&
 270       ((convention==AliMagF::kConvLHC     && l3Pol!=diPol) ||
 271        (convention==AliMagF::kConvDCS2008 && l3Pol==diPol)) ) {
 272     AliError(Form("Wrong combination for L3/Dipole polarities (%c/%c) for convention %d",
 273                   l3Pol>0?'+':'-',diPol>0?'+':'-',AliMagF::GetPolarityConvention()));
 274     return kFALSE;
 275   }
 276   //
 277   if (l3Pol<0) sclL3  = -sclL3;
 278   if (diPol<0) sclDip = -sclDip;
 279   //
 280   AliMagF::BeamType_t btype = AliMagF::kNoBeamField;
 281   TString btypestr = beamtype;
 282   btypestr.ToLower();
 283   TPRegexp protonBeam("(proton|p)\\s*-?\\s*\\1");
 284   TPRegexp ionBeam("(lead|pb|ion|a)\\s*-?\\s*\\1");
 285   if (btypestr.Contains(ionBeam)) btype = AliMagF::kBeamTypeAA;
 286   else if (btypestr.Contains(protonBeam)) btype = AliMagF::kBeamTypepp;
 287   else {
 288     AliInfo(Form("Cannot determine the beam type from %s, assume no LHC magnet field",beamtype));
 289   }
 290   char ttl[50];
 291   sprintf(ttl,"L3: %+5d Dip: %+4d kA; %s",(int)TMath::Sign(l3Cur,float(sclL3)),
 292           (int)TMath::Sign(diCur,float(sclDip)),uniform ? " Constant":"");
 293   AliMagF* fld = new AliMagF("MagneticFieldMap", ttl, 2, sclL3, sclDip, 10., map, path,
 294                              btype,beamenergy);
 295   TGeoGlobalMagField::Instance()->SetField( fld );
 296   TGeoGlobalMagField::Instance()->Lock();
 297   //
 298   return kTRUE;
 299 }