Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | List of all members
G4AdjointInterpolator Class Reference

#include <G4AdjointInterpolator.hh>

Public Member Functions

 ~G4AdjointInterpolator ()
 
G4double LinearInterpolation (G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)
 
G4double LogarithmicInterpolation (G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)
 
G4double ExponentialInterpolation (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")
 
size_t FindPosition (G4double &x, std::vector< G4double > &x_vec, size_t ind_min=0, size_t ind_max=0)
 
size_t FindPositionForLogVector (G4double &x, std::vector< G4double > &x_vec)
 
G4double Interpolate (G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec, G4String InterPolMethod="Log")
 
G4double InterpolateWithIndexVector (G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec, std::vector< size_t > &index_vec, G4double x0, G4double dx)
 
G4double InterpolateForLogVector (G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec)
 

Static Public Member Functions

static G4AdjointInterpolator * GetAdjointInterpolator ()
 
static G4AdjointInterpolator * GetInstance ()
 

Detailed Description

Definition at line 52 of file G4AdjointInterpolator.hh.

Constructor & Destructor Documentation

◆ ~G4AdjointInterpolator()

G4AdjointInterpolator::~G4AdjointInterpolator ( )

Definition at line 57 of file G4AdjointInterpolator.cc.

58{
59}

Member Function Documentation

◆ ExponentialInterpolation()

G4double G4AdjointInterpolator::ExponentialInterpolation ( G4double &  x,
G4double &  x1,
G4double &  x2,
G4double &  y1,
G4double &  y2 
)

Definition at line 85 of file G4AdjointInterpolator.cc.

86{
87 G4double B=(std::log(y2)-std::log(y1));
88 B=B/(x2-x1);
89 G4double A=y1*std::exp(-B*x1);
90 G4double res=A*std::exp(B*x);
91 return res;
92}
B
double B(double temperature)
Definition: G4DNAElectronHoleRecombination.cc:69
A
double A(double temperature)
Definition: G4DNAElectronHoleRecombination.cc:60
G4double
double G4double
Definition: G4Types.hh:83

Referenced by Interpolation().

◆ FindPosition()

size_t G4AdjointInterpolator::FindPosition ( G4double &  x,
std::vector< G4double > &  x_vec,
size_t  ind_min = 0,
size_t  ind_max = 0 
)

Definition at line 115 of file G4AdjointInterpolator.cc.

116{
117 //most rapid nethod could be used probably
118 //It is important to put std::vector<G4double>& such that the vector itself is used and not a copy
119
120
121 size_t ndim = x_vec.size();
122 size_t ind1 = 0;
123 size_t ind2 = ndim - 1;
124 /* if (ind_max >= ind_min){
125 ind1=ind_min;
126 ind2=ind_max;
127
128
129 }
130 */
131
132
133 if (ndim >1) {
134
135 if (x_vec[0] < x_vec[1] ) { //increasing
136 do {
137 size_t midBin = (ind1 + ind2)/2;
138 if (x < x_vec[midBin])
139 ind2 = midBin;
140 else
141 ind1 = midBin;
142 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
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 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
153 } while (ind2 - ind1 > 1);
154 }
155
156 }
157
158 return ind1;
159}

Referenced by G4AdjointCSMatrix::AddData(), FindPositionForLogVector(), Interpolate(), and InterpolateWithIndexVector().

◆ FindPositionForLogVector()

size_t G4AdjointInterpolator::FindPositionForLogVector ( G4double &  x,
std::vector< G4double > &  x_vec 
)

Definition at line 163 of file G4AdjointInterpolator.cc.

164{
165 //most rapid nethod could be used probably
166 //It is important to put std::vector<G4double>& such that the vector itself is used and not a copy
167 return FindPosition(log_x, log_x_vec);
168 /*
169 if (log_x_vec.size()>3){
170 size_t ind=0;
171 G4double log_x1=log_x_vec[1];
172 G4double d_log =log_x_vec[2]-log_x1;
173 G4double dind=(log_x-log_x1)/d_log +1.;
174 if (dind <1.) ind=0;
175 else if (dind >= double(log_x_vec.size())-2.) ind =log_x_vec.size()-2;
176 else ind =size_t(dind);
177 return ind;
178
179 }
180 else return FindPosition(log_x, log_x_vec);
181 */
182
183
184}
G4AdjointInterpolator::FindPosition
size_t FindPosition(G4double &x, std::vector< G4double > &x_vec, size_t ind_min=0, size_t ind_max=0)
Definition: G4AdjointInterpolator.cc:115

Referenced by InterpolateForLogVector(), and G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ GetAdjointInterpolator()

G4AdjointInterpolator * G4AdjointInterpolator::GetAdjointInterpolator ( )
static

Definition at line 33 of file G4AdjointInterpolator.cc.

34{
35 return GetInstance();
36}
G4AdjointInterpolator::GetInstance
static G4AdjointInterpolator * GetInstance()
Definition: G4AdjointInterpolator.cc:40

◆ GetInstance()

G4AdjointInterpolator * G4AdjointInterpolator::GetInstance ( )
static

Definition at line 40 of file G4AdjointInterpolator.cc.

41{
42 if(!theInstance)
43 {
44 theInstance = new G4AdjointInterpolator;
45 }
46 return theInstance;
47}

Referenced by G4AdjointCSMatrix::AddData(), GetAdjointInterpolator(), and G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ Interpolate()

G4double G4AdjointInterpolator::Interpolate ( G4double &  x,
std::vector< G4double > &  x_vec,
std::vector< G4double > &  y_vec,
G4String  InterPolMethod = "Log" 
)

Definition at line 188 of file G4AdjointInterpolator.cc.

189{
190 size_t i=FindPosition(x,x_vec);
191 //G4cout<<i<<G4endl;
192 //G4cout<<x<<G4endl;
193 //G4cout<<x_vec[i]<<G4endl;
194 return Interpolation( x,x_vec[i],x_vec[i+1],y_vec[i],y_vec[i+1],InterPolMethod);
195}
G4AdjointInterpolator::Interpolation
G4double Interpolation(G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2, G4String InterPolMethod="Log")
Definition: G4AdjointInterpolator.cc:96

Referenced by G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ InterpolateForLogVector()

G4double G4AdjointInterpolator::InterpolateForLogVector ( G4double &  x,
std::vector< G4double > &  x_vec,
std::vector< G4double > &  y_vec 
)

Definition at line 219 of file G4AdjointInterpolator.cc.

220{
221 //size_t i=0;
222 size_t i=FindPositionForLogVector(log_x,log_x_vec);
223 /*G4cout<<"In interpolate "<<G4endl;
224 G4cout<<i<<G4endl;
225 G4cout<<log_x<<G4endl;
226 G4cout<<log_x_vec[i]<<G4endl;
227 G4cout<<log_x_vec[i+1]<<G4endl;
228 G4cout<<log_y_vec[i]<<G4endl;
229 G4cout<<log_y_vec[i+1]<<G4endl;*/
230
231 G4double log_y=LinearInterpolation(log_x,log_x_vec[i],log_x_vec[i+1],log_y_vec[i],log_y_vec[i+1]);
232 return log_y;
233}
G4AdjointInterpolator::LinearInterpolation
G4double LinearInterpolation(G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)
Definition: G4AdjointInterpolator.cc:63
G4AdjointInterpolator::FindPositionForLogVector
size_t FindPositionForLogVector(G4double &x, std::vector< G4double > &x_vec)
Definition: G4AdjointInterpolator.cc:163

Referenced by G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ InterpolateWithIndexVector()

G4double G4AdjointInterpolator::InterpolateWithIndexVector ( G4double &  x,
std::vector< G4double > &  x_vec,
std::vector< G4double > &  y_vec,
std::vector< size_t > &  index_vec,
G4double  x0,
G4double  dx 
)

Definition at line 199 of file G4AdjointInterpolator.cc.

201{
202 size_t ind=0;
203 if (x>x0) ind=int((x-x0)/dx);
204 if (ind >= index_vec.size()-1) ind= index_vec.size()-2;
205 size_t ind1 = index_vec[ind];
206 size_t ind2 = index_vec[ind+1];
207 if (ind1 >ind2) {
208 size_t ind11=ind1;
209 ind1=ind2;
210 ind2=ind11;
211
212 }
213 ind=FindPosition(x,x_vec,ind1,ind2);
214 return Interpolation( x,x_vec[ind],x_vec[ind+1],y_vec[ind],y_vec[ind+1],"Lin");
215}

◆ Interpolation()

G4double G4AdjointInterpolator::Interpolation ( G4double &  x,
G4double &  x1,
G4double &  x2,
G4double &  y1,
G4double &  y2,
G4String  InterPolMethod = "Log" 
)

Definition at line 96 of file G4AdjointInterpolator.cc.

97{
98 if (InterPolMethod == "Log" ){
99 return LogarithmicInterpolation(x,x1,x2,y1,y2);
100 }
101 else if (InterPolMethod == "Lin" ){
102 return LinearInterpolation(x,x1,x2,y1,y2);
103 }
104 else if (InterPolMethod == "Exp" ){
105 return ExponentialInterpolation(x,x1,x2,y1,y2);
106 }
107 else {
108 //G4cout<<"The interpolation method that you invoked does not exist!"<<G4endl;
109 return -1111111111.;
110 }
111}
G4AdjointInterpolator::ExponentialInterpolation
G4double ExponentialInterpolation(G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)
Definition: G4AdjointInterpolator.cc:85
G4AdjointInterpolator::LogarithmicInterpolation
G4double LogarithmicInterpolation(G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)
Definition: G4AdjointInterpolator.cc:72

Referenced by Interpolate(), and InterpolateWithIndexVector().

◆ LinearInterpolation()

G4double G4AdjointInterpolator::LinearInterpolation ( G4double &  x,
G4double &  x1,
G4double &  x2,
G4double &  y1,
G4double &  y2 
)

Definition at line 63 of file G4AdjointInterpolator.cc.

64{
65 G4double res = y1+ (x-x1)*(y2-y1)/(x2-x1);
66 //G4cout<<"Linear "<<res<<G4endl;
67 return res;
68}

Referenced by InterpolateForLogVector(), Interpolation(), LogarithmicInterpolation(), and G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ LogarithmicInterpolation()

G4double G4AdjointInterpolator::LogarithmicInterpolation ( G4double &  x,
G4double &  x1,
G4double &  x2,
G4double &  y1,
G4double &  y2 
)

Definition at line 72 of file G4AdjointInterpolator.cc.

73{
74 if (y1<=0 || y2<=0 || x1<=0) return LinearInterpolation(x,x1,x2,y1,y2);
75 G4double B=std::log(y2/y1)/std::log(x2/x1);
76 //G4cout<<"x1,x2,y1,y2 "<<x1<<'\t'<<x2<<'\t'<<y1<<'\t'<<y2<<'\t'<<G4endl;
77 G4double A=y1/std::pow(x1,B);
78 G4double res=A*std::pow(x,B);
79 // G4cout<<"Log "<<res<<G4endl;
80 return res;
81}

Referenced by Interpolation().

The documentation for this class was generated from the following files: