Geant4_10
G4AdjointInterpolator.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // $Id: G4AdjointInterpolator.cc 71508 2013-06-17 11:57:13Z gcosmo $
27 //
28 #include "G4AdjointCSMatrix.hh"
29 #include "G4AdjointInterpolator.hh"
30 
31 G4ThreadLocal G4AdjointInterpolator* G4AdjointInterpolator::theInstance = 0;
33 //
35 {
36  return GetInstance();
37 }
38 
40 //
42 {
43  if(!theInstance)
44  {
45  theInstance = new G4AdjointInterpolator;
46  }
47  return theInstance;
48 }
49 
51 //
52 G4AdjointInterpolator::G4AdjointInterpolator()
53 {
54 }
55 
57 //
59 {
60 }
61 
63 //
65 {
66  G4double res = y1+ (x-x1)*(y2-y1)/(x2-x1);
67  //G4cout<<"Linear "<<res<<G4endl;
68  return res;
69 }
70 
72 //
74 {
75  if (y1<=0 || y2<=0 || x1<=0) return LinearInterpolation(x,x1,x2,y1,y2);
76  G4double B=std::log(y2/y1)/std::log(x2/x1);
77  //G4cout<<"x1,x2,y1,y2 "<<x1<<'\t'<<x2<<'\t'<<y1<<'\t'<<y2<<'\t'<<G4endl;
78  G4double A=y1/std::pow(x1,B);
79  G4double res=A*std::pow(x,B);
80  // G4cout<<"Log "<<res<<G4endl;
81  return res;
82 }
83 
85 //
87 {
88  G4double B=(std::log(y2)-std::log(y1));
89  B=B/(x2-x1);
90  G4double A=y1*std::exp(-B*x1);
91  G4double res=A*std::exp(B*x);
92  return res;
93 }
94 
96 //
98 {
99  if (InterPolMethod == "Log" ){
100  return LogarithmicInterpolation(x,x1,x2,y1,y2);
101  }
102  else if (InterPolMethod == "Lin" ){
103  return LinearInterpolation(x,x1,x2,y1,y2);
104  }
105  else if (InterPolMethod == "Exp" ){
106  return ExponentialInterpolation(x,x1,x2,y1,y2);
107  }
108  else {
109  //G4cout<<"The interpolation method that you invoked does not exist!"<<G4endl;
110  return -1111111111.;
111  }
112 }
113 
115 //
116 size_t G4AdjointInterpolator::FindPosition(G4double& x,std::vector<G4double>& x_vec,size_t , size_t ) //only valid if x_vec is monotically increasing
117 {
118  //most rapid nethod could be used probably
119  //It is important to put std::vector<G4double>& such that the vector itself is used and not a copy
120 
121 
122  size_t ndim = x_vec.size();
123  size_t ind1 = 0;
124  size_t ind2 = ndim - 1;
125  /* if (ind_max >= ind_min){
126  ind1=ind_min;
127  ind2=ind_max;
128 
129 
130  }
131  */
132 
133 
134  if (ndim >1) {
135 
136  if (x_vec[0] < x_vec[1] ) { //increasing
137  do {
138  size_t midBin = (ind1 + ind2)/2;
139  if (x < x_vec[midBin])
140  ind2 = midBin;
141  else
142  ind1 = midBin;
143  } while (ind2 - ind1 > 1);
144  }
145  else {
146  do {
147  size_t midBin = (ind1 + ind2)/2;
148  if (x < x_vec[midBin])
149  ind1 = midBin;
150  else
151  ind2 = midBin;
152  } while (ind2 - ind1 > 1);
153  }
154 
155  }
156 
157  return ind1;
158 }
159 
161 //
162 size_t G4AdjointInterpolator::FindPositionForLogVector(G4double& log_x,std::vector<G4double>& log_x_vec) //only valid if x_vec is monotically increasing
163 {
164  //most rapid nethod could be used probably
165  //It is important to put std::vector<G4double>& such that the vector itself is used and not a copy
166  return FindPosition(log_x, log_x_vec);
167  /*
168  if (log_x_vec.size()>3){
169  size_t ind=0;
170  G4double log_x1=log_x_vec[1];
171  G4double d_log =log_x_vec[2]-log_x1;
172  G4double dind=(log_x-log_x1)/d_log +1.;
173  if (dind <1.) ind=0;
174  else if (dind >= double(log_x_vec.size())-2.) ind =log_x_vec.size()-2;
175  else ind =size_t(dind);
176  return ind;
177 
178  }
179  else return FindPosition(log_x, log_x_vec);
180  */
181 
182 
183 }
184 
186 //
187 G4double G4AdjointInterpolator::Interpolate(G4double& x,std::vector<G4double>& x_vec,std::vector<G4double>& y_vec,G4String InterPolMethod)
188 {
189  size_t i=FindPosition(x,x_vec);
190  //G4cout<<i<<G4endl;
191  //G4cout<<x<<G4endl;
192  //G4cout<<x_vec[i]<<G4endl;
193  return Interpolation( x,x_vec[i],x_vec[i+1],y_vec[i],y_vec[i+1],InterPolMethod);
194 }
195 
197 //
198 G4double G4AdjointInterpolator::InterpolateWithIndexVector(G4double& x,std::vector<G4double>& x_vec,std::vector<G4double>& y_vec,
199  std::vector<size_t>& index_vec,G4double x0, G4double dx) //only linear interpolation possible
200 {
201  size_t ind=0;
202  if (x>x0) ind=int((x-x0)/dx);
203  if (ind >= index_vec.size()-1) ind= index_vec.size()-2;
204  size_t ind1 = index_vec[ind];
205  size_t ind2 = index_vec[ind+1];
206  if (ind1 >ind2) {
207  size_t ind11=ind1;
208  ind1=ind2;
209  ind2=ind11;
210 
211  }
212  ind=FindPosition(x,x_vec,ind1,ind2);
213  return Interpolation( x,x_vec[ind],x_vec[ind+1],y_vec[ind],y_vec[ind+1],"Lin");
214 }
215 
217 //
218 G4double G4AdjointInterpolator::InterpolateForLogVector(G4double& log_x,std::vector<G4double>& log_x_vec,std::vector<G4double>& log_y_vec)
219 {
220  //size_t i=0;
221  size_t i=FindPositionForLogVector(log_x,log_x_vec);
222  /*G4cout<<"In interpolate "<<G4endl;
223  G4cout<<i<<G4endl;
224  G4cout<<log_x<<G4endl;
225  G4cout<<log_x_vec[i]<<G4endl;
226  G4cout<<log_x_vec[i+1]<<G4endl;
227  G4cout<<log_y_vec[i]<<G4endl;
228  G4cout<<log_y_vec[i+1]<<G4endl;*/
229 
230  G4double log_y=LinearInterpolation(log_x,log_x_vec[i],log_x_vec[i+1],log_y_vec[i],log_y_vec[i+1]);
231  return log_y;
232 }
Double_t y2[nxs]
Definition: Style.C:21
G4double InterpolateWithIndexVector(G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec, std::vector< size_t > &index_vec, G4double x0, G4double dx)
Double_t y1[nxs]
Definition: Style.C:20
Double_t x2[nxs]
Definition: Style.C:19
typedef int(XMLCALL *XML_NotStandaloneHandler)(void *userData)
G4double LogarithmicInterpolation(G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)
G4double Interpolation(G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2, G4String InterPolMethod="Log")
tuple x
Definition: test.py:50
#define G4ThreadLocal
Definition: tls.hh:52
G4double InterpolateForLogVector(G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec)
G4double Interpolate(G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec, G4String InterPolMethod="Log")
static G4AdjointInterpolator * GetAdjointInterpolator()
size_t FindPositionForLogVector(G4double &x, std::vector< G4double > &x_vec)
Double_t x1[nxs]
Definition: Style.C:18
size_t FindPosition(G4double &x, std::vector< G4double > &x_vec, size_t ind_min=0, size_t ind_max=0)
G4double LinearInterpolation(G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)
static G4AdjointInterpolator * GetInstance()
double G4double
Definition: G4Types.hh:76
G4double ExponentialInterpolation(G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)