antioch-0.4.0
Functions
vanthoff_rate_vec_unit.C File Reference
#include "antioch_config.h"
#include <valarray>
#include "Eigen/Dense"
#include "metaphysicl/numberarray.h"
#include "vexcl/vexcl.hpp"
#include "antioch/eigen_utils_decl.h"
#include "antioch/metaphysicl_utils_decl.h"
#include "antioch/valarray_utils_decl.h"
#include "antioch/vanthoff_rate.h"
#include "antioch/eigen_utils.h"
#include "antioch/metaphysicl_utils.h"
#include "antioch/valarray_utils.h"
#include <cmath>
#include <limits>

Go to the source code of this file.

Functions

template<typename PairScalars >
int check_rate_and_derivative (const PairScalars &rate_exact, const PairScalars &derive_exact, const PairScalars &rate, const PairScalars &derive, const PairScalars &T)
 
template<typename PairScalars >
int vectester (const PairScalars &example, const std::string &testname)
 
int main ()
 

Function Documentation

template<typename PairScalars >
int check_rate_and_derivative ( const PairScalars &  rate_exact,
const PairScalars &  derive_exact,
const PairScalars &  rate,
const PairScalars &  derive,
const PairScalars &  T 
)

Definition at line 67 of file vanthoff_rate_vec_unit.C.

Referenced by vectester().

69 {
70  typedef typename Antioch::value_type<PairScalars>::type Scalar;
71  const Scalar tol = std::numeric_limits<Scalar>::epsilon() * 2;
72 
73  int return_flag(0);
74  for (unsigned int tuple=0; tuple != ANTIOCH_N_TUPLES; ++tuple)
75  {
76  if( abs( (rate[2*tuple] - rate_exact[2*tuple])/rate_exact[2*tuple] ) > tol )
77  {
78  std::cout << std::scientific << std::setprecision(16)
79  << "Error: Mismatch in rate values." << std::endl
80  << "T = " << T << " K" << std::endl
81  << "rate(T) = " << rate[2*tuple] << std::endl
82  << "rate_exact = " << rate_exact[2*tuple] << std::endl
83  << "relative difference = " << abs( (rate[2*tuple] - rate_exact[2*tuple])/rate_exact[2*tuple] ) << std::endl
84  << "tolerance = " << tol << std::endl;
85 
86  return_flag = 1;
87  }
88  if( abs( (rate[2*tuple+1] - rate_exact[2*tuple+1])/rate_exact[2*tuple+1] ) > tol )
89  {
90  std::cout << std::scientific << std::setprecision(16)
91  << "Error: Mismatch in rate values." << std::endl
92  << "T = " << T << " K" << std::endl
93  << "rate(T) = " << rate[2*tuple] << std::endl
94  << "rate_exact = " << rate_exact[2*tuple+1] << std::endl
95  << "relative difference = " << abs( (rate[2*tuple] - rate_exact[2*tuple+1])/rate_exact[2*tuple+1] ) << std::endl
96  << "tolerance = " << tol << std::endl;
97 
98  return_flag = 1;
99  }
100  if( abs( (derive[2*tuple] - derive_exact[2*tuple])/derive_exact[2*tuple] ) > tol )
101  {
102  std::cout << std::scientific << std::setprecision(16)
103  << "Error: Mismatch in rate derivative values." << std::endl
104  << "T = " << T << " K" << std::endl
105  << "drate_dT(T) = " << derive[2*tuple] << std::endl
106  << "derive_exact = " << derive_exact[2*tuple] << std::endl
107  << "relative difference = " << abs( (derive[2*tuple] - derive_exact[2*tuple])/derive_exact[2*tuple] ) << std::endl
108  << "tolerance = " << tol << std::endl;
109 
110  return_flag = 1;
111  }
112  if( abs( (derive[2*tuple+1] - derive_exact[2*tuple+1])/derive_exact[2*tuple+1] ) > tol )
113  {
114  std::cout << std::scientific << std::setprecision(16)
115  << "Error: Mismatch in rate derivative values." << std::endl
116  << "T = " << T << " K" << std::endl
117  << "drate_dT(T) = " << derive[2*tuple+1] << std::endl
118  << "derive_exact = " << derive_exact[2*tuple+1] << std::endl
119  << "relative difference = " << abs( (derive[2*tuple+1] - derive_exact[2*tuple+1])/derive_exact[2*tuple+1] ) << std::endl
120  << "tolerance = " << tol << std::endl;
121 
122  return_flag = 1;
123  }
124 
125  }
126  return return_flag;
127 }
int main ( )

