Dummy methods DefineParticle required by the interface added.
[u/mrichter/AliRoot.git] / TFluka / TFlukaCerenkov.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 // Stores user defined cerenkov properties of media like 
20 // absorption coefficient, refraction index and quantum efficiency. 
21 // The properties are stored in arrays. The array index corresponds to discrete 
22 // optical photon energies defined in fEnergy.
23 // Access to the properties is provided by interpolation.
24 // 
25 // Author:
26 // A. Morsch 
27 // andreas.morsch@cern.ch
28 //
29
30 #include "TFlukaCerenkov.h"
31
32 Double_t TFlukaCerenkov::fgGlobalMaximumEfficiency = 0.;
33    
34 ClassImp(TFlukaCerenkov)
35
36
37 TFlukaCerenkov::TFlukaCerenkov()
38     : fSamples(0), 
39       fIsMetal(kFALSE),
40       fIsSensitive(kFALSE),
41       fEnergy(0),
42       fWaveLength(0),
43       fAbsorptionCoefficient(0),
44       fQuantumEfficiency(0),
45       fRefractionIndex(0),
46       fReflectivity(0),
47       fMaximumEfficiency(0.)
48 {
49 // Default constructor
50 }
51
52
53 TFlukaCerenkov::TFlukaCerenkov(Int_t npckov, Float_t *ppckov, Float_t *absco, Float_t *effic, Float_t *rindex)
54     : fSamples(npckov),
55       fIsMetal(kFALSE),
56       fIsSensitive(kFALSE),
57       fEnergy(new Float_t[fSamples]),
58       fWaveLength(new Float_t[fSamples]),
59       fAbsorptionCoefficient(new Float_t[fSamples]),
60       fQuantumEfficiency(new Float_t[fSamples]),
61       fRefractionIndex(new Float_t[fSamples]),
62       fReflectivity(new Float_t[fSamples]),
63       fMaximumEfficiency(0.)
64 {
65 // Constructor
66
67 //    fSamples = npckov;
68 //    fEnergy                = new Float_t[fSamples];
69 //    fWaveLength            = new Float_t[fSamples];
70 //    fAbsorptionCoefficient = new Float_t[fSamples];
71 //    fRefractionIndex       = new Float_t[fSamples];
72 //    fQuantumEfficiency     = new Float_t[fSamples];
73 //    fReflectivity          = new Float_t[fSamples];    
74
75     for (Int_t i = 0; i < fSamples; i++) {
76         fEnergy[i]             = ppckov[i];
77         fWaveLength[i]         = khc / ppckov[i];
78         if (absco[i] > 0.) {
79             fAbsorptionCoefficient[i]   = 1./ absco[i];
80         } else {
81             fAbsorptionCoefficient[i]   = 1.e15;
82         }
83         fRefractionIndex[i]    = rindex[i];
84         fQuantumEfficiency[i]  = effic[i];
85         //
86         // Find local maximum quantum efficiency
87         if (effic[i] > fMaximumEfficiency) fMaximumEfficiency = effic[i];
88         //
89         // Flag is sensitive if quantum efficiency 0 < eff < 1 for at least one value.
90         if (effic[i] < 1. && effic[i] > 0.) fIsSensitive = 1;
91         // G3 way to define metal
92         if (rindex[0] == 0.) {
93             fIsMetal = kTRUE;
94             fReflectivity[i] = absco[i];
95         }
96     }
97     // Find global  maximum quantum efficiency
98     if (fMaximumEfficiency > GetGlobalMaximumEfficiency()) {
99         SetGlobalMaximumEfficiency(fMaximumEfficiency);
100     }
101 }
102
103 TFlukaCerenkov::TFlukaCerenkov(Int_t npckov, Float_t *ppckov, Float_t *absco, Float_t *effic, Float_t *rindex, Float_t *refl)
104     : fSamples(npckov),
105       fIsMetal(kFALSE),
106       fIsSensitive(kFALSE),
107       fEnergy(new Float_t[fSamples]),
108       fWaveLength(new Float_t[fSamples]),
109       fAbsorptionCoefficient(new Float_t[fSamples]),
110       fQuantumEfficiency(new Float_t[fSamples]),
111       fRefractionIndex(new Float_t[fSamples]),
112       fReflectivity(new Float_t[fSamples]),
113       fMaximumEfficiency(0.)
114 {
115     // Constructor including reflectivity
116 //    fSamples = npckov;
117 //    fEnergy                = new Float_t[fSamples];
118 //    fWaveLength            = new Float_t[fSamples];
119 //    fAbsorptionCoefficient = new Float_t[fSamples];
120 //    fRefractionIndex       = new Float_t[fSamples];
121 //    fQuantumEfficiency     = new Float_t[fSamples];
122     
123     
124     for (Int_t i = 0; i < fSamples; i++) {
125         fEnergy[i]             = ppckov[i];
126         fWaveLength[i]         = khc / ppckov[i];
127         if (absco[i] > 0.) {
128             fAbsorptionCoefficient[i]   = 1./ absco[i];
129         } else {
130             fAbsorptionCoefficient[i]   = 1.e15;
131         }
132         fRefractionIndex[i]    = rindex[i];
133         fQuantumEfficiency[i]  = effic[i];
134         //
135         // Find local maximum quantum efficiency
136         if (effic[i] > fMaximumEfficiency) fMaximumEfficiency = effic[i];
137         //
138         // Flag is sensitive if quantum efficiency 0 < eff < 1 for at least one value.
139         if (effic[i] < 1. && effic[i] > 0.) fIsSensitive = 1;
140         //
141
142     }
143     // Find global  maximum quantum efficiency
144     if (fMaximumEfficiency > GetGlobalMaximumEfficiency()) {
145         SetGlobalMaximumEfficiency(fMaximumEfficiency);
146     }
147 //    fReflectivity     = new Float_t[fSamples];
148     for (Int_t i = 0; i < fSamples; i++) fReflectivity[i] = refl[i];
149     fIsMetal = kTRUE;
150 }
151
152 Float_t TFlukaCerenkov::GetAbsorptionCoefficient(Float_t energy)
153 {
154 //
155 // Get AbsorptionCoefficient for given energy 
156 //
157     return Interpolate(energy, fEnergy, fAbsorptionCoefficient);
158     
159 }
160
161 Float_t TFlukaCerenkov::GetRefractionIndex(Float_t energy)
162 {
163 //
164 // Get RefractionIndex for given energy 
165 //
166     return Interpolate(energy, fEnergy, fRefractionIndex);
167     
168 }
169
170 Float_t TFlukaCerenkov::GetReflectivity(Float_t energy)
171 {
172 //
173 // Get RefractionIndex for given energy 
174 //
175     return Interpolate(energy, fEnergy, fReflectivity);
176     
177 }
178
179 Float_t TFlukaCerenkov::GetQuantumEfficiency(Float_t energy)
180 {
181 //
182 // Get QuantumEfficiency for given energy 
183 //
184     return Interpolate(energy, fEnergy, fQuantumEfficiency);
185     
186 }
187
188
189 Float_t TFlukaCerenkov::GetAbsorptionCoefficientByWaveLength(Float_t wavelength)
190 {
191 //
192 // Get AbsorptionCoefficient for given wavelength 
193 //
194     Float_t energy = khc / wavelength;    
195     return Interpolate(energy, fEnergy, fAbsorptionCoefficient);
196     
197 }
198
199 Float_t TFlukaCerenkov::GetRefractionIndexByWaveLength(Float_t wavelength)
200 {
201 //
202 // Get RefractionIndex for given wavelenth 
203 //
204     Float_t energy = khc / wavelength;    
205     return Interpolate(energy, fEnergy, fRefractionIndex);
206 }
207
208 Float_t TFlukaCerenkov::GetReflectivityByWaveLength(Float_t wavelength)
209 {
210 //
211 // Get RefractionIndex for given wavelenth 
212 //
213     Float_t energy = khc / wavelength;    
214     return Interpolate(energy, fEnergy, fReflectivity);
215 }
216
217 Float_t TFlukaCerenkov::GetQuantumEfficiencyByWaveLength(Float_t wavelength)
218 {
219 //
220 // Get QuantumEfficiency for given wavelength 
221 //
222     Float_t energy = khc / wavelength;    
223     return Interpolate(energy, fEnergy, fQuantumEfficiency);
224 }
225
226 Float_t TFlukaCerenkov::Interpolate(Float_t value, Float_t* array1, Float_t* array2)
227 {
228 //
229 // Interpolate array values 
230 //
231     if (value < array1[0] && value >= array1[fSamples - 1]) {
232         Warning("Interpolate()", "Photon energy out of range. Returning 0.");
233         return (0.);
234     }
235     
236     Int_t i = TMath::BinarySearch(fSamples, array1, value);
237     if (i == (fSamples-1)) {
238         return (array2[i]);
239     } else {
240         return (array2[i] + (array2[i+1] - array2[i]) / (array1[i+1] - array1[i]) * (value - array1[i]));
241     }
242 }
243