Completely Updated (Mario Sitta)
[u/mrichter/AliRoot.git] / STEER / AliMagFC.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 /* $Id$ */
17
18 //-------------------------------------------------------------------------
19 //     Constant magnetic field class
20 //     Used by AliRun class
21 //     Author:
22 //-------------------------------------------------------------------------
23
24 #include <stdlib.h>
25
26 #include "AliLog.h"
27 #include "AliMagFC.h"
28
29 ClassImp(AliMagFC)
30
31 //________________________________________
32 AliMagFC::AliMagFC(const char *name, const char *title, Int_t integ, 
33                    Float_t factor, Float_t fmax)
34     : AliMagF(name,title,integ,factor,fmax),
35       fCompensator(kFALSE)
36 {
37   // 
38   // Standard constructor
39   //
40   fType = kConst;
41   fMap  = 1;
42 }
43
44 //________________________________________
45 void AliMagFC::Field(Float_t *x, Float_t *b) const
46 {
47   //
48   // Method to return the field in a point
49   //
50   b[0]=b[1]=b[2]=0;
51   if(fMap==1) {
52     if(TMath::Abs(x[2])<700 && x[0]*x[0]+(x[1]+30)*(x[1]+30) < 560*560) {
53       b[2]=2;
54     } else {
55       if ( -725 >= x[2] && x[2] >= -1225 ) {
56         Float_t dz = TMath::Abs(-975-x[2])*0.01;
57         b[0] = - (1-0.1*dz*dz)*7;
58       }
59       else {
60           ZDCField(x, b);
61       }
62     }
63     if(fFactor!=1) {
64         b[0]*=fFactor;
65         b[1]*=fFactor;
66         b[2]*=fFactor;
67     }
68   } else {
69       AliFatal(Form("Invalid field map for constant field %d",fMap));
70   }
71 }
72
73
74 void AliMagFC::ZDCField(Float_t *x, Float_t *b) const
75 {
76 //This is the ZDC part
77     Float_t rad2 = x[0] * x[0] + x[1] * x[1];
78
79     if (fCompensator && (x[2] > 919. && x[2] < 1231.) && rad2 < 16.) {
80       // Compensator magnet at z = 1075 m 
81         b[0] = 10.9;
82         b[1] = 0.;
83         b[2] = 0.;
84         return;
85     }
86     
87     
88     if(x[2] < kCORBEG2 && x[2] > kCOREND2){
89         if(rad2<kCOR2RA2){
90             b[0] = - kFCORN2;
91         }
92     }
93     else if(x[2] < kZ1BEG && x[2] > kZ1END){  
94         if(rad2<kZ1RA2){
95             b[0] =  kG1*x[1];
96             b[1] =  kG1*x[0];
97         }
98     }
99     else if(x[2] < kZ2BEG && x[2] > kZ2END){  
100         if(rad2<kZ2RA2){
101             b[0] = -kG1*x[1];
102             b[1] = -kG1*x[0];
103         }
104     }
105     else if(x[2] < kZ3BEG && x[2] > kZ3END){  
106         if(rad2<kZ3RA2){
107             b[0] = -kG1*x[1];
108             b[1] = -kG1*x[0];
109         }
110     }
111     else if(x[2] < kZ4BEG && x[2] > kZ4END){  
112         if(rad2<kZ4RA2){
113             b[0] =  kG1*x[1];
114             b[1] =  kG1*x[0];
115         }
116     }
117     else if(x[2] < kD1BEG && x[2] > kD1END){ 
118         if(rad2<kD1RA2){
119             b[1] = -kFDIP;
120         }
121     }
122     else if(x[2] < kD2BEG && x[2] > kD2END){
123         if(((x[0]-kXCEN1D2)*(x[0]-kXCEN1D2)+(x[1]-kYCEN1D2)*(x[1]-kYCEN1D2))<kD2RA2
124            || ((x[0]-kXCEN2D2)*(x[0]-kXCEN2D2)+(x[1]-kYCEN2D2)*(x[1]-kYCEN2D2))<kD2RA2){
125             b[1] = kFDIP;
126         }
127     }
128     
129 }