EIC code displayed by LXR master/​include/​Geant4/​G4OpBoundaryProcess.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-21 09:10:50

 //
 // ********************************************************************
 // * License and Disclaimer                                           *
 // *                                                                  *
 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
 // * conditions of the Geant4 Software License,  included in the file *
 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
 // * include a list of copyright holders.                             *
 // *                                                                  *
 // * Neither the authors of this software system, nor their employing *
 // * institutes,nor the agencies providing financial support for this *
 // * work  make  any representation or  warranty, express or implied, *
 // * regarding  this  software system or assume any liability for its *
 // * use.  Please see the license in the file  LICENSE  and URL above *
 // * for the full disclaimer and the limitation of liability.         *
 // *                                                                  *
 // * This  code  implementation is the result of  the  scientific and *
 // * technical work of the GEANT4 collaboration.                      *
 // * By using,  copying,  modifying or  distributing the software (or *
 // * any work based  on the software)  you  agree  to acknowledge its *
 // * use  in  resulting  scientific  publications,  and indicate your *
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
 //
 //
 //
 ////////////////////////////////////////////////////////////////////////
 // Optical Photon Boundary Process Class Definition
 ////////////////////////////////////////////////////////////////////////
 //
 // File:        G4OpBoundaryProcess.hh
 // Description: Discrete Process -- reflection/refraction at
 //                                  optical interfaces
 // Version:     1.1
 // Created:     1997-06-18
 // Modified:    2005-07-28 add G4ProcessType to constructor
 //              1999-10-29 add method and class descriptors
 //              1999-10-10 - Fill NewMomentum/NewPolarization in
 //                           DoAbsorption. These members need to be
 //                           filled since DoIt calls
 //                           aParticleChange.SetMomentumChange etc.
 //                           upon return (thanks to: Clark McGrew)
 //              2006-11-04 - add capability of calculating the reflectivity
 //                           off a metal surface by way of a complex index
 //                           of refraction - Thanks to Sehwook Lee and John
 //                           Hauptman (Dept. of Physics - Iowa State Univ.)
 //              2009-11-10 - add capability of simulating surface reflections
 //                           with Look-Up-Tables (LUT) containing measured
 //                           optical reflectance for a variety of surface
 //                           treatments - Thanks to Martin Janecek and
 //                           William Moses (Lawrence Berkeley National Lab.)
 //              2013-06-01 - add the capability of simulating the transmission
 //                           of a dichronic filter
 //              2017-02-24 - add capability of simulating surface reflections
 //                           with Look-Up-Tables (LUT) developed in DAVIS
 //
 // Author:      Peter Gumplinger
 //              adopted from work by Werner Keil - April 2/96
 //
 ////////////////////////////////////////////////////////////////////////
 
 #ifndef G4OpBoundaryProcess_h
 #define G4OpBoundaryProcess_h 1
 
 #include "G4OpticalPhoton.hh"
 #include "G4OpticalSurface.hh"
 #include "G4RandomTools.hh"
 #include "G4VDiscreteProcess.hh"
 
 enum G4OpBoundaryProcessStatus
 {
   Undefined,
   Transmission,
   FresnelRefraction,
   FresnelReflection,
   TotalInternalReflection,
   LambertianReflection,
   LobeReflection,
   SpikeReflection,
   BackScattering,
   Absorption,
   Detection,
   NotAtBoundary,
   SameMaterial,
   StepTooSmall,
   NoRINDEX,
   PolishedLumirrorAirReflection,
   PolishedLumirrorGlueReflection,
   PolishedAirReflection,
   PolishedTeflonAirReflection,
   PolishedTiOAirReflection,
   PolishedTyvekAirReflection,
   PolishedVM2000AirReflection,
   PolishedVM2000GlueReflection,
   EtchedLumirrorAirReflection,
   EtchedLumirrorGlueReflection,
   EtchedAirReflection,
   EtchedTeflonAirReflection,
   EtchedTiOAirReflection,
   EtchedTyvekAirReflection,
   EtchedVM2000AirReflection,
   EtchedVM2000GlueReflection,
   GroundLumirrorAirReflection,
   GroundLumirrorGlueReflection,
   GroundAirReflection,
   GroundTeflonAirReflection,
   GroundTiOAirReflection,
   GroundTyvekAirReflection,
   GroundVM2000AirReflection,
   GroundVM2000GlueReflection,
   Dichroic,
   CoatedDielectricReflection,
   CoatedDielectricRefraction,
   CoatedDielectricFrustratedTransmission
 };
 
 class G4OpBoundaryProcess : public G4VDiscreteProcess
 {
  public:
   explicit G4OpBoundaryProcess(const G4String& processName = "OpBoundary",
                                G4ProcessType type          = fOptical);
   virtual ~G4OpBoundaryProcess();
 
   virtual G4bool IsApplicable(
     const G4ParticleDefinition& aParticleType) override;
   // Returns true -> 'is applicable' only for an optical photon.
 
   virtual G4double GetMeanFreePath(const G4Track&, G4double,
                                    G4ForceCondition* condition) override;
   // Returns infinity; i. e. the process does not limit the step, but sets the
   // 'Forced' condition for the DoIt to be invoked at every step. However, only
   // at a boundary will any action be taken.
 
   G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
                                   const G4Step& aStep) override;
   // This is the method implementing boundary processes.
 
   virtual G4OpBoundaryProcessStatus GetStatus() const;
   // Returns the current status.
 
   virtual void SetInvokeSD(G4bool);
   // Set flag for call to InvokeSD method.
 
   virtual void PreparePhysicsTable(const G4ParticleDefinition&) override;
 
   virtual void Initialise();
 
   void SetVerboseLevel(G4int);
 
  private:
   G4OpBoundaryProcess(const G4OpBoundaryProcess& right) = delete;
   G4OpBoundaryProcess& operator=(const G4OpBoundaryProcess& right) = delete;
 
   G4bool G4BooleanRand(const G4double prob) const;
 
   G4ThreeVector GetFacetNormal(const G4ThreeVector& Momentum,
                                const G4ThreeVector& Normal) const;
 
   void DielectricMetal();
   void DielectricDielectric();
 
   void DielectricLUT();
   void DielectricLUTDAVIS();
 
   void DielectricDichroic();
   void CoatedDielectricDielectric();
 
   void ChooseReflection();
   void DoAbsorption();
   void DoReflection();
   void DoTransmission();
 
   void ApplyDielectricBoundaryTransition(G4double cost, G4bool roughnessPass,
                                          G4bool& inside, G4bool& swap);
   // Apply boundary actions at a dielectric–dielectric interface
 
   G4double GetIncidentAngle();
   // Returns the incident angle of optical photon
 
   G4double GetReflectivity(G4double E1_perp, G4double E1_parl,
                            G4double incidentangle, G4double RealRindex,
                            G4double ImaginaryRindex);
   // Returns the Reflectivity on a metallic surface
 
   G4double GetReflectivityThroughThinLayer(G4double sinTL, G4double E1_perp,
                                            G4double E1_parl, G4double wavelength,
                                            G4double cost1, G4double cost2);
   // Returns the Reflectivity on a coated surface
 
   void CalculateReflectivity();
 
   void BoundaryProcessVerbose() const;
 
   // Invoke SD for post step point if the photon is 'detected'
   G4bool InvokeSD(const G4Step* step);
 
   // Check if the given surface finish corresponds to a backpainted surface
   static constexpr G4bool IsBackpainted(G4OpticalSurfaceFinish finish) noexcept
   {
     return finish == polishedbackpainted || finish == groundbackpainted;
   }
 
   G4ThreeVector fOldMomentum;
   G4ThreeVector fOldPolarization;
 
   G4ThreeVector fNewMomentum;
   G4ThreeVector fNewPolarization;
 
   G4ThreeVector fGlobalNormal;
   G4ThreeVector fFacetNormal;
 
   const G4Material* fMaterial1;
   const G4Material* fMaterial2;
 
   G4OpticalSurface* fOpticalSurface;
 
   G4MaterialPropertyVector* fRealRIndexMPV;
   G4MaterialPropertyVector* fImagRIndexMPV;
   G4Physics2DVector* fDichroicVector;
 
   G4double fPhotonMomentum;
   G4double fRindex1;
   G4double fRindex2;
 
   G4double fSint1;
 
   G4double fReflectivity;
   G4double fEfficiency;
   G4double fTransmittance;
   G4double fSurfaceRoughness;
 
   G4double fProb_sl, fProb_ss, fProb_bs;
   G4double fCarTolerance;
 
   // Used by CoatedDielectricDielectric()
   G4double fCoatedRindex, fCoatedThickness;
 
   G4OpBoundaryProcessStatus fStatus;
   G4OpticalSurfaceModel fModel;
   G4OpticalSurfaceFinish fFinish;
 
   G4int f_iTE, f_iTM;
 
   G4int fNumSmallStepWarnings = 0; // number of times small step warning printed
   G4int fNumBdryTypeWarnings = 0;  // number of times boundary type warning printed
 
   size_t idx_dichroicX      = 0;
   size_t idx_dichroicY      = 0;
   size_t idx_rindex1        = 0;
   size_t idx_rindex_surface = 0;
   size_t idx_reflect        = 0;
   size_t idx_eff            = 0;
   size_t idx_trans          = 0;
   size_t idx_lobe           = 0;
   size_t idx_spike          = 0;
   size_t idx_back           = 0;
   size_t idx_rindex2        = 0;
   size_t idx_groupvel       = 0;
   size_t idx_rrindex        = 0;
   size_t idx_irindex        = 0;
   size_t idx_coatedrindex   = 0;
 
   // Used by CoatedDielectricDielectric()
   G4bool fCoatedFrustratedTransmission = true;
 
   G4bool fInvokeSD;
 };
 
 ////////////////////
 // Inline methods
 ////////////////////
 
 inline G4bool G4OpBoundaryProcess::G4BooleanRand(const G4double prob) const
 {
   // Returns a random boolean variable with the specified probability
   return (G4UniformRand() < prob);
 }
 
 inline G4bool G4OpBoundaryProcess::IsApplicable(
   const G4ParticleDefinition& aParticleType)
 {
   return (&aParticleType == G4OpticalPhoton::OpticalPhoton());
 }
 
 inline G4OpBoundaryProcessStatus G4OpBoundaryProcess::GetStatus() const
 {
   return fStatus;
 }
 
 inline void G4OpBoundaryProcess::ChooseReflection()
 {
   G4double rand = G4UniformRand();
   if(rand < fProb_ss)
   {
     fStatus      = SpikeReflection;
     fFacetNormal = fGlobalNormal;
   }
   else if(rand < fProb_ss + fProb_sl)
   {
     fStatus = LobeReflection;
   }
   else if(rand < fProb_ss + fProb_sl + fProb_bs)
   {
     fStatus = BackScattering;
   }
   else
   {
     fStatus = LambertianReflection;
   }
 }
 
 inline void G4OpBoundaryProcess::DoAbsorption()
 {
   fStatus = Absorption;
 
   if(G4BooleanRand(fEfficiency))
   {
     // EnergyDeposited =/= 0 means: photon has been detected
     fStatus = Detection;
     aParticleChange.ProposeLocalEnergyDeposit(fPhotonMomentum);
   }
   else
   {
     aParticleChange.ProposeLocalEnergyDeposit(0.0);
   }
 
   fNewMomentum     = fOldMomentum;
   fNewPolarization = fOldPolarization;
 
   aParticleChange.ProposeTrackStatus(fStopAndKill);
 }
 
 inline void G4OpBoundaryProcess::DoTransmission()
 {
   // Optical photons pass through the boundary without changing momentum or
   // polarization
   fStatus = Transmission;
   fNewMomentum = fOldMomentum;
   fNewPolarization = fOldPolarization;
 }
 
 inline void G4OpBoundaryProcess::DoReflection()
 {
   if(fStatus == LambertianReflection)
   {
     fNewMomentum = G4LambertianRand(fGlobalNormal);
     fFacetNormal = (fNewMomentum - fOldMomentum).unit();
   }
   else if(fFinish == ground)
   {
     fStatus = LobeReflection;
     if(!fRealRIndexMPV || !fImagRIndexMPV)
     {
       fFacetNormal = GetFacetNormal(fOldMomentum, fGlobalNormal);
     }
     // else
       // complex ref. index to be implemented
     fNewMomentum =
       fOldMomentum - (2. * fOldMomentum * fFacetNormal * fFacetNormal);
   }
   else
   {
     fStatus      = SpikeReflection;
     fFacetNormal = fGlobalNormal;
     fNewMomentum =
       fOldMomentum - (2. * fOldMomentum * fFacetNormal * fFacetNormal);
   }
   fNewPolarization =
     -fOldPolarization + (2. * fOldPolarization * fFacetNormal * fFacetNormal);
 }
 
 #endif /* G4OpBoundaryProcess_h */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team