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