/*

-------------------------------------------------------------------------------

Copyright 2005 Scott C. Noble, Charles F. Gammie,

Jonathan C. McKinney, and Luca Del Zanna

This file is part of PVS-GRMHD.

PVS-GRMHD is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

PVS-GRMHD is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with PVS-GRMHD; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

-------------------------------------------------------------------------------

*/

/*************************************************************************************/

/*************************************************************************************/

/*************************************************************************************

utoprim_1dvsq1.c:

---------------

Uses the 1D_{v^2} method:

-- solves for one independent variable (v^2) via a 1D

Newton-Raphson method using the known analytic solution for W

per value of v^2;

-- CANNOT be used for arbitrary equations of state, only a Gamma-law

EOS is compatible; if you wish to use another EOS, please

use utoprim_2d.c, or utoprim_1d.c;

-- This method is different from utoprim_1dvsq2.c in that it uses

the closed-form solution of W(v^2) rather than a numerically-calculated

value via Newton-Raphson;

-- Currently returns with an error state (>0) if a negative rest-mass

density or internal energy density is calculated. You may want

to change this aspect of the code so that it still calculates the

velocity and so that you can floor the densities. If you want to

change this aspect of the code please comment out the "return(retval)"

statement after "retval = 5;" statement in Utoprim_new_body();

******************************************************************************/

#include "u2p_util.h"

#define NEWT_DIM 1

/* these variables need to be shared between the functions

Utoprim_1D, residual, and utsq */

FTYPE Bsq,QdotBsq,Qtsq,Qdotn,D,Wc;

FTYPE Ec, Dc, Ssq, igam1;

// Declarations:

static FTYPE vsq_calc(FTYPE W);

/**********************************************************************/

/******************************************************************

Utoprim_1dvsq1():

-- Driver for new prim. var. solver. The driver just translates

between the two sets of definitions for U and P. The user may

wish to alter the translation as they see fit.

It assumes that on input/output:

/ rho u^t \

U = | T^t_t + rho u^t | sqrt(-det(g_{\mu\nu}))

| T^t_\mu |

\ B^i /

/ rho \

P = | uu |

| \tilde{u}^i |

\ B^i /

ala HARM.

Arguments:

U[NPR] = conserved variables (current values on input/output);

gcov[NDIM][NDIM] = covariant form of the metric ;

gcon[NDIM][NDIM] = contravariant form of the metric ;

gdet = sqrt( - determinant of the metric) ;

prim[NPR] = primitive variables (guess on input, calculated values on

output if there are no problems);

-- NOTE: for those using this routine for special relativistic MHD and are

unfamiliar with metrics, merely set

gcov = gcon = diag(-1,1,1,1) and gdet = 1. ;

******************************************************************/

int Utoprim_1dvsq1(FTYPE U[NPR], FTYPE gcov[NDIM][NDIM], FTYPE gcon[NDIM][NDIM],

FTYPE gdet, FTYPE prim[NPR])

{

static int Utoprim_new_body(FTYPE U[], FTYPE gcov[NDIM][NDIM],

FTYPE gcon[NDIM][NDIM], FTYPE gdet, FTYPE prim[]);

FTYPE U_tmp[NPR], prim_tmp[NPR];

int i, j, ret;

FTYPE alpha;

/* First update the primitive B-fields */

for(i = BCON1; i <= BCON3; i++) prim[i] = U[i] / gdet ;

/* Set the geometry variables: */

alpha = 1.0/sqrt(-gcon[0][0]);

/* Transform the CONSERVED variables into the new system */

U_tmp[RHO] = alpha * U[RHO] / gdet;

U_tmp[UU] = alpha * (U[UU] - U[RHO]) / gdet;

for( i = UTCON1; i <= UTCON3; i++ ) {

U_tmp[i] = alpha * U[i] / gdet ;

}

for( i = BCON1; i <= BCON3; i++ ) {

U_tmp[i] = alpha * U[i] / gdet ;

}

/* Transform the PRIMITIVE variables into the new system */

for( i = 0; i < BCON1; i++ ) {

prim_tmp[i] = prim[i];

}

for( i = BCON1; i <= BCON3; i++ ) {

prim_tmp[i] = alpha*prim[i];

}

ret = Utoprim_new_body(U_tmp, gcov, gcon, gdet, prim_tmp);

/* Transform new primitive variables back if there was no problem : */

if( ret == 0 ) {

for( i = 0; i < BCON1; i++ ) {

prim[i] = prim_tmp[i];

}

}

return( ret ) ;

}

