const XC::Vector &XC::CorotTruss::getResistingForceIncInertia(void) const
{
Vector &P = *theVector;
P = this->getResistingForce();
const double rho= getRho();
if(rho != 0.0)
{
const XC::Vector &accel1 = theNodes[0]->getTrialAccel();
const XC::Vector &accel2 = theNodes[1]->getTrialAccel();
double M = 0.5*rho*Lo;
int numDOF2 = numDOF/2;
for(int i = 0; i < getNumDIM(); i++)
{
P(i)+= M*accel1(i);
P(i+numDOF2)+= M*accel2(i);
}
}
// add the damping forces if rayleigh damping
if(!rayFactors.nullValues())
*theVector+= this->getRayleighDampingForces();
if(isDead())
(*theVector)*=dead_srf; //XXX Se aplica 2 veces sobre getResistingForce: arreglar.
return *theVector;
}
std::vector<double> BlackScholesGreeks::getAllGreeks()
{
std::vector<double> data;
data.push_back(getPremium());
data.push_back(getDelta());
data.push_back(getGamma());
data.push_back(getVega());
data.push_back(getRho());
data.push_back(getTheta());
return data;
}
bool ECDLCpuContext::init()
{
reset();
for(int i = 0; i < _numThreads; i++) {
_workerCtx.push_back(getRho());
}
return true;
}
void ECDLCpuContext::benchmarkThreadFunction(unsigned long long *iterationsPerSecond)
{
util::Timer timer;
timer.start();
RhoBase *r = getRho(false);
for(int i = 0; i < BENCHMARK_ITERATIONS; i++)
{
r->doStep();
}
unsigned int t = timer.getTime();
*iterationsPerSecond = (unsigned long long) ((double)BENCHMARK_ITERATIONS / ((double)t/1000.0));
}
const XC::Matrix &XC::CorotTruss::getMass(void) const
{
Matrix &Mass = *theMatrix;
Mass.Zero();
const double rho= getRho();
// check for quick return
if(Lo == 0.0 || rho == 0.0)
return Mass;
double M = 0.5*rho*Lo;
int numDOF2 = numDOF/2;
for(int i = 0; i < getNumDIM(); i++)
{
Mass(i,i) = M;
Mass(i+numDOF2,i+numDOF2) = M;
}
if(isDead())
(*theMatrix)*=dead_srf;
return *theMatrix;
}
main()
{
/* Change of variables info */
double *r,*dr;
int N;
/* Physics variables */
double *V,*Rho,*Rhonew,*phi,*Vxc,*Depsxc,*integrand,Z;
int lmax,*nmax,nmaxmax;
double **E,***Psi,**F;
double Etot;
const double alpha = 0.35;
/* Working variables */
int n,l,k;
double x;
/* Solver iteration varibles */
int it=0;
/* Value of pi */
const double pi=4.*atan(1.);
/* Specs for Sb */
Z=92.;
lmax=3;
nmax=ivector(0,lmax);
nmax[0]=6;
nmax[1]=4;
nmax[2]=3;
nmax[3]=1;
nmaxmax=0;
for (l=0; l<=lmax; l++)
if (nmax[l]>nmaxmax) nmaxmax=nmax[l];
F=dmatrix(0,lmax,0,nmaxmax);
F[0][0]=2.; /* 1s */
F[0][1]=2.; /* 2s */
F[0][2]=2.;
F[0][3]=2.; /* 1s */
F[0][4]=2.; /* 2s */
F[0][5]=2.;
F[0][6]=2.;
F[1][0]=6.; /* 2p */
F[1][1]=6.; /* 3p */
F[1][2]=6.; /* 4p */
F[1][3]=6.; /* 5p */
F[1][4]=6.; /* 5p */
F[2][0]=10.; /* 2p */
F[2][1]=10.; /* 3p */
F[2][2]=10.; /* 4p */
F[2][3]=1.; /* 5p */
F[3][0]=14.; /* 2p */
F[3][1]=3.; /* 3p */
/* The rest is now general for ANY case */
E=dmatrix(0,lmax,0,nmaxmax); /* Make space for E's and Psi's */
Psi=d3tensor(0,lmax,0,nmaxmax,0,Nmx);
Rho=dvector(0,Nmx);
Rhonew=dvector(0,Nmx);
phi=dvector(0,Nmx);
Vxc=dvector(0,Nmx);
Depsxc=dvector(0,Nmx);
integrand=dvector(0,Nmx);
/* Grid vectors */
r=dvector(0,Nmx);
dr=dvector(0,Nmx);
V=dvector(0,Nmx);
N=4000;
/* Set up grid */
for (k=0; k<=N; k++) {
x=((double) k)/((double) N);
r[k]=1/(1-x)-1-x-x*x-x*x*x;
dr[k]=1/(1-x)/(1-x)-1-2*x-3*x*x;
}
dr[N]=0.;
/* Initialize charge density */
for (k=0; k<=N; k++)
Rho[k]=0.;
while(1){
it++;
/* Make potential from zero charge (debugs NaNs, etc.) */
getphi(phi,Rho,r,dr,N);
getVxc(Vxc,Rho,r,dr,N);
for (k=0; k<=N; k++)
V[k]=-Z/r[k]+phi[k]+Vxc[k];
V[0]=0.;
/* Get H 1s wave function, and DENSITY */
getallEs(E,lmax,nmax,Z,V,r,dr,N);
getallPsis(Psi,E,lmax,nmax,V,r,dr,N);
getRho(Rhonew,Psi,F,lmax,nmax,N);
for(k=0;k<=N;k++)Rho[k]=(1. - alpha)*Rho[k]+alpha*Rhonew[k];
/* Compute and output total energy */
/* Get correction to sum of electron energies */
getDepsxc(Depsxc,Rho,r,dr,N);
for (k=0; k<=N; k++)
integrand[k]=(-0.5*phi[k]+Depsxc[k])*Rho[k];
Etot=simpint(integrand,r,dr,N);
/* Add on the sum of the electron energies times the occupancies */
for (l=0; l<=lmax; l++)
for (n=0; n<=nmax[l]; n++)
Etot+=F[l][n]*E[l][n];
printf("%d \t Etot: %20.15f\t E (from NIST): %f \t error: %f\n",it, Etot, -25658.417889, fabs(Etot+25658.417889));
}
/* Be a good citizen and clean up... */
free_dvector(r,0,Nmx);
free_dvector(dr,0,Nmx);
free_dvector(V,0,Nmx);
free_dmatrix(E,0,lmax,0,nmaxmax);
free_dmatrix(F,0,lmax,0,nmaxmax);
free_d3tensor(Psi,0,lmax,0,nmaxmax,0,Nmx);
free_dvector(Rho,0,Nmx);
free_dvector(Rhonew,0,Nmx);
free_dvector(phi,0,Nmx);
free_dvector(Vxc,0,Nmx);
free_dvector(Depsxc,0,Nmx);
free_dvector(integrand,0,Nmx);
free_ivector(nmax,0,lmax);
}
/* ******************************************************************************** */
int CalcConc(double *x, int **A, double *G, double *x0, int numSS, int numTotal,
int MaxIters, double tol, double deltaBar, double eta, double kT,
int MaxNoStep, int MaxTrial, double PerturbScale, int quiet,
int WriteLogFile, char *logFile, double MolesWaterPerLiter,
unsigned long seed) {
/*
Computes the equilbrium mole fractions of species in dilute
solution using a trust region algorithm on the dual problem.
Discussion of the method is in Dirks, et al., Thermodynamic
analysis of interacting nucleic acid strands, SIAM Review, (2006),
in press. The trust region algorithm for solving the dual problem
is that in Nocedal and Wright, Numerical Optimization, 1999, page
68, with the dogleg method on page 71.
Returns 1 if converged and 0 otherwise.
*/
int i,j; // Counters, i is over single-species and j is over all complexes
int iters; // Number of iterations
double *AbsTol; // The absolute tolerance on all values of gradient
double rho; // Ratio of actual to predicted reduction in trust region method
double delta; // Radius of trust region
double *Grad; // The gradient of -g(lambda)
double *lambda; // Lagrange multipliers (dual variables),x[j] = Q[j]*exp(lambda[j])
// for j \in \Psi^0
double *p; // The step we take toward minimization
double **Hes; // The Hessian
double FreeEnergy; // The free energy of the solution
unsigned long rand_seed = 0; // Random number seed
int nNoStep; // Number of iterations without taking a step
int nTrial; // Number of times we've perturbed lambda
int **AT; // Transpose of A
int RunStats[6]; // Statistics on results from getSearchDir (see comments below)
FILE *fplog; // Log file
// Initialize iters just so compiler doesn't give a warning when optimization is on
iters = 0;
// Allocate memory
AT = (int **) malloc(numTotal * sizeof(int *));
for (j = 0; j < numTotal; j++) {
AT[j] = (int *) malloc(numSS * sizeof(int));
}
Hes = (double **) malloc(numSS * sizeof(double *));
for (i = 0; i < numSS; i++) {
Hes[i] = (double *) malloc(numSS * sizeof(double));
}
AbsTol = (double *) malloc(numSS * sizeof(double));
Grad = (double *) malloc(numSS * sizeof(double));
lambda = (double *) malloc(numSS * sizeof(double));
p = (double *) malloc(numSS * sizeof(double));
// The absolute tolerance is a percentage of the entries in x0
for (i = 0; i < numSS; i++) {
AbsTol[i] = tol * x0[i];
}
// Compute AT (transpose of A), useful to have around.
IntTranspose(AT,A,numSS,numTotal);
nTrial = 0;
for (i = 0; i < numSS; i++) {
Grad[i] = AbsTol[i] + 1.0; // Initialize just to get started.
}
while (CheckTol(Grad,AbsTol,numSS) == 0 && nTrial < MaxTrial) {
if (nTrial == 1) {
// Seed the random number generator if necessary
rand_seed = GetRandSeed(seed);
init_genrand(rand_seed);
}
// Set initial guess
getInitialGuess(x0,lambda,G,AT,A,numSS,numTotal,PerturbScale,rand_seed);
// Calculate the counts of the species based on lambda
if (getx(x,lambda,G,AT,numSS,numTotal) == 0) { // Should be fine; checked prev.
if (quiet == 0) {
printf("Overflow error in calcution of mole fractions.\n\n");
printf("Exiting....\n");
}
exit(ERR_OVERFLOW);
}
// Calculate the gradient
getGrad(Grad,x0,x,A,numSS,numTotal);
// Initialize delta to be just less than deltaBar
delta = 0.99 * deltaBar;
// Initializations
iters = 0;
nNoStep = 0;
RunStats[0] = 0; // Number of pure Newton steps (didn't hit trust region boundary)
RunStats[1] = 0; // Number of pure Cauchy steps (hit trust region boundary)
RunStats[2] = 0; // Number of dogleg steps (part Newton and part Cauchy)
RunStats[3] = 0; // Number of steps with Cholesky failure forcing Cauchy step
RunStats[4] = 0; // Number of steps with irrelevant Cholesky failures
RunStats[5] = 0; // Number of failed dogleg calculations
// Run trust region with these initial conditions
while (iters < MaxIters && CheckTol(Grad,AbsTol,numSS) == 0
&& nNoStep < MaxNoStep) {
// Compute the Hessian (symmetric, positive, positive definite)
getHes(Hes,x,A,numSS,numTotal);
// Solve for the search direction
(RunStats[getSearchDir(p,Grad,Hes,delta,numSS) - 1])++;
// Calculate rho, ratio of actual to predicted reduction
rho = getRho(lambda,p,Grad,x,Hes,x0,G,AT,numSS,numTotal);
// Adjust delta and make step based on rho
if (rho < 0.25) {
delta /= 4.0;
}
else if (rho > 0.75 && fabs(norm(p,numSS) - delta) < NUM_PRECISION) {
delta = min2(2.0*delta,deltaBar);
}
if (rho > eta) {
for (i = 0; i < numSS; i++) {
lambda[i] += p[i];
}
nNoStep = 0;
}
else {
nNoStep++;
}
// Calculate the mole fractions of the complexes based on lambda
if (getx(x,lambda,G,AT,numSS,numTotal) == 0) {// Should be fine;checked prev.
if (quiet == 0) {
printf("Overflow error in calcution of mole fractions.\n\n");
printf("Exiting....\n");
}
exit(ERR_OVERFLOW);
}
// Calculate the gradient
getGrad(Grad,x0,x,A,numSS,numTotal);
// Advance the iterations count
iters++;
}
// Advance the number of perturbations we've tried
nTrial++;
}
// Compute the free energy
FreeEnergy = 0;
// First the reference free energy
for (i = 0; i < numSS; i++) {
FreeEnergy += x0[i]*(1.0 - log(x0[i]));
}
// Now the free energy
for (j = 0; j < numTotal; j++) {
if (x[j] > 0) {
FreeEnergy += x[j]*(log(x[j]) + G[j] - 1.0);
}
}
// Convert to kcal/liter of solution
FreeEnergy *= kT*MolesWaterPerLiter;
/* **************** WRITE OUT RESULTS ********************************* */
if ( nTrial == MaxTrial && quiet == 0) {
printf("\n\n TRUST REGION METHOD DID NOT CONVERGE DUE TO PRECISION ISSUES\n\n");
}
// Report errors in conservation of mass to screen
if (quiet == 0) {
// Print out values of the gradient, which is the error in cons. of mass
printf("Error in conservation of mass:\n");
for (i = 0; i < numSS; i++) {
printf(" %8.6e Molar\n",Grad[i]*MolesWaterPerLiter);
}
printf("\n");
// Print out the free energy of the solution
printf("Free energy = %8.6e kcal/litre of solution\n",FreeEnergy);
}
// Write out details of calculation to outfile
if (WriteLogFile) {
if ((fplog = fopen(logFile,"a")) == NULL) {
if (quiet == 0) {
printf("Error opening %s.\n\nExiting....\n",logFile);
}
exit(ERR_LOG);
}
if (nTrial == MaxTrial) {
fprintf(fplog,"TRUST REGION DID NOT CONVERGE DUE TO PRECISION ISSUES\n\n");
}
fprintf(fplog," --Trust region results:\n");
fprintf(fplog," No. of initial conditions tried: %d\n",nTrial);
fprintf(fplog," Results from succesful trial:\n");
fprintf(fplog," No. of iterations: %d\n",iters);
fprintf(fplog," No. of Newton steps: %d\n",RunStats[0]);
fprintf(fplog," No. of Cauchy steps: %d\n",RunStats[1]);
fprintf(fplog," No. of dogleg steps: %d\n",RunStats[2]);
fprintf(fplog," No. of Cholesky failures resulting in Cauchy steps: %d\n"
,RunStats[3]);
fprintf(fplog," No. of inconsequential Cholesky failures: %d\n",
RunStats[4]);
fprintf(fplog," No. of dogleg failures: %d\n",RunStats[5]);
fprintf(fplog," Error in conservation of mass (units of molarity):\n");
fprintf(fplog," Error\tTolerance\n");
for (i = 0; i < numSS; i++) {
fprintf(fplog, " %.14e\t%.14e\n",Grad[i]*MolesWaterPerLiter,
AbsTol[i]*MolesWaterPerLiter);
}
fprintf(fplog," --Free energy of solution = %.14e kcal/litre of solution\n",
FreeEnergy);
fclose(fplog);
}
/* **************** END OF WRITING OUT RESULTS **************************** */
// Free memory
for (j = 0; j < numTotal; j++) {
free(AT[j]);
}
for (i = 0; i < numSS; i++) {
free(Hes[i]);
}
free(AbsTol);
free(AT);
free(Hes);
free(Grad);
free(p);
free(lambda);
// Return convergence
if (nTrial == MaxTrial) {
return 0;
}
else {
return 1;
}
}
main()
{
/* Change of variables info */
double *r,*dr;
int N;
/* Physics variables */
double *V,*Rho,Z;
int lmax,*nmax,nmaxmax;
double **E,***Psi,**F;
/* Working variables */
int n,l,k;
double x;
/* Value of pi */
const double pi=4.*atan(1.);
/* Specifications for carbon */
Z=6.;
lmax=1;
nmax=ivector(0,lmax);
nmax[0]=1;
nmax[1]=0;
nmaxmax=0; /* Find max of all nmax's */
for (l=0; l<=lmax; l++)
if (nmax[l]>nmaxmax) nmaxmax=nmax[l];
F=dmatrix(0,lmax,0,nmaxmax);
F[0][0]=2.; /* 2 electrons in 1s */
F[0][1]=2.; /* 2 electrons in 2s */
F[1][0]=2.; /* 2 electrons in 2p */
/* The rest is now general for ANY case */
E=dmatrix(0,lmax,0,nmaxmax); /* Make space for E's and Psi's */
Psi=d3tensor(0,lmax,0,nmaxmax,0,Nmx);
Rho=dvector(0,Nmx);
/* Grid vectors */
r=dvector(0,Nmx);
dr=dvector(0,Nmx);
V=dvector(0,Nmx);
/* Set up grid */
N=400;
for (k=0; k<=N; k++) {
x=((double) k)/((double) N);
r[k]=1./(1.-x)-1.-x-x*x;
dr[k]=1./(1.-x)/(1.-x)-1.-2*x;
V[k]=-Z/r[k];
}
V[0]=0.; dr[N]=0.;
/* Test section */
getallEs(E,lmax,nmax,Z,V,r,dr,N);
getallPsis(Psi,E,lmax,nmax,V,r,dr,N);
getRho(Rho,Psi,F,lmax,nmax,N);
printf("Total charge is: %20.15f\n",simpint(Rho,r,dr,N));
/* Be a good citizen and clean up... */
free_dvector(r,0,Nmx);
free_dvector(dr,0,Nmx);
free_dvector(V,0,Nmx);
free_dmatrix(E,0,lmax,0,nmaxmax);
free_dmatrix(F,0,lmax,0,nmaxmax);
free_d3tensor(Psi,0,lmax,0,nmaxmax,0,Nmx);
free_dvector(Rho,0,Nmx);
}
