| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
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
27 #include "G4AdjointCSMatrix.hh"
28
29 #include "G4AdjointInterpolator.hh"
30 #include "G4SystemOfUnits.hh"
31
32 #include <iomanip>
33 #include <fstream>
34
35 //////////////////////////////////////////////
36 G4AdjointCSMatrix::G4AdjointCSMatrix(G4bool aB
37
38 //////////////////////////////////////////////
39 G4AdjointCSMatrix::~G4AdjointCSMatrix()
40 {
41 fLogPrimEnergyVector.clear();
42 fLogCrossSectionVector.clear();
43
44 for (auto p : fLogSecondEnergyMatrix) {
45 p->clear();
46 delete p;
47 p = nullptr;
48 }
49 fLogSecondEnergyMatrix.clear();
50
51 for (auto p : fLogProbMatrix) {
52 p->clear();
53 delete p;
54 p = nullptr;
55 }
56 fLogProbMatrix.clear();
57
58 for (auto p : fLogProbMatrixIndex) {
59 if (p) {
60 p->clear();
61 delete p;
62 p = nullptr;
63 }
64 }
65 fLogProbMatrixIndex.clear();
66 }
67
68 //////////////////////////////////////////////
69 void G4AdjointCSMatrix::Clear()
70 {
71 fLogPrimEnergyVector.clear();
72 fLogCrossSectionVector.clear();
73 fLogSecondEnergyMatrix.clear();
74 fLogProbMatrix.clear();
75 fLogProbMatrixIndex.clear();
76 fLog0Vector.clear();
77 fNbPrimEnergy = 0;
78 }
79
80 //////////////////////////////////////////////
81 void G4AdjointCSMatrix::AddData(G4double aLogP
82 std::vector<G4
83 std::vector<G4
84 std::size_t n_
85 {
86 G4AdjointInterpolator* theInterpolator = G4A
87
88 // At this time we consider that the energy
89 fLogPrimEnergyVector.push_back(aLogPrimEnerg
90 fLogCrossSectionVector.push_back(aLogCS);
91 fLogSecondEnergyMatrix.push_back(aLogSecondE
92 fLogProbMatrix.push_back(aLogProbVector);
93
94 std::vector<std::size_t>* aLogProbVectorInde
95
96 if(n_pro_decade > 0 && !aLogProbVector->empt
97 {
98 aLogProbVectorIndex = new std::vector<std:
99 G4double dlog = std::log(10.) / n_pr
100 G4double log_val =
101 G4int(std::min((*aLogProbVector)[0], aLo
102 fLog0Vector.push_back(log_val);
103
104 // Loop checking, 07-Aug-2015, Vladimir Iv
105 while(log_val < 0.)
106 {
107 aLogProbVectorIndex->push_back(
108 theInterpolator->FindPosition(log_val,
109 log_val += dlog;
110 }
111 }
112 else
113 {
114 fLog0Vector.push_back(0.);
115 }
116 fLogProbMatrixIndex.push_back(aLogProbVector
117
118 ++fNbPrimEnergy;
119 }
120
121 //////////////////////////////////////////////
122 G4bool G4AdjointCSMatrix::GetData(unsigned int
123 G4double& aL
124 std::vector<
125 std::vector<
126 std::vector<
127 {
128 if(i >= fNbPrimEnergy)
129 return false;
130 aLogPrimEnergy = fLogPrimEnergyVecto
131 aLogCS = fLogCrossSectionVec
132 aLogSecondEnergyVector = fLogSecondEnergyMat
133 aLogProbVector = fLogProbMatrix[i];
134 aLogProbVectorIndex = fLogProbMatrixIndex
135 log0 = fLog0Vector[i];
136 return true;
137 }
138
139 //////////////////////////////////////////////
140 void G4AdjointCSMatrix::Write(const G4String&
141 {
142 std::fstream FileOutput(file_name, std::ios:
143 FileOutput << std::setiosflags(std::ios::sci
144 FileOutput << std::setprecision(6);
145 FileOutput << fLogPrimEnergyVector.size() <<
146 for(std::size_t i = 0; i < fLogPrimEnergyVec
147 {
148 FileOutput << std::exp(fLogPrimEnergyVecto
149 << std::exp(fLogCrossSectionVec
150 std::size_t j1 = 0;
151 FileOutput << fLogSecondEnergyMatrix[i]->s
152 for(std::size_t j = 0; j < fLogSecondEnerg
153 {
154 FileOutput << std::exp((*fLogSecondEnerg
155 ++j1;
156 if(j1 < 10)
157 FileOutput << '\t';
158 else
159 {
160 FileOutput << G4endl;
161 j1 = 0;
162 }
163 }
164 if(j1 > 0)
165 FileOutput << G4endl;
166 j1 = 0;
167 FileOutput << fLogProbMatrix[i]->size() <<
168 for(std::size_t j = 0; j < fLogProbMatrix[
169 {
170 FileOutput << std::exp((*fLogProbMatrix[
171 ++j1;
172 if(j1 < 10)
173 FileOutput << '\t';
174 else
175 {
176 FileOutput << G4endl;
177 j1 = 0;
178 }
179 }
180 if(j1 > 0)
181 FileOutput << G4endl;
182 }
183 }
184
185 //////////////////////////////////////////////
186 void G4AdjointCSMatrix::Read(const G4String& f
187 {
188 std::fstream FileOutput(file_name, std::ios:
189 std::size_t n1, n2;
190
191 fLogPrimEnergyVector.clear();
192 fLogCrossSectionVector.clear();
193 fLogSecondEnergyMatrix.clear();
194 fLogProbMatrix.clear();
195 FileOutput >> n1;
196 for(std::size_t i = 0; i < n1; ++i)
197 {
198 G4double E, CS;
199 FileOutput >> E >> CS;
200 fLogPrimEnergyVector.push_back(E);
201 fLogCrossSectionVector.push_back(CS);
202 FileOutput >> n2;
203 fLogSecondEnergyMatrix.push_back(new std::
204 fLogProbMatrix.push_back(new std::vector<G
205
206 for(std::size_t j = 0; j < n2; ++j)
207 {
208 G4double E1;
209 FileOutput >> E1;
210 fLogSecondEnergyMatrix[i]->push_back(E1)
211 }
212 FileOutput >> n2;
213 for(std::size_t j = 0; j < n2; ++j)
214 {
215 G4double prob;
216 FileOutput >> prob;
217 fLogProbMatrix[i]->push_back(prob);
218 }
219 }
220 }
221