/**********************************************************************/

/**********************************************************************************

Utoprim_new_body():

-- Attempt an inversion from U to prim using the initial guess prim.

-- This is the main routine that calculates auxiliary quantities for the

Newton-Raphson routine.

-- assumes that

/ rho gamma \

U = | alpha T^t_\mu |

\ alpha B^i /

/ rho \

prim = | uu |

| \tilde{u}^i |

\ alpha B^i /

return: (i*100 + j) where

i = 0 -> Newton-Raphson solver either was not called (yet or not used)

or returned successfully;

1 -> Newton-Raphson solver did not converge to a solution with the

given tolerances;

2 -> Newton-Raphson procedure encountered a numerical divergence

(occurrence of "nan" or "+/-inf" ;

j = 0 -> success

1 -> failure: some sort of failure in Newton-Raphson;

2 -> failure: utsq<0 w/ initial p[] guess;

3 -> failure: W<0 or W>W_TOO_BIG

4 -> failure: v^2 > 1

5 -> failure: rho,uu <= 0 ;

**********************************************************************************/

static int Utoprim_new_body( FTYPE U[NPR], FTYPE gcov[NDIM][NDIM],

FTYPE gcon[NDIM][NDIM], FTYPE gdet, FTYPE prim[NPR])

{

static void func_1d_dbl( FTYPE x[], FTYPE dx[], FTYPE resid[],

FTYPE jac[][NEWT_DIM], FTYPE *f, FTYPE *df, int n);

static int general_newton_raphson( FTYPE x[], int n,

void (*funcd) (FTYPE [], FTYPE [],

FTYPE [], FTYPE [][NEWT_DIM],

FTYPE *, FTYPE *, int) );

FTYPE x_1d[1];

FTYPE QdotB,Bcon[NDIM],Bcov[NDIM],Qcov[NDIM],Qcon[NDIM],ncov[NDIM],ncon[NDIM],Qsq,Qtcon[NDIM];

FTYPE rho0,u,p,w,gammasq,gamma,gtmp,W_last,W,utsq,vsq,tmpdiff ;

int i,j, retval, i_increase ;

// Assume ok initially:

retval = 0;

for(i = BCON1; i <= BCON3; i++) prim[i] = U[i] ;

// Calculate various scalars (Q.B, Q^2, etc) from the conserved variables:

Bcon[0] = 0. ;

for(i=1;i<4;i++) Bcon[i] = U[BCON1+i-1] ;

lower_g(Bcon,gcov,Bcov) ;

for(i=0;i<4;i++) Qcov[i] = U[QCOV0+i] ;

raise_g(Qcov,gcon,Qcon) ;

Bsq = 0. ;

for(i=1;i<4;i++) Bsq += Bcon[i]*Bcov[i] ;

QdotB = 0. ;

for(i=0;i<4;i++) QdotB += Qcov[i]*Bcon[i] ;

QdotBsq = QdotB*QdotB ;

ncov_calc(gcon,ncov) ;

raise_g(ncov,gcon,ncon);

Qdotn = Qcon[0]*ncov[0] ;

Qsq = 0. ;

for(i=0;i<4;i++) Qsq += Qcov[i]*Qcon[i] ;

Qtsq = Qsq + Qdotn*Qdotn ;

D = Dc = U[RHO] ;

Ec = -Qdotn;

Ssq = QdotBsq;

igam1 = (GAMMA - 1.)/GAMMA ;

/* calculate W from last timestep and use for guess */

utsq = 0. ;

for(i=1;i<4;i++)

for(j=1;j<4;j++) utsq += gcov[i][j]*prim[UTCON1+i-1]*prim[UTCON1+j-1] ;

if( (utsq < 0.) && (fabs(utsq) < 1.0e-13) ) {

utsq = fabs(utsq);

}

if(utsq < 0. || utsq > UTSQ_TOO_BIG) {

retval = 2;

return(retval) ;

}

gammasq = 1. + utsq ;

gamma = sqrt(gammasq);

// Always calculate rho from D and gamma so that using D in EOS remains consistent

// i.e. you don't get positive values for dP/d(vsq) .

rho0 = D / gamma ;

u = prim[UU] ;

p = pressure_rho0_u(rho0,u) ;

w = rho0 + u + p ;

W_last = w*gammasq ;

// Make sure that W is large enough so that v^2 < 1 :

i_increase = 0;

while( (( W_last*W_last*W_last * ( W_last + 2.*Bsq )

- QdotBsq*(2.*W_last + Bsq) ) <= W_last*W_last*(Qtsq-Bsq*Bsq))

&& (i_increase < 10) ) {

W_last *= 10.;

i_increase++;

}

// METHOD specific:

Wc = W_last;

x_1d[0] = 1. - 1. / gammasq ;

// Find vsq :

retval = general_newton_raphson( x_1d, 1, func_1d_dbl ) ;

// Find W from this vsq:

vsq = x_1d[0] ;

W = Wc;

/* Problem with solver, so return denoting error before doing anything further */

if( (retval != 0) || (W == FAIL_VAL) ) {

retval = retval*100+1;

return(retval);

}

else{

if(W <= 0. || W > W_TOO_BIG) {

retval = 3;

return(retval) ;

}

}

// Calculate utsq

// calculated from above:

if( vsq >= 1. ) {

retval = 4;

return(retval) ;

}

// Recover the primitive variables from the scalars and conserved variables:

gtmp = sqrt(1. - vsq);

gamma = 1./gtmp ;

rho0 = D * gtmp;

w = W * (1. - vsq) ;

p = pressure_rho0_w(rho0,w) ;

u = w - (rho0 + p) ;

// User may want to handle this case differently, e.g. do NOT return upon

// a negative rho/u, calculate v^i so that rho/u can be floored by other routine:

if( (rho0 <= 0.) || (u <= 0.) ) {

retval = 5;

return(retval) ;

}

prim[RHO] = rho0 ;

prim[UU] = u ;

for(i=1;i<4;i++) Qtcon[i] = Qcon[i] + ncon[i] * Qdotn;

for(i=1;i<4;i++) prim[UTCON1+i-1] = gamma/(W+Bsq) * ( Qtcon[i] + QdotB*Bcon[i]/W ) ;

/* set field components */

for(i = BCON1; i <= BCON3; i++) prim[i] = U[i] ;

/* done! */

return(retval) ;

}

