| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // 23 //
>> 24 // $Id: G4OpWLS.hh,v 1.1 2003/09/23 22:23:57 gum Exp $
>> 25 // GEANT4 tag $Name: geant4-07-00-patch-01 $
27 // 26 //
28 ////////////////////////////////////////////// 27 ////////////////////////////////////////////////////////////////////////
29 // Optical Photon WaveLength Shifting (WLS) Cl 28 // Optical Photon WaveLength Shifting (WLS) Class Definition
30 ////////////////////////////////////////////// 29 ////////////////////////////////////////////////////////////////////////
31 // 30 //
32 // File: G4OpWLS.hh 31 // File: G4OpWLS.hh
33 // Description: Discrete Process -- Wavelength << 32 // Description: Discrete Process -- Wavelength Shifting of Optical Photons
34 // Version: 1.0 33 // Version: 1.0
35 // Created: 2003-05-13 34 // Created: 2003-05-13
36 // Author: John Paul Archambault 35 // Author: John Paul Archambault
37 // (Adaptation of G4Scintillation 36 // (Adaptation of G4Scintillation and G4OpAbsorption)
38 // Updated: 2005-07-28 add G4ProcessType t << 37 // Updated:
39 // 2006-05-07 - add G4VWLSTimeGen << 38 // mail: gum@triumf.ca
>> 39 // jparcham@phys.ualberta.ca
40 // 40 //
41 ////////////////////////////////////////////// 41 ////////////////////////////////////////////////////////////////////////
42 42
43 #ifndef G4OpWLS_h 43 #ifndef G4OpWLS_h
44 #define G4OpWLS_h 1 44 #define G4OpWLS_h 1
45 45
>> 46 /////////////
>> 47 // Includes
>> 48 /////////////
>> 49
>> 50 #include "globals.hh"
>> 51 #include "templates.hh"
>> 52 #include "Randomize.hh"
>> 53 #include "G4Poisson.hh"
>> 54 #include "G4ThreeVector.hh"
>> 55 #include "G4ParticleMomentum.hh"
>> 56 #include "G4Step.hh"
46 #include "G4VDiscreteProcess.hh" 57 #include "G4VDiscreteProcess.hh"
>> 58 #include "G4DynamicParticle.hh"
>> 59 #include "G4Material.hh"
47 #include "G4OpticalPhoton.hh" 60 #include "G4OpticalPhoton.hh"
>> 61 #include "G4PhysicsTable.hh"
>> 62 #include "G4MaterialPropertiesTable.hh"
>> 63 #include "G4PhysicsOrderedFreeVector.hh"
>> 64
>> 65 // Class Description:
>> 66 // Discrete Process -- Bulk absorption of Optical Photons.
>> 67 // Class inherits publicly from G4VDiscreteProcess
>> 68 // Class Description - End:
>> 69
>> 70 /////////////////////
>> 71 // Class Definition
>> 72 /////////////////////
48 73
49 class G4VWLSTimeGeneratorProfile; << 74 class G4OpWLS : public G4VDiscreteProcess
50 <<
51 class G4OpWLS : public G4VDiscreteProcess <<
52 { 75 {
53 public: <<
54 explicit G4OpWLS(const G4String& processName <<
55 G4ProcessType type <<
56 virtual ~G4OpWLS(); <<
57 76
58 virtual G4bool IsApplicable( << 77 public: // Without description
59 const G4ParticleDefinition& aParticleType) << 78
>> 79 ////////////////////////////////
>> 80 // Constructors and Destructor
>> 81 ////////////////////////////////
>> 82
>> 83 G4OpWLS(const G4String& processName = "OpWLS");
>> 84
>> 85 ~G4OpWLS();
>> 86
>> 87 ////////////
>> 88 // Methods
>> 89 ////////////
>> 90
>> 91 public: // With description
>> 92
>> 93 G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
60 // Returns true -> 'is applicable' only for 94 // Returns true -> 'is applicable' only for an optical photon.
61 95
62 virtual void BuildPhysicsTable( << 96 G4double GetMeanFreePath(const G4Track& aTrack,
63 const G4ParticleDefinition& aParticleType) << 97 G4double ,
64 // Build the WLS integral table at the right << 98 G4ForceCondition* );
65 << 99 // Returns the absorption length for bulk absorption of optical
66 virtual G4double GetMeanFreePath(const G4Tra <<
67 G4ForceCond <<
68 // Returns the absorption length for WLS abs <<
69 // photons in media with a specified attenua 100 // photons in media with a specified attenuation length.
70 101
71 virtual G4VParticleChange* PostStepDoIt(cons << 102 G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
72 cons << 103 const G4Step& aStep);
73 // This is the method implementing WLS for o << 104 // This is the method implementing bulk absorption of optical
>> 105 // photons.
74 106
75 virtual G4PhysicsTable* GetIntegralTable() c << 107 G4PhysicsTable* GetIntegralTable() const;
76 // Returns the address of the WLS integral t 108 // Returns the address of the WLS integral table.
77 109
78 virtual void DumpPhysicsTable() const; << 110 void DumpPhysicsTable() const;
79 // Prints the WLS integral table. 111 // Prints the WLS integral table.
80 112
81 virtual void UseTimeProfile(const G4String n << 113 private:
82 // Selects the time profile generator <<
83 114
84 virtual void PreparePhysicsTable(const G4Par << 115 void BuildThePhysicsTable();
85 virtual void Initialise(); << 116 // Is the WLS integral table;
86 117
87 void SetVerboseLevel(G4int); << 118 protected:
88 119
89 protected: <<
90 G4VWLSTimeGeneratorProfile* WLSTimeGenerator <<
91 G4PhysicsTable* theIntegralTable; 120 G4PhysicsTable* theIntegralTable;
92 121
93 private: <<
94 G4OpWLS(const G4OpWLS& right) = delete; <<
95 G4OpWLS& operator=(const G4OpWLS& right) = d <<
96 <<
97 std::size_t idx_wls = 0; <<
98 }; 122 };
99 123
100 //////////////////// 124 ////////////////////
101 // Inline methods 125 // Inline methods
102 //////////////////// 126 ////////////////////
103 127
104 inline G4bool G4OpWLS::IsApplicable(const G4Pa << 128 inline
>> 129 G4bool G4OpWLS::IsApplicable(const G4ParticleDefinition& aParticleType)
105 { 130 {
106 return (&aParticleType == G4OpticalPhoton::O << 131 return ( &aParticleType == G4OpticalPhoton::OpticalPhoton() );
107 } 132 }
108 133
109 inline G4PhysicsTable* G4OpWLS::GetIntegralTab << 134 inline
>> 135 G4PhysicsTable* G4OpWLS::GetIntegralTable() const
110 { 136 {
111 return theIntegralTable; 137 return theIntegralTable;
112 } 138 }
113 139
114 inline void G4OpWLS::DumpPhysicsTable() const << 140 inline
>> 141 void G4OpWLS::DumpPhysicsTable() const
115 { 142 {
116 std::size_t PhysicsTableSize = theIntegralTa << 143 G4int PhysicsTableSize = theIntegralTable->entries();
117 G4PhysicsFreeVector* v; << 144 G4PhysicsOrderedFreeVector *v;
118 << 145
119 for(std::size_t i = 0; i < PhysicsTableSize; << 146 for (G4int i = 0 ; i < PhysicsTableSize ; i++ )
120 { << 147 {
121 v = (G4PhysicsFreeVector*) (*theIntegralTa << 148 v = (G4PhysicsOrderedFreeVector*)(*theIntegralTable)[i];
122 v->DumpValues(); << 149 v->DumpValues();
123 } << 150 }
124 } 151 }
125 152
126 #endif /* G4OpWLS_h */ 153 #endif /* G4OpWLS_h */
127 154