static void func_vsq(FTYPE x[], FTYPE dx[], FTYPE resid[], FTYPE jac[][NEWT_DIM], FTYPE *f, FTYPE *df, int n)
{
FTYPE W, vsq, Wsq, p_tmp, dPdvsq, dPdW, temp, detJ,tmp2,tmp3;
const int ltrace = 0;
W = x[0];
vsq = x[1];
Wsq = W*W;
p_tmp = pressure_W_vsq( W, vsq );
dPdW = dpdW_calc_vsq( W, vsq );
dPdvsq = dpdvsq_calc( W, vsq );
/* These expressions were calculated using Mathematica */
/* Since we know the analytic form of the equations, we can explicitly
calculate the Newton-Raphson step: */
dx[0] = (-Bsq/2. + dPdvsq)*(Qtsq - vsq*((Bsq+W)*(Bsq+W)) +
(QdotBsq*(Bsq + 2*W))/Wsq) +
((Bsq+W)*(Bsq+W))*(-Qdotn - (Bsq*(1 + vsq))/2. + QdotBsq/(2.*Wsq) -
W + p_tmp);
dx[1] = -((-1 + dPdW - QdotBsq/(Wsq*W))*
(Qtsq - vsq*((Bsq+W)*(Bsq+W)) + (QdotBsq*(Bsq + 2*W))/Wsq)) -
2*(vsq + QdotBsq/(Wsq*W))*(Bsq + W)*
(-Qdotn - (Bsq*(1 + vsq))/2. + QdotBsq/(2.*Wsq) - W + p_tmp);
detJ = (Bsq + W)*((-1 + dPdW - QdotBsq/(Wsq*W))*(Bsq + W) +
((Bsq - 2*dPdvsq)*(QdotBsq + vsq*(Wsq*W)))/(Wsq*W));
dx[0] /= -(detJ) ;
dx[1] /= -(detJ) ;
jac[0][0] = -2*(vsq + QdotBsq/(Wsq*W))*(Bsq + W);
jac[0][1] = -(Bsq + W)*(Bsq + W);
jac[1][0] = -1 - QdotBsq/(Wsq*W) + dPdW;
jac[1][1] = -Bsq/2. + dPdvsq;
resid[0] = Qtsq - vsq*(Bsq + W)*(Bsq + W) + (QdotBsq*(Bsq + 2*W))/Wsq;
resid[1] = -Qdotn - (Bsq*(1 + vsq))/2. + QdotBsq/(2.*Wsq) - W + p_tmp;
*df = -resid[0]*resid[0] - resid[1]*resid[1];
*f = -0.5 * ( *df );
#if(!OPTIMIZED)
if( ltrace ) {
dualfprintf(fail_file,"func_vsq(): x[0] = %21.15g , x[1] = %21.15g , dx[0] = %21.15g , dx[1] = %21.15g , f = %21.15g \n",
x[0], x[1],dx[0], dx[1], *f);
}
#endif
}
static void func_vsq(FTYPE x[2], FTYPE dx[2], FTYPE *f, FTYPE *df, int n)
{
// extern FTYPE Qtsq, Bsq, QdotBsq, Qdotn;
FTYPE W, vsq, Wsq, p_tmp, dPdvsq, dPdW, temp, detJ,tmp2,tmp3;
const int ltrace = 0;
W = x[0];
vsq = x[1];
Wsq = W*W;
p_tmp = pressure_W_vsq( W, vsq );
dPdW = dpdW_calc_vsq( W, vsq );
dPdvsq = dpdvsq_calc( W, vsq );
/* These expressions were calculated using Mathematica */
/* Since we know the analytic form of the equations, we can explicitly
calculate the Newton-Raphson step: */
dx[0] = (-Bsq/2. + dPdvsq)*(Qtsq - vsq*((Bsq+W)*(Bsq+W)) +
(QdotBsq*(Bsq + 2*W))/Wsq) +
((Bsq+W)*(Bsq+W))*(Qdotn - (Bsq*(1 + vsq))/2. + QdotBsq/(2.*Wsq) -
W + p_tmp);
dx[1] = -((-1 + dPdW - QdotBsq/(Wsq*W))*
(Qtsq - vsq*((Bsq+W)*(Bsq+W)) + (QdotBsq*(Bsq + 2*W))/Wsq)) -
2*(vsq + QdotBsq/(Wsq*W))*(Bsq + W)*
(Qdotn - (Bsq*(1 + vsq))/2. + QdotBsq/(2.*Wsq) - W + p_tmp);
detJ = (Bsq + W)*((-1 + dPdW - QdotBsq/(Wsq*W))*(Bsq + W) +
((Bsq - 2*dPdvsq)*(QdotBsq + vsq*(Wsq*W)))/(Wsq*W));
dx[0] /= -(detJ) ;
dx[1] /= -(detJ) ;
tmp2 = (Qtsq - vsq*((Bsq+W)*(Bsq+W)) + (QdotBsq*(Bsq + 2*W))/Wsq);
tmp3 = (Qdotn - (Bsq*(1 + vsq))/2. + QdotBsq/(2.*Wsq) - W + p_tmp);
*df = -tmp2*tmp2 - tmp3*tmp3;
*f = -0.5 * ( *df );
if( ltrace ) {
fprintf(stdout,"func_vsq(): x[0] = %21.15g , x[1] = %21.15g , dx[0] = %21.15g , dx[1] = %21.15g , f = %21.15g \n", x[0], x[1],dx[0], dx[1], *f);
fflush(stdout);
}
}
static void func_1d_gnr(FTYPE x[], FTYPE dx[], FTYPE resid[],
FTYPE jac[][NEWT_DIM], FTYPE *f, FTYPE *df, int n)
{
FTYPE vsq,W,W0,dpdW,Wsq,W3,p_tmp,dWdvsq , dpdvsq, fact_tmp ;
int retval, iters;
static void func_1d_gnr2(FTYPE x[], FTYPE dx[], FTYPE resid[],
FTYPE jac[][NEWT_DIM], FTYPE *f, FTYPE *df, int n);
static int gnr2( FTYPE x[], int n,
void (*funcd) (FTYPE [], FTYPE [], FTYPE [],
FTYPE [][NEWT_DIM], FTYPE *, FTYPE *, int) );
static FTYPE dpdvsq_calc(FTYPE W, FTYPE vsq);
vsq = x[0];
// Calculate best value for W given current guess for vsq:
vsq_for_gnr2 = vsq;
W0 = W_for_gnr;
retval = 1 ;
iters = 0;
while ( (retval != 0) && (++iters < 6) ) {
x[0] = W0;
retval = gnr2( x, 1, func_1d_gnr2 ) ;
W0 *= 10.;
}
W = W_for_gnr = x[0];
Wsq = W*W;
W3 = W*Wsq;
x[0] = vsq;
dpdW = dpdW_calc_vsq( W, vsq );
dpdvsq = dpdvsq_calc( W, vsq );
dWdvsq = ( dpdvsq - 0.5*Bsq ) / ( 1. - dpdW + QdotBsq/W3 ) ;
fact_tmp = (Bsq + W) ;
resid[0] = Qtsq - vsq * fact_tmp * fact_tmp + QdotBsq * ( Bsq + 2.*W ) / Wsq ;
jac[0][0] = -fact_tmp * ( fact_tmp + 2. * dWdvsq * ( vsq + QdotBsq/W3 ) ) ;
dx[0] = -resid[0]/jac[0][0];
*f = 0.5*resid[0]*resid[0];
*df = -2. * (*f);
}
static FTYPE res_sq_vsq(FTYPE x[])
{
FTYPE W, vsq, Wsq, p_tmp, dPdvsq, dPdW, temp, detJ,tmp2,tmp3;
FTYPE resid[2];
const int ltrace = 0;
W = x[0];
vsq = x[1];
Wsq = W*W;
p_tmp = pressure_W_vsq( W, vsq );
dPdW = dpdW_calc_vsq( W, vsq );
dPdvsq = dpdvsq_calc( W, vsq );
/* These expressions were calculated using Mathematica */
/* Since we know the analytic form of the equations, we can explicitly
calculate the Newton-Raphson step: */
resid[0] = Qtsq - vsq*(Bsq + W)*(Bsq + W) + (QdotBsq*(Bsq + 2*W))/Wsq;
resid[1] = -Qdotn - (Bsq*(1 + vsq))/2. + QdotBsq/(2.*Wsq) - W + p_tmp;
tmp3 = 0.5 * ( resid[0]*resid[0] + resid[1]*resid[1] ) ;
#if(!OPTIMIZED)
if( ltrace ) {
dualfprintf(fail_file,"res_sq_vsq(): W,vsq,resid0,resid1,f = %21.15g %21.15g %21.15g %21.15g %21.15g \n",
W,vsq,resid[0],resid[1],tmp3);
dualfprintf(fail_file,"res_sq_vsq(): Qtsq, Bsq, QdotBsq, Qdotn = %21.15g %21.15g %21.15g %21.15g \n",
Qtsq, Bsq, QdotBsq, Qdotn);
}
#endif
return( tmp3 );
}
static void func_vsq(FTYPE x[], FTYPE dx[], FTYPE resid[],
FTYPE jac[][NEWT_DIM], FTYPE *f, FTYPE *df, int n)
{
FTYPE W, vsq, Wsq, p_tmp, dPdvsq, dPdW, temp, detJ,tmp2,tmp3;
FTYPE t11;
FTYPE t16;
FTYPE t18;
FTYPE t2;
FTYPE t21;
FTYPE t23;
FTYPE t24;
FTYPE t25;
FTYPE t3;
FTYPE t35;
FTYPE t36;
FTYPE t4;
FTYPE t40;
FTYPE t9;
W = x[0];
vsq = x[1];
Wsq = W*W;
p_tmp = pressure_W_vsq( W, vsq );
dPdW = dpdW_calc_vsq( W, vsq );
dPdvsq = dpdvsq_calc( W, vsq );
// These expressions were calculated using Mathematica, but made into efficient
// code using Maple. Since we know the analytic form of the equations, we can
// explicitly calculate the Newton-Raphson step:
t2 = -0.5*Bsq+dPdvsq;
t3 = Bsq+W;
t4 = t3*t3;
t9 = 1/Wsq;
t11 = Qtsq-vsq*t4+QdotBsq*(Bsq+2.0*W)*t9;
t16 = QdotBsq*t9;
t18 = -Qdotn-0.5*Bsq*(1.0+vsq)+0.5*t16-W+p_tmp;
t21 = 1/t3;
t23 = 1/W;
t24 = t16*t23;
t25 = -1.0+dPdW-t24;
t35 = t25*t3+(Bsq-2.0*dPdvsq)*(QdotBsq+vsq*Wsq*W)*t9*t23;
t36 = 1/t35;
dx[0] = -(t2*t11+t4*t18)*t21*t36;
t40 = (vsq+t24)*t3;
dx[1] = -(-t25*t11-2.0*t40*t18)*t21*t36;
detJ = t3*t35;
jac[0][0] = -2.0*t40;
jac[0][1] = -t4;
jac[1][0] = t25;
jac[1][1] = t2;
resid[0] = t11;
resid[1] = t18;
*df = -resid[0]*resid[0] - resid[1]*resid[1];
*f = -0.5 * ( *df );
}
