| 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 // G4ProcessTable inline methods implementatio <<
27 // 23 //
28 // Author: H.Kurashige, 4 August 1998 << 24 // $Id: G4ProcessTable.icc,v 1.4 2001/07/11 10:08:17 gunter Exp $
29 // ------------------------------------------- << 25 // GEANT4 tag $Name: geant4-05-01 $
30 << 26 //
31 // ------------------------------------------- << 27 // History:
>> 28 // Use STL vector instead of RW vector 1. Mar 00 H.Kurashige
32 // 29 //
>> 30 #include "G4ParticleTable.hh"
>> 31
>> 32 //////////////////////////
33 inline 33 inline
34 void G4ProcessTable::SetVerboseLevel(G4int val << 34 void G4ProcessTable::SetVerboseLevel(G4int value)
35 { 35 {
36 verboseLevel = value; 36 verboseLevel = value;
37 } 37 }
38 38
39 // ------------------------------------------- << 39 //////////////////////////
40 // <<
41 inline 40 inline
42 G4int G4ProcessTable::GetVerboseLevel() const << 41 G4int G4ProcessTable::GetVerboseLevel() const
43 { 42 {
44 return verboseLevel; 43 return verboseLevel;
45 } 44 }
46 45
47 // ------------------------------------------- << 46 //////////////////////////
48 // <<
49 inline 47 inline
50 G4int G4ProcessTable::Length() const << 48 G4int G4ProcessTable::Length() const
51 { 49 {
52 return G4int(fProcTblVector->size()); << 50 return fProcTblVector->size();
53 } 51 }
54 52
55 // ------------------------------------------- << 53 //////////////////////////
56 // <<
57 inline 54 inline
58 G4ProcessTable::G4ProcNameVector* G4ProcessTab << 55 G4ProcessTable::G4ProcNameVector* G4ProcessTable::GetNameList()
59 { 56 {
60 return fProcNameVector; << 57 return fProcNameVector;
61 } 58 }
62 59
63 // ------------------------------------------- << 60 //////////////////////////
64 // <<
65 inline 61 inline
66 G4ProcessTable::G4ProcTableVector* G4ProcessTa << 62 G4ProcessTable::G4ProcTableVector* G4ProcessTable::GetProcTableVector()
67 { 63 {
68 return fProcTblVector; 64 return fProcTblVector;
69 } 65 }
70 66
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 67
108 // ------------------------------------------- << 68 //////////////////////////
109 // <<
110 inline 69 inline
111 G4ProcessVector* G4ProcessTable::FindProcesses << 70 G4VProcess* G4ProcessTable::FindProcess(const G4String& processName,
>> 71 const G4ParticleDefinition* particle)
>> 72 const
112 { 73 {
113 return ExtractProcesses(fProcTblVector); << 74 if ( particle == 0 ) return 0;
>> 75 else return FindProcess(processName, particle->GetProcessManager());
114 } 76 }
115 77
116 // ------------------------------------------- << 78 //////////////////////////
117 // << 79 inline
118 inline << 80 G4VProcess* G4ProcessTable::FindProcess(const G4String& processName,
119 G4ProcessVector* << 81 const G4String& particleName) const
120 G4ProcessTable::FindProcesses( const G4Process <<
121 { 82 {
122 G4ProcessVector* procList = pManager->GetPro << 83 return FindProcess(processName,
123 return new G4ProcessVector(*procList); << 84 G4ParticleTable::GetParticleTable()->FindParticle(particleName));
124 } 85 }
125 86
126 // ------------------------------------------- << 87
127 // << 88 //////////////////////////
128 inline << 89 inline
129 G4ProcessVector* G4ProcessTable::FindProcesses << 90 void G4ProcessTable::SetProcessActivation(
130 { << 91 const G4String& processName,
131 G4ProcTableVector* pTblVector = Find(process << 92 G4ParticleDefinition* particle,
132 return ExtractProcesses(pTblVector); << 93 G4bool fActive)
>> 94 {
>> 95 if ( particle != 0 ) {
>> 96 SetProcessActivation(processName, particle->GetProcessManager(), fActive);
>> 97 }
>> 98 }
>> 99 //////////////////////////
>> 100 inline
>> 101 void G4ProcessTable::SetProcessActivation(
>> 102 const G4String& processName,
>> 103 const G4String& particleName,
>> 104 G4bool fActive )
>> 105 {
>> 106 if (particleName == "ALL" ) {
>> 107 SetProcessActivation( processName , fActive);
>> 108 } else {
>> 109 SetProcessActivation(
>> 110 processName,
>> 111 G4ParticleTable::GetParticleTable()->FindParticle(particleName),
>> 112 fActive );
>> 113 }
133 } 114 }
134 115
135 // ------------------------------------------- << 116 //////////////////////////
136 // << 117 inline
137 inline << 118 void G4ProcessTable::SetProcessActivation(
138 G4ProcessVector* G4ProcessTable::FindProcesses << 119 G4ProcessType processType,
139 { << 120 G4ParticleDefinition* particle,
140 G4ProcTableVector* pTblVector = Find(process << 121 G4bool fActive)
141 return ExtractProcesses(pTblVector); << 122 {
>> 123 if ( particle != 0 ) {
>> 124 SetProcessActivation( processType, particle->GetProcessManager(), fActive);
>> 125 }
>> 126 }
>> 127
>> 128 //////////////////////////
>> 129 inline
>> 130 void G4ProcessTable::SetProcessActivation(
>> 131 G4ProcessType processType,
>> 132 const G4String& particleName ,
>> 133 G4bool fActive)
>> 134 {
>> 135 if ((particleName == "ALL" )||(particleName == "all" )) {
>> 136 SetProcessActivation( processType, fActive );
>> 137 } else {
>> 138 SetProcessActivation(
>> 139 processType,
>> 140 G4ParticleTable::GetParticleTable()->FindParticle(particleName),
>> 141 fActive );
>> 142 }
142 } 143 }
>> 144
143 145