/**********************************************************************/

/****************************************************************************

vsq_calc():

-- evaluate v^2 (spatial, normalized velocity) from

W = \gamma^2 w

****************************************************************************/

static FTYPE vsq_calc(FTYPE W)

{

FTYPE Wsq,Xsq;

Wsq = W*W ;

Xsq = (Bsq + W) * (Bsq + W);

return( ( Wsq * Qtsq + QdotBsq * (Bsq + 2.*W)) / (Wsq*Xsq) );

}

/********************************************************************

validate_x():

-- makes sure that x[0] is physical, based upon its definition;

*********************************************************************/

static void validate_x(FTYPE x[1], FTYPE x0[1] )

{

FTYPE small = 1.e-10;

/* Always take the absolute value of x[0] and check to see if it's too big: */

x[0] = (x[0] > 1.0) ? ( 0.5*(x0[0] + 1.) ) : x[0];

x[0] = (x[0] < -small) ? ( 0.5*x0[0] ) : x[0];

x[0] = fabs(x[0]);

return;

}

/**********************************************************************/

/************************************************************

general_newton_raphson():

-- performs Newton-Rapshon method on an arbitrary system.

-- inspired in part by Num. Rec.'s routine newt();

Arguements:

-- x[] = set of independent variables to solve for;

-- n = number of independent variables and residuals;

-- funcd = name of function that calculates residuals, etc.;

*****************************************************************/

static int general_newton_raphson( FTYPE x[], int n,

void (*funcd) (FTYPE [], FTYPE [], FTYPE [],

FTYPE [][NEWT_DIM], FTYPE *,

FTYPE *, int))

