Possibility to define reflectivity of optical medium.
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 7 Feb 2005 09:25:57 +0000 (09:25 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 7 Feb 2005 09:25:57 +0000 (09:25 +0000)
TFluka/TFluka.cxx
TFluka/TFluka.h
TFluka/TFlukaCerenkov.cxx
TFluka/TFlukaCerenkov.h
TFluka/rflctv.cxx

index 8dbcf46..eff2154 100644 (file)
@@ -739,14 +739,42 @@ void TFluka::SetCerenkov(Int_t itmed, Int_t npckov, Float_t* ppckov,
     medium->SetCerenkovProperties(cerenkovProperties);
 }  
 
+void TFluka::SetCerenkov(Int_t itmed, Int_t npckov, Float_t* ppckov,
+                        Float_t* absco, Float_t* effic, Float_t* rindex, Float_t* rfl) {
+//
+// Set Cerenkov properties for medium itmed
+//
+// npckov: number of sampling points
+// ppckov: energy values
+// absco:  absorption length
+// effic:  quantum efficiency
+// rindex: refraction index
+// rfl:    reflectivity for boundary to medium itmed
+//
+//  
+//  Create object holding Cerenkov properties
+//  
+    TFlukaCerenkov* cerenkovProperties = new TFlukaCerenkov(npckov, ppckov, absco, effic, rindex, rfl);
+//
+//  Pass object to medium
+    TGeoMedium* medium = gGeoManager->GetMedium(itmed);
+    medium->SetCerenkovProperties(cerenkovProperties);
+}  
+
+
 //______________________________________________________________________________ 
 void TFluka::SetCerenkov(Int_t /*itmed*/, Int_t /*npckov*/, Double_t * /*ppckov*/,
                         Double_t * /*absco*/, Double_t * /*effic*/, Double_t * /*rindex*/) {
 //
-// Not implemented with TGeo - what G4 did ? Any FLUKA card generated?
-   Warning("SetCerenkov", "Not implemented with TGeo");
+//  Double_t version not implemented
 }  
-    
+
+void TFluka::SetCerenkov(Int_t /*itmed*/, Int_t /*npckov*/, Double_t* /*ppckov*/,
+                        Double_t* /*absco*/, Double_t* /*effic*/, Double_t* /*rindex*/, Double_t* /*rfl*/) { 
+//
+// //  Double_t version not implemented
+}
+
 // Euclid
 //______________________________________________________________________________ 
 void TFluka::WriteEuclid(const char* /*fileName*/, const char* /*topVol*/, 
@@ -1074,7 +1102,7 @@ void TFluka::SetMaxStep(Double_t step)
     
     Int_t mreg, latt;
     fGeom->GetCurrentRegion(mreg, latt);
-    STEPSZ.stepmx[mreg - 1] = step;
+//    STEPSZ.stepmx[mreg - 1] = step;
 }
 
 
@@ -1316,12 +1344,12 @@ Double_t TFluka::Edep() const
   if (caller == 11 || caller==12 || caller==6 || caller == 40) return 0.0;
   Double_t sum = 0;
   for ( Int_t j=0;j<TRACKR.mtrack;j++) {
-    sum +=TRACKR.dtrack[j];  
+      sum +=TRACKR.dtrack[j];  
   }
   if (TRACKR.ntrack == 0 && TRACKR.mtrack == 0)
-    return fRull + sum;
+      return fRull + sum;
   else {
-    return sum;
+      return sum;
   }
 }
 
@@ -1921,7 +1949,7 @@ extern "C" {
        fluka->SetZsco(z);
        fluka->SetNCerenkov(nphot);
        fluka->SetCaller(50);
-       printf("userstepping ckv: %10d %10d %13.3f %13.3f %13.2f\n", nphot, mreg, x, y, z);
+       printf("userstepping ckv: %10d %10d %13.3f %13.3f %13.2f %s\n", nphot, mreg, x, y, z, fluka->CurrentVolName());
        (TVirtualMCApplication::Instance())->Stepping();
     }
 }
