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