| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // <<
26 // 7 //
>> 8 // $Id: G4OpAbsorption.hh,v 1.4.4.1 1999/12/07 20:52:51 gunter Exp $
>> 9 // GEANT4 tag $Name: geant4-01-01 $
27 // 10 //
28 ////////////////////////////////////////////// 11 ////////////////////////////////////////////////////////////////////////
29 // Optical Photon Absorption Class Definition 12 // Optical Photon Absorption Class Definition
30 ////////////////////////////////////////////// 13 ////////////////////////////////////////////////////////////////////////
31 // 14 //
32 // File: G4OpAbsorption.hh 15 // File: G4OpAbsorption.hh
33 // Description: Discrete Process -- Bulk absor 16 // Description: Discrete Process -- Bulk absorption of Optical Photons
34 // Version: 1.0 17 // Version: 1.0
35 // Created: 1996-05-21 18 // Created: 1996-05-21
36 // Author: Juliet Armstrong 19 // Author: Juliet Armstrong
37 // Updated: 2005-07-28 add G4ProcessType t << 20 // Updated: 1999-10-29 add method and class descriptors
38 // 1999-10-29 add method and clas <<
39 // 1997-04-09 by Peter Gumplinger 21 // 1997-04-09 by Peter Gumplinger
40 // > new physics/tracking scheme 22 // > new physics/tracking scheme
41 // 1998-08-25 by Stefano Magni 23 // 1998-08-25 by Stefano Magni
42 // > Change process to use G4Mate 24 // > Change process to use G4MaterialPropertiesTables
>> 25 // mail: gum@triumf.ca
>> 26 // magni@mi.infn.it
43 // 27 //
44 ////////////////////////////////////////////// 28 ////////////////////////////////////////////////////////////////////////
45 29
46 #ifndef G4OpAbsorption_h 30 #ifndef G4OpAbsorption_h
47 #define G4OpAbsorption_h 1 31 #define G4OpAbsorption_h 1
48 32
>> 33 /////////////
>> 34 // Includes
>> 35 /////////////
>> 36
>> 37 #include "globals.hh"
>> 38 #include "templates.hh"
>> 39 #include "Randomize.hh"
>> 40 #include "G4Step.hh"
49 #include "G4VDiscreteProcess.hh" 41 #include "G4VDiscreteProcess.hh"
>> 42 #include "G4DynamicParticle.hh"
>> 43 #include "G4Material.hh"
50 #include "G4OpticalPhoton.hh" 44 #include "G4OpticalPhoton.hh"
51 45
52 class G4OpAbsorption : public G4VDiscreteProce << 46 // Class Description:
>> 47 // Discrete Process -- Bulk absorption of Optical Photons.
>> 48 // Class inherits publicly from G4VDiscreteProcess
>> 49 // Class Description - End:
>> 50
>> 51 /////////////////////
>> 52 // Class Definition
>> 53 /////////////////////
>> 54
>> 55 class G4OpAbsorption : public G4VDiscreteProcess
53 { 56 {
54 public: <<
55 explicit G4OpAbsorption(const G4String& proc <<
56 G4ProcessType type <<
57 virtual ~G4OpAbsorption(); <<
58 57
59 virtual G4bool IsApplicable( << 58 private:
60 const G4ParticleDefinition& aParticleType) << 59
61 // Returns true -> 'is applicable' only for << 60 //////////////
>> 61 // Operators
>> 62 //////////////
>> 63
>> 64 // G4OpAbsorption& operator=(const G4OpAbsorption &right);
>> 65
>> 66 public: // Without description
>> 67
>> 68 ////////////////////////////////
>> 69 // Constructors and Destructor
>> 70 ////////////////////////////////
>> 71
>> 72 G4OpAbsorption(const G4String& processName = "Absorption");
>> 73
>> 74 // G4OpAbsorption(const G4OpAbsorption &right);
62 75
63 virtual G4double GetMeanFreePath(const G4Tra << 76 ~G4OpAbsorption();
64 G4ForceCond <<
65 // Returns the absorption length for bulk ab <<
66 // photons in media with a specified attenua <<
67 77
68 virtual G4VParticleChange* PostStepDoIt(cons << 78 ////////////
69 cons << 79 // Methods
70 // Method implementing bulk absorption of op << 80 ////////////
71 81
72 virtual void PreparePhysicsTable(const G4Par << 82 public: // With description
73 83
74 virtual void Initialise(); << 84 G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
>> 85 // Returns true -> 'is applicable' only for an optical photon.
75 86
76 void SetVerboseLevel(G4int); << 87 G4double GetMeanFreePath(const G4Track& aTrack,
>> 88 G4double ,
>> 89 G4ForceCondition* );
>> 90 // Returns the absorption length for bulk absorption of optical
>> 91 // photons in media with a specified attenuation length.
77 92
78 private: << 93 G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
79 G4OpAbsorption(const G4OpAbsorption& right) << 94 const G4Step& aStep);
80 G4OpAbsorption& operator=(const G4OpAbsorpti << 95 // This is the method implementing bulk absorption of optical
>> 96 // photons.
81 97
82 size_t idx_absorption = 0; <<
83 }; 98 };
84 99
>> 100 ////////////////////
85 // Inline methods 101 // Inline methods
>> 102 ////////////////////
86 103
87 inline G4bool G4OpAbsorption::IsApplicable( << 104 inline
88 const G4ParticleDefinition& aParticleType) << 105 G4bool G4OpAbsorption::IsApplicable(const G4ParticleDefinition& aParticleType)
89 { 106 {
90 return (&aParticleType == G4OpticalPhoton::O << 107 return ( &aParticleType == G4OpticalPhoton::OpticalPhoton() );
91 } 108 }
92 109
93 #endif /* G4OpAbsorption_h */ 110 #endif /* G4OpAbsorption_h */
94 111