Definition at line 220 of file vanthoff_rate_vec_unit.C.

References vectester().

221 {
222  int returnval = 0;
223 
224  returnval = returnval ||
225  vectester (std::valarray<float>(2*ANTIOCH_N_TUPLES), "valarray<float>");
226  returnval = returnval ||
227  vectester (std::valarray<double>(2*ANTIOCH_N_TUPLES), "valarray<double>");
228  returnval = returnval ||
229  vectester (std::valarray<long double>(2*ANTIOCH_N_TUPLES), "valarray<ld>");
230 #ifdef ANTIOCH_HAVE_EIGEN
231  returnval = returnval ||
232  vectester (Eigen::Array<float, 2*ANTIOCH_N_TUPLES, 1>(), "Eigen::ArrayXf");
233  returnval = returnval ||
234  vectester (Eigen::Array<double, 2*ANTIOCH_N_TUPLES, 1>(), "Eigen::ArrayXd");
235  returnval = returnval ||
236  vectester (Eigen::Array<long double, 2*ANTIOCH_N_TUPLES, 1>(), "Eigen::ArrayXld");
237 #endif
238 #ifdef ANTIOCH_HAVE_METAPHYSICL
239  returnval = returnval ||
240  vectester (MetaPhysicL::NumberArray<2*ANTIOCH_N_TUPLES, float> (0), "NumberArray<float>");
241  returnval = returnval ||
242  vectester (MetaPhysicL::NumberArray<2*ANTIOCH_N_TUPLES, double> (0), "NumberArray<double>");
243  returnval = returnval ||
244  vectester (MetaPhysicL::NumberArray<2*ANTIOCH_N_TUPLES, long double> (0), "NumberArray<ld>");
245 #endif
246 #ifdef ANTIOCH_HAVE_VEXCL
247  vex::Context ctx_f (vex::Filter::All);
248  if (!ctx_f.empty())
249  returnval = returnval ||
250  vectester (vex::vector<float> (ctx_f, 2*ANTIOCH_N_TUPLES), "vex::vector<float>");
251 
252  vex::Context ctx_d (vex::Filter::DoublePrecision);
253  if (!ctx_d.empty())
254  returnval = returnval ||
255  vectester (vex::vector<double> (ctx_d, 2*ANTIOCH_N_TUPLES), "vex::vector<double>");
256 #endif
257 
258 #ifdef ANTIOCH_HAVE_GRVY
259  gt.Finalize();
260  gt.Summarize();
261 #endif
262 
263  return returnval;
264 }
vectester
int vectester(const PairScalars &example, const std::string &testname)
Definition: vanthoff_rate_vec_unit.C:130
template<typename PairScalars >
int vectester ( const PairScalars &  example,
const std::string &  testname 
)

Definition at line 130 of file vanthoff_rate_vec_unit.C.

References check_rate_and_derivative(), Antioch::KineticsModel::D, Antioch::VantHoffRate< CoeffType >::derivative(), std::pow(), and Antioch::VantHoffRate< CoeffType >::rate_and_derivative.

Referenced by main().

