| 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 // $Id: G4AdjointInterpolator.cc,v 1.4 2009/11/20 10:31:20 ldesorgh Exp $
>> 27 // GEANT4 tag $Name: geant4-09-03-patch-02 $
>> 28 //
>> 29 #include "G4AdjointCSMatrix.hh"
27 #include "G4AdjointInterpolator.hh" 30 #include "G4AdjointInterpolator.hh"
28 31
29 G4ThreadLocal G4AdjointInterpolator* G4Adjoint << 32 G4AdjointInterpolator* G4AdjointInterpolator::theInstance = 0;
30 <<
31 ////////////////////////////////////////////// 33 ///////////////////////////////////////////////////////
>> 34 //
32 G4AdjointInterpolator* G4AdjointInterpolator:: 35 G4AdjointInterpolator* G4AdjointInterpolator::GetAdjointInterpolator()
33 { << 36 { if(theInstance == 0) {
34 return GetInstance(); << 37 static G4AdjointInterpolator interpolator;
>> 38 theInstance = &interpolator;
>> 39 }
>> 40 return theInstance;
35 } 41 }
36 <<
37 ////////////////////////////////////////////// 42 ///////////////////////////////////////////////////////
>> 43 //
38 G4AdjointInterpolator* G4AdjointInterpolator:: 44 G4AdjointInterpolator* G4AdjointInterpolator::GetInstance()
39 { << 45 { if(theInstance == 0) {
40 if(!fInstance) << 46 static G4AdjointInterpolator interpolator;
41 { << 47 theInstance = &interpolator;
42 fInstance = new G4AdjointInterpolator; <<
43 } 48 }
44 return fInstance; << 49 return theInstance;
45 } 50 }
46 51
47 ////////////////////////////////////////////// 52 ///////////////////////////////////////////////////////
48 G4AdjointInterpolator::G4AdjointInterpolator() << 53 //
49 << 54 G4AdjointInterpolator::G4AdjointInterpolator()
>> 55 {;
>> 56 }
50 ////////////////////////////////////////////// 57 ///////////////////////////////////////////////////////
51 G4AdjointInterpolator::~G4AdjointInterpolator( << 58 //
52 << 59 G4AdjointInterpolator::~G4AdjointInterpolator()
>> 60 {;
>> 61 }
53 ////////////////////////////////////////////// 62 ///////////////////////////////////////////////////////
54 G4double G4AdjointInterpolator::LinearInterpol << 63 //
55 << 64 G4double G4AdjointInterpolator::LinearInterpolation(G4double& x,G4double& x1,G4double& x2,G4double& y1,G4double& y2)
56 << 65 { G4double res = y1+ (x-x1)*(y2-y1)/(x2-x1);
57 { << 66 //G4cout<<"Linear "<<res<<G4endl;
58 G4double res = y1 + (x - x1) * (y2 - y1) / ( << 67 return res;
59 return res; <<
60 } 68 }
61 <<
62 ////////////////////////////////////////////// 69 ///////////////////////////////////////////////////////
63 G4double G4AdjointInterpolator::LogarithmicInt << 70 //
64 G4double& x, G4double& x1, G4double& x2, G4d << 71 G4double G4AdjointInterpolator::LogarithmicInterpolation(G4double& x,G4double& x1,G4double& x2,G4double& y1,G4double& y2)
65 { << 72 { if (y1<=0 || y2<=0 || x1<=0) return LinearInterpolation(x,x1,x2,y1,y2);
66 if(y1 <= 0. || y2 <= 0. || x1 <= 0.) << 73 G4double B=std::log(y2/y1)/std::log(x2/x1);
67 return LinearInterpolation(x, x1, x2, y1, << 74 //G4cout<<"x1,x2,y1,y2 "<<x1<<'\t'<<x2<<'\t'<<y1<<'\t'<<y2<<'\t'<<G4endl;
68 G4double B = std::log(y2 / y1) / std::log( << 75 G4double A=y1/std::pow(x1,B);
69 G4double A = y1 / std::pow(x1, B); << 76 G4double res=A*std::pow(x,B);
70 G4double res = A * std::pow(x, B); << 77 // G4cout<<"Log "<<res<<G4endl;
71 return res; 78 return res;
72 } 79 }
73 <<
74 ////////////////////////////////////////////// 80 ///////////////////////////////////////////////////////
75 G4double G4AdjointInterpolator::ExponentialInt << 81 //
76 G4double& x, G4double& x1, G4double& x2, G4d << 82 G4double G4AdjointInterpolator::ExponentialInterpolation(G4double& x,G4double& x1,G4double& x2,G4double& y1,G4double& y2)
77 { << 83 { G4double B=(std::log(y2)-std::log(y1));
78 G4double B = (std::log(y2) - std::log(y1)) << 84 B=B/(x2-x1);
79 G4double A = y1 * std::exp(-B * x1); << 85 G4double A=y1*std::exp(-B*x1);
80 G4double res = A * std::exp(B * x); << 86 G4double res=A*std::exp(B*x);
81 return res; 87 return res;
82 } 88 }
83 <<
84 ////////////////////////////////////////////// 89 ///////////////////////////////////////////////////////
85 G4double G4AdjointInterpolator::Interpolation( << 90 //
86 << 91 G4double G4AdjointInterpolator::Interpolation(G4double& x,G4double& x1,G4double& x2,G4double& y1,G4double& y2,G4String InterPolMethod)
87 <<
88 <<
89 { 92 {
90 if(InterPolMethod == "Log") << 93 if (InterPolMethod == "Log" ){
91 { << 94 return LogarithmicInterpolation(x,x1,x2,y1,y2);
92 return LogarithmicInterpolation(x, x1, x2, << 95 }
93 } << 96 else if (InterPolMethod == "Lin" ){
94 else if(InterPolMethod == "Lin") << 97 return LinearInterpolation(x,x1,x2,y1,y2);
95 { << 98 }
96 return LinearInterpolation(x, x1, x2, y1, << 99 else if (InterPolMethod == "Exp" ){
97 } << 100 return ExponentialInterpolation(x,x1,x2,y1,y2);
98 else if(InterPolMethod == "Exp") << 101 }
99 { << 102 else {
100 return ExponentialInterpolation(x, x1, x2, << 103 //G4cout<<"The interpolation method that you invoked does not exist!"<<G4endl;
101 } << 104 return -1111111111.;
102 else <<
103 { <<
104 G4ExceptionDescription ed; <<
105 ed << "The interpolation method that you i <<
106 G4Exception("G4AdjointInterpolator::Interp <<
107 FatalException, ed); <<
108 return 0.; <<
109 } 105 }
110 } 106 }
111 <<
112 ////////////////////////////////////////////// 107 ///////////////////////////////////////////////////////
113 // only valid if x_vec is monotically increasi << 108 //
114 std::size_t G4AdjointInterpolator::FindPositio << 109 size_t G4AdjointInterpolator::FindPosition(G4double& x,std::vector<G4double>& x_vec,size_t , size_t ) //only valid if x_vec is monotically increasing
115 std << 110 { //most rapid nethod could be used probably
116 std << 111 //It is important to put std::vector<G4double>& such that the vector itself is used and not a copy
117 { << 112
118 // most rapid method could be used probably << 113
119 << 114 size_t ndim = x_vec.size();
120 std::size_t ndim = x_vec.size(); << 115 size_t ind1 = 0;
121 std::size_t ind1 = 0; << 116 size_t ind2 = ndim - 1;
122 std::size_t ind2 = ndim - 1; << 117 /* if (ind_max >= ind_min){
123 << 118 ind1=ind_min;
124 if(ndim > 1) << 119 ind2=ind_max;
125 { << 120
126 if(x_vec[0] < x_vec[1]) << 121
127 { // increasing << 122 }
128 do << 123 */
129 { << 124
130 std::size_t midBin = (ind1 + ind2) / 2 << 125
131 if(x < x_vec[midBin]) << 126 if (ndim >1) {
132 ind2 = midBin; << 127
133 else << 128 if (x_vec[0] < x_vec[1] ) { //increasing
134 ind1 = midBin; << 129 do {
135 } while(ind2 - ind1 > 1); << 130 size_t midBin = (ind1 + ind2)/2;
136 } << 131 if (x < x_vec[midBin])
137 else << 132 ind2 = midBin;
138 { << 133 else
139 do << 134 ind1 = midBin;
140 { << 135 } while (ind2 - ind1 > 1);
141 std::size_t midBin = (ind1 + ind2) / 2 << 136 }
142 if(x < x_vec[midBin]) << 137 else {
143 ind1 = midBin; << 138 do {
144 else << 139 size_t midBin = (ind1 + ind2)/2;
145 ind2 = midBin; << 140 if (x < x_vec[midBin])
146 } while(ind2 - ind1 > 1); << 141 ind1 = midBin;
147 } << 142 else
>> 143 ind2 = midBin;
>> 144 } while (ind2 - ind1 > 1);
>> 145 }
>> 146
148 } 147 }
149 << 148
150 return ind1; 149 return ind1;
151 } 150 }
152 151
153 ////////////////////////////////////////////// 152 ///////////////////////////////////////////////////////
154 // only valid if x_vec is monotically increasi << 153 //
155 std::size_t G4AdjointInterpolator::FindPositio << 154 size_t G4AdjointInterpolator::FindPositionForLogVector(G4double& log_x,std::vector<G4double>& log_x_vec) //only valid if x_vec is monotically increasing
156 G4double& log_x, std::vector<G4double>& log_ << 155 { //most rapid nethod could be used probably
157 { << 156 //It is important to put std::vector<G4double>& such that the vector itself is used and not a copy
158 // most rapid method could be used probably <<
159 return FindPosition(log_x, log_x_vec); 157 return FindPosition(log_x, log_x_vec);
160 } << 158 if (log_x_vec.size()>3){
161 << 159 size_t ind=0;
162 ////////////////////////////////////////////// << 160 G4double log_x1=log_x_vec[1];
163 G4double G4AdjointInterpolator::Interpolate(G4 << 161 G4double d_log =log_x_vec[2]-log_x1;
164 st << 162 G4double dind=(log_x-log_x1)/d_log +1.;
165 st << 163 if (dind <1.) ind=0;
166 co << 164 else if (dind >= double(log_x_vec.size())-2.) ind =log_x_vec.size()-2;
167 { << 165 else ind =size_t(dind);
168 std::size_t i = FindPosition(x, x_vec); << 166 return ind;
169 return Interpolation(x, x_vec[i], x_vec[i + << 167
170 InterPolMethod); << 168 }
171 } << 169 else return FindPosition(log_x, log_x_vec);
172 << 170
173 ////////////////////////////////////////////// << 171
174 G4double G4AdjointInterpolator::InterpolateWit << 172 }
175 G4double& x, std::vector<G4double>& x_vec, s << 173 ///////////////////////////////////////////////////////
176 std::vector<std::size_t>& index_vec, G4doubl << 174 //
177 G4double dx) // only linear interpolation p << 175 G4double G4AdjointInterpolator::Interpolate(G4double& x,std::vector<G4double>& x_vec,std::vector<G4double>& y_vec,G4String InterPolMethod)
178 { << 176 { size_t i=FindPosition(x,x_vec);
179 std::size_t ind = 0; << 177 //G4cout<<i<<G4endl;
180 if(x > x0) << 178 //G4cout<<x<<G4endl;
181 ind = G4int((x - x0) / dx); << 179 //G4cout<<x_vec[i]<<G4endl;
182 if(ind >= index_vec.size() - 1) << 180 return Interpolation( x,x_vec[i],x_vec[i+1],y_vec[i],y_vec[i+1],InterPolMethod);
183 ind = index_vec.size() - 2; << 181 }
184 std::size_t ind1 = index_vec[ind]; << 182
185 std::size_t ind2 = index_vec[ind + 1]; << 183 ///////////////////////////////////////////////////////
186 if(ind1 > ind2) << 184 //
187 { << 185 G4double G4AdjointInterpolator::InterpolateWithIndexVector(G4double& x,std::vector<G4double>& x_vec,std::vector<G4double>& y_vec,
188 std::size_t ind11 = ind1; << 186 std::vector<size_t>& index_vec,G4double x0, G4double dx) //only linear interpolation possible
189 ind1 = ind2; << 187 { size_t ind=0;
190 ind2 = ind11; << 188 if (x>x0) ind=int((x-x0)/dx);
191 } << 189 if (ind >= index_vec.size()-1) ind= index_vec.size()-2;
192 ind = FindPosition(x, x_vec, ind1, ind2); << 190 size_t ind1 = index_vec[ind];
193 return Interpolation(x, x_vec[ind], x_vec[in << 191 size_t ind2 = index_vec[ind+1];
194 y_vec[ind + 1], "Lin"); << 192 if (ind1 >ind2) {
195 } << 193 size_t ind11=ind1;
196 << 194 ind1=ind2;
197 ////////////////////////////////////////////// << 195 ind2=ind11;
198 G4double G4AdjointInterpolator::InterpolateFor << 196
199 G4double& log_x, std::vector<G4double>& log_ << 197 }
200 std::vector<G4double>& log_y_vec) << 198
201 { << 199 ind=FindPosition(x,x_vec,ind1,ind2);
202 std::size_t i = FindPositionForLogVector(log << 200 return Interpolation( x,x_vec[ind],x_vec[ind+1],y_vec[ind],y_vec[ind+1],"Lin");
203 << 201
204 G4double log_y = LinearInterpolation(log_x, << 202 }
205 log_y_v << 203
206 return log_y; << 204
207 } << 205 ///////////////////////////////////////////////////////
>> 206 //
>> 207 G4double G4AdjointInterpolator::InterpolateForLogVector(G4double& log_x,std::vector<G4double>& log_x_vec,std::vector<G4double>& log_y_vec)
>> 208 { //size_t i=0;
>> 209 size_t i=FindPositionForLogVector(log_x,log_x_vec);
>> 210 /*G4cout<<"In interpolate "<<G4endl;
>> 211 G4cout<<i<<G4endl;
>> 212 G4cout<<log_x<<G4endl;
>> 213 G4cout<<log_x_vec[i]<<G4endl;
>> 214 G4cout<<log_x_vec[i+1]<<G4endl;
>> 215 G4cout<<log_y_vec[i]<<G4endl;
>> 216 G4cout<<log_y_vec[i+1]<<G4endl;*/
>> 217
>> 218 G4double log_y=LinearInterpolation(log_x,log_x_vec[i],log_x_vec[i+1],log_y_vec[i],log_y_vec[i+1]);
>> 219 return log_y;
>> 220
>> 221 }
208 222