index 8212073..8e27d0d 100644 (file)
@@ -94,6 +94,10 @@ class TFluka : public TVirtualMC {
                             Float_t *absco, Float_t *effic, Float_t *rindex);
   virtual void   SetCerenkov(Int_t itmed, Int_t npckov, Double_t *ppckov,
                             Double_t *absco, Double_t *effic, Double_t *rindex);
+  virtual void   SetCerenkov(Int_t itmed, Int_t npckov, Float_t *ppckov,
+                            Float_t *absco, Float_t *effic, Float_t *rindex, Float_t *rfl);
+  virtual void   SetCerenkov(Int_t itmed, Int_t npckov, Double_t *ppckov,
+                            Double_t *absco, Double_t *effic, Double_t *rindex, Double_t *rfl);
   
   
   // Functions for drawing
index fe1616c..5eb019b 100644 (file)
@@ -43,6 +43,7 @@ TFlukaCerenkov::TFlukaCerenkov()
       fAbsorptionCoefficient(0),
       fQuantumEfficiency(0),
       fRefractionIndex(0),
+      fReflectivity(0),
       fMaximumEfficiency(0.)
 {
 // Default constructor
@@ -59,6 +60,7 @@ TFlukaCerenkov::TFlukaCerenkov(Int_t npckov, Float_t *ppckov, Float_t *absco, Fl
     fRefractionIndex       = new Float_t[fSamples];
     fQuantumEfficiency     = new Float_t[fSamples];
     
+    
     for (Int_t i = 0; i < fSamples; i++) {
        fEnergy[i]             = ppckov[i];
        fWaveLength[i]         = khc / ppckov[i];
@@ -82,6 +84,43 @@ TFlukaCerenkov::TFlukaCerenkov(Int_t npckov, Float_t *ppckov, Float_t *absco, Fl
     }
 }
 
+TFlukaCerenkov::TFlukaCerenkov(Int_t npckov, Float_t *ppckov, Float_t *absco, Float_t *effic, Float_t *rindex, Float_t *refl)
+{
+    // Constructor including reflectivity
+    fSamples = npckov;
+    fEnergy                = new Float_t[fSamples];
+    fWaveLength            = new Float_t[fSamples];
+    fAbsorptionCoefficient = new Float_t[fSamples];
+    fRefractionIndex       = new Float_t[fSamples];
+    fQuantumEfficiency     = new Float_t[fSamples];
+    
+    
+    for (Int_t i = 0; i < fSamples; i++) {
+       fEnergy[i]             = ppckov[i];
+       fWaveLength[i]         = khc / ppckov[i];
+       if (absco[i] > 0.) {
+           fAbsorptionCoefficient[i]   = 1./ absco[i];
+       } else {
+           fAbsorptionCoefficient[i]   = 1.e15;
+       }
+       fRefractionIndex[i]    = rindex[i];
+       fQuantumEfficiency[i]  = effic[i];
+       //
+       // Find local maximum quantum efficiency
+       if (effic[i] > fMaximumEfficiency) fMaximumEfficiency = effic[i];
+       //
+       // Flag is sensitive if quantum efficiency 0 < eff < 1 for at least one value.
+       if (effic[i] < 1. && effic[i] > 0.) fIsSensitive = 1;
+    }
+    // Find global  maximum quantum efficiency
+    if (fMaximumEfficiency > GetGlobalMaximumEfficiency()) {
+       SetGlobalMaximumEfficiency(fMaximumEfficiency);
+    }
+    fReflectivity     = new Float_t[fSamples];
+    for (Int_t i = 0; i < fSamples; i++) fReflectivity[i] = refl[i];
+    fIsMetal = kTRUE;
+}
+
 Float_t TFlukaCerenkov::GetAbsorptionCoefficient(Float_t energy)
 {
 //
@@ -100,6 +139,15 @@ Float_t TFlukaCerenkov::GetRefractionIndex(Float_t energy)
     
 }
 
+Float_t TFlukaCerenkov::GetReflectivity(Float_t energy)
+{
+//
+// Get RefractionIndex for given energy 
+//
+    return Interpolate(energy, fEnergy, fReflectivity);
+    
+}
+
 Float_t TFlukaCerenkov::GetQuantumEfficiency(Float_t energy)
 {
 //
@@ -129,6 +177,15 @@ Float_t TFlukaCerenkov::GetRefractionIndexByWaveLength(Float_t wavelength)
     return Interpolate(energy, fEnergy, fRefractionIndex);
 }
 
+Float_t TFlukaCerenkov::GetReflectivityByWaveLength(Float_t wavelength)
+{
+//
+// Get RefractionIndex for given wavelenth 
+//
+    Float_t energy = khc / wavelength;    
+    return Interpolate(energy, fEnergy, fReflectivity);
+}
+
 Float_t TFlukaCerenkov::GetQuantumEfficiencyByWaveLength(Float_t wavelength)
 {
 //
index 3af8389..84c00a5 100644 (file)
@@ -29,12 +29,15 @@ public:
    // constructors
     TFlukaCerenkov();
     TFlukaCerenkov(Int_t npckov, Float_t *ppckov, Float_t *absco, Float_t *effic, Float_t *rindex);
+    TFlukaCerenkov(Int_t npckov, Float_t *ppckov, Float_t *absco, Float_t *effic, Float_t *rindex, Float_t* rfl);
     virtual Float_t   GetAbsorptionCoefficient(Float_t energy);
     virtual Float_t   GetQuantumEfficiency(Float_t energy);
     virtual Float_t   GetRefractionIndex(Float_t energy);
+    virtual Float_t   GetReflectivity(Float_t energy);    
     virtual Float_t   GetAbsorptionCoefficientByWaveLength(Float_t energy);
     virtual Float_t   GetQuantumEfficiencyByWaveLength(Float_t energy);
     virtual Float_t   GetRefractionIndexByWaveLength(Float_t energy);
+    virtual Float_t   GetReflectivityByWaveLength(Float_t energy);
     virtual Float_t   GetMinimumEnergy()     {return fEnergy[0];}
     virtual Float_t   GetMaximumEnergy()     {return fEnergy[fSamples-1];}
     virtual Float_t   GetMinimumWavelength() {return khc / fEnergy[fSamples-1];}
@@ -57,6 +60,7 @@ public:
     Float_t*     fAbsorptionCoefficient;    // [fSamples] Absorption Coefficient (1/cm)
     Float_t*     fQuantumEfficiency;        // [fSamples] Quantum efficiency
     Float_t*     fRefractionIndex;          // [fSamples] Refraction Index
+    Float_t*     fReflectivity;             // [fSamples] Reflectivity
     Double_t     fMaximumEfficiency;        // Local maximum quantum efficiency
     // static 
     static Double_t fgGlobalMaximumEfficiency; // Global maximum quantum efficiency
index d312b0e..a3aaa6a 100644 (file)
@@ -1,15 +1,26 @@
 #include "Fdimpar.h"  //(DIMPAR) fluka include
 #include "Ftrackr.h"  //(TRACKR) fluka common
 #include "Fiounit.h"  //(IOUNIT) fluka common
+#include "TFluka.h"
+#include "TGeoMaterial.h"
+#include "TFlukaCerenkov.h"
+
+
 #ifndef WIN32
 # define rflctv rflctv_
 #else
 # define rflctv RFLCTV
 #endif
 extern "C" {
-Double_t rflctv(Double_t& wvlngt, Double_t& omgpho, Int_t& mmat)
+Double_t rflctv(Double_t& wvlngt, Double_t& /*omgpho*/, Int_t& mmat)
 {
-    printf("rflctv called  %e %e %d \n", wvlngt, omgpho, mmat);
-    return (0.);
+//
+//  Return reflectivity (1-r) for given photon energy and material
+//
+    TFluka* fluka =  (TFluka*) gMC;
+    TGeoMaterial*    material =  (TGeoMaterial*) (fluka->GetFlukaMaterials())->At(fluka->GetMaterialIndex(mmat));
+    TFlukaCerenkov*  cerenkov = dynamic_cast<TFlukaCerenkov*> (material->GetCerenkovProperties());
+    Double_t y =  (cerenkov->GetReflectivityByWaveLength(wvlngt));
+    return (y);
 }
 }