131 {
132  using std::abs;
133  using std::exp;
134  using std::pow;
135 
136  typedef typename Antioch::value_type<PairScalars>::type Scalar;
137 
138  const Scalar Cf = 1.4;
139  const Scalar eta = 1.2;
140  const Scalar Ea = 5.0;
141  const Scalar D = -2.5;
142 
143  Antioch::VantHoffRate<Scalar> vanthoff_rate(Cf,eta,Ea,D,1.,1.);
144 
145  // Construct from example to avoid resizing issues
146  PairScalars T = example;
147  PairScalars rate_exact = example;
148  PairScalars derive_exact = example;
149  for (unsigned int tuple=0; tuple != ANTIOCH_N_TUPLES; ++tuple)
150  {
151  T[2*tuple] = 1500.1;
152  T[2*tuple+1] = 1600.1;
153  rate_exact[2*tuple] = Cf*pow(Scalar(1500.1),eta)*exp(-Ea/1500.1+D*1500.1);
154  rate_exact[2*tuple+1] = Cf*pow(Scalar(1600.1),eta)*exp(-Ea/1600.1+D*1600.1);
155  derive_exact[2*tuple] = Cf * pow(Scalar(1500.1),eta) * exp(-Ea/Scalar(1500.1) + D*Scalar(1500.1)) * (D + eta/Scalar(1500.1) + Ea/(Scalar(1500.1)*Scalar(1500.1)));
156  derive_exact[2*tuple+1] = Cf * pow(Scalar(1600.1),eta) * exp(-Ea/Scalar(1600.1) + D*Scalar(1600.1)) * (D + eta/Scalar(1600.1) + Ea/(Scalar(1600.1)*Scalar(1600.1)));
157  }
158  Antioch::KineticsConditions<PairScalars> cond(T);
159 
160  int return_flag = 0;
161 
162 // KineticsConditions
163 #ifdef ANTIOCH_HAVE_GRVY
164  gt.BeginTimer(testname);
165 #endif
166 
167  PairScalars rate = vanthoff_rate(cond);
168  PairScalars derive = vanthoff_rate.derivative(cond);
169 
170 #ifdef ANTIOCH_HAVE_GRVY
171  gt.EndTimer(testname);
172 #endif
173 
174  return_flag = check_rate_and_derivative(rate_exact, derive_exact, rate, derive,T) || return_flag;
175 
176 #ifdef ANTIOCH_HAVE_GRVY
177  gt.BeginTimer(testname);
178 #endif
179 
180  vanthoff_rate.rate_and_derivative(cond,rate,derive);
181 
182 #ifdef ANTIOCH_HAVE_GRVY
183  gt.EndTimer(testname);
184 #endif
185 
186  return_flag = check_rate_and_derivative(rate_exact, derive_exact, rate, derive,T) || return_flag;
187 
188 // T
189 #ifdef ANTIOCH_HAVE_GRVY
190  gt.BeginTimer(testname);
191 #endif
192 
193  rate = vanthoff_rate(T);
194  derive = vanthoff_rate.derivative(T);
195 
196 #ifdef ANTIOCH_HAVE_GRVY
197  gt.EndTimer(testname);
198 #endif
199 
200  return_flag = check_rate_and_derivative(rate_exact, derive_exact, rate, derive,T) || return_flag;
201 
202 #ifdef ANTIOCH_HAVE_GRVY
203  gt.BeginTimer(testname);
204 #endif
205 
206  vanthoff_rate.rate_and_derivative(cond,rate,derive);
207 
208 #ifdef ANTIOCH_HAVE_GRVY
209  gt.EndTimer(testname);
210 #endif
211 
212  return_flag = check_rate_and_derivative(rate_exact, derive_exact, rate, derive,T) || return_flag;
213 
214  std::cout << "Van't Hoff rate: " << vanthoff_rate << std::endl;
215 
216  return return_flag;
217 }
std::pow
Antioch::enable_if_c< Antioch::is_valarray< T >::value, typename Antioch::state_type< T >::type >::type pow(const T &in, const T2 &n)
Definition: valarray_utils.h:71
Antioch::VantHoffRate
Van't Hoff rate equation.
Definition: kinetics_type.h:62
check_rate_and_derivative
int check_rate_and_derivative(const PairScalars &rate_exact, const PairScalars &derive_exact, const PairScalars &rate, const PairScalars &derive, const PairScalars &T)
Definition: vanthoff_rate_vec_unit.C:67
Antioch::KineticsConditions
This class contains the conditions of the chemistry.
Definition: kinetics_conditions.h:64
Generated on Thu Jul 7 2016 11:09:48 for antioch-0.4.0 by  doxygen 1.8.8