| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4ProcessTable inline methods implementatio <<
27 // 26 //
28 // Author: H.Kurashige, 4 August 1998 << 27 // $Id$
29 // ------------------------------------------- << 28 //
30 << 29 // History:
31 // ------------------------------------------- << 30 // Use STL vector instead of RW vector 1. Mar 00 H.Kurashige
32 // 31 //
>> 32 #include "G4ParticleTable.hh"
>> 33
>> 34 //////////////////////////
33 inline 35 inline
34 void G4ProcessTable::SetVerboseLevel(G4int val << 36 void G4ProcessTable::SetVerboseLevel(G4int value)
35 { 37 {
36 verboseLevel = value; 38 verboseLevel = value;
37 } 39 }
38 40
39 // ------------------------------------------- << 41 //////////////////////////
40 // <<
41 inline 42 inline
42 G4int G4ProcessTable::GetVerboseLevel() const << 43 G4int G4ProcessTable::GetVerboseLevel() const
43 { 44 {
44 return verboseLevel; 45 return verboseLevel;
45 } 46 }
46 47
47 // ------------------------------------------- << 48 //////////////////////////
48 // <<
49 inline 49 inline
50 G4int G4ProcessTable::Length() const << 50 G4int G4ProcessTable::Length() const
51 { 51 {
52 return G4int(fProcTblVector->size()); << 52 return fProcTblVector->size();
53 } 53 }
54 54
55 // ------------------------------------------- << 55 //////////////////////////
56 // <<
57 inline 56 inline
58 G4ProcessTable::G4ProcNameVector* G4ProcessTab << 57 G4ProcessTable::G4ProcNameVector* G4ProcessTable::GetNameList()
59 { 58 {
60 return fProcNameVector; << 59 return fProcNameVector;
61 } 60 }
62 61
63 // ------------------------------------------- << 62 //////////////////////////
64 // <<
65 inline 63 inline
66 G4ProcessTable::G4ProcTableVector* G4ProcessTa << 64 G4ProcessTable::G4ProcTableVector* G4ProcessTable::GetProcTableVector()
67 { 65 {
68 return fProcTblVector; 66 return fProcTblVector;
69 } 67 }
70 68
71 // ------------------------------------------- <<
72 // <<
73 inline <<
74 G4VProcess* <<
75 G4ProcessTable::FindProcess(const G4String& pr <<
76 const G4ParticleDe <<
77 { <<
78 return (particle) ? <<
79 FindProcess(processName, particle->GetProc <<
80 } <<
81 <<
82 // ------------------------------------------- <<
83 // <<
84 inline <<
85 void G4ProcessTable::SetProcessActivation(cons <<
86 cons <<
87 <<
88 { <<
89 if ( particle != nullptr ) <<
90 { <<
91 SetProcessActivation(processName, particle <<
92 } <<
93 } <<
94 <<
95 // ------------------------------------------- <<
96 // <<
97 inline <<
98 void G4ProcessTable::SetProcessActivation(G4Pr <<
99 cons <<
100 <<
101 { <<
102 if ( particle != nullptr ) <<
103 { <<
104 SetProcessActivation(processType, particle <<
105 } <<
106 } <<
107 69
108 // ------------------------------------------- << 70 //////////////////////////
109 // <<
110 inline 71 inline
111 G4ProcessVector* G4ProcessTable::FindProcesses << 72 G4VProcess* G4ProcessTable::FindProcess(const G4String& processName,
>> 73 const G4ParticleDefinition* particle)
>> 74 const
112 { 75 {
113 return ExtractProcesses(fProcTblVector); << 76 if ( particle == 0 ) return 0;
>> 77 else return FindProcess(processName, particle->GetProcessManager());
114 } 78 }
115 79
116 // ------------------------------------------- << 80 //////////////////////////
117 // << 81 inline
118 inline << 82 G4VProcess* G4ProcessTable::FindProcess(const G4String& processName,
119 G4ProcessVector* << 83 const G4String& particleName) const
120 G4ProcessTable::FindProcesses( const G4Process <<
121 { 84 {
122 G4ProcessVector* procList = pManager->GetPro << 85 return FindProcess(processName,
123 return new G4ProcessVector(*procList); << 86 G4ParticleTable::GetParticleTable()->FindParticle(particleName));
124 } 87 }
125 88
126 // ------------------------------------------- << 89
127 // << 90 //////////////////////////
128 inline << 91 inline
129 G4ProcessVector* G4ProcessTable::FindProcesses << 92 void G4ProcessTable::SetProcessActivation(
130 { << 93 const G4String& processName,
131 G4ProcTableVector* pTblVector = Find(process << 94 G4ParticleDefinition* particle,
132 return ExtractProcesses(pTblVector); << 95 G4bool fActive)
>> 96 {
>> 97 if ( particle != 0 ) {
>> 98 SetProcessActivation(processName, particle->GetProcessManager(), fActive);
>> 99 }
>> 100 }
>> 101 //////////////////////////
>> 102 inline
>> 103 void G4ProcessTable::SetProcessActivation(
>> 104 const G4String& processName,
>> 105 const G4String& particleName,
>> 106 G4bool fActive )
>> 107 {
>> 108 if (particleName == "ALL" ) {
>> 109 SetProcessActivation( processName , fActive);
>> 110 } else {
>> 111 SetProcessActivation(
>> 112 processName,
>> 113 G4ParticleTable::GetParticleTable()->FindParticle(particleName),
>> 114 fActive );
>> 115 }
133 } 116 }
134 117
135 // ------------------------------------------- << 118 //////////////////////////
136 // << 119 inline
137 inline << 120 void G4ProcessTable::SetProcessActivation(
138 G4ProcessVector* G4ProcessTable::FindProcesses << 121 G4ProcessType processType,
139 { << 122 G4ParticleDefinition* particle,
140 G4ProcTableVector* pTblVector = Find(process << 123 G4bool fActive)
141 return ExtractProcesses(pTblVector); << 124 {
>> 125 if ( particle != 0 ) {
>> 126 SetProcessActivation( processType, particle->GetProcessManager(), fActive);
>> 127 }
>> 128 }
>> 129
>> 130 //////////////////////////
>> 131 inline
>> 132 void G4ProcessTable::SetProcessActivation(
>> 133 G4ProcessType processType,
>> 134 const G4String& particleName ,
>> 135 G4bool fActive)
>> 136 {
>> 137 if ((particleName == "ALL" )||(particleName == "all" )) {
>> 138 SetProcessActivation( processType, fActive );
>> 139 } else {
>> 140 SetProcessActivation(
>> 141 processType,
>> 142 G4ParticleTable::GetParticleTable()->FindParticle(particleName),
>> 143 fActive );
>> 144 }
142 } 145 }
>> 146
143 147