{

FTYPE f, df, dx[NEWT_DIM], x_old[NEWT_DIM], resid[NEWT_DIM],

jac[NEWT_DIM][NEWT_DIM];

FTYPE errx, x_orig[NEWT_DIM];

int n_iter, id, jd, i_extra, doing_extra;

FTYPE dW,dvsq,vsq_old,vsq,W,W_old;

int keep_iterating;

// Initialize various parameters and variables:

errx = 1. ;

df = f = 1.;

i_extra = doing_extra = 0;

for( id = 0; id < n ; id++) x_old[id] = x_orig[id] = x[id] ;

vsq_old = vsq = W = W_old = 0.;

n_iter = 0;

/* Start the Newton-Raphson iterations : */

keep_iterating = 1;

while( keep_iterating ) {

(*funcd) (x, dx, resid, jac, &f, &df, n); /* returns with new dx, f, df */

/* Save old values before calculating the new: */

errx = 0.;

for( id = 0; id < n ; id++) {

x_old[id] = x[id] ;

}

/* Make the newton step: */

for( id = 0; id < n ; id++) {

x[id] += dx[id] ;

}

/****************************************/

/* Calculate the convergence criterion */

/****************************************/

W_old = W;

W = Wc;

errx = (W==0.) ? fabs(W-W_old) : fabs((W-W_old)/W);

/****************************************/

/* Make sure that the new x[] is physical : */

/****************************************/

// METHOD specific

validate_x( x, x_old ) ;

/*****************************************************************************/

/* If we've reached the tolerance level, then just do a few extra iterations */

/* before stopping */

/*****************************************************************************/

if( (fabs(errx) <= NEWT_TOL) && (doing_extra == 0) && (EXTRA_NEWT_ITER > 0) ) {

doing_extra = 1;

}

if( doing_extra == 1 ) i_extra++ ;

if( ((fabs(errx) <= NEWT_TOL)&&(doing_extra == 0))

|| (i_extra > EXTRA_NEWT_ITER) || (n_iter >= (MAX_NEWT_ITER-1)) ) {

keep_iterating = 0;

}

n_iter++;

} // END of while(keep_iterating)

/* Check for bad untrapped divergences : */

if( (finite(f)==0) || (finite(df)==0) ) {

return(2);

}

if( fabs(errx) > MIN_NEWT_TOL){

return(1);

}

if( (fabs(errx) <= MIN_NEWT_TOL) && (fabs(errx) > NEWT_TOL) ){

return(0);

}

if( fabs(errx) <= NEWT_TOL ){

return(0);

}

return(0);

}

/**********************************************************************/

/*********************************************************************************

func_1d_dbl():

-- calculates the residuals, and Newton step for general_newton_raphson();

-- for this method, x=vsq here;

-- figures out the right closed form of the solution to use, so that it

uses the simplest form and to reduce the error that may arise from

non-zero cancelations of the imaginary terms (since answer is always

real;

Arguments:

x = current value of independent var's (on input & output);

dx = Newton-Raphson step (on output);

resid = residuals based on x (on output);

jac = Jacobian matrix based on x (on output);

f = resid.resid/2 (on output)

df = -2*f; (on output)

n = dimension of x[];

*********************************************************************************/

static void func_1d_dbl(FTYPE x[], FTYPE dx[], FTYPE resid[],

FTYPE jac[][NEWT_DIM], FTYPE *f, FTYPE *df_out, int n)

