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 {
  55 // Constructor
  56     fSamples = npckov;
  57     fEnergy                = new Float_t[fSamples];
  58     fWaveLength            = new Float_t[fSamples];
  59     fAbsorptionCoefficient = new Float_t[fSamples];
  60     fRefractionIndex       = new Float_t[fSamples];
  61     fQuantumEfficiency     = new Float_t[fSamples];
  62     fReflectivity          = new Float_t[fSamples];
  63
  64     for (Int_t i = 0; i < fSamples; i++) {
  65         fEnergy[i]             = ppckov[i];
  66         fWaveLength[i]         = khc / ppckov[i];
  67         if (absco[i] > 0.) {
  68             fAbsorptionCoefficient[i]   = 1./ absco[i];
  69         } else {
  70             fAbsorptionCoefficient[i]   = 1.e15;
  71         }
  72         fRefractionIndex[i]    = rindex[i];
  73         fQuantumEfficiency[i]  = effic[i];
  74         //
  75         // Find local maximum quantum efficiency
  76         if (effic[i] > fMaximumEfficiency) fMaximumEfficiency = effic[i];
  77         //
  78         // Flag is sensitive if quantum efficiency 0 < eff < 1 for at least one value.
  79         if (effic[i] < 1. && effic[i] > 0.) fIsSensitive = 1;
  80         // G3 way to define metal
  81         if (rindex[0] == 0.) {
  82             fIsMetal = kTRUE;
  83             fReflectivity[i] = absco[i];
  84         }
  85     }
  86     // Find global  maximum quantum efficiency
  87     if (fMaximumEfficiency > GetGlobalMaximumEfficiency()) {
  88         SetGlobalMaximumEfficiency(fMaximumEfficiency);
  89     }
  90 }
  91
  92 TFlukaCerenkov::TFlukaCerenkov(Int_t npckov, Float_t *ppckov, Float_t *absco, Float_t *effic, Float_t *rindex, Float_t *refl)
  93 {
  94     // Constructor including reflectivity
  95     fSamples = npckov;
  96     fEnergy                = new Float_t[fSamples];
  97     fWaveLength            = new Float_t[fSamples];
  98     fAbsorptionCoefficient = new Float_t[fSamples];
  99     fRefractionIndex       = new Float_t[fSamples];
 100     fQuantumEfficiency     = new Float_t[fSamples];
 101
 102
 103     for (Int_t i = 0; i < fSamples; i++) {
 104         fEnergy[i]             = ppckov[i];
 105         fWaveLength[i]         = khc / ppckov[i];
 106         if (absco[i] > 0.) {
 107             fAbsorptionCoefficient[i]   = 1./ absco[i];
 108         } else {
 109             fAbsorptionCoefficient[i]   = 1.e15;
 110         }
 111         fRefractionIndex[i]    = rindex[i];
 112         fQuantumEfficiency[i]  = effic[i];
 113         //
 114         // Find local maximum quantum efficiency
 115         if (effic[i] > fMaximumEfficiency) fMaximumEfficiency = effic[i];
 116         //
 117         // Flag is sensitive if quantum efficiency 0 < eff < 1 for at least one value.
 118         if (effic[i] < 1. && effic[i] > 0.) fIsSensitive = 1;
 119         //
 120
 121     }
 122     // Find global  maximum quantum efficiency
 123     if (fMaximumEfficiency > GetGlobalMaximumEfficiency()) {
 124         SetGlobalMaximumEfficiency(fMaximumEfficiency);
 125     }
 126     fReflectivity     = new Float_t[fSamples];
 127     for (Int_t i = 0; i < fSamples; i++) fReflectivity[i] = refl[i];
 128     fIsMetal = kTRUE;
 129 }
 130
 131 Float_t TFlukaCerenkov::GetAbsorptionCoefficient(Float_t energy)
 132 {
 133 //
 134 // Get AbsorptionCoefficient for given energy
 135 //
 136     return Interpolate(energy, fEnergy, fAbsorptionCoefficient);
 137
 138 }
 139
 140 Float_t TFlukaCerenkov::GetRefractionIndex(Float_t energy)
 141 {
 142 //
 143 // Get RefractionIndex for given energy
 144 //
 145     return Interpolate(energy, fEnergy, fRefractionIndex);
 146
 147 }
 148
 149 Float_t TFlukaCerenkov::GetReflectivity(Float_t energy)
 150 {
 151 //
 152 // Get RefractionIndex for given energy
 153 //
 154     return Interpolate(energy, fEnergy, fReflectivity);
 155
 156 }
 157
 158 Float_t TFlukaCerenkov::GetQuantumEfficiency(Float_t energy)
 159 {
 160 //
 161 // Get QuantumEfficiency for given energy
 162 //
 163     return Interpolate(energy, fEnergy, fQuantumEfficiency);
 164
 165 }
 166
 167
 168 Float_t TFlukaCerenkov::GetAbsorptionCoefficientByWaveLength(Float_t wavelength)
 169 {
 170 //
 171 // Get AbsorptionCoefficient for given wavelength
 172 //
 173     Float_t energy = khc / wavelength;
 174     return Interpolate(energy, fEnergy, fAbsorptionCoefficient);
 175
 176 }
 177
 178 Float_t TFlukaCerenkov::GetRefractionIndexByWaveLength(Float_t wavelength)
 179 {
 180 //
 181 // Get RefractionIndex for given wavelenth
 182 //
 183     Float_t energy = khc / wavelength;
 184     return Interpolate(energy, fEnergy, fRefractionIndex);
 185 }
 186
 187 Float_t TFlukaCerenkov::GetReflectivityByWaveLength(Float_t wavelength)
 188 {
 189 //
 190 // Get RefractionIndex for given wavelenth
 191 //
 192     Float_t energy = khc / wavelength;
 193     return Interpolate(energy, fEnergy, fReflectivity);
 194 }
 195
 196 Float_t TFlukaCerenkov::GetQuantumEfficiencyByWaveLength(Float_t wavelength)
 197 {
 198 //
 199 // Get QuantumEfficiency for given wavelength
 200 //
 201     Float_t energy = khc / wavelength;
 202     return Interpolate(energy, fEnergy, fQuantumEfficiency);
 203 }
 204
 205 Float_t TFlukaCerenkov::Interpolate(Float_t value, Float_t* array1, Float_t* array2)
 206 {
 207 //
 208 // Interpolate array values
 209 //
 210     if (value < array1[0] && value >= array1[fSamples - 1]) {
 211         Warning("Interpolate()", "Photon energy out of range. Returning 0.");
 212         return (0.);
 213     }
 214
 215     Int_t i = TMath::BinarySearch(fSamples, array1, value);
 216     if (i == (fSamples-1)) {
 217         return (array2[i]);
 218     } else {
 219         return (array2[i] + (array2[i+1] - array2[i]) / (array1[i+1] - array1[i]) * (value - array1[i]));
 220     }
 221 }
 222