STEER/AliMagFMaps.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 /* $Header$ */
  17
  18 //
  19 // Author: Andreas Morsch <andreas.morsch@cern.ch>
  20 //
  21
  22 #include <TFile.h>
  23 #include <TSystem.h>
  24
  25 #include "AliFieldMap.h"
  26 #include "AliMagFMaps.h"
  27
  28
  29 ClassImp(AliMagFMaps)
  30
  31 //_______________________________________________________________________
  32 AliMagFMaps::AliMagFMaps():
  33   fSolenoid(0),
  34   fL3Option(0),
  35   fFieldRead(0)
  36 {
  37   //
  38   // Default constructor
  39   //
  40   fFieldMap[0] = fFieldMap[1] = fFieldMap[2] = 0;
  41 }
  42
  43 //_______________________________________________________________________
  44 AliMagFMaps::AliMagFMaps(const char *name, const char *title, const Int_t integ,
  45                          const Float_t factor, const Float_t fmax, const Int_t map,
  46                          const Int_t l3):
  47   AliMagF(name,title,integ,factor,fmax),
  48   fSolenoid(0),
  49   fL3Option(l3),
  50   fFieldRead(0)
  51 {
  52   //
  53   // Standard constructor
  54   //
  55   fType         = kConMesh;
  56   fFieldMap[0]  = 0;
  57   fMap          = map;
  58   fL3Option     = l3;
  59
  60   ReadField();
  61   fFieldRead = 1;
  62   //
  63   // Don't replicate field information in gAlice
  64   for (Int_t i = 0; i < 3; i++)  fFieldMap[i]->SetWriteEnable(0);
  65   //
  66 }
  67
  68 //_______________________________________________________________________
  69 AliMagFMaps::AliMagFMaps(const AliMagFMaps &magf):
  70   AliMagF(magf),
  71   fSolenoid(0),
  72   fL3Option(0),
  73   fFieldRead(0)
  74 {
  75   //
  76   // Copy constructor
  77   //
  78   magf.Copy(*this);
  79 }
  80
  81 //_______________________________________________________________________
  82 AliMagFMaps::~AliMagFMaps()
  83 {
  84   //
  85   //  Destructor
  86   //
  87   delete fFieldMap[0];
  88   delete fFieldMap[1];
  89   delete fFieldMap[2];
  90 }
  91
  92 //_______________________________________________________________________
  93 void AliMagFMaps::ReadField()
  94 {
  95   //  Read Field Map from file
  96   //
  97   //  don't read twice
  98   //
  99   if (fFieldRead) return;
 100   fFieldRead = 1;
 101   //
 102   char* fname;
 103   TFile* file = 0;
 104   if (fMap == k2kG) {
 105         if (fL3Option) {
 106       fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/L3B02.root");
 107       file = new TFile(fname);
 108       fFieldMap[0] = dynamic_cast<AliFieldMap*>(file->Get("L3B02"));
 109       file->Close();
 110       delete file;
 111         }
 112         fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/DipB02.root");
 113         file = new TFile(fname);
 114         fFieldMap[1] = dynamic_cast<AliFieldMap*>(file->Get("DipB02"));
 115         file->Close();
 116         delete file;;
 117
 118         fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/ExtB02.root");
 119         file = new TFile(fname);
 120         fFieldMap[2] = dynamic_cast<AliFieldMap*>(file->Get("ExtB02"));
 121         file->Close();
 122         delete file;
 123         fSolenoid = 2.;
 124   } else if (fMap == k4kG) {
 125         if (fL3Option) {
 126       fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/L3B04.root");
 127       file = new TFile(fname);
 128       fFieldMap[0] = dynamic_cast<AliFieldMap*>(file->Get("L3B04"));
 129       file->Close();
 130       delete file;
 131         }
 132
 133         fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/DipB04.root");
 134         file = new TFile(fname);
 135         fFieldMap[1] = dynamic_cast<AliFieldMap*>(file->Get("DipB04"));
 136         file->Close();
 137         delete file;
 138
 139         fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/ExtB04.root");
 140         file = new TFile(fname);
 141         fFieldMap[2] = dynamic_cast<AliFieldMap*>(file->Get("ExtB04"));
 142         file->Close();
 143         delete file;
 144         fSolenoid = 4.;
 145   } else if (fMap == k5kG) {
 146         if (fL3Option) {
 147       fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/L3B05.root");
 148       file = new TFile(fname);
 149       fFieldMap[0] = dynamic_cast<AliFieldMap*>(file->Get("L3B05"));
 150       file->Close();
 151       delete file;
 152         }
 153
 154         fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/DipB05.root");
 155         file = new TFile(fname);
 156         fFieldMap[1] = dynamic_cast<AliFieldMap*>(file->Get("DipB05"));
 157         file->Close();
 158         delete file;
 159
 160         fname = gSystem->ExpandPathName("$(ALICE_ROOT)/data/maps/ExtB05.root");
 161         file = new TFile(fname);
 162         fFieldMap[2] = dynamic_cast<AliFieldMap*>(file->Get("ExtB05"));
 163         file->Close();
 164         delete file;
 165
 166         fSolenoid = 5.;
 167   }
 168
 169   if (!fL3Option) {
 170     //
 171     // Dummy L3 map
 172         fFieldMap[0] = new AliFieldMap();
 173         fFieldMap[0] -> SetLimits(-800., 800., -800., 800., -700., 700.);
 174   }
 175 }
 176
 177 //_______________________________________________________________________
 178 Float_t AliMagFMaps::SolenoidField() const
 179 {
 180   //
 181   // Returns max. L3 (solenoid) field strength
 182   // according to field map setting
 183   //
 184   return fSolenoid;
 185 }
 186
 187 //_______________________________________________________________________
 188 void AliMagFMaps::Field(Float_t *x, Float_t *b)
 189 {
 190   //
 191   // Method to calculate the magnetic field
 192   //
 193   // --- find the position in the grid ---
 194
 195   if (!fFieldRead) ReadField();
 196
 197   b[0]=b[1]=b[2]=0;
 198   AliFieldMap* map = 0;
 199   if (fFieldMap[0]->Inside(x[0], x[1], x[2])) {
 200     map = fFieldMap[0];
 201     if (!fL3Option) {
 202       //
 203       //     Constant L3 field, if this option was selected
 204       //
 205           b[2] = fSolenoid;
 206           return;
 207     }
 208   } else if (fFieldMap[1]->Inside(x[0], x[1], x[2])) {
 209     map = fFieldMap[1];
 210   } else if (fFieldMap[2]->Inside(x[0], x[1], x[2])) {
 211     map = fFieldMap[2];
 212   }
 213
 214   if(map){
 215     map->Field(x,b);
 216   } else {
 217     //This is the ZDC part
 218     Float_t rad2=x[0]*x[0]+x[1]*x[1];
 219     if(x[2]>kCORBEG2 && x[2]<kCOREND2){
 220           if(rad2<kCOR2RA2){
 221         b[0] = kFCORN2;
 222           }
 223     }
 224     else if(x[2]>kZ1BEG && x[2]<kZ1END){
 225           if(rad2<kZ1RA2){
 226         b[0] = -kG1*x[1];
 227         b[1] = -kG1*x[0];
 228           }
 229     }
 230     else if(x[2]>kZ2BEG && x[2]<kZ2END){
 231           if(rad2<kZ2RA2){
 232         b[0] = kG1*x[1];
 233         b[1] = kG1*x[0];
 234           }
 235     }
 236     else if(x[2]>kZ3BEG && x[2]<kZ3END){
 237           if(rad2<kZ3RA2){
 238         b[0] = kG1*x[1];
 239         b[1] = kG1*x[0];
 240           }
 241     }
 242     else if(x[2]>kZ4BEG && x[2]<kZ4END){
 243           if(rad2<kZ4RA2){
 244         b[0] = -kG1*x[1];
 245         b[1] = -kG1*x[0];
 246           }
 247     }
 248     else if(x[2]>kD1BEG && x[2]<kD1END){
 249           if(rad2<kD1RA2){
 250         b[1] = -kFDIP;
 251           }
 252     }
 253     else if(x[2]>kD2BEG && x[2]<kD2END){
 254           if(((x[0]-kXCEN1D2)*(x[0]-kXCEN1D2)+(x[1]-kYCEN1D2)*(x[1]-kYCEN1D2))<kD2RA2
 255              || ((x[0]-kXCEN2D2)*(x[0]-kXCEN2D2)+(x[1]-kYCEN2D2)*(x[1]-kYCEN2D2))<kD2RA2){
 256         b[1] = kFDIP;
 257           }
 258     }
 259   }
 260   if(fFactor!=1) {
 261     b[0]*=fFactor;
 262     b[1]*=fFactor;
 263     b[2]*=fFactor;
 264   }
 265 }
 266
 267 //_______________________________________________________________________
 268 void AliMagFMaps::Copy(AliMagFMaps & /* magf */) const
 269 {
 270   //
 271   // Copy *this onto magf -- Not implemented
 272   //
 273   Fatal("Copy","Not implemented!\n");
 274 }
 275
 276 //_______________________________________________________________________
 277 void AliMagFMaps::Streamer(TBuffer &R__b)
 278 {
 279   // Stream an object of class AliMagFMaps.
 280   if (R__b.IsReading()) {
 281     AliMagFMaps::Class()->ReadBuffer(R__b, this);
 282     fFieldRead = 0;
 283   } else {
 284     AliMagFMaps::Class()->WriteBuffer(R__b, this);
 285   }
 286 }