{

FTYPE vsq,glf1,cc,wsq,dw, df ;

FTYPE a2,a1,a0,q,r,th,w1,vp2,vp3,cosa,dvar,dvarcubed, a2p,z1,z2 ;

FTYPE discrim, df_check, f_check, fm, dfm;

vsq = x[0] ;

glf1 = sqrt(1. - vsq) ;

z2 = 1. - igam1*(1. - vsq);

cc = 1./z2 ;

z1 = -(Ec - igam1*glf1*Dc - 0.5*Bsq) ;

a2p = z1 + 0.5 * Bsq * vsq;

a2 = a2p*cc;

a0 = - 0.5 * Ssq * cc;

dvar = a2 / 3. ;

dvarcubed = a2 * a2 * a2 / 27. ;

// Determine which type of solution it is, and calculate W and dW/dvsq

// accordingly:

if( a0 < 0. ) {

if( a2 == 0. ) { // Case 3

Wc = pow( -a0, (1./3.) );

dw = - Wc * igam1 * cc / 3. ;

}

else if( dvarcubed == -0.25*a0 ) { // Case 4 -- rare

Wc = dvar ;

// dw = cc * ( 0.5*Bsq - 0.5*Dc*igam1/glf1 - a2 * igam1 ) / 3. ;

dw = - igam1 * pow( Ssq, (1./3.) ) * pow( z2, (-4./3.) ) / 6.;

}

else if( dvarcubed < -0.25*a0 ) { // Case 2

discrim = a0 * ( 0.25*a0 + dvarcubed );

r = - 0.5 * a0 - dvarcubed;

Wc = -dvar + pow( (r + sqrt(discrim) ), (1./3.))

+ pow( (r - sqrt(discrim) ), (1./3.)) ;

dw = ( Wc*Wc*( igam1*(0.5*Dc/glf1 + a2) - 0.5*Bsq ) + a0*igam1 )

/ ( Wc*( 3.*Wc*z2 + 2.*a2p ) );

}

else if( dvarcubed > -0.25*a0 ) { // Case 1

cosa = -( dvarcubed + 0.5*a0 ) / dvarcubed;

if(cosa > 1.) cosa = 1. ;

th = acos(cosa) ;

Wc = dvar * ( 2.*cos(th/3.) - 1. ) ;

dw = ( Wc*Wc*( igam1*(0.5*Dc/glf1 + a2) - 0.5*Bsq ) + a0*igam1 )

/ ( Wc*( 3.*Wc*z2 + 2.*a2p ) );

}

else { // Invalid case

*f = FAIL_VAL;

df = FAIL_VAL;

*df_out = FAIL_VAL;

dx[0] = FAIL_VAL;

Wc=FAIL_VAL;

return;

}

}

else if( (a0 == 0.) && (a2 < 0.) ) { // Case 5 -- rare

Wc = -a2 ;

dw = -cc * ( 0.5*Bsq - 0.5*Dc*igam1/glf1 - a2 * igam1 ) ;

}

else { // Invalid case

*f = FAIL_VAL;

df = FAIL_VAL;

*df_out = FAIL_VAL;

dx[0] = FAIL_VAL;

Wc=FAIL_VAL;

return;

}

// With the best values for W and dW/dvsq, calculate the rest:

wsq = Wc*Wc ;

vp2 = Wc + Bsq;

vp3 = vp2 + Wc;

*f = Qtsq - vsq * vp2 * vp2 + vp3 * Ssq / wsq;

df = -vp2 * ( vp2 + 2. * dw * ( vsq + Ssq / (wsq*Wc) ) ) ;

dx[0] = -(*f) / (df) ;

resid[0] = (*f);

jac[0][0] = df;

*f = 0.5 * (*f) * (*f) ;

*df_out = -2.0 * (*f);

}

/**********************************************************************

**********************************************************************

The following routines specify the equation of state.

The above routines DO assume that the equation of state is as

stated below. If one wishes to use this method with a different

EOS, please use Utoprim_1dvsq2() instead and change the EOS

routines at the bottom of utoprim_1dvsq.c.

**********************************************************************

**********************************************************************/

/**********************************************************************/

/**********************************************************************

pressure_W_vsq():

-- Gamma-law equation of state;

-- pressure as a function of W, vsq, and D:

**********************************************************************/

static FTYPE pressure_W_vsq(FTYPE W, FTYPE vsq)

{

FTYPE gtmp;

gtmp = 1. - vsq;

return( (GAMMA - 1.) * ( W * gtmp - D * sqrt(gtmp) ) / GAMMA );

}

/**********************************************************************/

/**********************************************************************

dpdW_calc_vsq():

-- partial derivative of pressure with respect to W;

**********************************************************************/

static FTYPE dpdW_calc_vsq(FTYPE W, FTYPE vsq)

{

return( (GAMMA - 1.) * (1. - vsq) / GAMMA ) ;

}

/**********************************************************************/

/**********************************************************************

dpdvsq_calc():

-- partial derivative of pressure with respect to vsq

**********************************************************************/

static FTYPE dpdvsq_calc(FTYPE W, FTYPE vsq)

{

return( (GAMMA - 1.) * ( 0.5 * D / sqrt(1.-vsq) - W ) / GAMMA ) ;

}

/******************************************************************************

END OF UTOPRIM_1DVSQ1.C

******************************************************************************/