prototypes.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	ARRAY_1D(nx, type)    (type *)Array1D(nx,sizeof(type))
#define	ARRAY_2D(nx, ny, type)    (type **)Array2D(nx,ny,sizeof(type))
#define	ARRAY_3D(nx, ny, nz, type)    (type ***)Array3D(nx,ny,nz,sizeof(type))
#define	ARRAY_4D(nx, ny, nz, nv, type)   (type ****)Array4D(nx,ny,nz,nv,sizeof(type))

Functions
int	AdvanceStep (const Data *, Riemann_Solver *, Time_Step *, Grid *)
void	AdvectFlux (const State_1D *, int, int, Grid *)
void	Analysis (const Data *, Grid *)
void	Boundary (const Data *, int, Grid *)
char *	Array1D (int, size_t)
char **	Array2D (int, int, size_t)
char ***	Array3D (int, int, int, size_t)
char ****	Array4D (int, int, int, int, size_t)
double ***	ArrayBox (long int, long int, long int, long int, long int, long int)
double ***	ArrayBoxMap (int, int, int, int, int, int, double *)
double ***	ArrayMap (int, int, int, double *)
unsigned char ***	ArrayCharMap (int, int, int, unsigned char *)
void	BodyForceVectorGet (double **v, double **g, double *, double *, double *, int beg, int end, Grid *grid)
void	BodyForcePotentialGet (double **v, double **gphi, double *phi_p, double *phi_c, int beg, int end, Grid *grid)
double	BodyForcePotential (double, double, double)
void	BodyForceVector (double *, double *, double, double, double)
void	ChangeDumpVar ()
void	CharTracingStep (const State_1D *, int, int, Grid *)
void	CheckPrimStates (double **, double **, double **, int, int)
int	CheckNaN (double **, int, int, int)
int	CloseBinaryFile (FILE *, int)
void	ComputeUserVar (const Data *, Grid *)
float ***	Convert_dbl2flt (double ***, double, int)
void	ConsToPrim3D (Data_Arr, Data_Arr, unsigned char ***, RBox *)
void	CreateImage (char *)
void	ComputeEntropy (const Data *, Grid *)
void	EntropySwitch (const Data *, Grid *)
void	EntropyOhmicHeating (const Data *, Data_Arr, double, Grid *)
void	FreeArray1D (void *)
void	FreeArray2D (void **)
void	FreeArray3D (void ***)
void	FreeArray4D (void ****)
void	FreeArrayBox (double ***, long, long, long)
void	FreeArrayBoxMap (double ***, int, int, int, int, int, int)
void	FreeArrayMap (double ***)
void	FreeArrayCharMap (unsigned char ***)
void	FindShock (const Data *, Grid *)
void	FlagShock (const Data *, Grid *)
void	Flatten (const State_1D *, int, int, Grid *)
void	FreeGrid (Grid *)
void	GetAreaFlux (const State_1D *, double **, double **, int, int, Grid *)
void	GetCGSUnits (double *u)
Image *	GetImage (char *)
double *	GetInverse_dl (const Grid *)
int	GetNghost (void)
void	GetOutputFrequency (Output *, const char *)
RBox *	GetRBox (int, int)
double ***	GetUserVar (char *)
void	HancockStep (const State_1D *, int, int, Grid *)
int	LocateIndex (double *, int, int, double)
void	Init (double *, double, double, double)
void	Initialize (int argc, char *argv[], Data *, Runtime *, Grid *, Cmd_Line *)
void	InternalBoundaryReset (const State_1D *, Time_Step *, int, int, Grid *)
void	InputDataFree (void)
void	InputDataInterpolate (double *, double, double, double)
void	InputDataRead (char *, char *)
void	InputDataSet (char *, int *)
int	IsLittleEndian (void)
void	MakeState (State_1D *)
void	MakeGeometry (Grid *)
double	MeanMolecularWeight (double *)
double	Median (double a, double b, double c)
FILE *	OpenBinaryFile (char *, int, char *)
void	ParabolicFlux (Data_Arr, Data_Arr J, double ***, const State_1D *, double **, int, int, Grid *)
double	ParabolicRHS (const Data *, Data_Arr, double, Grid *)
void	ParseCmdLineArgs (int, char *argv[], char *, Cmd_Line *)
int	ParamFileRead (char *)
char *	ParamFileGet (const char *, int)
int	ParamExist (const char *)
int	ParamFileHasBoth (const char *, const char *)
void	PrimToChar (double **, double *, double *)
void	PrimToCons3D (Data_Arr, Data_Arr, RBox *)
void	ReadBinaryArray (void *, size_t, int, FILE *, int, int)
void	ReadHDF5 (Output *output, Grid *grid)
void	ResetState (const Data *, State_1D *, Grid *)
void	RestartFromFile (Runtime *, int, int, Grid *)
void	RestartDump (Runtime *)
void	RestartGet (Runtime *, int, int, int)
void	RightHandSide (const State_1D *, Time_Step *, int, int, double, Grid *)
void	RightHandSideSource (const State_1D *, Time_Step *, int, int, double, double *, Grid *)
void	RKC (const Data *d, Time_Step *, Grid *)
Runtime *	RuntimeGet (void)
int	RuntimeSetup (Runtime *, Cmd_Line *, char *)
void	RuntimeSet (Runtime *runtime)
void	SetColorMap (unsigned char *, unsigned char *, unsigned char *, char *)
void	SetDefaultVarNames (Output *)
int	SetDumpVar (char *, int, int)
void	SetIndexes (Index *indx, Grid *grid)
int	SetLogFile (char *, Cmd_Line *)
void	SetOutput (Data *d, Runtime *input)
void	SetRBox (void)
Riemann_Solver *	SetSolver (const char *)
void	SetGrid (Runtime *, Grid *)
void	SetJetDomain (const Data *, int, int, Grid *)
void	Show (double **, int)
void	ShowMatrix (double **, int n, double)
void	ShowVector (double *, int n)
void	ShowConfig (int, char *a[], char *)
void	ShowDomainDecomposition (int, Grid *)
void	ShowUnits ()
void	SplitSource (const Data *, double, Time_Step *, Grid *)
void	STS (const Data *d, Time_Step *, Grid *)
void	Startup (Data *, Grid *)
void	States (const State_1D *, int, int, Grid *)
void	SwapEndian (void *, const int)
void	UnsetJetDomain (const Data *, int, Grid *)
void	UpdateStage (const Data *, Data_Arr, double **, Riemann_Solver *, double, Time_Step *, Grid *)
void	UserDefBoundary (const Data *, RBox *, int, Grid *)
void	VectorPotentialDiff (double *, int, int, int, Grid *)
void	Where (int, Grid *)
void	WriteData (const Data *, Output *, Grid *)
void	WriteBinaryArray (void *, size_t, int, FILE *, int)
void	WriteHDF5 (Output *output, Grid *grid)
void	WriteVTK_Header (FILE *, Grid *)
void	WriteVTK_Vector (FILE *, Data_Arr, double, char *, Grid *)
void	WriteVTK_Scalar (FILE *, double ***, double, char *, Grid *)
void	WriteTabArray (Output *, char *, Grid *)
void	WritePPM (double ***, char *, char *, Grid *)
void	WritePNG (double ***, char *, char *, Grid *)
void	print (const char *fmt,...)
void	print1 (const char *fmt,...)
void	Trace (double)
void	FlipSign (int, int, int *)
void	OutflowBound (double ***, int, int, Grid *)
void	PeriodicBound (double ***, int, int)
void	ReflectiveBound (double ***, int, int, int)
void	PlutoError (int, char *)
double	Length_1 (int i, int j, int k, Grid *)
double	Length_2 (int i, int j, int k, Grid *)
double	Length_3 (int i, int j, int k, Grid *)
void	VectorPotentialUpdate (const Data *d, const void *vp, const State_1D *state, const Grid *grid)
void	Enthalpy (double **, double *, int, int)
void	Entropy (double **, double *, int, int)
void	SoundSpeed2 (double **, double *, double *, int, int, int, Grid *)
double	GetEntropy (double x)
void	WriteAsciiFile (char *fname, double *q, int nvar)

Macro Definition Documentation

#define ARRAY_1D	(		nx,
			type
	)		(type *)Array1D(nx,sizeof(type))

Definition at line 170 of file prototypes.h.

#define ARRAY_2D	(		nx,
			ny,
			type
	)		(type **)Array2D(nx,ny,sizeof(type))

Definition at line 171 of file prototypes.h.

#define ARRAY_3D	(		nx,
			ny,
			nz,
			type
	)		(type ***)Array3D(nx,ny,nz,sizeof(type))

Definition at line 172 of file prototypes.h.

#define ARRAY_4D	(		nx,
			ny,
			nz,
			nv,
			type
	)		(type ****)Array4D(nx,ny,nz,nv,sizeof(type))

Definition at line 173 of file prototypes.h.

Function Documentation

int AdvanceStep	(	const Data *	d,
		Riemann_Solver *	Riemann,
		Time_Step *	Dts,
		Grid *	grid
	)

Advance equations using the corner transport upwind method (CTU)

Parameters

[in,out]	d	pointer to Data structure
[in]	Riemann	pointer to a Riemann solver function
[in,out]	Dts	pointer to time step structure
[in]	grid	pointer to array of Grid structures

Advance the equations by a single time step using unsplit integrators based on the method of lines.

Parameters

[in,out]	d	pointer to Data structure
[in]	Riemann	pointer to a Riemann solver function
[in,out]	Dts	pointer to time step structure
[in]	grid	pointer to array of Grid structures

Definition at line 88 of file ctu_step.c.

{
  int i, j,k, nv, *in;
  int errp, errm;
  double dt2, inv_dtp, *inv_dl;
  Index indx;
  static unsigned char *flagm, *flagp;
  static Data_Arr UM[DIMENSIONS], UP[DIMENSIONS];  

  static Data_Arr dU, UH, Bs0;
  static State_1D state;
  static double **dtdV, **dcoeff, ***T;
  double *dtdV2, **rhs;
  RBox *box = GetRBox(DOM, CENTER);
  
/* -----------------------------------------------------------------
               Check algorithm compatibilities
   ----------------------------------------------------------------- */

  #if !(GEOMETRY == CARTESIAN || GEOMETRY == CYLINDRICAL)
   print1 ("! AdvanceStep(): ");
   print1 ("CTU only works in Cartesian or cylindrical coordinates\n");
   QUIT_PLUTO(1);
  #endif

/*  --------------------------------------------------------
                   Allocate static memory areas   
   --------------------------------------------------------- */

  if (dU == NULL){

    dtdV = ARRAY_2D(DIMENSIONS,NMAX_POINT, double);

    MakeState (&state);

    flagp = ARRAY_1D(NMAX_POINT, unsigned char);
    flagm = ARRAY_1D(NMAX_POINT, unsigned char);

    UH  = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double);
    dU  = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double);
    #ifdef STAGGERED_MHD
     Bs0 = ARRAY_4D(DIMENSIONS, NX3_TOT, NX2_TOT, NX1_TOT, double);
    #endif
    
  /* ---------------------------------------------------------
      corner-coupled multidimensional arrays are stored into 
      memory following the same conventions adopted when 
      sweeping along the coordinate directions, i.e., 

         (z,y,x)->(z,x,y)->(y,x,z).

      This allows 1-D arrays to conveniently point at the 
      fastest running indexes of the respective multi-D ones.
     --------------------------------------------------------- */  
     
    UM[IDIR] = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double);
    UP[IDIR] = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double);

    UM[JDIR] = ARRAY_4D(NX3_TOT, NX1_TOT, NX2_TOT, NVAR, double);
    UP[JDIR] = ARRAY_4D(NX3_TOT, NX1_TOT, NX2_TOT, NVAR, double);

    #if DIMENSIONS == 3
     UM[KDIR] = ARRAY_4D(NX2_TOT, NX1_TOT, NX3_TOT, NVAR, double);
     UP[KDIR] = ARRAY_4D(NX2_TOT, NX1_TOT, NX3_TOT, NVAR, double);
    #endif
 
    #if (PARABOLIC_FLUX & EXPLICIT)
     dcoeff = ARRAY_2D(NMAX_POINT, NVAR, double);
    #endif
    #if THERMAL_CONDUCTION == EXPLICIT
     T = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, double);
    #endif
  }

/* -- save pointers -- */

  rhs = state.rhs;
/*  memset (dU[0][0][0], 0.0, NX3_TOT*NX2_TOT*NX1_TOT*NVAR*sizeof(double));   */

  #ifdef FARGO
   FARGO_SubtractVelocity (d,grid); 
  #endif

/* -------------------------------------------------------
    Set boundary conditions and flag shocked regions for
    shock flattening or energy/entropy selective update.
   ------------------------------------------------------- */

  g_intStage = 1;
  Boundary (d, ALL_DIR, grid);
  #if (SHOCK_FLATTENING == MULTID) || (ENTROPY_SWITCH) 
   FlagShock (d, grid);
  #endif

  dt2 = 0.5*g_dt;
  D_EXPAND(
    ITOT_LOOP(i) dtdV[IDIR][i] = dt2/grid[IDIR].dV[i]; ,
    JTOT_LOOP(j) dtdV[JDIR][j] = dt2/grid[JDIR].dV[j]; ,
    KTOT_LOOP(k) dtdV[KDIR][k] = dt2/grid[KDIR].dV[k];
  )

  #if THERMAL_CONDUCTION == EXPLICIT
   TOT_LOOP(k,j,i) T[k][j][i] = d->Vc[PRS][k][j][i]/d->Vc[RHO][k][j][i];
  #endif
  
/* ------------------------------------------------
    Compute current arrays
   ------------------------------------------------ */

  #if (RESISTIVITY == EXPLICIT) && (defined STAGGERED_MHD)
   GetCurrent (d, -1, grid);
  #endif
 
/* ----------------------------------------------------
    Convert primitive to conservative and reset arrays
   ---------------------------------------------------- */

  KTOT_LOOP(k) JTOT_LOOP(j){
    ITOT_LOOP(i){
      VAR_LOOP(nv) state.v[i][nv] = d->Vc[nv][k][j][i];
    }
    PrimToCons(state.v, d->Uc[k][j], 0, NX1_TOT-1);
  }

  #ifdef STAGGERED_MHD
   nv = NX1_TOT*sizeof(double);
   KTOT_LOOP(k) JTOT_LOOP(j){
     D_EXPAND(memcpy(Bs0[BX1s][k][j], d->Vs[BX1s][k][j], nv);  ,
              memcpy(Bs0[BX2s][k][j], d->Vs[BX2s][k][j], nv);  ,
              memcpy(Bs0[BX3s][k][j], d->Vs[BX3s][k][j], nv);)
   }
  #endif
  
/* ----------------------------------------------------
     1. Compute Normal predictors and
        solve normal Riemann problems. 
        Store computations in UP, UM, RHS (X,Y,Z)
   ---------------------------------------------------- */

  for (g_dir = 0; g_dir < DIMENSIONS; g_dir++){

    SetIndexes (&indx, grid);
    ResetState (d, &state, grid);
    #if (RESISTIVITY == EXPLICIT) && !(defined STAGGERED_MHD)
     GetCurrent(d, g_dir, grid);
    #endif
    TRANSVERSE_LOOP(indx,in,i,j,k){  

      g_i = i; g_j = j; g_k = k;

    /* ---------------------------------------------
        save computational time by having state.up 
        and state.um pointing at the fastest 
        running indexes of UP and UM. 
        Also, during the x-sweep we initialize Uc 
        and dU by changing the memory address of 
        state.u and state.rhs. 
       --------------------------------------------- */
        
      state.up = UP[g_dir][*(indx.pt2)][*(indx.pt1)]; state.uL = state.up;
      state.um = UM[g_dir][*(indx.pt2)][*(indx.pt1)]; state.uR = state.um + 1;

    /* ---- get a 1-D array of primitive quantities ---- */

      for (*in = 0; (*in) < indx.ntot; (*in)++) {
        VAR_LOOP(nv) state.v[*in][nv] = d->Vc[nv][k][j][i];
        state.flag[*in] = d->flag[k][j][i];
        #ifdef STAGGERED_MHD
         state.bn[*in] = d->Vs[g_dir][k][j][i];
        #endif
      }

      CheckNaN (state.v, 0, indx.ntot - 1, 0);

#if !(PARABOLIC_FLUX & EXPLICIT)   /* adopt this formulation when there're no
                                      explicit diffusion  flux terms */
      States  (&state, indx.beg - 1, indx.end + 1, grid);
      Riemann (&state, indx.beg - 1, indx.end, Dts->cmax, grid);
      #ifdef STAGGERED_MHD
       CT_StoreEMF (&state, indx.beg - 1, indx.end, grid);
      #endif
      RightHandSide (&state, Dts, indx.beg, indx.end, dt2, grid);

      #if CTU_MHD_SOURCE == YES
       CTU_CT_Source (state.v, state.up, state.um,
                           dtdV[g_dir], indx.beg - 1, indx.end + 1, grid);
      #endif

   /* ------------------------------------------------------------------
       At this point we have at disposal the normal predictors U^_\pm.
       To save memory, we compute corner coupled states by first
       subtracting the normal contribution and then by adding the total
       time increment. For example, in the x-direction, we do

           U^{n+1/2}_\pm = U^_\pm - RX + (RX + RY + RZ)

       where the first subtraction is done here while dU = (RX + RY + RZ) is
       the total time increment which will be added later (step 2 below).
       In a 2-D domain dU  contains the following (X,Y,Z) contributions:

        0    X     0        0    X     0
         +--------+          +--------+
         |        |          |        |
        0|   X    |0   -->  Y|   XY   |Y  
         |        |          |        |
         +--------+          +--------+
        0    X     0        0    X     0

         (X sweep)           (Y sweep)

       Also, evolve cell center values by dt/2. 
       For staggered mhd, this step should be carried also in one rows of
       boundary zones in order to provide the cell  and time centered
       e.m.f.
      ------------------------------------------------------------------ */

      if (g_dir == IDIR){
          
        for (nv = NVAR; nv--; ) {
          state.rhs[indx.beg - 1][nv] = 0.0;
          state.rhs[indx.end + 1][nv] = 0.0;
        }

        for ((*in) = indx.beg-1; (*in) <= indx.end+1; (*in)++) {
        for (nv = NVAR; nv--; ){
          dU[k][j][i][nv]  = state.rhs[*in][nv];
          UH[k][j][i][nv]  = d->Uc[k][j][i][nv] + state.rhs[*in][nv];
          state.up[*in][nv]   -= state.rhs[*in][nv];
          state.um[*in][nv]   -= state.rhs[*in][nv];
        }}
      }else{
        for ((*in) = indx.beg; (*in) <= indx.end; (*in)++) {
        for (nv = NVAR; nv--; ){
          dU[k][j][i][nv] += state.rhs[*in][nv];
          UH[k][j][i][nv] += state.rhs[*in][nv];
          state.up[*in][nv]   -= state.rhs[*in][nv];
          state.um[*in][nv]   -= state.rhs[*in][nv];
        }}
      }

#else 

   /* -------------------------------------------------------------
       When parabolic terms have to be included explicitly, we use 
       a slightly different formulation where the transverse 
       predictors are computed using 1st order states. 
       This still yields a second-order accurate scheme but allow 
       to compute the solution at the half time step in one rows 
       of ghost zones, which is essential to update the parabolic 
       terms using midpoint rule:

            U^{n+1} = U^n - RHS(hyp, n+1/2) - RHS(par, n+1/2) 
      
           
       Since RHS(par) has a stencil 3-point wide.
       Corner coupled states are modified to account for parabolic 
       terms in the following way:

            U^{n+1/2}_\pm = U^_\pm - RX,h + (RX,h + RY,h + RZ,h) 
                                          + (RX,p + RY,p + RZ,p) 
      -------------------------------------------------------------- */

      for ((*in) = 0; (*in) < indx.ntot; (*in)++) {
      for (nv = NVAR; nv--;  ) {
        state.vp[*in][nv] = state.vm[*in][nv] = state.vh[*in][nv] = state.v[*in][nv];
      }}
      #ifdef STAGGERED_MHD
       for (*in = 0; (*in) < indx.ntot-1; (*in)++) {
         state.vR[*in][BXn] = state.vL[*in][BXn] = state.bn[*in];
       }
      #endif
      PrimToCons(state.vm, state.um, 0, indx.ntot-1);
      PrimToCons(state.vp, state.up, 0, indx.ntot-1);
      
      Riemann (&state, indx.beg-1, indx.end, Dts->cmax, grid);
      #ifdef STAGGERED_MHD
       CT_StoreEMF (&state, indx.beg-1, indx.end, grid);
      #endif

  /* -----------------------------------------------------------
          compute rhs using the hyperbolic fluxes only
     ----------------------------------------------------------- */

      #if (VISCOSITY == EXPLICIT)
       for ((*in) = 0; (*in) < indx.ntot; (*in)++) for (nv = NVAR; nv--;  )
         state.par_src[*in][nv] = 0.0;
      #endif
      RightHandSide (&state, Dts, indx.beg, indx.end, dt2, grid);
      ParabolicFlux (d->Vc, d->J, T, &state, dcoeff, indx.beg-1, indx.end, grid);

  /* ----------------------------------------------------------------
      compute LR states and subtract normal (hyperbolic) 
      rhs contribution.
      NOTE: states are computed from IBEG - 1 (= indx.beg) up to
            IEND + 1 (= indx.end) since EMF has already been evaluated
            and stored using 1st order states above.
      NOTE: States should be called after ParabolicFlux since some
            terms (e.g. thermal conduction) may depend on left and
            right normal states.
     ---------------------------------------------------------------- */

      States  (&state, indx.beg, indx.end, grid);
      #if CTU_MHD_SOURCE == YES
       CTU_CT_Source (state.v, state.up, state.um,
                           dtdV[g_dir], indx.beg, indx.end, grid);
      #endif

      for ((*in) = indx.beg; (*in) <= indx.end; (*in)++) {
      for (nv = NVAR; nv--; ){
        state.up[*in][nv] -= state.rhs[*in][nv];
        state.um[*in][nv] -= state.rhs[*in][nv];
      }}

  /* -----------------------------------------------------------
       re-compute the full rhs using the total (hyp+par) rhs
     ----------------------------------------------------------- */

      RightHandSide (&state, Dts, indx.beg, indx.end, dt2, grid);

      if (g_dir == IDIR){
        for ((*in) = indx.beg; (*in) <= indx.end; (*in)++) {
        for (nv = NVAR; nv--; ){
          dU[k][j][i][nv] = state.rhs[*in][nv];
          UH[k][j][i][nv] = d->Uc[k][j][i][nv] + state.rhs[*in][nv];
        }}
      }else{
        for ((*in) = indx.beg; (*in) <= indx.end; (*in)++) {
        for (nv = NVAR; nv--; ){
          dU[k][j][i][nv] += state.rhs[*in][nv];
          UH[k][j][i][nv] += state.rhs[*in][nv];
        }}
      }
#endif
    } /* -- end loop on transverse directions -- */

  } /* -- end loop on dimensions -- */

/* -------------------------------------------------------
     2a. Advance staggered magnetic fields by dt/2 
   ------------------------------------------------------- */

  #ifdef STAGGERED_MHD     
   CT_Update (d, d->Vs, 0.5*g_dt, grid);
   CT_AverageMagneticField (d->Vs, UH, grid);
  #endif

/* ----------------------------------------------------------
     2b. Convert cell and time centered values to primitive. 
         UH is transformed from conservative to primitive 
         variables for efficiency purposes.
   ---------------------------------------------------------- */

  g_dir = IDIR;
  SetIndexes (&indx, grid);
  TRANSVERSE_LOOP(indx,in,i,j,k){
    g_i = i; g_j = j; g_k = k;
    errp = ConsToPrim(UH[k][j], state.v, indx.beg, indx.end, d->flag[k][j]);
    for ((*in) = indx.beg; (*in) <= indx.end; (*in)++) {
      VAR_LOOP(nv) d->Vc[nv][k][j][i] = state.v[*in][nv];
    }
    #if THERMAL_CONDUCTION == EXPLICIT
     for ((*in) = indx.beg; (*in) <= indx.end; (*in)++){
       T[k][j][i] = d->Vc[PRS][k][j][i]/d->Vc[RHO][k][j][i];
     }
    #endif
  }
  #if (RESISTIVITY == EXPLICIT) && (defined STAGGERED_MHD)
   GetCurrent (d, -1, grid);
  #endif
  
/* ---------------------------------------------------- 
     3. Final conservative update
   ---------------------------------------------------- */

  g_intStage = 2;
  for (g_dir = 0; g_dir < DIMENSIONS; g_dir++){

    SetIndexes (&indx, grid);
    ResetState (d, &state, grid);
    #if (RESISTIVITY == EXPLICIT) && !(defined STAGGERED_MHD)
     GetCurrent(d, g_dir, grid);
    #endif
    TRANSVERSE_LOOP(indx,in,i,j,k){  

      g_i = i;  g_j = j;  g_k = k;

    /* ---------------------------------------------------------
        Convert conservative corner-coupled states to primitive 
       --------------------------------------------------------- */
       
      state.up = UP[g_dir][*(indx.pt2)][*(indx.pt1)]; state.uL = state.up;
      state.um = UM[g_dir][*(indx.pt2)][*(indx.pt1)]; state.uR = state.um + 1;
      
      for ((*in) = indx.beg-1; (*in) <= indx.end+1; (*in)++){
        for (nv = NVAR; nv--; ){
          state.up[*in][nv] += dU[k][j][i][nv];
          state.um[*in][nv] += dU[k][j][i][nv];
        }
        flagp[*in] = flagm[*in] = d->flag[k][j][i];
      }

    /* -------------------------------------------------------
        compute time centered, cell centered state. 
        Useful for source terms like gravity, 
        curvilinear terms and Powell's 8wave 
       ------------------------------------------------------- */

      for ((*in) = indx.beg-1; (*in) <= indx.end+1; (*in)++) {
        NVAR_LOOP(nv) state.vh[*in][nv] = d->Vc[nv][k][j][i];
        state.flag[*in] = d->flag[k][j][i];
      }

      #ifdef STAGGERED_MHD
      for ((*in) = indx.beg - 2; (*in) <= indx.end + 1; (*in)++){
        state.uL[*in][BXn] = state.uR[*in][BXn] = d->Vs[BXs + g_dir][k][j][i];
        state.bn[*in] = state.uL[*in][BXn];
      }
      #endif

      errm = ConsToPrim (state.um, state.vm, indx.beg - 1, indx.end + 1, flagm);
      errp = ConsToPrim (state.up, state.vp, indx.beg - 1, indx.end + 1, flagp);
/*
      if (errm || errp){
        WARNING(print ("! Corner coupled states not physical: reverting to 1st order\n");)
        for (in = indx.beg - 1; in <= indx.end + 1; in++){
          if (   (flagm[*in] & FLAG_CONS2PRIM_FAIL)
              || (flagm[in]  & FLAG_CONS2PRIM_FAIL) ) {
            for (nv = 0; nv < NVAR; nv++) {
              state.v[in][nv] = d->Vc[nv][*k][*j][*i];
            }
            PrimToCons(state.v, state.u, in, in);
            for (nv = 0; nv < NVAR; nv++) {
              state.vm[in][nv] = state.vp[in][nv] = state.vh[in][nv] = state.v[in][nv];
              state.um[in][nv] = state.up[in][nv] = state.uh[in][nv] = state.u[in][nv];
            }
          }
        }
      }
*/

   /* ------------------------------------------
           compute flux & righ-hand-side
      ------------------------------------------ */

      Riemann (&state, indx.beg - 1, indx.end, Dts->cmax, grid);
      #ifdef STAGGERED_MHD
       CT_StoreEMF (&state, indx.beg - 1, indx.end, grid);
      #endif
      #if (PARABOLIC_FLUX & EXPLICIT)

     /* -------------------------------------------------------- 
         since integration in the transverse directions extends 
         one point below and one point above the computational 
         box (when using CT), we avoid computing parabolic 
         operators in one row of boundary zones below and above 
         since the 3-point wide stencil may not be available.
        -------------------------------------------------------- */

       errp = 1;
       #ifdef STAGGERED_MHD
       D_EXPAND(                                                        ,
         errp = (*(indx.pt1) < indx.t1_end) && (*(indx.pt1) > indx.t1_beg);     ,
         errp = errp && (*(indx.pt2) < indx.t2_end) && (*(indx.pt2) > indx.t2_beg);)
       #endif
       if (errp) {
         ParabolicFlux (d->Vc, d->J, T, &state, dcoeff, indx.beg - 1, indx.end, grid);
         inv_dl  = GetInverse_dl(grid);
         for ((*in) = indx.beg; (*in) <= indx.end; (*in)++) {
           inv_dtp = 0.0;
           #if VISCOSITY == EXPLICIT
            inv_dtp = MAX(inv_dtp, dcoeff[*in][MX1]);
           #endif
           #if RESISTIVITY == EXPLICIT
            EXPAND(inv_dtp = MAX(inv_dtp, dcoeff[*in][BX1]);  ,
                   inv_dtp = MAX(inv_dtp, dcoeff[*in][BX2]);  ,
                   inv_dtp = MAX(inv_dtp, dcoeff[*in][BX3]);)
           #endif
           #if THERMAL_CONDUCTION == EXPLICIT
            inv_dtp = MAX(inv_dtp, dcoeff[*in][ENG]);
           #endif
           inv_dtp *= inv_dl[*in]*inv_dl[*in];

           Dts->inv_dtp = MAX(Dts->inv_dtp, inv_dtp);
         }
       }
      #endif
      #if UPDATE_VECTOR_POTENTIAL == YES
       VectorPotentialUpdate (d, NULL, &state, grid);
      #endif
      #ifdef SHEARINGBOX
       SB_SaveFluxes(&state, grid);
      #endif

      RightHandSide (&state, Dts, indx.beg, indx.end, g_dt, grid);

      for ((*in) = indx.beg; (*in) <= indx.end; (*in)++) {
        NVAR_LOOP(nv) d->Uc[k][j][i][nv] += state.rhs[*in][nv];
      }           
    }
  }

  #ifdef SHEARINGBOX
   SB_CorrectFluxes(d->Uc, g_time+0.5*g_dt, g_dt, grid);
  #endif

  #ifdef STAGGERED_MHD
   CT_Update (d, Bs0, g_dt, grid);
   CT_AverageMagneticField (d->Vs, d->Uc, grid);
  #endif

/* ----------------------------------------------
           convert to primitive 
   ---------------------------------------------- */

  #ifdef FARGO
   FARGO_ShiftSolution (d->Uc, d->Vs, grid);
  #endif 

  ConsToPrim3D(d->Uc, d->Vc, d->flag, box);

  #ifdef FARGO
   FARGO_AddVelocity (d,grid); 
  #endif

  return(0); /* -- step has been achieved, return success -- */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AdvectFlux	(	const State_1D *	state,
		int	beg,
		int	end,
		Grid *	grid
	)

Parameters

[in,out]	state
[in]	beg	initial index of computation
[in]	end	final index of computation

Returns

This function has no return value.

Definition at line 47 of file adv_flux.c.

{
  int    i, nv;
  double *ts, *flux, *vL, *vR;
  double s, rho;
  double phi;
  static double *sigma, **vi;
  
/* -- compute scalar's fluxes -- */

  for (i = beg; i <= end; i++){

    flux = state->flux[i];
    vL   = state->vL[i];
    vR   = state->vR[i];

    ts = flux[RHO] > 0.0 ? vL:vR;

    NSCL_LOOP(nv) flux[nv] = flux[RHO]*ts[nv];
    
    #if COOLING == MINEq

     /* -----   He   -----  */
                         
     phi = ts[X_HeI] + ts[X_HeII];
     for (nv = X_HeI; nv <= X_HeII; nv++) flux[nv] /= phi;

     /* -----   C   -----  */

     phi = 0.0;
     for (nv = X_CI; nv < X_CI + C_IONS; nv++) phi += ts[nv]; 
     for (nv = X_CI; nv < X_CI + C_IONS; nv++) flux[nv] /= phi;

     /* -----   N   -----  */

     phi = 0.0;
     for (nv = X_NI; nv < X_NI+N_IONS; nv++) phi += ts[nv]; 
     for (nv = X_NI; nv < X_NI+N_IONS; nv++) flux[nv] /= phi;

     /* -----   O   -----  */

     phi = 0.0;
     for (nv = X_OI; nv < X_OI+O_IONS; nv++) phi += ts[nv]; 
     for (nv = X_OI; nv < X_OI+O_IONS; nv++) flux[nv] /= phi;

     /* -----   Ne   -----  */

     phi = 0.0;
     for (nv = X_NeI; nv < X_NeI+Ne_IONS; nv++) phi += ts[nv];
     for (nv = X_NeI; nv < X_NeI+Ne_IONS; nv++) flux[nv] /= phi;

     /* -----   S   -----  */

     phi = 0.0;
     for (nv = X_SI; nv < X_SI+S_IONS; nv++) phi += ts[nv]; 
     for (nv = X_SI; nv < X_SI+S_IONS; nv++) flux[nv] /= phi;

    #endif

    #if COOLING == H2_COOL
     phi = ts[X_HI] + 2.0*ts[X_H2] + ts[X_HII];
     for (nv = X_HI; nv < X_HI + NIONS; nv++) flux[nv] /= phi; 
    #endif

    #if USE_CMA == YES  /* -- only for tracers -- */
     phi = 0.0;
     NTRACER_LOOP(nv) phi += ts[nv];
     NTRACER_LOOP(nv) flux[nv] /= phi;
    #endif

    #if ENTROPY_SWITCH
     if (flux[RHO] >= 0.0) flux[ENTR] = state->vL[i][ENTR]*flux[RHO];
     else                  flux[ENTR] = state->vR[i][ENTR]*flux[RHO];
    #endif
  }
}

Here is the caller graph for this function:

void Analysis	(	const Data *	d,
		Grid *	grid
	)

Perform runtime data analysis.

Parameters

[in]	d	the PLUTO Data structure
[in]	grid	pointer to array of Grid structures

Compute volume-integrated magnetic pressure, Maxwell and Reynolds stresses. Save them to "averages.dat"

Definition at line 66 of file init.c.

{

}

Here is the call graph for this function:

Here is the caller graph for this function:

char* Array1D	(	int	nx,
		size_t	dsize
	)

Allocate memory for a 1-D array of any basic data type starting at 0.

Parameters

[in]	nx	number of elements to be allocated
[in]	dsize	data-type of the array to be allocated

Returns

A pointer of type (char *) to the allocated memory area.

Definition at line 80 of file arrays.c.

{
  char *v;
  v = (char *) malloc (nx*dsize);
  PlutoError (!v, "Allocation failure in Array1D");
  g_usedMemory += nx*dsize;

  #if NONZERO_INITIALIZE == YES
   if (dsize==sizeof(double)){
     int i;
     double *q;
     q = (double *) v;
     for (i = nx; i--; ) q[i] = i*1.e18 - 1.e16;
   }
  #endif
  return v;
}

Here is the call graph for this function:

char** Array2D	(	int	nx,
		int	ny,
		size_t	dsize
	)

Allocate memory for a 2-D array of any basic data type.

Parameters

[in]	nx	number of elements in the 2nd dimension
[in]	ny	number of elements in the 1st dimension
[in]	dsize	data-type of the array to be allocated

Returns

A pointer of type (char **) to the allocated memory area with index range [0...nx-1][0...ny-1]

Definition at line 108 of file arrays.c.

{
  int i;
  char **m;
 
  m    = (char **)malloc ((size_t) nx*sizeof(char *));
  PlutoError (!m, "Allocation failure in Array2D (1)");
  m[0] = (char *) malloc ((size_t) nx*ny*dsize);
  PlutoError (!m[0],"Allocation failure in Array2D (2)");
 
  for (i = 1; i < nx; i++) m[i] = m[(i - 1)] + ny*dsize;
 
  g_usedMemory += nx*ny*dsize;

  #if NONZERO_INITIALIZE == YES
   if (dsize==sizeof(double)){
     int j;
     double **q;
     q = (double **)m;
     for (i = nx; i--; ){
     for (j = ny; j--; ){
       q[i][j] = i*j*1.e18 + 1.e16*j;
     }} 
   }
  #endif

  return m;
}

Here is the call graph for this function:

char*** Array3D	(	int	nx,
		int	ny,
		int	nz,
		size_t	dsize
	)

Allocate memory for a 3-D array of any basic data type.

Parameters

[in]	nx	number of elements in the 3rd dimension
[in]	ny	number of elements in the 2nd dimension
[in]	nz	number of elements in the 1st dimension
[in]	dsize	data-type of the array to be allocated

Returns

A pointer of type (char ***) to the allocated memory area with index range [0...nx-1][0...ny-1][0...nz-1]

Definition at line 149 of file arrays.c.

{
  int i, j;
  char ***m;

  m = (char ***) malloc ((size_t) nx*sizeof (char **));
  PlutoError (!m, "Allocation failure in Array3D (1)");

  m[0] = (char **) malloc ((size_t) nx*ny*sizeof(char *));
  PlutoError (!m[0],"Allocation failure in Array3D (2)");

  m[0][0] = (char *) malloc ((size_t) nx*ny*nz*dsize);
  PlutoError (!m[0][0],"Allocation failure in Array3D (3)");

/* ---------------------------
       single subscript: i
   --------------------------- */

  for (i = 1; i < nx; i++) m[i] = m[i - 1] + ny;
  
/* ---------------------------
     double subscript:
     
      (i,0)  (0,j) 
      (i,j)  
   --------------------------- */
  
  for (j = 1; j < ny; j++) m[0][j] = m[0][j - 1] + nz*dsize;
  for (i = 1; i < nx; i++) m[i][0] = m[i - 1][0] + ny*nz*dsize;

  for (i = 1; i < nx; i++) {
  for (j = 1; j < ny; j++) {
    m[i][j] = m[i][j - 1] + nz*dsize;
  }}

  for (j = 0; j < ny; j++){
  for (i = 0; i < nx; i++){
    if (m[i][j] == NULL){
      print ("! Allocation failure in Array3D\n");
      QUIT_PLUTO(1);
    }
  }}
  
  g_usedMemory += nx*ny*nz*dsize;

  #if NONZERO_INITIALIZE == YES
   if (dsize==sizeof(double)){
     double ***q;
     int k;
     q = (double ***)m;
     for (i = nx; i--; ){
     for (j = ny; j--; ){
     for (k = nz; k--; ){
       q[i][j][k] = 1.e18*i + 1.e17*j + 1.e16*k + 1.e15;
     }}}
   }
  #endif

  return m;
}

Here is the call graph for this function:

char**** Array4D	(	int	nx,
		int	ny,
		int	nz,
		int	nv,
		size_t	dsize
	)

Allocate memory for a 4-D array of any basic data type.

Parameters

[in]	nx	number of elements in the 4th dimension
[in]	ny	number of elements in the 3rd dimension
[in]	nz	number of elements in the 2nd dimension
[in]	nv	number of elements in the 1st dimension
[in]	dsize	data-type of the array to be allocated

Returns

A pointer of type (char ****) to the allocated memory area with index range [0...nx-1][0...ny-1][0...nz-1][0...nv-1]

Definition at line 222 of file arrays.c.

{
  int i, j, k;
  char ****m;

  m = (char ****) malloc ((size_t) nx*sizeof (char ***));
  PlutoError (!m, "Allocation failure in Array4D (1)");

  m[0] = (char ***) malloc ((size_t) nx*ny*sizeof (char **));
  PlutoError (!m[0], "Allocation failure in Array4D (2)");

  m[0][0] = (char **) malloc ((size_t) nx*ny*nz*sizeof (char *));
  PlutoError (!m[0][0], "Allocation failure in Array4D (3)");

  m[0][0][0] = (char *) malloc ((size_t) nx*ny*nz*nv*dsize);
  PlutoError (!m[0][0][0], "Allocation failure in Array4D (4)");

/* ---------------------------
       single subscript: i
   --------------------------- */
   
  for (i = 1; i < nx; i++) m[i] = m[i - 1] + ny;

/* ---------------------------
     double subscript:
     
      (i,0)  (0,j) 
      (i,j)  
   --------------------------- */

  for (i = 1; i < nx; i++) {
    m[i][0] = m[i - 1][0] + ny*nz;
  }
  for (j = 1; j < ny; j++) {
    m[0][j] = m[0][j - 1] + nz;
  }

  for (i = 1; i < nx; i++) {
  for (j = 1; j < ny; j++) {
    m[i][j] = m[i][j - 1] + nz;
  }}

/* ---------------------------
     triple subscript:
     
     (i,0,0) (0,j,0) (0,0,k)
     (i,j,0) (i,0,k) (0,j,k)
     (i,j,k)
   --------------------------- */

  for (i = 1; i < nx; i++) {
    m[i][0][0] = m[i - 1][0][0] + ny*nz*nv*dsize;
  }
  for (j = 1; j < ny; j++) {
    m[0][j][0] = m[0][j - 1][0] + nz*nv*dsize;
  }
  
  for (k = 1; k < nz; k++) {
    m[0][0][k] = m[0][0][k - 1] + nv*dsize;
  }
  
  
  for (i = 1; i < nx; i++) {
  for (j = 1; j < ny; j++) {
    m[i][j][0] = m[i][j - 1][0] + nz*nv*dsize;
  }}
   
  for (i = 1; i < nx; i++) {
  for (k = 1; k < nz; k++) {
    m[i][0][k] = m[i][0][k - 1] + nv*dsize;
  }}
  
  for (j = 1; j < ny; j++) {
  for (k = 1; k < nz; k++) {
    m[0][j][k] = m[0][j][k - 1] + nv*dsize;
  }}

  for (i = 1; i < nx; i++) {
    for (j = 1; j < ny; j++) {
      for (k = 1; k < nz; k++) {
        m[i][j][k] = m[i][j][k - 1] + nv*dsize;
      }
    }
  }
      
  g_usedMemory += nx*ny*nz*nv*dsize;

  #if NONZERO_INITIALIZE == YES
   if (dsize==sizeof(double)){
     int l;
     double ****q;
     q = (double ****)m;
     for (i = nx; i--; ){
     for (j = ny; j--; ){
     for (k = nz; k--; ){
     for (l = nv; l--; ){
       q[i][j][k][l] = l*1.e18*i + 1.e17*i*j - 1.e16*k*j + 1.e17;
     }}}}
   }
  #endif

  return m;
}

Here is the call graph for this function:

double*** ArrayBox	(	long int	nrl,
		long int	nrh,
		long int	ncl,
		long int	nch,
		long int	ndl,
		long int	ndh
	)

Allocate memory for a 3-D array in double precision with given subscript range [low...high] for each direction. Useful for staggered arrays which do not start at [0].

Parameters

[in]	nrl	lower bound index for the 3rd dimension
[in]	nrh	upper bound index for the 3rd dimension
[in]	ncl	lower bound index for the 2nd dimension
[in]	nch	upper bound index for the 2nd dimension
[in]	ndl	lower bound index for the 1st dimension
[in]	ndh	upper bound index for the 1st dimension

Returns

A pointer of type (double ***) to the allocated memory area with index range [nrl...nhl][ncl...nch][ndl...ndh].

Definition at line 341 of file arrays.c.

{
  long i,j,nrow=nrh-nrl+1,ncol=nch-ncl+1,ndep=ndh-ndl+1;
  double ***t;

/* allocate pointers to pointers to rows */

  t=(double ***) malloc((unsigned int)(nrow*sizeof(double**)));
  if (!t) {
    print ("! ArrayBox: allocation failure (1)\n");
    QUIT_PLUTO(1);
  }
  t -= nrl;

/* allocate pointers to rows and set pointers to them */

  t[nrl]=(double **) malloc((unsigned int)(nrow*ncol*sizeof(double*)));
  if (!t[nrl]) {
    print ("! ArrayBox: allocation failure (2)\n");
    QUIT_PLUTO(1);
  }
  t[nrl] -= ncl;

/* allocate rows and set pointers to them */

  t[nrl][ncl]=(double *) malloc((unsigned int)(nrow*ncol*ndep*sizeof(double)));
  if (!t[nrl][ncl]) {
    print ("! ArrayBox: allocation failure (3)\n");
    QUIT_PLUTO(1);
  }
  t[nrl][ncl] -= ndl;

  for(j=ncl+1;j<=nch;j++) t[nrl][j]=t[nrl][j-1]+ndep;
  for(i=nrl+1;i<=nrh;i++) {
    t[i]=t[i-1]+ncol;
    t[i][ncl]=t[i-1][ncl]+ncol*ndep;
    for(j=ncl+1;j<=nch;j++) t[i][j]=t[i][j-1]+ndep;
  }

/* return pointer to array of pointers to rows */

  return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

double*** ArrayBoxMap	(	int	nrl,
		int	nrh,
		int	ncl,
		int	nch,
		int	ndl,
		int	ndh,
		double *	uptr
	)

Convert a one-dimensional array into a 3D array with given subscript range [low...high] for each direction.

Definition at line 537 of file arrays.c.

{
  int i,j,nrow=nrh-nrl+1,ncol=nch-ncl+1,ndep=ndh-ndl+1;
  double ***t;

/* -- allocate pointers to pointers to rows -- */

  t = (double ***) malloc((size_t)((nrow)*sizeof(double**)));
  if (!t) {
    print ("! ArrayBoxMap: allocation failure (1) \n");
    QUIT_PLUTO (1);
  }
  t -= nrl;

/* -- allocate pointers to rows and set pointers to them -- */

  t[nrl] = (double **) malloc((size_t)((nrow*ncol)*sizeof(double*)));
  if (!t[nrl]) {
    print ("! ArrayBoxMap: allocation failure (2) \n");
    QUIT_PLUTO (1);
  }
  t[nrl] -= ncl;

  t[nrl][ncl] = uptr;
  if (!t[nrl][ncl]) {
    print ("! ArrayBoxMap: allocation failure (3) \n");
    QUIT_PLUTO (1);
  }
  t[nrl][ncl] -= ndl;

  for(j = ncl+1; j <= nch; j++) t[nrl][j] = t[nrl][j-1] + ndep;
  for(i = nrl+1; i <= nrh; i++) {
    t[i]      = t[i-1] + ncol;
    t[i][ncl] = t[i-1][ncl] + ncol*ndep;
    for(j = ncl+1; j <= nch; j++) t[i][j] = t[i][j-1] + ndep;
  }

  return t;
}

Here is the call graph for this function:

unsigned char*** ArrayCharMap	(	int	,
		int	,
		int	,
		unsigned char *
	)

Definition at line 476 of file arrays.c.

{
  int i,j;
  unsigned char ***t;

/* -- allocate pointers to pointers to rows -- */

  t = (unsigned char ***) malloc((size_t)((nx)*sizeof(unsigned char**)));
  if (!t) {
    print ("! ArrayCharMap: allocation failure (1) \n");
    QUIT_PLUTO (1);
  }

/* -- allocate pointers to rows and set pointers to them -- */

  t[0] = (unsigned char **) malloc((size_t)((nx*ny)*sizeof(unsigned char*)));
  if (!t[0]) {
    print ("! ArrayCharMap: allocation failure (2) \n");
    QUIT_PLUTO(1);
  }

/* -- make the 3D array point to uptr -- */

  t[0][0] = uptr;
  if (!t[0][0]) {
    print ("! ArrayCharMap: allocation failure (3) \n");
    QUIT_PLUTO (1);
  }

  for(j = 1; j < ny; j++) t[0][j]=t[0][j-1] + nz;

  for(i = 1; i < nx; i++) {
    t[i]    = t[i-1] + ny;
    t[i][0] = t[i-1][0] + ny*nz;
    for(j = 1; j < ny; j++) t[i][j] = t[i][j-1] + nz;
  }
  
  return t;
}

Here is the call graph for this function:

double*** ArrayMap	(	int	nx,
		int	ny,
		int	nz,
		double *	uptr
	)

Convert a one dimensional array with (nx*ny*nz) elements into a 3D array with index range [0..nx-1][0..ny-1][0..nz-1]. This function is similar, conceptually, to Array3D() except that the memory area is already allocated.

Parameters

[in]	uptr	pointer to 1D array
[in]	nx	number of elements in the 3rd dimension
[in]	ny	number of elements in the 2nd dimensions
[in]	nz	number of elements in the 1st dimensions

Returns

A pointer to the 3D array.

Definition at line 421 of file arrays.c.

{
  int i,j;
  double ***t;

/* -- allocate pointers to pointers to rows -- */
   
  t = (double ***) malloc((size_t)((nx)*sizeof(double**)));
  if (!t) {
    print ("! ArrayMap: allocation failure (1) \n");
    QUIT_PLUTO (1);
  }

/* -- allocate pointers to rows and set pointers to them -- */

  t[0] = (double **) malloc((size_t)((nx*ny)*sizeof(double*)));
  if (!t[0]) {
    print ("! ArrayMap: allocation failure (2) \n");
    QUIT_PLUTO(1);
  }

/* -- make the 3D array point to uptr -- */

  t[0][0] = uptr;
  if (!t[0][0]) {
    print ("! ArrayMap: allocation failure (3) \n");
    QUIT_PLUTO (1);
  }

  for(j = 1; j < ny; j++) t[0][j]=t[0][j-1] + nz;

  for(i = 1; i < nx; i++) {
    t[i]    = t[i-1] + ny;
    t[i][0] = t[i-1][0] + ny*nz;
    for(j = 1; j < ny; j++) t[i][j] = t[i][j-1] + nz;
  }
     
  return t;
}

Here is the call graph for this function:

double BodyForcePotential	(	double	,
		double	,
		double
	)

Definition at line 479 of file init.c.

{
  double om2 = SB_OMEGA*SB_OMEGA;
  double zb  = g_domBeg[KDIR], ze = g_domEnd[KDIR];
  double psi;
 
#if STRATIFICATION == YES
  psi = om2*(0.5*z*z - SB_Q*x*x);
  #ifdef CTU /* see note in BodyForceVector() */
  if (z > ze) psi -= 2.0*om2*ze*(z - ze);
  if (z < zb) psi -= 2.0*om2*zb*(z - zb); 
  #endif
  return psi;
#else
  return -om2*SB_Q*x*x;
#endif
}

Here is the caller graph for this function:

void BodyForcePotentialGet	(	double **	v,
		double **	gphi,
		double *	phi_p,
		double *	phi_c,
		int	beg,
		int	end,
		Grid *	grid
	)

void BodyForceVector	(	double *	v,
		double *	g,
		double	x,
		double	y,
		double	z
	)

Include gravitational force in the shearing box module. Coriolis terms are included elsewhere.

Note: with FARGO, gravity in the x-direction must not be included.

Definition at line 441 of file init.c.

{
  double om2 = SB_OMEGA*SB_OMEGA;
  double zb  = g_domBeg[KDIR], ze  = g_domEnd[KDIR];

#ifdef FARGO
  g[IDIR] = 0.0;
#else
  g[IDIR] = om2*2.0*SB_Q*x;
#endif
  g[JDIR] = 0.0;

#if STRATIFICATION == YES
  g[KDIR] = -om2*z;

/* -----------------------------------------------------------
    With CTU and a reflective vertical boundary, gravity must
    be symmetrized since the predictor step of CTU does not
    not preserve the symmetry.
   ----------------------------------------------------------- */

  #ifdef CTU   
  if      (z > ze) g[KDIR] += 2.0*om2*ze;
  else if (z < zb) g[KDIR] += 2.0*om2*zb;
  #endif

#else
  g[KDIR] = 0.0; 
#endif
}

Here is the caller graph for this function:

void BodyForceVectorGet	(	double **	v,
		double **	g,
		double *	,
		double *	,
		double *	,
		int	beg,
		int	end,
		Grid *	grid
	)

void Boundary	(	const Data *	d,
		int	idim,
		Grid *	grid
	)

Set boundary conditions on one or more sides of the computational domain.

Parameters

[in,out]	d	pointer to PLUTO Data structure containing the solution array (including centered and staggered fields)
[in]	idim	specifies on which side(s) of the computational domain boundary conditions must be set. Possible values are idim = IDIR first dimension (x1) idim = JDIR second dimenson (x2) idim = KDIR third dimension (x3) idim = ALL_DIR all dimensions
[in]	grid	pointer to an array of grid structures.

Definition at line 36 of file boundary.c.

{
  int  is, nv, fargo_velocity_has_changed;
  int  side[6] = {X1_BEG, X1_END, X2_BEG, X2_END, X3_BEG, X3_END};
  int  type[6], sbeg, send, vsign[NVAR];
  int  par_dim[3] = {0, 0, 0};
  double ***q;

/* ---------------------------------------------------
    Check the number of processors in each direction
   --------------------------------------------------- */

  D_EXPAND(par_dim[0] = grid[IDIR].nproc > 1;  ,
           par_dim[1] = grid[JDIR].nproc > 1;  ,
           par_dim[2] = grid[KDIR].nproc > 1;)

/* -------------------------------------------------
    With FARGO, boundary conditions must be set on 
    total velocity. 
    We temporarily add the background motion if 
    the input array contains the deviation only.
   ------------------------------------------------- */
   
   #ifdef FARGO
    fargo_velocity_has_changed = NO;
    if (FARGO_HasTotalVelocity() == NO) {
      FARGO_AddVelocity (d,grid);
      fargo_velocity_has_changed = YES;
    }
   #endif

/* -------------------------------------------------
    Call userdef internal boundary with side == 0
   -------------------------------------------------  */

  #if INTERNAL_BOUNDARY == YES
   UserDefBoundary (d, NULL, 0, grid);
  #endif
  
/* -------------------------------------
     Exchange data between processors 
   ------------------------------------- */
   
  #ifdef PARALLEL
   MPI_Barrier (MPI_COMM_WORLD);
   for (nv = 0; nv < NVAR; nv++) {
     AL_Exchange_dim ((char *)d->Vc[nv][0][0], par_dim, SZ);
   }
   #ifdef STAGGERED_MHD 
    D_EXPAND(
      AL_Exchange_dim ((char *)(d->Vs[BX1s][0][0] - 1), par_dim, SZ_stagx);  ,
      AL_Exchange_dim ((char *)d->Vs[BX2s][0][-1]     , par_dim, SZ_stagy);  ,
      AL_Exchange_dim ((char *)d->Vs[BX3s][-1][0]     , par_dim, SZ_stagz);)
   #endif
   MPI_Barrier (MPI_COMM_WORLD);
  #endif

/* ----------------------------------------------------------------
     When idim == ALL_DIR boundaries are imposed on ALL sides:
     a loop from sbeg = 0 to send = 2*DIMENSIONS - 1 is performed. 
     When idim = n, boundaries are imposed at the beginning and 
     the end of the i-th direction.
   ---------------------------------------------------------------- */ 

  if (idim == ALL_DIR) {
    sbeg = 0;
    send = 2*DIMENSIONS - 1;
  } else {
    sbeg = 2*idim;
    send = 2*idim + 1;
  }

/* --------------------------------------------------------
        Main loop on computational domain sides
   -------------------------------------------------------- */

  type[0] = grid[IDIR].lbound; type[1] = grid[IDIR].rbound;
  type[2] = grid[JDIR].lbound; type[3] = grid[JDIR].rbound;
  type[4] = grid[KDIR].lbound; type[5] = grid[KDIR].rbound;

  for (is = sbeg; is <= send; is++){

    if (type[is] == 0) continue;  /* no physical boundary: skip */

    if (type[is] == OUTFLOW) {

    /* -------------------------------
         OUTFLOW boundary condition 
       ------------------------------- */
 
      for (nv = 0; nv < NVAR; nv++){
        OutflowBound (d->Vc[nv], side[is], CENTER, grid + (is/2));   
      }
      #ifdef STAGGERED_MHD 
       D_EXPAND(OutflowBound (d->Vs[BX1s], side[is], X1FACE, grid+(is/2)); ,
                OutflowBound (d->Vs[BX2s], side[is], X2FACE, grid+(is/2)); ,
                OutflowBound (d->Vs[BX3s], side[is], X3FACE, grid+(is/2));)

    /* ---------------------------------------------------------
        average normal field only since transverse components
        are assigned consistently with cell-centered quantities.
       --------------------------------------------------------- */
            
       CT_AverageNormalMagField (d, side[is], grid);
      #endif

    }else if (  (type[is] == REFLECTIVE) 
             || (type[is] == AXISYMMETRIC)
             || (type[is] == EQTSYMMETRIC)){

    /* -------------------------------------
        REFLECTIVE-type boundary conditions 
       ------------------------------------- */

      FlipSign (side[is], type[is], vsign);
      for (nv = 0; nv < NVAR; nv++){
        ReflectiveBound (d->Vc[nv], vsign[nv], side[is], CENTER);
      }
      #ifdef STAGGERED_MHD  
       D_EXPAND(ReflectiveBound(d->Vs[BX1s], vsign[BX1], side[is], X1FACE);  ,
                ReflectiveBound(d->Vs[BX2s], vsign[BX2], side[is], X2FACE);  ,
                ReflectiveBound(d->Vs[BX3s], vsign[BX3], side[is], X3FACE);)
      #endif

    }else if (type[is] == PERIODIC) {

    /* ----------------------------------------
        PERIODIC boundary condition (only for 
        one processor in the direction) 
       ---------------------------------------- */

      if (!par_dim[is/2]) {
        for (nv = 0; nv < NVAR; nv++){
          PeriodicBound (d->Vc[nv], side[is], CENTER);
        }
        #ifdef STAGGERED_MHD
         D_EXPAND(PeriodicBound (d->Vs[BX1s], side[is], X1FACE);  ,
                  PeriodicBound (d->Vs[BX2s], side[is], X2FACE);  ,
                  PeriodicBound (d->Vs[BX3s], side[is], X3FACE);)
        #endif
 
      }

    }else if (type[is] == SHEARING) {  /* -- shearingbox boundary -- */

    /* ---------------------------------------------------------
         SHEARING-BOX boundary condition is implemented as

        1) apply periodic boundary conditions for all variables
          (except staggered BX)
        2) Perform spatial shift in the y-direction
       --------------------------------------------------------- */

      #ifdef SHEARINGBOX
       if (side[is] != X1_BEG && side[is] != X1_END){
         print1 ("! BOUNDARY: shearingbox can only be assigned at an X1 boundary\n");
         QUIT_PLUTO(1);
       }
       if (grid[IDIR].nproc == 1){
         for (nv = 0; nv < NVAR; nv++) {
           PeriodicBound (d->Vc[nv], side[is], CENTER);
         }
         #ifdef STAGGERED_MHD
          D_EXPAND(                                             ;  ,
                   PeriodicBound (d->Vs[BX2s], side[is], X2FACE);  ,
                   PeriodicBound (d->Vs[BX3s], side[is], X3FACE);)
         #endif
       }
       SB_Boundary (d, side[is], grid);

     /* -- assign normal component of staggered B 
           using the div.B = 0 condition           -- */

       #ifdef STAGGERED_MHD
        FillMagneticField (d, side[is], grid);  
        CT_AverageNormalMagField (d, side[is], grid);
        CT_AverageTransverseMagField (d, side[is], grid);
       #endif
      #endif  /* def SHEARINGBOX */

    }else if (type[is] == USERDEF) {

    /* --------------------------------------------------------------
             USER-DEFINED boundary condition
       -------------------------------------------------------------- */

      #ifdef GLM_MHD
      {int i,j,k;
       switch(side[is]){
         case X1_BEG: X1_BEG_LOOP(k,j,i) d->Vc[PSI_GLM][k][j][i] = 0.0; break;
         case X1_END: X1_END_LOOP(k,j,i) d->Vc[PSI_GLM][k][j][i] = 0.0; break;
         case X2_BEG: X2_BEG_LOOP(k,j,i) d->Vc[PSI_GLM][k][j][i] = 0.0; break;
         case X2_END: X2_END_LOOP(k,j,i) d->Vc[PSI_GLM][k][j][i] = 0.0; break;
         case X3_BEG: X3_BEG_LOOP(k,j,i) d->Vc[PSI_GLM][k][j][i] = 0.0; break;
         case X3_END: X3_END_LOOP(k,j,i) d->Vc[PSI_GLM][k][j][i] = 0.0; break;
       }
      }
      #endif

      RBox *box = GetRBox(side[is], CENTER);
      UserDefBoundary (d, box, side[is], grid);
      #ifdef STAGGERED_MHD
        D_EXPAND(box = GetRBox(side[is], X1FACE);
                 UserDefBoundary (d, box, side[is], grid);  ,
                 box = GetRBox(side[is], X2FACE);
                 UserDefBoundary (d, box, side[is], grid);  ,
                 box = GetRBox(side[is], X3FACE);
                 UserDefBoundary (d, box, side[is], grid);)

       /* -- assign normal component of staggered B 
             using the div.B = 0 condition           -- */

       FillMagneticField (d, side[is], grid);  
       CT_AverageNormalMagField (d, side[is], grid);
       CT_AverageTransverseMagField (d, side[is], grid);
      #endif
    }
  }

/* --------------------------------------------------
    With FARGO, restore velocity deviation if the 
    original input array to Boundary() did not 
    contain the background velocity.
   -------------------------------------------------- */
   
   #ifdef FARGO
    if (fargo_velocity_has_changed){
      if (FARGO_HasTotalVelocity() == YES) FARGO_SubtractVelocity(d,grid);
    }
   #endif

/* -------------------------------------------------------
    Compute entropy for the next time level
   ------------------------------------------------------- */

  #if ENTROPY_SWITCH
   ComputeEntropy (d, grid);
  #endif
    
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ChangeDumpVar

(

)

Definition at line 21 of file userdef_output.c.

{ 
  Image *image;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void CharTracingStep	(	const State_1D *	state,
		int	beg,
		int	end,
		Grid *	grid
	)

Compute interface states using characteristic tracing step.

Parameters

[in]	state	pointer to a State_1D structure
[in]	beg	initial index of computation
[in]	end	final index of computation
[in]	grid	pointer to an array of Grid structures

Returns

This function has no return value.

Tasks are numbered below.

1) Compute eigenvectors and eigenvalues if not yet defined.

2) Obtain characteristic variable increments dwp and dwm.

3) Initialize vp and vm to the reference state. Since this is somewhat arbitrary we use the value of CHTR_REF_STATE to select one of the following cases:

• CHTR_REF_STATE==1: use cell-center value;
• CHTR_REF_STATE==2: interpolated value at base time level
• CHTR_REF_STATE==3: traditional PPM reference state (fastest wave), minimize the size of the term subject to characteristic limiting.

Passive scalars use always CHTR_REF_STATE == 2.

4) Compute left and right states in primitive variables. This step also depends on the value of CHTR_REF_STATE and include:

• evolve characteristic variable increments by dt/2;
• discard contributions from waves not reaching the interface;
• project characteristic differences dwp and dwm onto right eigenvectors

5) Add source term to L/R states

6) Repeat construction for passive scalars

Definition at line 198 of file char_tracing.c.

{
  int    i, j, k, nv;
  double dx, dtdx, scrh;
  double dv[NVAR], dw[NVAR];
  double nu_max=1.0, nu_min=-1.0, nu[NVAR];
  double *vc, *vp, *vm, **L, **R, *lambda;
  double *dfR, *dfL;
  #if GEOMETRY != CARTESIAN
   double betaL[NVAR], betaR[NVAR];
  #endif
  static double **src;

/* --------------------------------------------
    allocate memory and set pointer shortcuts
   -------------------------------------------- */

  if (src == NULL){
    src = ARRAY_2D(NMAX_POINT, NVAR, double);
  }

  #if GEOMETRY != CARTESIAN
   dfL  = grid[g_dir].dfL;
   dfR  = grid[g_dir].dfR;
  #endif

/* ---------------------------------------------
    define some useful quantities, compute
    source term and undivided differences
   --------------------------------------------- */

  #if CHAR_LIMITING == NO
   SoundSpeed2 (state->v, state->a2, state->h, beg, end, CELL_CENTER, grid);
  #endif

  PrimSource  (state, beg, end, state->a2, state->h, src, grid);
  for (i = beg; i <= end; i++){    

    dx   = grid[g_dir].dx[i];
    dtdx = g_dt/dx;

    vc     = state->v[i];
    vp     = state->vp[i];
    vm     = state->vm[i];
    L      = state->Lp[i];
    R      = state->Rp[i];
    lambda = state->lambda[i];

  /* --------------------------------------------------------------
     1. Compute eigenvectors and eigenvalues if not yet defined
     -------------------------------------------------------------- */

    #if CHAR_LIMITING == NO
     PrimEigenvectors (vc, state->a2[i], state->h[i], lambda, L, R);
     #if NVAR != NFLX
      for (k = NFLX; k < NVAR; k++) lambda[k] = vc[V1]; 
     #endif
    #endif
    for (k = 0; k < NVAR; k++) nu[k] = dtdx*lambda[k];
    nu_max = MAX(nu[1], 0.0); nu_min = MIN(nu[0], 0.0);

  /* ------------------------------------------------------------
     1a. Geometry
     ------------------------------------------------------------ */


    #if GEOMETRY == CYLINDRICAL || GEOMETRY == POLAR
     if (g_dir == IDIR) {
       double *xR = grid[IDIR].xr;
       for (k = NVAR; k--;  ){
betaR[k] = betaL[k] = 0.0;
/*
         scrh = nu[k]*dx;
         betaR[k] = (nu[k] >  1.e-12 ?  scrh/(6.0*xR[i]   - 3.0*scrh):0.0);
         betaL[k] = (nu[k] < -1.e-12 ? -scrh/(6.0*xR[i-1] - 3.0*scrh):0.0);
*/
       }
       nu_max *= (1.0 - betaR[1]);
       nu_min *= (1.0 + betaL[0]);
     }else{
       for (k = NVAR; k--;  )  betaR[k] = betaL[k] = 0.0;
     }
    #endif


  /* --------------------------------------------------------------
     2. Obtain characteristic variable increment dw
     -------------------------------------------------------------- */

    for (nv = NVAR; nv--;  ) dv[nv] = vp[nv] - vm[nv];
    PrimToChar(L, dv, dw);

  /* ----------------------------------------------------------------
     3. Initialize vp and vm to the reference state.
        Since this is somewhat arbitrary we set it using REF_STATE:

        REF_STATE==1: use cell-center value;
        REF_STATE==2: interpolated value at base time level 
        REF_STATE==3: traditional PPM reference state (fastest
                      wave), minimize the size of the term 
                      subject to characteristic limiting. 

        Passive scalars use always REF_STATE == 2.
     ---------------------------------------------------------------- */

    #if REF_STATE == 1
     for (nv = NFLX; nv--; ) vp[nv] = vm[nv] = vc[nv];
    #elif REF_STATE == 3
     for (nv = NFLX; nv--; ) {
       #if GEOMETRY == CARTESIAN
        vp[nv] = vc[nv] + 0.5*dv[nv]*(1.0 - nu_max);
        vm[nv] = vc[nv] - 0.5*dv[nv]*(1.0 + nu_min);
       #else
        vp[nv] = vc[nv] + dv[nv]*(dfR[i] - 0.5*nu_max);
        vm[nv] = vc[nv] + dv[nv]*(dfL[i] - 0.5*nu_min);
       #endif
     }
    #endif

  /* --------------------------------------------------------------------
     4. Compute L/R states in primitive variables:

         Evolve interface states for dt/2 using characteristic tracing.
         Depending on the choice of the reference state (i.e. 
         REF_STATE = 1,2,3) we compute, e.g. Vp(t+dt/2), as

         Vp(t+dt/2) = \sum [w + dw*dfR - nu*dw*(1-beta)]*R =

    = V    + \sum [dfR - nu*(1-beta)]*dw*R                  (REF_STATE = 1)
    = Vp   + \sum [    - nu*(1-beta)]*dw*R                  (REF_STATE = 2)
    = Vmax + \sum [nu_max*(1-beta_max) - nu*(1-beta)]*dw*R  (REF_STATE = 3)

        where Vmax = Vp - nu_max*(1-beta_max) is the reference state
        of the original PPM algorithm.
     -------------------------------------------------------------------- */

    #ifdef GLM_MHD  /* -- hot fix for backward test compatibility 
                          must review this at some point !! -- */
     nu_max = nu[1]; nu_min = nu[0];
    #endif

    for (k = 0; k < NFLX; k++){
      if (nu[k] >= 0.0) {
        #if GEOMETRY != CARTESIAN
         nu[k] *= (1.0 - betaR[k]);
        #endif
        #if REF_STATE == 1
         dw[k] *= 0.5*(1.0 - nu[k]);
        #elif REF_STATE == 2
         dw[k] *= -0.5*nu[k];
        #elif REF_STATE == 3
         dw[k] *= 0.5*(nu_max - nu[k]);
        #endif
        for (nv = 0; nv < NFLX; nv++) vp[nv] += dw[k]*R[nv][k];
      }else{     
        #if GEOMETRY != CARTESIAN
         nu[k] *= (1.0 + betaL[k]);
        #endif
        #if REF_STATE == 1
         dw[k] *= -0.5*(1.0 + nu[k]);
        #elif REF_STATE == 2
         dw[k] *= -0.5*nu[k];
        #elif REF_STATE == 3
         dw[k] *= 0.5*(nu_min - nu[k]);
        #endif
        for (nv = 0; nv < NFLX; nv++) vm[nv] += dw[k]*R[nv][k];
      }
    }

  /* -------------------------------------------------------
     5. Add source term to L/R states
     ------------------------------------------------------- */

    for (nv = NFLX; nv--;   ) {
      vp[nv] += 0.5*g_dt*src[i][nv];
      vm[nv] += 0.5*g_dt*src[i][nv];
    }

 /* -------------------------------------------------------
     6. Repeat construction for passive scalars
     ------------------------------------------------------- */

    #if NVAR != NFLX
     for (nv = NFLX; nv < NVAR; nv++) {
       #if GEOMETRY == CARTESIAN
        vp[nv] = vc[nv] + 0.5*dv[nv];
        vm[nv] = vc[nv] - 0.5*dv[nv];
       #else
        vp[nv] = vc[nv] + dv[nv]*dfR[i];
        vm[nv] = vc[nv] + dv[nv]*dfL[i];
       #endif
     }
     if (nu[NFLX] >= 0.0){  /* -- scalars all move at the flow speed -- */
       scrh = -0.5*nu[NFLX];
       #if GEOMETRY != CARTESIAN
        scrh *= (1.0 - betaR[k]);
       #endif
       for (k = NFLX; k < NVAR; k++) vp[k] += dw[k]*scrh;
     }else {
       scrh = -0.5*nu[NFLX];
       #if GEOMETRY != CARTESIAN
        scrh *= (1.0 + betaL[k]);
       #endif
       for (k = NFLX; k < NVAR; k++) vm[k] += dw[k]*scrh;
     }
    #endif

  }  /* -- end main loop on grid points -- */

/*  -------------------------------------------
        Shock flattening (only 1D)
    -------------------------------------------  */

  #if SHOCK_FLATTENING == ONED
   Flatten (state, beg, end, grid);
  #endif

/*  -------------------------------------------
      Assign face-centered magnetic field
    -------------------------------------------  */

  #ifdef STAGGERED_MHD
   for (i = beg-1; i <= end; i++) {
     state->vR[i][BXn] = state->vL[i][BXn] = state->bn[i];
   }
  #endif

/* --------------------------------------------------------
          evolve cell-center values by dt/2
   -------------------------------------------------------- */

  CheckPrimStates (state->vm, state->vp, state->v, beg, end);

  for (i = beg; i <= end; i++){ 
    vp = state->vp[i];
    vm = state->vm[i];
    for (nv = NVAR; nv--; ) {
      state->vh[i][nv] = 0.5*(vp[nv] + vm[nv]);
    }
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

int CheckNaN	(	double **	u,
		int	is,
		int	ie,
		int	id
	)

Cheeck whether the array u contains Not-a-Number (NaN)

Definition at line 19 of file tools.c.

{
  int ii, nv, i, j;

  for (ii = is; ii <= ie; ii++) {
  for (nv = 0; nv < NVAR; nv++) {
    if (u[ii][nv] != u[ii][nv]) {
      print (" > NaN found (%d), |", id);
      Show (u, ii);
      QUIT_PLUTO(1);
    }
  }}
  return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CheckPrimStates	(	double **	,
		double **	,
		double **	,
		int	,
		int
	)

Definition at line 4 of file check_states.c.

{
#if PHYSICS != ADVECTION
  int    i, nv, switch_to_1st;
  double scrhm, scrhp;
  double *ac, *ap, *am;

  for (i = beg; i <= end; i++){
  
    switch_to_1st = 0;

    ac = v0[i];
    am = vM[i];
    ap = vP[i];

  /*  ----  Prevent unphysical states by revertin to first
            order in time and space,  i.e.  set dw = 0      ----  */

    #if HAVE_ENERGY
     switch_to_1st = (ap[PRS] < 0.0) || (am[PRS] < 0.0) ;
    #endif
    switch_to_1st = switch_to_1st || 
                    (ap[RHO] < 0.0) || (am[RHO] < 0.0) ;

    /*  ----  Check for superluminal velocities  ---- */

#if (PHYSICS == RHD) || (PHYSICS == RMHD)
    #if RECONSTRUCT_4VEL == NO    
    scrhm = EXPAND(am[VX1]*am[VX1], + am[VX2]*am[VX2], + am[VX3]*am[VX3]);
    scrhp = EXPAND(ap[VX1]*ap[VX1], + ap[VX2]*ap[VX2], + ap[VX3]*ap[VX3]);
    switch_to_1st = switch_to_1st || (scrhm >= 1.0);
    switch_to_1st = switch_to_1st || (scrhp >= 1.0);
    #endif  
#endif

    if (switch_to_1st){
/*
      WARNING (
        print (" ! CheckPrimStates: Unphysical state, ");
        Where (i,NULL);
      )
*/              
      #ifdef STAGGERED_MHD 
       scrhp = ap[BXn];
       scrhm = am[BXn];
      #endif

      for (nv = 0; nv < NVAR; nv++){
        am[nv] = ap[nv] = ac[nv];
      }
 
      #ifdef STAGGERED_MHD
       ap[BXn] = scrhp;
       am[BXn] = scrhm;
      #endif
      
    }
  }
#endif
}

Here is the caller graph for this function:

int CloseBinaryFile	(	FILE *	fbin,
		int	sz
	)

Close file.

Parameters

[in]	fbin	pointer to the FILE that needs to be closed (serial mode only)
[in]	sz	the distributed array descriptor for parallel mode

Returns

Returns 0 on success

Definition at line 78 of file bin_io.c.

{
  #ifdef PARALLEL 
   AL_File_close(sz); 
  #else
   fclose (fbin);
  #endif
  return(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ComputeEntropy	(	const Data *	,
		Grid *
	)

Here is the caller graph for this function:

void ComputeUserVar	(	const Data *	,
		Grid *
	)

Definition at line 4 of file userdef_output.c.

{
  int i, j, k;  
  
  DOM_LOOP(k,j,i){
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ConsToPrim3D	(	Data_Arr	U,
		Data_Arr	V,
		unsigned char ***	flag,
		RBox *	box
	)

Convert a 3D array of conservative variables U to an array of primitive variables V. Note that [nv] is the fastest running index for U while it is the slowest running index for V.

Parameters

[in]	U	pointer to 3D array of conserved variables, with array indexing [k][j][i][nv]
[out]	V	pointer to 3D array of primitive variables, with array indexing [nv][k][j][i]
[in,out]	flag	pointer to 3D array of flags.
[in]	box	pointer to RBox structure containing the domain portion over which conversion must be performed.

Definition at line 16 of file mappers3D.c.

{
  int   i, j, k, nv, err;
  int   ibeg, iend, jbeg, jend, kbeg, kend;
  int   current_dir;
  static double **v, **u;

  if (v == NULL){
    v = ARRAY_2D(NMAX_POINT, NVAR, double);
    u = ARRAY_2D(NMAX_POINT, NVAR, double);
  }

/* ----------------------------------------------
    Save current sweep direction and by default,
    perform the conversion along X1 stripes
   ---------------------------------------------- */

  current_dir = g_dir; 
  g_dir = IDIR;
  
/* -----------------------------------------------
    Set (beg,end) indices in ascending order for
    proper call to ConsToPrim()
   ----------------------------------------------- */

  ibeg = (box->ib <= box->ie) ? (iend=box->ie, box->ib):(iend=box->ib, box->ie);
  jbeg = (box->jb <= box->je) ? (jend=box->je, box->jb):(jend=box->jb, box->je);
  kbeg = (box->kb <= box->ke) ? (kend=box->ke, box->kb):(kend=box->kb, box->ke);

  for (k = kbeg; k <= kend; k++){ g_k = k;
  for (j = jbeg; j <= jend; j++){ g_j = j;

#ifdef CHOMBO
    for (i = ibeg; i <= iend; i++) NVAR_LOOP(nv) u[i][nv] = U[nv][k][j][i];
    #if COOLING == MINEq || COOLING == H2_COOL
    if (g_intStage == 1) for (i = ibeg; i <= iend; i++) NormalizeIons(u[i]);
    #endif
    err = ConsToPrim (u, v, ibeg, iend, flag[k][j]);

  /* -------------------------------------------------------------
      Ensure any change to 1D conservative arrays is not lost.
      Note: Conversion must be done even when err = 0 in case
            ENTROPY_SWITCH is employed.
     ------------------------------------------------------------- */

    for (i = ibeg; i <= iend; i++) NVAR_LOOP(nv) U[nv][k][j][i] = u[i][nv];
#else
    err = ConsToPrim (U[k][j], v, ibeg, iend, flag[k][j]);
#endif
    for (i = ibeg; i <= iend; i++) NVAR_LOOP(nv) V[nv][k][j][i] = v[i][nv];
  }}
  g_dir = current_dir;

}

Here is the call graph for this function:

Here is the caller graph for this function:

float*** Convert_dbl2flt	(	double ***	Vdbl,
		double	unit,
		int	swap_endian
	)

Convert the a double-precision 3D array into single precision. Swap endianity if swap_endian == 1.

Parameters

[in]	Vdbl	pointer to a 3D double precision aray
[in]	unit	a multiplicative constant typically used to write in c.g.s units.
[in]	swap_endian	when set to 1, swap endianity during the conversion.

Returns

a pointer to a 3D array in single precision.

Definition at line 216 of file bin_io.c.

{
  int i, j, k;
  float  flt;
  static float ***Vflt;
  
  if (Vflt == NULL) Vflt = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, float);

  if (!swap_endian){
    DOM_LOOP(k,j,i){
      Vflt[k][j][i] = (float)(Vdbl[k][j][i]*unit);
    }
  }else{
    DOM_LOOP(k,j,i){
      flt = (float)(Vdbl[k][j][i]*unit);
      SWAP_VAR(flt);
      Vflt[k][j][i] = flt;
    }
  }

  return (Vflt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CreateImage

(

char *

)

Definition at line 8 of file set_image.c.

{
  static int icount = 0;

  sprintf (image[icount].basename,"%s",var_name);

  image[icount].slice_plane = X12_PLANE;
  image[icount].slice_coord = 0.0;

  image[icount].max = image[icount].min = 0.0;
  image[icount].logscale = 0;
  image[icount].colormap = "br";

  icount++; 
}

Here is the caller graph for this function:

void Enthalpy	(	double **	v,
		real *	h,
		int	beg,
		int	end
	)

Compute the enthalpy.

Parameters

[in]	v	1D array of primitive quantities
[in]	h	1D array of enthalpy values
[in]	beg	initial index of computation
[in]	end	final index of computation

Returns

This function has no return value.

Definition at line 48 of file eos.c.

{
  int i;
  double gmmr, theta;

  gmmr = g_gamma/(g_gamma - 1.0);

/* ---------------------------------------------------------------
              Classical equations of state
   --------------------------------------------------------------- */

  #if PHYSICS == HD || PHYSICS == MHD
   for (i = beg; i <= end; i++) h[i] = gmmr*v[i][PRS]/v[i][RHO];
  #elif PHYSICS == RHD || PHYSICS == RMHD
   for (i = beg; i <= end; i++) {
     theta = v[i][PRS]/v[i][RHO];
     h[i] = 1.0 + gmmr*theta;
   }
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Entropy	(	double **	v,
		double *	s,
		int	beg,
		int	end
	)

Compute the entropy.

Parameters

[in]	v	1D array of primitive quantities
[in]	s	1D array of entropy values
[in]	is	initial index of computation
[in]	ie	final index of computation

Returns

This function has no return value.

Definition at line 80 of file eos.c.

{
  int i;
  double rho, th;

  #if PHYSICS == HD || PHYSICS == MHD
   for (i = beg; i <= end; i++){
     rho  = v[i][RHO];
     s[i] = v[i][PRS]/pow(rho,g_gamma);
   }
  #elif PHYSICS == RHD || PHYSICS == RMHD
   for (i = beg; i <= end; i++) {
     rho = v[i][RHO];
     s[i] = v[i][PRS]/pow(rho,g_gamma);
   }
  #endif
}

Here is the call graph for this function:

void EntropyOhmicHeating	(	const Data *	,
		Data_Arr	,
		double	,
		Grid *
	)

Here is the caller graph for this function:

void EntropySwitch	(	const Data *	,
		Grid *
	)

void FindShock	(	const Data *	,
		Grid *
	)

Here is the caller graph for this function:

void FlagShock	(	const Data *	,
		Grid *
	)

Here is the caller graph for this function:

void Flatten	(	const State_1D *	,
		int	,
		int	,
		Grid *
	)

Definition at line 4 of file flatten.c.

{
  int    i, nv, sj;
  double scrh, dp, d2p, min_p, vf, fj;
  real **v, **vp, **vm;
  static real *f_t;
   
  #if EOS == ISOTHERMAL 
   int PRS = RHO;
  #endif
   
  if (f_t == NULL){
    f_t   = ARRAY_1D(NMAX_POINT, double);    
  }

  v  = state->v;
  vp = state->vp;
  vm = state->vm;

/* ---------------------------------------------------------
     the following constraints is necessary for
     a particular combinations of algorithms:
 
      - CTU + CT + MHD + userdef boundary 
      - shock flattening.

     This is necessary when user defined boundary conditions 
     are used in the fully corner coupled unsplit schemes 
     (HANCOCK and CHARACTERISTIC_TRACING), since the 
     grid is expanded by one point in the userdef boundary 
     to get the correct electric field 
     (see the EXPAND_CTU_GRID in unsplit_ctu.c).
   -------------------------------------------------------- */

  beg = MAX(beg, 3);
  end = MIN(end, grid[g_dir].np_tot - 4);

  for (i = beg - 1; i <= end + 1; i++) {
    dp    = v[i + 1][PRS] - v[i - 1][PRS];
    min_p = MIN(v[i + 1][PRS], v[i - 1][PRS]);
    d2p   = v[i + 2][PRS] - v[i - 2][PRS];
    scrh = fabs(dp)/min_p;
    if (scrh < EPS2 || (v[i + 1][VXn] > v[i - 1][VXn])){
      f_t[i] = 0.0;
    }else{ 
      scrh   = OME2*(fabs(dp/d2p) - OME1);
      scrh   = MIN(1.0, scrh);
      f_t[i] = MAX(0.0, scrh);
    }
  }

  for (i = beg; i <= end; i++) {
    sj = (v[i + 1][PRS] < v[i - 1][PRS] ?  1 : -1);
    fj = MAX(f_t[i], f_t[i + sj]);
    for (nv = 0; nv < NVAR; nv++){
      vf   = v[i][nv]*fj;
      scrh = 1.0 - fj;
      vm[i][nv] = vf + vm[i][nv]*scrh;
      vp[i][nv] = vf + vp[i][nv]*scrh;
    }
  }

/*
  int   beg, end, i, nv, sj;
  real   scrh1, scrh2, scrh3;
  real **a, **ap, **am;
  static real  *f_t, *fj, *dp, *d2p, *min_p;
   
  #if EOS == ISOTHERMAL 
   int PR = DN;
  #endif
     
  if (dp == NULL){
    f_t   = ARRAY_1D(NMAX_POINT, double);    
    fj    = ARRAY_1D(NMAX_POINT, double);
    dp    = ARRAY_1D(NMAX_POINT, double);
    d2p   = ARRAY_1D(NMAX_POINT, double);
    min_p = ARRAY_1D(NMAX_POINT, double);
  }

  a  = state->v;
  ap = state->vp;
  am = state->vm;

  beg = grid[g_dir].lbeg - 1;
  end = grid[g_dir].lend + 1;

  beg = MAX(beg, 3);
  end = MIN(end, grid[g_dir].np_tot - 3);

  for (i = beg - 2; i <= end + 2; i++) {
    dp[i]    = a[i + 1][PRS] - a[i - 1][PRS];
    min_p[i] = MIN(a[i + 1][PRS], a[i - 1][PRS]);
  }
  for (i = beg - 1; i <= end + 1; i++) {
    d2p[i]   = a[i + 2][PRS] - a[i - 2][PRS];
  }

  for (i = beg - 1; i <= end + 1; i++) {
    scrh1 = fabs(dp[i]) / min_p[i];
    scrh2 = a[i + 1][VXn] - a[i - 1][VXn];
    if (scrh1 < EPS2 || scrh2 > 0.0){
      f_t[i] = 0.0;
    }else{ 
      scrh3  = OME2*(fabs(dp[i]/d2p[i]) - OME1);
      scrh3  = MIN(1.0, scrh3);
      f_t[i] = MAX(0.0, scrh3);
    }
  }

  for (i = beg; i <= end; i++) {
    sj = (dp[i] < 0.0 ?  1 : -1);
    fj[i] = MAX(f_t[i], f_t[i + sj]);
  }

  for (i = beg; i <= end; i++) {
  for (nv = 0; nv < NVAR; nv++){
    scrh1 = a[i][nv]*fj[i];
    scrh2 = 1.0 - fj[i];
    am[i][nv] = scrh1 + am[i][nv]*scrh2;
    ap[i][nv] = scrh1 + ap[i][nv]*scrh2;
  }}
*/

}

Here is the caller graph for this function:

void FlipSign	(	int	side,
		int	type,
		int *	vsign
	)

Reverse the sign of vector components with respect to axis side. Depending on type, one needs to symmetrize or anti-symmetrize:

• REFLECTIVE:
  o Vn -> -Vn, Bn -> -Bn
  o Vp -> Vp, Bp -> Bp
  o Vt -> Vt, Bt -> Bt
• AXISYMMETRIC:
  o Vn -> -Vn, Bn -> -Bn
  o Vp -> Vp, Bp -> Bp
  o Vt -> -Vt, Bt -> -Bt
• EQTSYMMETRIC:
  o Vn -> -Vn, Bn -> Bn
  o Vp -> Vp, Bp -> -Bp
  o Vt -> Vt, Bt -> -Bt

where (n) is the normal components, (p) and (t) are the transverse (or poloidal and toroidal for cylindrical and spherical coordinates) components.

Parameters

[in]	side	boundary side
[in]	type	boundary condition type
[out]	vsign	an array of values (+1 or -1) giving the sign

Definition at line 408 of file boundary.c.

{
  int nv;
  int Vn, Vp, Vt;
  int Bn, Bp, Bt;

  #if PHYSICS == ADVECTION
   for (nv = 0; nv < NVAR; nv++) vsign[nv] = 1.0;
   return;
  #endif

/* ----------------------------------------------------------
    get normal (n), poloidal (p) and toroidal (t) vector 
    components. The ordering is the same as in SetIndexes()
   ---------------------------------------------------------- */

  if (side == X1_BEG || side == X1_END){
    Vn = VX1; Vp = VX2; Vt = VX3;
    #if PHYSICS == MHD || PHYSICS == RMHD
     Bn = BX1; Bp = BX2; Bt = BX3;
    #endif
  }else if (side == X2_BEG || side == X2_END){
    Vn = VX2; Vp = VX1; Vt = VX3;
    #if PHYSICS == MHD || PHYSICS == RMHD
     Bn = BX2; Bp = BX1; Bt = BX3;
    #endif
  }else if (side == X3_BEG || side == X3_END){
    Vn = VX3; Vp = VX1; Vt = VX2;
    #if PHYSICS == MHD || PHYSICS == RMHD
     Bn = BX3; Bp = BX1; Bt = BX2;
    #endif
  }

/* ---------------------------------------
     decide which variable flips sign
   --------------------------------------- */

  for (nv = 0; nv < NVAR; nv++) vsign[nv] = 1.0;

  vsign[Vn] = -1.0;
  #if PHYSICS == MHD || PHYSICS == RMHD
   vsign[Bn] = -1.0;
  #endif

  #if COMPONENTS == 3
   if (type == AXISYMMETRIC){
     vsign[Vt] = -1.0;
     #if PHYSICS == MHD || PHYSICS == RMHD
      vsign[Bt] = -1.0;
     #endif
   }
  #endif

  #if PHYSICS == MHD || PHYSICS == RMHD
   if (type == EQTSYMMETRIC){
     EXPAND(vsign[Bn] =  1.0; ,
            vsign[Bp] = -1.0; ,
            vsign[Bt] = -1.0;)
     #ifdef GLM_MHD 
      vsign[PSI_GLM] = -1.0;
     #endif
   }
  #endif
}

Here is the caller graph for this function:

void FreeArray1D

(

void *

v

)

Free memory allocated by the pointer *v.

Definition at line 37 of file arrays.c.

{
  free ((char *)v);
}

Here is the caller graph for this function:

void FreeArray2D

(

void **

m

)

Free memory allocated by the double pointer **v.

Definition at line 46 of file arrays.c.

{
  free ((char *) m[0]);
  free ((char *) m);
}

void FreeArray3D

(

void ***

m

)

Free memory allocated by the pointer ***v.

Definition at line 56 of file arrays.c.

{
  free ((char *) m[0][0]);
  free ((char *) m[0]);
  free ((char *) m);
}

void FreeArray4D

(

void ****

m

)

Free memory allocated by the pointer ****v.

Definition at line 67 of file arrays.c.

{
  free ((char *) m[0][0][0]);
  free ((char *) m[0][0]);
  free ((char *) m[0]);
  free ((char *) m);
}

Here is the caller graph for this function:

void FreeArrayBox	(	double ***	t,
		long	nrl,
		long	ncl,
		long	ndl
	)

Free memory allocated by the ArrayBox function.

Parameters

[in]	t	pointer to an allocated memory area
[in]	nrl	starting index of the array for the 3rd dimension
[in]	ncl	starting index of the array for the 2nd dimension
[in]	ndl	starting index of the array for the 1st dimension

Definition at line 403 of file arrays.c.

{
  free((char *) (t[nrl][ncl]+ndl));
  free((char *) (t[nrl]+ncl));
  free((char *) (t+nrl));
}

Here is the caller graph for this function:

void FreeArrayBoxMap	(	double ***	t,
		int	nrl,
		int	nrh,
		int	ncl,
		int	nch,
		int	ndl,
		int	ndh
	)

Free memory allocated with the ArrayBoxMap () function

Definition at line 586 of file arrays.c.

{
  free((char*) (t[nrl]+ncl));
  free((char*) (t+nrl));
}

void FreeArrayCharMap

(

unsigned char ***

)

Definition at line 530 of file arrays.c.

{
  free((char*) t[0]);
  free((char*) t);
}

void FreeArrayMap

(

double ***

t

)

Free memory allocate with ArrayMap()

Definition at line 518 of file arrays.c.

{
  free((char*) t[0]);
  free((char*) t);
}

void FreeGrid

(

Grid *

grid

)

Free array memory allocated previously.

Definition at line 191 of file set_grid.c.

{
  int dir;
  
  for (dir = 0; dir < 3; dir++){
    FreeArray1D(grid[dir].x);
    FreeArray1D(grid[dir].xl);
    FreeArray1D(grid[dir].xr);
    FreeArray1D(grid[dir].dx);
    FreeArray1D(grid[dir].xgc);
    FreeArray1D(grid[dir].dV);
    FreeArray1D(grid[dir].A-1);
    FreeArray1D(grid[dir].r_1);
    FreeArray1D(grid[dir].ct);
    FreeArray1D(grid[dir].inv_dx);
    FreeArray1D(grid[dir].inv_dxi);
  }
}

Here is the call graph for this function:

void GetAreaFlux	(	const State_1D *	,
		double **	,
		double **	,
		int	,
		int	,
		Grid *
	)

Definition at line 4 of file get_area_flux.c.

{
  int    i,j,k, nv;
  double A, rp, rp2, rp3, s, s2;
  double **flux = state->flux;
#if ENTROPY_SWITCH
  double **visc_flux = state->visc_flux; 
  double **visc_src  = state->visc_src; 
  double **tc_flux   = state->tc_flux; 
  double **res_flux  = state->res_flux;
#endif 

  if (g_dir == IDIR) { 

    for (i = beg - 1; i <= end; i++){ 
      A  = grid[IDIR].A[i];
      rp = grid[IDIR].xr[i];
#if GEOMETRY == CYLINDRICAL
      NVAR_LOOP(nv) fA[i][nv] = flux[i][nv]*A;
  #if COMPONENTS == 3    
      fA[i][MX3] = flux[i][MX3]*A*A;
      IF_DUST(fA[i][MX3_D] = flux[i][MX3_D]*A*A;)
  #endif    
#elif GEOMETRY == POLAR
      NVAR_LOOP(nv) fA[i][nv] = flux[i][nv]*A;
  #if COMPONENTS >= 2
      fA[i][MX2] *= A;
      IF_DUST(fA[i][MX2_D] *= A;)
  #endif    
#elif GEOMETRY == SPHERICAL
      rp2 = rp*rp;
      NVAR_LOOP(nv) fA[i][nv] = flux[i][nv]*rp2;
  #if COMPONENTS == 3
      rp3 = rp2*rp;
      fA[i][MX3] = flux[i][MX3]*rp3;
      IF_DUST(fA[i][MX3_D] = flux[i][MX3_D]*rp3;)
  #endif
  #if PHYSICS == MHD
      EXPAND(                            ;   ,
             fA[i][BX2] = flux[i][BX2]*rp;  ,
             fA[i][BX3] = flux[i][BX3]*rp;)
  #endif
#endif

      #if (ENTROPY_SWITCH) && (VISCOSITY == EXPLICIT)
       EXPAND(fvA[i][MX1] = visc_flux[i][MX1]*A; ,
              fvA[i][MX2] = visc_flux[i][MX2]*A; ,
              fvA[i][MX3] = visc_flux[i][MX3]*A;)
       #if GEOMETRY == CYLINDRICAL && COMPONENTS == 3
        fvA[i][MX3] *= rp;
       #elif GEOMETRY == POLAR && COMPONENTS >= 2
        fvA[i][MX2] *= rp; 
       #elif GEOMETRY == SPHERICAL && COMPONENTS == 3
        fvA[i][MX3] *= rp; 
       #endif
       #if HAVE_ENERGY
        fvA[i][ENG] = visc_flux[i][ENG]*A;
       #endif
      #endif
    }

  }else if (g_dir == JDIR){

    for (j = beg - 1; j <= end; j++){

#if GEOMETRY == SPHERICAL  
      s  = grid[JDIR].A[j];
      s2 = s*s; 

      NVAR_LOOP(nv) fA[j][nv] = flux[j][nv]*s;
  #if COMPONENTS == 3
      fA[j][MX3] = flux[j][MX3]*s2;
      IF_DUST(fA[j][MX3_D] = flux[j][MX3_D]*s2;)
  #endif

      #if (ENTROPY_SWITCH) && (VISCOSITY == EXPLICIT)
       EXPAND(fvA[j][iMR]   = visc_flux[j][iMR]*s;    ,
              fvA[j][iMTH]  = visc_flux[j][iMTH]*s;   ,
              fvA[j][iMPHI] = visc_flux[j][iMPHI]*s2;)
       #if HAVE_ENERGY
        fvA[j][ENG] = visc_flux[j][ENG]*s;
       #endif
      #endif
#endif

    }

  }else if (g_dir == KDIR){

    print1 ("! GetAreaFlux(): should not be called during x3 sweep\n");
    QUIT_PLUTO(1);

  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void GetCGSUnits

(

double *

u

)

Compute an array of c.g.s units

Parameters

[in]

u

an array containing the c.g.s units of the primitive variables, e.g., u[RHO] will be in gr/cm^3, u[VX1] will be in cm/s, etc...

Definition at line 557 of file write_data.c.

{
  int nv;
  double unit_velocity = UNIT_VELOCITY;
  double unit_pressure = UNIT_DENSITY*UNIT_VELOCITY*UNIT_VELOCITY;
  double unit_mag      = UNIT_VELOCITY*sqrt(4.0*CONST_PI*UNIT_DENSITY);
  
  #if PHYSICS == RHD || PHYSICS == RMHD
   unit_velocity = CONST_c;
  #endif

  u[RHO] = UNIT_DENSITY;
  EXPAND(u[VX1] = unit_velocity;  ,
         u[VX2] = unit_velocity;  ,
         u[VX3] = unit_velocity;)
  #if PHYSICS == MHD || PHYSICS == RMHD
   EXPAND(u[BX1] = unit_mag;  ,
          u[BX2] = unit_mag;  ,
          u[BX3] = unit_mag;)
  #endif
  #if HAVE_ENERGY
   u[PRS] = unit_pressure;
  #endif
}

Here is the caller graph for this function:

double GetEntropy

(

double

x

)

Image* GetImage

(

char *

)

Definition at line 35 of file set_image.c.

{
  int indx = -1;

  while (strcmp(image[++indx].basename, var_name)) {
    if (image[indx].colormap == NULL) { /* if colormap is NULL, image does not exist! */
      print1 ("! Error: var '%s' is not associated with a valid image\n"); 
      QUIT_PLUTO(1);
    }
  }
   
  return (image + indx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

double* GetInverse_dl

(

const Grid *

)

Definition at line 205 of file set_geometry.c.

{
#if GEOMETRY == CARTESIAN || GEOMETRY == CYLINDRICAL

  return grid[g_dir].inv_dx;

#elif GEOMETRY == POLAR

  if (g_dir != JDIR){
    return grid[g_dir].inv_dx;
  }else{
    int    j;
    double r_1;
    static double *inv_dl;
   
    if (inv_dl == NULL) {
     #ifdef CHOMBO
      inv_dl = ARRAY_1D(NX2_MAX, double);
     #else
      inv_dl = ARRAY_1D(NX2_TOT, double);
     #endif
    }
    r_1 = grid[IDIR].r_1[g_i];
    JTOT_LOOP(j) inv_dl[j] = grid[JDIR].inv_dx[j]*r_1;
    return inv_dl;
  }

#elif GEOMETRY == SPHERICAL

  int    j, k;
  double r_1, s;
  static double *inv_dl2, *inv_dl3;

  if (inv_dl2 == NULL) {
   #ifdef CHOMBO
    inv_dl2 = ARRAY_1D(NX2_MAX, double);
    inv_dl3 = ARRAY_1D(NX3_MAX, double);
   #else
    inv_dl2 = ARRAY_1D(NX2_TOT, double);
    inv_dl3 = ARRAY_1D(NX3_TOT, double);
   #endif
  }

  if (g_dir == IDIR){
    return grid[IDIR].inv_dx;
  }else if (g_dir == JDIR) {
    r_1 = grid[IDIR].r_1[g_i];
    JTOT_LOOP(j) inv_dl2[j] = grid[JDIR].inv_dx[j]*r_1;
    return inv_dl2;
  }else if (g_dir == KDIR){
    r_1 = grid[IDIR].r_1[g_i];
    s   = grid[JDIR].x[g_j];
    s   = sin(s);
    KTOT_LOOP(k) inv_dl3[k] = grid[KDIR].inv_dx[k]*r_1/s;
    return inv_dl3;
  }

#endif

  return NULL;
}

Here is the caller graph for this function:

int GetNghost

(

void

)

Compute the number of ghost zones, depending on the selected scheme.

Definition at line 18 of file get_nghost.c.

{
  int nv, nghost ;
  Limiter *limiter[NVAR];

  #if RECONSTRUCTION == FLAT

   nghost = 2;

  #elif RECONSTRUCTION == LINEAR || RECONSTRUCTION == LimO3\
                                || RECONSTRUCTION == WENO3
   #if LIMITER == FOURTH_ORDER_LIM
    nghost = 3;
   #else
    nghost = 2;
   #endif

  #elif RECONSTRUCTION == LINEAR_MULTID

   nghost = 2;

  #elif RECONSTRUCTION == PARABOLIC

   #if PHYSICS == HD || PHYSICS == RHD
    nghost = 4;   /* -- since HD makes use of contact steepener -- */
   #else
    nghost = 3;
   #endif

  #elif RECONSTRUCTION == WENO3_FD || RECONSTRUCTION == LIMO3_FD

   nghost = 2;

  #elif RECONSTRUCTION == WENOZ_FD  || \
        RECONSTRUCTION == MP5_FD

   nghost = 3;

  #endif

  #if SHOCK_FLATTENING == ONED

   nghost = MAX(4, nghost);

  #elif SHOCK_FLATTENING == MULTID

/* ------------------------------------------------------
    The MULTID shock flattening only need 2 ghost zones.
    However for axisymmetric simulations with CTU 
    3 zones will ensure that flag[][][] will remain 
    symmetric around the axis.
   ------------------------------------------------------ */

   nghost = MAX(3, nghost);
  #endif

/* ----------------------------------------------------
    The following should operate on the static grid 
    version of the code. Add an extra row of boundary
    zones if CTU+CT is selected.
    At least 3 ghost zones.
   ---------------------------------------------------- */

  #ifdef CTU
   #ifdef STAGGERED_MHD
    nghost++;
   #endif
  #endif

/* ----------------------------------------
    FARGO PPM needs at least 3 ghost zones 
   ---------------------------------------- */

  #ifdef FARGO
   #if FARGO_ORDER == 3
    nghost = MAX(3,nghost);
   #endif
  #endif

  #if (defined CH_SPACEDIM) && (TIME_STEPPING == RK_MIDPOINT) 
   nghost++;  /* AMR + RK_MIDPOINT */
  #endif  

  return (nghost);
}

Here is the caller graph for this function:

void GetOutputFrequency	(	Output *	output,
		const char *	output_format
	)

Set the intervals between output files. This can be done in three different ways:

• dt: time interval in code units
• dn: step interval
• dclock: actual clock time (in hours)

However, dn and dclock are mutually exclusive.

Definition at line 433 of file runtime_setup.c.

{
  char *str;
  int len, nhrs, nmin, nsec;

/* -- time interval in code units (dt) -- */

  output->dt = atof(ParamFileGet(output_format, 1));

/* -- check the 2nd field and decide to set "dn" or "dclock" -- */

  str = ParamFileGet(output_format,2);
  len = strlen(str);
  if (str[len-1] == 'h'){
    output->dclock = atof(str);    /* clock interval in hours */
    nhrs = (int)output->dclock;    /* integer part */
    nmin = (int)((output->dclock - nhrs)*100.0); /* remainder in minutes */
    if (nmin >= 60){
      printf ("! OutputFrequency: number of minutes exceeds 60 in %s output\n",
               output_format);
      QUIT_PLUTO(1);
    }
    output->dclock = nhrs*3600.0 + nmin*60;  /* convert to seconds */
    output->dn     = -1;
  }else if (str[len-1] == 'm'){
    output->dclock = atof(str);      /* clock interval in minutes */
    nmin = (int)output->dclock;      /* integer part */
    nsec = (int)((output->dclock - nmin)*100.0); /* remainder in seconds */
    if (nsec >= 60){
      printf ("! OutputFrequency: number of seconds exceeds 60 in %s output\n",
               output_format);
      QUIT_PLUTO(1);
    }
    output->dclock = nmin*60.0 + nsec;
    output->dn     = -1;
  }else if (str[len-1] == 's'){
    output->dclock = atof(str);           /* clock interval in seconds */
    output->dn     = -1;
  }else{
    output->dclock = -1.0;    
    output->dn     = atoi(ParamFileGet(output_format, 2));
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

RBox* GetRBox	(	int	side,
		int	vpos
	)

Returns a pointer to a local static RBox

Parameters

[in]	side	the region of the computational domain where the box is required. There 8 possible values: X1_BEG, ... , X3_END, DOM, TOT.
[in]	vpos	the variable position inside the cell: CENTER, X1FACE, X2FACE or X3FACE.

Definition at line 232 of file rbox.c.

{
  if      (vpos == CENTER) return &(rbox_center[side-X1_BEG]);
  else if (vpos == X1FACE) return &(rbox_x1face[side-X1_BEG]);
  else if (vpos == X2FACE) return &(rbox_x2face[side-X1_BEG]);
  else if (vpos == X3FACE) return &(rbox_x3face[side-X1_BEG]);
}

Here is the caller graph for this function:

double*** GetUserVar

(

char *

var_name

)

return a pointer to the 3D array associated with the variable named 'var_name'.

Definition at line 251 of file set_output.c.

{
  int indx = -1;
  
  while (strcmp(all_outputs->var_name[++indx], var_name)){
    if (all_outputs->V[indx] == NULL){
      print1 ("! Error: uservar '%s' is not allocated\n"); 
      QUIT_PLUTO(1);
    }
  }
  return (all_outputs->V[indx]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void HancockStep	(	const State_1D *	,
		int	,
		int	,
		Grid *
	)

Definition at line 136 of file hancock.c.

 {
  int    nv, i, ifail;
  double dBx, dpsi, dtdx, dt, dtdV;
  double *A, *dx, *dV, r;
  double *vp, *vm, *vc, dvp[NVAR], dvm[NVAR];
  double P0, P1, P2; 
  double **rhs;
  static double **fp, **fm, **uh, **u;
  static double *pp, *pm, *hp, *hm;
  static double *lambda_max, *lambda_min;

#if GEOMETRY != CARTESIAN && GEOMETRY != CYLINDRICAL
  print1 ("! Hancock does not work in this geometry \n");
  QUIT_PLUTO(1);
#endif
#if BODY_FORCE != NO
  print ("! Conservative Hancock scheme does not support gravity\n");
  QUIT_PLUTO(1);
#endif
#if RECONSTRUCTION != LINEAR
  print1 ("! The MUSCL-Hancock scheme works with Linear reconstruction only\n");
  QUIT_PLUTO(1);
#endif
#if (PARABOLIC_FLUX & EXPLICIT)
  print1 ("! Conservative MUSCL-Hancock incompatible with Explicit Diffusion\n");
  QUIT_PLUTO(1);
#endif

  if (fp == NULL){
    fp   = ARRAY_2D(NMAX_POINT, NVAR, double);
    fm   = ARRAY_2D(NMAX_POINT, NVAR, double);
    pp   = ARRAY_1D(NMAX_POINT, double);
    pm   = ARRAY_1D(NMAX_POINT, double);
    u    = ARRAY_2D(NMAX_POINT, NVAR, double);
    uh   = ARRAY_2D(NMAX_POINT, NVAR, double);

    hp   = ARRAY_1D(NMAX_POINT, double);
    hm   = ARRAY_1D(NMAX_POINT, double);
    lambda_max = ARRAY_1D(NMAX_POINT, double);
    lambda_min = ARRAY_1D(NMAX_POINT, double);
  }
  rhs = state->rhs;

#if RECONSTRUCT_4VEL
  ConvertTo3vel (state->v, beg-1, end+1);
  ConvertTo3vel (state->vp, beg, end);
  ConvertTo3vel (state->vm, beg, end);
#endif

/* --------------------------------
         make fluxes  
   -------------------------------- */

  PrimToCons (state->v, u, beg, end);
  PrimToCons (state->vp, state->up, beg, end);
  PrimToCons (state->vm, state->um, beg, end);

  Enthalpy (state->vp, hp, beg, end);
  Enthalpy (state->vm, hm, beg, end);

  Flux(state->up, state->vp, hp, fp, pp, beg, end);
  Flux(state->um, state->vm, hm, fm, pm, beg, end);

  dx = grid[g_dir].dx; A = grid[g_dir].A; dV = grid[g_dir].dV;

/* ---------------------------------------------------
          Compute passive scalar fluxes
   --------------------------------------------------- */

  #if NFLX != NVAR
   for (i = beg; i <= end; i++){
     vp  = state->vp[i]; vm  = state->vm[i];
     #if NSCL > 0
      for (nv = NFLX; nv < (NFLX + NSCL); nv++){
        fp[i][nv] = fp[i][RHO]*vp[nv];
        fm[i][nv] = fm[i][RHO]*vm[nv];
      }
     #endif
   }
  #endif

  #if CHAR_UPWIND == YES  
   MAX_CH_SPEED (state->v, lambda_min, lambda_max, beg, end);
  #endif

/* ------------------------------------------------------
      Initialize right-hand-side with flux difference  
   ------------------------------------------------------ */

  dt = 0.5*g_dt; 
  for (i = beg; i <= end; i++) { 

    dtdx = dt/dx[i]; 
    vp  = state->vp[i]; 
    vm  = state->vm[i];
    #if GEOMETRY == CARTESIAN
     for (nv = NVAR; nv--;   ) rhs[i][nv] = -dtdx*(fp[i][nv] - fm[i][nv]);
    #elif GEOMETRY == CYLINDRICAL
     dtdV = dt/dV[i];
     for (nv = NVAR; nv--;   ) {
       rhs[i][nv] = -dtdV*(A[i]*fp[i][nv] - A[i-1]*fm[i][nv]);
     }
     #ifdef GLM_MHD
      rhs[i][BXn] = -dtdx*(vp[PSI_GLM] - vm[PSI_GLM]);
     #endif
    #endif
    rhs[i][MXn] -= dtdx*(pp[i] - pm[i]);

  /* ---- add Powell source term ---- */

    #if (PHYSICS == MHD || PHYSICS == RMHD) && (DIVB_CONTROL == EIGHT_WAVES)
     dBx = (vp[BXn]*A[i] - vm[BXn]*A[i-1])/dV[i];
     EXPAND(rhs[i][BX1] -= dt*state->v[i][VX1]*dBx;  ,
            rhs[i][BX2] -= dt*state->v[i][VX2]*dBx;  ,
            rhs[i][BX3] -= dt*state->v[i][VX3]*dBx;)
    #endif

  /* ---- Extended GLM source term ---- */

    #ifdef GLM_MHD
     #if GLM_EXTENDED == YES
      dBx  = (vp[BXn]*A[i] - vm[BXn]*A[i-1])/dV[i];
      EXPAND(rhs[i][MX1] -= dt*state->v[i][BX1]*dBx;  ,
             rhs[i][MX2] -= dt*state->v[i][BX2]*dBx;  ,
             rhs[i][MX3] -= dt*state->v[i][BX3]*dBx;)
      #if HAVE_ENERGY
       dpsi = (vp[PSI_GLM] - vm[PSI_GLM])/dx[i];
       rhs[i][ENG] -= dt*state->v[i][BXn]*dpsi;
      #endif
     #endif
    #endif
  }
   
/* ------------------------------------------------
       Source terms: geometry
   ------------------------------------------------ */

  #if GEOMETRY == CYLINDRICAL && COMPONENTS == 3
   if (g_dir == IDIR) {
     double vB, vel2, g_2, r_1, *uc;

     for (i = beg; i <= end; i++){
       r_1 = grid[IDIR].r_1[i];
       vc  = state->v[i];
       uc  = u[i];

       vB   = EXPAND(vc[VX1]*vc[BX1], + vc[VX2]*vc[BX2], + vc[VX3]*vc[BX3]);
       vel2 = EXPAND(vc[VX1]*vc[VX1], + vc[VX2]*vc[VX2], + vc[VX3]*vc[VX3]);
       g_2  = 1.0 - vel2;

       rhs[i][iMR] += dt*((uc[MX3]*vc[VX3] - (vc[BX3]*g_2 + vB*vc[VX3])*vc[BX3]))*r_1;

       rhs[i][iMPHI] = -dtdV*(A[i]*A[i]*fp[i][iMPHI] - A[i-1]*A[i-1]*fm[i][iMPHI]);
       rhs[i][iMPHI] *= r_1;

       rhs[i][iBPHI] -= dt*(vc[VX3]*uc[BX1] - uc[BX3]*vc[VX1])*r_1;
     }
   }
  #endif

/* ------------------------------------------------
        Update solution vector to get u(n+1/2)
   ------------------------------------------------ */

  for (i = beg; i <= end; i++) {
    for (nv = NVAR; nv--;  ) uh[i][nv] = u[i][nv] + rhs[i][nv];
  }

/* -------------------------------------------------
     check if U(x_i, n+1/2) has physical meaning.
     Revert to 1st order otherwise.
   ------------------------------------------------- */

  if (ConsToPrim (uh, state->vh, beg, end, state->flag) != 0){
    for (i = beg; i <= end; i++){
      if (state->flag[i] != 0){
        for (nv = NVAR; nv--;   ){
          uh[i][nv]        = u[i][nv];
          state->vh[i][nv] = state->v[i][nv];
          state->vp[i][nv] = state->vm[i][nv] = state->v[i][nv];
        }
        #ifdef STAGGERED_MHD
         state->vp[i][BXn] = state->bn[i];
         state->vm[i][BXn] = state->bn[i-1];
        #endif
      }
    }
  }    

/* ----------------------------------------------------
        evolve interface values accordingly 
   ---------------------------------------------------- */

  for (i = beg; i <= end; i++) {
    vp  = state->vp[i]; 
    vm  = state->vm[i];
    vc  = state->v[i];

    for (nv = NVAR; nv--;    ){
/*
      dvp[nv] = dvm[nv] = state->vh[i][nv] - state->v[i][nv]; 

      P0 = 1.5*vc[nv] - 0.25*(vp[nv] + vm[nv]);
      P1 = vp[nv] - vm[nv];
      P2 = 3.0*(vp[nv] - 2.0*vc[nv] + vm[nv]);

      dvp[nv] += P0 + 0.5*P1 + 0.25*P2 - vc[nv];
      dvm[nv] += P0 - 0.5*P1 + 0.25*P2 - vc[nv];
*/
      P1 = vp[nv] - vm[nv];
      dvp[nv] = dvm[nv] = state->vh[i][nv] - state->v[i][nv]; 
      dvp[nv] += 0.5*P1;
      dvm[nv] -= 0.5*P1;
    }

    #if CHAR_UPWIND == YES
  
     if (lambda_min[i] > 0.0) 
       for (nv = NVAR; nv--;    )  dvm[nv] = 0.0;
     else if (lambda_max[i] < 0.0)
       for (nv = NVAR; nv--;    )  dvp[nv] = 0.0;
        
    #endif

    for (nv = NVAR; nv--;    ){
      vp[nv] = vc[nv] + dvp[nv];
      vm[nv] = vc[nv] + dvm[nv];
    }
  }
  #ifdef STAGGERED_MHD
   for (i = beg-1; i <= end; i++){
     state->vp[i][BXn] = state->vm[i+1][BXn] = state->bn[i];
   }
  #endif

  CheckPrimStates (state->vm, state->vp, state->v, beg, end);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Init	(	double *	v,
		double	x1,
		double	x2,
		double	x3
	)

The Init() function can be used to assign initial conditions as as a function of spatial position.

Parameters

[out]	v	a pointer to a vector of primitive variables
[in]	x1	coordinate point in the 1st dimension
[in]	x2	coordinate point in the 2nd dimension
[in]	x3	coordinate point in the 3rdt dimension

The meaning of x1, x2 and x3 depends on the geometry:

Variable names are accessed by means of an index v[nv], where nv = RHO is density, nv = PRS is pressure, nv = (VX1, VX2, VX3) are the three components of velocity, and so forth.

Definition at line 17 of file init.c.

{
  v[RHO] = 1.0;
  v[VX1] = 0.0;
  v[VX2] = 0.0;
  v[VX3] = 0.0;
  #if HAVE_ENERGY
   v[PRS] = 1.0;
  #endif
  v[TRC] = 0.0;

  #if PHYSICS == MHD || PHYSICS == RMHD

   v[BX1] = 0.0;
   v[BX2] = 0.0;
   v[BX3] = 0.0;

   v[AX1] = 0.0;
   v[AX2] = 0.0;
   v[AX3] = 0.0;

  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Initialize	(	int	argc,
		char *	argv[],
		Data *	data,
		Runtime *	runtime,
		Grid *	grid,
		Cmd_Line *	cmd_line
	)

Initialize computational grid, domain decomposition and memory allocation. Also, set initial conditions and output attributes.

Parameters

[in]	argc	the number of command-line argument passed to the code
[in]	argv	the argument value as a 1D array of char
[in,out]	data	a pointer to the main PLUTO data structure
[in,out]	runtime	a pointer to the Runtime structure
[in]	grid	pointer to an array of Grid structures
[in]	cmd_line	pointer to the Cmd_Line structure

Returns

This function has no return value.

Definition at line 37 of file initialize.c.

{
  int  nprocs, decomp_mode;
  int  i, j, k, idim, nv;
  int  nx, ny, nz, nghost, status;
  int  gsize[DIMENSIONS], lsize[DIMENSIONS];
  int  beg[DIMENSIONS], end[DIMENSIONS];
  int  gbeg[DIMENSIONS], gend[DIMENSIONS];
  int  lbeg[DIMENSIONS], lend[DIMENSIONS];
  int  is_gbeg[DIMENSIONS], is_gend[DIMENSIONS];
  int  ghosts[DIMENSIONS];
  int  periods[DIMENSIONS];
  int  pardim[DIMENSIONS], stagdim[DIMENSIONS];
  int  procs[DIMENSIONS];
  char ini_file[128];
  double scrh, dxmin[3], dxming[3];
  Output *output;
  #ifdef PARALLEL
   MPI_Datatype rgb_type;
   MPI_Datatype Float_Vect_type;
  #endif

/* -- set default input file name -- */

  sprintf (ini_file,"pluto.ini");

/* -- parse command line options -- */

  ParseCmdLineArgs (argc, argv, ini_file, cmd_line);

  #ifdef PARALLEL

/* -- get number of processors -- */

   MPI_Comm_size(MPI_COMM_WORLD, &nprocs);

/* -- read initialization file -- */

   if (prank == 0) RuntimeSetup (runtime, cmd_line, ini_file);
   MPI_Bcast (runtime,  sizeof (struct RUNTIME) , MPI_BYTE, 0, MPI_COMM_WORLD);

/* -- get number of ghost zones and set periodic boundaries -- */

   nghost = GetNghost();
   MPI_Allreduce (&nghost, &idim, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
   nghost = idim;
   
   for (idim = 0; idim < DIMENSIONS; idim++) {
     gsize[idim]   = runtime->npoint[idim];
     ghosts[idim]  = nghost;
     periods[idim] =    (runtime->left_bound[idim] == PERIODIC ? 1:0)
                     || (runtime->left_bound[idim] == SHEARING ? 1:0);
     pardim[idim]  = cmd_line->parallel_dim[idim];
   }

/* -- find parallel decomposition mode and number of processors -- */

   decomp_mode = GetDecompMode(cmd_line, procs);

/* ---- double distributed array descriptor ---- */

/* SetDistributedArray (SZ, type, gsize, periods, stagdim); 
  return args: beg, end, lsize, lbeg, lend, gbeg, gend, is_gbeg, is_gend
*/

   AL_Sz_init (MPI_COMM_WORLD, &SZ);
   AL_Set_type (MPI_DOUBLE, 1, SZ);
   AL_Set_dimensions (DIMENSIONS, SZ);
   AL_Set_global_dim (gsize, SZ);
   AL_Set_ghosts (ghosts, SZ);
   AL_Set_periodic_dim (periods, SZ);
   AL_Set_parallel_dim (pardim, SZ);

   AL_Decompose (SZ, procs, decomp_mode);
   AL_Get_local_dim (SZ, lsize);
   AL_Get_bounds (SZ, beg, end, ghosts, AL_C_INDEXES);
   AL_Get_lbounds (SZ, lbeg, lend, ghosts, AL_C_INDEXES);
   AL_Get_gbounds (SZ, gbeg, gend, ghosts, AL_C_INDEXES);
   AL_Is_boundary (SZ, is_gbeg, is_gend);

/* ---- float distributed array descriptor ---- */

   AL_Sz_init (MPI_COMM_WORLD, &SZ_float);
   AL_Set_type (MPI_FLOAT, 1, SZ_float);
   AL_Set_dimensions (DIMENSIONS, SZ_float);
   AL_Set_global_dim (gsize, SZ_float);
   AL_Set_ghosts (ghosts, SZ_float);
   AL_Set_periodic_dim (periods, SZ_float);
   AL_Set_parallel_dim (pardim, SZ_float);

   AL_Decompose (SZ_float, procs, decomp_mode);
   AL_Get_local_dim (SZ_float, lsize);
   AL_Get_bounds (SZ_float, beg, end, ghosts, AL_C_INDEXES);
   AL_Get_lbounds (SZ_float, lbeg, lend, ghosts, AL_C_INDEXES);
   AL_Get_gbounds (SZ_float, gbeg, gend, ghosts, AL_C_INDEXES);
   AL_Is_boundary (SZ_float, is_gbeg, is_gend);

/* ---- char distributed array descriptor ---- */

   AL_Sz_init (MPI_COMM_WORLD, &SZ_char);
   AL_Set_type (MPI_CHAR, 1, SZ_char);
   AL_Set_dimensions (DIMENSIONS, SZ_char);
   AL_Set_global_dim (gsize, SZ_char);
   AL_Set_ghosts (ghosts, SZ_char);
   AL_Set_periodic_dim (periods, SZ_char);
   AL_Set_parallel_dim (pardim, SZ_char);

   AL_Decompose (SZ_char, procs, decomp_mode);
   AL_Get_local_dim (SZ_char, lsize);
   AL_Get_bounds (SZ_char, beg, end, ghosts, AL_C_INDEXES);
   AL_Get_lbounds (SZ_char, lbeg, lend, ghosts, AL_C_INDEXES);
   AL_Get_gbounds (SZ_char, gbeg, gend, ghosts, AL_C_INDEXES);
   AL_Is_boundary (SZ_char, is_gbeg, is_gend);

/* ---- Float_Vec distributed array descriptor ---- */

   MPI_Type_contiguous (3, MPI_FLOAT, &Float_Vect_type);
   MPI_Type_commit (&Float_Vect_type);
 
   AL_Sz_init (MPI_COMM_WORLD, &SZ_Float_Vect);
   AL_Set_type (MPI_FLOAT, 3, SZ_Float_Vect);
   AL_Set_dimensions (DIMENSIONS, SZ_Float_Vect);
   AL_Set_global_dim (gsize, SZ_Float_Vect);
   AL_Set_ghosts (ghosts, SZ_Float_Vect);
   AL_Set_periodic_dim (periods, SZ_Float_Vect);
   AL_Set_parallel_dim (pardim, SZ_Float_Vect);

   AL_Decompose (SZ_Float_Vect, procs, decomp_mode);
   AL_Get_local_dim (SZ_Float_Vect, lsize);
   AL_Get_bounds  (SZ_Float_Vect, beg, end, ghosts, AL_C_INDEXES);
   AL_Get_lbounds (SZ_Float_Vect, lbeg, lend, ghosts, AL_C_INDEXES);
   AL_Get_gbounds (SZ_Float_Vect, gbeg, gend, ghosts, AL_C_INDEXES);
   AL_Is_boundary (SZ_Float_Vect, is_gbeg, is_gend);

   for (idim = 0; idim < DIMENSIONS; idim++) {
     grid[idim].nghost      = nghost;
     grid[idim].np_tot      = lsize[idim] + 2*ghosts[idim];
     grid[idim].np_int      = lsize[idim];
     grid[idim].np_tot_glob = runtime->npoint[idim] + 2*ghosts[idim];
     grid[idim].np_int_glob = runtime->npoint[idim];
     grid[idim].beg         = beg[idim];
     grid[idim].end         = end[idim];
     grid[idim].gbeg        = gbeg[idim];
     grid[idim].gend        = gend[idim];
     grid[idim].lbeg        = lbeg[idim];
     grid[idim].lend        = lend[idim];
     grid[idim].lbound = runtime->left_bound[idim]*is_gbeg[idim];
     grid[idim].rbound = runtime->right_bound[idim]*is_gend[idim];
     grid[idim].nproc  = procs[idim];
   }

/* -- Find total number of processors & decomposition mode -- */

/*    AL_Get_size(SZ, &nprocs);  Replaced by MPI_Comm_size above */

   #ifdef STAGGERED_MHD

/* ---- x-staggered array descriptor (double) ---- */

    #if DIMENSIONS >= 1
     D_EXPAND(stagdim[IDIR] = AL_TRUE;  ,
              stagdim[JDIR] = AL_FALSE; , 
              stagdim[KDIR] = AL_FALSE;)

     DIM_LOOP(idim) gsize[idim] = runtime->npoint[idim];
     gsize[IDIR] += 1;

     #ifdef SHEARINGBOX
      periods[IDIR] = 0;
     #endif

     AL_Sz_init (MPI_COMM_WORLD, &SZ_stagx);
     AL_Set_type (MPI_DOUBLE, 1, SZ_stagx);
     AL_Set_dimensions (DIMENSIONS, SZ_stagx);
     AL_Set_global_dim (gsize, SZ_stagx);
     AL_Set_ghosts (ghosts, SZ_stagx);
     AL_Set_staggered_dim(stagdim, SZ_stagx);
     AL_Set_periodic_dim (periods, SZ_stagx);
     AL_Set_parallel_dim (pardim, SZ_stagx);

     AL_Decompose (SZ_stagx, procs, decomp_mode);
     AL_Get_local_dim (SZ_stagx, lsize);
     AL_Get_bounds (SZ_stagx, beg, end, ghosts, AL_C_INDEXES);
     AL_Get_lbounds (SZ_stagx, lbeg, lend, ghosts, AL_C_INDEXES);
     AL_Get_gbounds (SZ_stagx, gbeg, gend, ghosts, AL_C_INDEXES);
     AL_Is_boundary (SZ_stagx, is_gbeg, is_gend);

     #ifdef SHEARINGBOX
      periods[IDIR] = 1;
     #endif
    #endif

    #if DIMENSIONS >= 2
     D_EXPAND(stagdim[IDIR] = AL_FALSE;  ,
              stagdim[JDIR] = AL_TRUE;   , 
              stagdim[KDIR] = AL_FALSE;)

     DIM_LOOP(idim) gsize[idim] = runtime->npoint[idim];
     gsize[JDIR] += 1;

     AL_Sz_init (MPI_COMM_WORLD, &SZ_stagy);
     AL_Set_type (MPI_DOUBLE, 1, SZ_stagy);
     AL_Set_dimensions (DIMENSIONS, SZ_stagy);
     AL_Set_global_dim (gsize, SZ_stagy);
     AL_Set_ghosts (ghosts, SZ_stagy);
     AL_Set_staggered_dim(stagdim, SZ_stagy);
     AL_Set_periodic_dim (periods, SZ_stagy);
     AL_Set_parallel_dim (pardim, SZ_stagy);

     AL_Decompose (SZ_stagy, procs, decomp_mode);
     AL_Get_local_dim (SZ_stagy, lsize);
     AL_Get_bounds  (SZ_stagy, beg, end, ghosts, AL_C_INDEXES);
     AL_Get_lbounds (SZ_stagy, lbeg, lend, ghosts, AL_C_INDEXES);
     AL_Get_gbounds (SZ_stagy, gbeg, gend, ghosts, AL_C_INDEXES);
     AL_Is_boundary (SZ_stagy, is_gbeg, is_gend);
    #endif

    #if DIMENSIONS == 3
     D_EXPAND(stagdim[IDIR] = AL_FALSE;  ,
              stagdim[JDIR] = AL_FALSE;  , 
              stagdim[KDIR] = AL_TRUE;)

     DIM_LOOP(idim) gsize[idim] = runtime->npoint[idim];
     gsize[KDIR] += 1;

     AL_Sz_init (MPI_COMM_WORLD, &SZ_stagz);
     AL_Set_type (MPI_DOUBLE, 1, SZ_stagz);
     AL_Set_dimensions (DIMENSIONS, SZ_stagz);
     AL_Set_global_dim (gsize, SZ_stagz);
     AL_Set_ghosts (ghosts, SZ_stagz);
     AL_Set_staggered_dim(stagdim, SZ_stagz);
     AL_Set_periodic_dim (periods, SZ_stagz);
     AL_Set_parallel_dim (pardim, SZ_stagz);

     AL_Decompose (SZ_stagz, procs, decomp_mode);
     AL_Get_local_dim (SZ_stagz, lsize);
     AL_Get_bounds  (SZ_stagz, beg, end, ghosts, AL_C_INDEXES);
     AL_Get_lbounds (SZ_stagz, lbeg, lend, ghosts, AL_C_INDEXES);
     AL_Get_gbounds (SZ_stagz, gbeg, gend, ghosts, AL_C_INDEXES);
     AL_Is_boundary (SZ_stagz, is_gbeg, is_gend);
    #endif

   #endif /* STAGGERED_MHD */

  /* -- find processors coordinates in a Cartesian topology -- */

  {
    int coords[3] = {0,0,0};
    int rank;
    MPI_Comm cartcomm;
    AL_Get_cart_comm(SZ, &cartcomm);
    MPI_Cart_get(cartcomm, DIMENSIONS, procs, periods, coords);
    MPI_Cart_rank(cartcomm, coords, &rank);
    if (rank != prank) {
      printf ("! Initialize: rank and prank are different\n");
      QUIT_PLUTO(1);
    }
    for (idim = 0; idim < DIMENSIONS; idim++) {
      grid[idim].rank_coord = coords[idim];
    }
  }

  #else  /* if NOT PARALLEL */

/* -----------------------------------------------------
               Serial Initialization
   ----------------------------------------------------- */

   RuntimeSetup (runtime, cmd_line, ini_file);
   nghost = GetNghost();

   for (idim = 0; idim < DIMENSIONS; idim++) {
     grid[idim].nghost  = nghost;
     grid[idim].np_int  = grid[idim].np_int_glob = runtime->npoint[idim];
     grid[idim].np_tot  = grid[idim].np_tot_glob = runtime->npoint[idim] + 2*nghost;
     grid[idim].beg     = grid[idim].gbeg = grid[idim].lbeg = nghost;
     grid[idim].end     = grid[idim].gend = grid[idim].lend 
                        = (grid[idim].lbeg - 1) + grid[idim].np_int;
     grid[idim].lbound  = runtime->left_bound[idim];
     grid[idim].rbound  = runtime->right_bound[idim];
     grid[idim].nproc   = 1;
   }
   nprocs = 1;

  #endif

  RuntimeSet (runtime);

/* ----------------------------------------------------
    Set output directory and log file
   ---------------------------------------------------- */

  SetLogFile  (runtime->output_dir, cmd_line);
  ShowConfig  (argc, argv, ini_file);

/* ---------------------------------------------------
                Grid Generation
   --------------------------------------------------- */

  print1 ("\n> Generating grid...\n\n");
  SetGrid (runtime, grid);
  Where (-1, grid);     /* -- store grid inside the "Where" 
                              function for subsequent calls -- */
  if (cmd_line->makegrid == YES) {
    print1 ("\n> Done < \n");
    QUIT_PLUTO(0);
  }

/* ------------------------------------------------
     Initialize global variables
   ------------------------------------------------ */

  g_dt             = runtime->first_dt;
  g_time           = 0.0;
  g_maxMach        = 0.0;
  g_maxRiemannIter = 0;
  g_usedMemory     = 0;

  IBEG = grid[IDIR].lbeg; IEND = grid[IDIR].lend;
  JBEG = grid[JDIR].lbeg; JEND = grid[JDIR].lend;
  KBEG = grid[KDIR].lbeg; KEND = grid[KDIR].lend;

  NX1 = grid[IDIR].np_int;
  NX2 = grid[JDIR].np_int;
  NX3 = grid[KDIR].np_int;

  NX1_TOT = grid[IDIR].np_tot; 
  NX2_TOT = grid[JDIR].np_tot;
  NX3_TOT = grid[KDIR].np_tot;

/* ---------------------------------------
     Get the maximum number of points 
     among all directions
   --------------------------------------- */

  NMAX_POINT = MAX(NX1_TOT, NX2_TOT);
  NMAX_POINT = MAX(NMAX_POINT, NX3_TOT);

/* ---------------------------------------------
    Define the RBox structures.
   --------------------------------------------- */

  SetRBox();

/* --------------------------------------------------------------------
     Find the minimum physical cell length for each direction
   -------------------------------------------------------------------- */

  for (idim = 0; idim < DIMENSIONS; idim++)  dxmin[idim] = 1.e30;

  for (i = IBEG; i <= IEND; i++) {
  for (j = JBEG; j <= JEND; j++) {
  for (k = KBEG; k <= KEND; k++) {

    scrh = Length_1(i, j, k, grid);
    dxmin[IDIR] = MIN (dxmin[IDIR], scrh);

    scrh = Length_2(i, j, k, grid);
    dxmin[JDIR] = MIN (dxmin[JDIR], scrh);
 
    scrh = Length_3(i, j, k, grid); 
    dxmin[KDIR] = MIN (dxmin[KDIR], scrh);
     
  }}}

  #ifdef PARALLEL
   MPI_Allreduce (dxmin, dxming, 3, MPI_DOUBLE, MPI_MIN, MPI_COMM_WORLD);
   dxmin[IDIR] = dxming[IDIR];
   dxmin[JDIR] = dxming[JDIR];
   dxmin[KDIR] = dxming[KDIR];
  #endif

  grid[IDIR].dl_min = dxmin[IDIR];
  grid[JDIR].dl_min = dxmin[JDIR];
  grid[KDIR].dl_min = dxmin[KDIR];

/* --------------------------------------------------------------
    Define geometrical coefficients for linear interpolation
   -------------------------------------------------------------- */
   
  PLM_CoefficientsSet (grid);   /* -- these may be needed by
                                      shock flattening algorithms */
  #if RECONSTRUCTION == PARABOLIC
   PPM_CoefficientsSet (grid);  
  #endif

/* --------------------------------------------------------------
    Copy user defined parameters into global array g_inputParam 
   -------------------------------------------------------------- */

  for (nv = 0; nv < USER_DEF_PARAMETERS; nv++) g_inputParam[nv] = runtime->aux[nv];

/* ------------------------------------------------------------
          Allocate memory for 3D data arrays
   ------------------------------------------------------------ */

  print1 ("\n> Memory allocation\n");
  data->Vc = ARRAY_4D(NVAR, NX3_TOT, NX2_TOT, NX1_TOT, double);
  data->Uc = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double); 

  #ifdef STAGGERED_MHD
   data->Vs = ARRAY_1D(DIMENSIONS, double ***);
   D_EXPAND(
     data->Vs[BX1s] = ArrayBox( 0, NX3_TOT-1, 0, NX2_TOT-1,-1, NX1_TOT-1); ,
     data->Vs[BX2s] = ArrayBox( 0, NX3_TOT-1,-1, NX2_TOT-1, 0, NX1_TOT-1); ,
     data->Vs[BX3s] = ArrayBox(-1, NX3_TOT-1, 0, NX2_TOT-1, 0, NX1_TOT-1);)
  #endif  

  #if UPDATE_VECTOR_POTENTIAL == YES 
   D_EXPAND(                                                  ,
     data->Ax3 = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, double);  , 
     data->Ax1 = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, double);  
     data->Ax2 = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, double);  
   )
  #endif

  #if RESISTIVITY != NO
   data->J = ARRAY_4D(3,NX3_TOT, NX2_TOT, NX1_TOT, double);
  #endif

  data->flag = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, unsigned char);

/* ------------------------------------------------------------
    Initialize tables needed for EOS 
   ------------------------------------------------------------ */
  
  #if EOS == PVTE_LAW && NIONS == 0
   #if TV_ENERGY_TABLE == YES
    MakeInternalEnergyTable();
   #else
    MakeEV_TemperatureTable();
   #endif
   MakePV_TemperatureTable();
  #endif

/* ------------------------------------------------------------
              Assign initial conditions
   ------------------------------------------------------------ */

  Startup (data, grid);

/* ------------------------------------------------------------ 
    Set output attributes (names, images, number of outputs...)
   ------------------------------------------------------------ */

  SetOutput (data, runtime);

/* -----------------------------------
      print normalization units
   ----------------------------------- */

  ShowUnits();  

  print1 ("> Number of processors: %d\n",nprocs);
  D_EXPAND(print1 ("> Typical proc size:    %d",grid[IDIR].np_int);  ,
           print1 (" X %d", grid[JDIR].np_int);                      ,
           print1 (" X %d", grid[KDIR].np_int);)
  print1 ("\n");
  #ifdef PARALLEL
   print1 ("> Parallel Directions: ");
   D_EXPAND(if (pardim[IDIR]) print1 (" X1");  ,
            if (pardim[JDIR]) print1 ("/X2");  ,
            if (pardim[KDIR]) print1 ("/X3");)
   print1 ("\n");
  #endif   
  if (cmd_line->show_dec) ShowDomainDecomposition (nprocs, grid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void InputDataFree

(

void

)

Free memory stored by user-supplied data.

Definition at line 484 of file input_data.c.

{
  int nv;
  for (nv = 0; nv < id_nvar; nv++){
    free ((char *) Vin[nv][0][0]);    
    free ((char *) Vin[nv][0]);
    free ((char *) Vin[nv]);
  }
}

void InputDataInterpolate	(	double *	vs,
		double	x1,
		double	x2,
		double	x3
	)

Perform bi- or tri-linear interpolation on external dataset to compute vs[] at the given point {x1,x2,x3}.

Parameters

[in]	vs	interpolated value
[in]	x1	coordinate point at which at interpolates are desired
[in]	x2	coordinate point at which at interpolates are desired
[in]	x3	coordinate point at which at interpolates are desired

Returns

This function has no return value.

The function performs the following tasks.

• Convert PLUTO coordinates to input grid geometry if necessary.
• Make sure point (x1,x2,x3) does not fall outside input grid range. Limit to input grid edge otherwise.
• Use table lookup by binary search to find the indices il, jl and kl such that grid points of PLUTO fall between [il, il+1], [jl, jl+1], [kl, kl+1].
• Define normalized coordinates between [0,1]:
  • x[il+1] < x1[i] < x[il+1] ==> 0 < xx < 1
  • y[jl+1] < x2[j] < y[jl+1] ==> 0 < yy < 1
  • z[kl+1] < x3[k] < z[kl+1] ==> 0 < zz < 1
• Perform bi- or tri-linear interpolation.

Definition at line 287 of file input_data.c.

{
  int il = 0, jl = 0, kl = 0;
  int ih, jh, kh;
  int im, jm, km;
  int i, j, k, nv, inv;
  double xx, yy, zz;
  double ***V;

/* --------------------------------------------------------------------- */
/*! - Convert PLUTO coordinates to input grid geometry if necessary.     */
/* --------------------------------------------------------------------- */

  #if GEOMETRY == CARTESIAN
   if (id_geom == GEOMETRY) {  

     /* same coordinate system: nothing to do */
     
   }else if (id_geom == CYLINDRICAL) {  
     double R, z, phi;
     R   = sqrt(x1*x1 + x2*x2);
     phi = atan2(x2,x1);
     if (phi < 0.0) phi += 2.0*CONST_PI;
     z   = x3;

     x1 = R; x2 = z; x3 = phi;
   }else if (id_geom == POLAR) {  
     double R, phi, z;
     R   = sqrt(x1*x1 + x2*x2);
     phi = atan2(x2,x1);
     if (phi < 0.0) phi += 2.0*CONST_PI;
     z   = x3;

     x1 = R; x2 = phi; x3 = z;
   }else if (id_geom == SPHERICAL){
     double r, theta, phi;
     r     = D_EXPAND(x1*x1, + x2*x2, + x3*x3);
     r     = sqrt(r);
     theta = acos(x3/r);
     phi   = atan2(x2,x1);
     if (phi   < 0.0) phi   += 2.0*CONST_PI;
     if (theta < 0.0) theta += 2.0*CONST_PI;
     
     x1 = r; x2 = theta; x3 = phi;
   }else{
     print1 ("! InputDataInterpolate: invalid or unsupported coordinate transformation.\n");
     QUIT_PLUTO(1);
   }
  #elif GEOMETRY == CYLINDRICAL
   if (id_geom == GEOMETRY) {  

     /* same coordinate system: nothing to do */
     
   }else if (id_geom == SPHERICAL) {  
     double r, theta, phi;
     r     = D_EXPAND(x1*x1, + x2*x2, + 0.0);
     r     = sqrt(r);
     theta = acos(x2/r);
     phi   = 0.0;
     if (theta < 0.0) theta += 2.0*CONST_PI;
     
     x1 = r; x2 = theta; x3 = phi;
   }else{
     print1 ("! InputDataInterpolate: invalid or unsupported coordinate transformation.\n");
     QUIT_PLUTO(1);
   }
  #elif GEOMETRY == POLAR
   if (id_geom == GEOMETRY) {  

     /* same coordinate system: nothing to do */
     
   }else if (id_geom == CARTESIAN) {  
     double x, y, z;
     x = x1*cos(x2);
     y = x1*sin(x2);
     z = x3;
     
     x1 = x; x2 = y; x3 = z;
   }else{
     print1 ("! InputDataInterpolate: invalid or unsupported coordinate transformation.\n");
     QUIT_PLUTO(1);
   }   
  #elif GEOMETRY == SPHERICAL
   if (id_geom == GEOMETRY) {  

     /* same coordinate system: nothing to do */
     

   }else if (id_geom == CARTESIAN) {  
     double x, y, z;
     x = x1*sin(x2)*cos(x3);
     y = x1*sin(x2)*sin(x3);
     z = x1*cos(x2);
     
     x1 = x; x2 = y; x3 = z;
   }else{
     print1 ("! InputDataInterpolate: invalid or unsupported coordinate transformation.\n");
     QUIT_PLUTO(1);
   }   
  #endif

/* --------------------------------------------------------------------- */
/*! - Make sure point (x1,x2,x3) does not fall outside input grid range. 
      Limit to input grid edge otherwise.                                */
/* --------------------------------------------------------------------- */
   
  D_EXPAND(if      (x1 < id_x1[0])         x1 = id_x1[0];
           else if (x1 > id_x1[id_nx1-1]) x1 = id_x1[id_nx1-1];  ,
           
           if      (x2 < id_x2[0])         x2 = id_x2[0];
           else if (x2 > id_x2[id_nx2-1]) x2 = id_x2[id_nx2-1];  ,
           
           if      (x3 < id_x3[0])         x3 = id_x3[0];
           else if (x3 > id_x3[id_nx3-1]) x3 = id_x3[id_nx3-1]; )

/* --------------------------------------------------------------------- */
/*! - Use table lookup by binary search to  find the indices 
      il, jl and kl such that grid points of PLUTO fall between 
      [il, il+1], [jl, jl+1], [kl, kl+1].                                */
/* --------------------------------------------------------------------- */

  il = 0;
  ih = id_nx1 - 1;
  while (il != (ih-1)){
    im = (il+ih)/2;
    if   (x1 <= id_x1[im]) ih = im;   
    else                    il = im;
  }
  
  if (id_nx2 > 1){
    jl = 0;
    jh = id_nx2 - 1;
    while (jl != (jh-1)){
      jm = (jl+jh)/2;
      if (x2 <= id_x2[jm]) jh = jm;   
      else                  jl = jm;
    }
  }

  if (id_nx3 > 1){
    kl = 0;
    kh = id_nx3 - 1;
    while (kl != (kh - 1)){
      km = (kl+kh)/2;
      if (x3 <= id_x3[km]) kh = km;   
      else                  kl = km;
    }
  }

/* --------------------------------------------------------------------- */
/*! - Define normalized coordinates between [0,1]:
      - x[il+1] < x1[i] < x[il+1] ==> 0 < xx < 1
      - y[jl+1] < x2[j] < y[jl+1] ==> 0 < yy < 1
      - z[kl+1] < x3[k] < z[kl+1] ==> 0 < zz < 1                            */
/* --------------------------------------------------------------------- */

  xx = yy = zz = 0.0; /* initialize normalized coordinates */

  if (id_nx1 > 1) xx = (x1 - id_x1[il])/(id_x1[il+1] - id_x1[il]);  
  if (id_nx2 > 1) yy = (x2 - id_x2[jl])/(id_x2[jl+1] - id_x2[jl]);  
  if (id_nx3 > 1) zz = (x3 - id_x3[kl])/(id_x3[kl+1] - id_x3[kl]);

/* --------------------------------------------------------------------- */
/*! - Perform bi- or tri-linear interpolation.                           */
/* --------------------------------------------------------------------- */

  for (nv = 0; nv < id_nvar; nv++) { 
    inv = id_var_indx[nv];
    V = Vin[nv];
    vs[inv] =   V[kl][jl][il]*(1.0 - xx)*(1.0 - yy)*(1.0 - zz)
              + V[kl][jl][il+1]*xx*(1.0 - yy)*(1.0 - zz);
    if (id_nx2 > 1){
      vs[inv] +=   V[kl][jl+1][il]*(1.0 - xx)*yy*(1.0 - zz)
                 + V[kl][jl+1][il+1]*xx*yy*(1.0 - zz);
    }
    if (id_nx3 > 1){
     vs[inv] +=   V[kl+1][jl][il]*(1.0 - xx)*(1.0 - yy)*zz
                + V[kl+1][jl][il+1]*xx*(1.0 - yy)*zz
                + V[kl+1][jl+1][il]*(1.0 - xx)*yy*zz
                + V[kl+1][jl+1][il+1]*xx*yy*zz;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void InputDataRead	(	char *	data_fname,
		char *	endianity
	)

Read input data file and store the contents into the local storage array Vin. Memory allocation is also done here. The grid size and number of variables must have previously set by calling InputDataSet().

Parameters

[in]	data_fname	the data file name
[in]	endianity	an input string ("little" or "big") giving the byte-order of how the input data file was originally written. If an empty string is supplied, no change is made.

Returns

This function has no return value.

Definition at line 191 of file input_data.c.

{
  int   i, j, k, nv, swap_endian=NO;
  size_t dsize, dcount;
  double udbl;
  float  uflt;
  char   ext[] = "   ";
  FILE *fp;

/* ----------------------------------------------------
             Check endianity 
   ---------------------------------------------------- */
  
  if ( (!strcmp(endianity,"big")    &&  IsLittleEndian()) ||
       (!strcmp(endianity,"little") && !IsLittleEndian())) {
    swap_endian = YES;
  }
  
  print1 ("  Input data file:       %s (endianity: %s) \n", 
           data_fname, endianity);
  
/* ------------------------------------------------------
    Get data type from file extensions (dbl or flt).
   ------------------------------------------------------ */

  dcount = strlen(data_fname);
  for (i = 0; i < 3; i++) ext[i] = data_fname[dcount-3+i];

  if (!strcmp(ext,"dbl")){
    print1 ("  Precision:             (double)\n");
    dsize = sizeof(double);
  } else if (!strcmp(ext,"flt")) {
    print1 ("  Precision:\t\t  (single)\n");
    dsize = sizeof(float);
  } else {
    print1 ("! InputDataRead: unsupported data type '%s'\n",ext);
    QUIT_PLUTO(1);
  }
  
/* -------------------------------------------------------
     Read and store data values
   ------------------------------------------------------- */

  fp = fopen(data_fname, "rb");
  if (fp == NULL){
    print1 ("! InputDataRead: file %s does not exist\n");
    QUIT_PLUTO(1);
  }
  for (nv = 0; nv < id_nvar; nv++){
    if (Vin[nv] == NULL) Vin[nv] = ARRAY_3D(id_nx3, id_nx2, id_nx1, double);

    dcount  = 1;

    if (dsize == sizeof(double)){
      for (k = 0; k < id_nx3; k++){ 
      for (j = 0; j < id_nx2; j++){
      for (i = 0; i < id_nx1; i++){
        if (fread (&udbl, dsize, dcount, fp) != dcount){
          print1 ("! InputDataRead: error reading data %d.\n",nv);
          break;
        }
        if (swap_endian) SWAP_VAR(udbl);
        Vin[nv][k][j][i] = udbl;
      }}}
    }else{
      for (k = 0; k < id_nx3; k++){ 
      for (j = 0; j < id_nx2; j++){
      for (i = 0; i < id_nx1; i++){
        if (fread (&uflt, dsize, dcount, fp) != dcount){
          print1 ("! InputDataRead: error reading data %d.\n",nv);
          break;
        }
        if (swap_endian) SWAP_VAR(uflt);
        Vin[nv][k][j][i] = uflt;
      }}}
    }
  }
  fclose(fp);
  print1 ("\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void InputDataSet	(	char *	grid_fname,
		int *	get_var
	)

Initialize access to input data file by assigning values to grid-related information (geometry, number of points, etc...). This function should be called just once for input-data initialization.

Parameters

[in]	gname	the grid file name
[in]	get_var	an array of integers specifying which variables have to be read from the input data.

Returns

Thi function has no return value.

The following tasks are performed.

• Scan grid data file and try to determine the grid geometry (id_geom). Search for tag "GEOMETRY:" and read the word that follows.
• Move file pointer until the first line that does not begin with a "#".
• Start reading number of points and grid coordinates. For the input x1 direction these are stored inside the module variables id_nx1 and id_x1.
• Find out how many and which variables we have to read (:id_nvar and id_var_indx). Stop counting variables as soon as the first occurrence of "-1" in get_var is encountered

Definition at line 54 of file input_data.c.

{
  int    i, ip, nv, success;
  size_t dsize, dcount;
  char *sub_str, sline[256];
  const char delimiters[] = " \t\r\f\n";
  double xl, xr;
  fpos_t file_pos;
  FILE *fp;

  print1 ("> Input data:\n\n");

/* --------------------------------------------------------------------- */
/*! - Scan grid data file and try to determine the grid geometry 
      (::id_geom). Search for tag "GEOMETRY:" and read the word that
      follows.                                                           */
/* --------------------------------------------------------------------- */

  fp = fopen(grid_fname,"r");
  if (fp == NULL){
    print1 ("! InputDataSet: grid file %s not found\n",grid_fname);
    QUIT_PLUTO(1);
  }
  success = 0;
  while(!success){
    fgets(sline,512,fp);
    sub_str = strtok(sline, delimiters);
    while (sub_str != NULL){
      if (!strcmp(sub_str,"GEOMETRY:")) {
        sub_str = strtok(NULL, delimiters);     
        success = 1;
        break;
      }
      sub_str = strtok(NULL, delimiters);     
    }  
  }
  
  if      (!strcmp(sub_str,"CARTESIAN"))   id_geom = CARTESIAN;
  else if (!strcmp(sub_str,"CYLINDRICAL")) id_geom = CYLINDRICAL;
  else if (!strcmp(sub_str,"POLAR"))       id_geom = POLAR;
  else if (!strcmp(sub_str,"SPHERICAL"))   id_geom = SPHERICAL;
  else{
    print1 ("! InputDataSet: unknown geometry\n");
    QUIT_PLUTO(1);
  }
    
  print1 ("  Input grid file:       %s\n", grid_fname);
  print1 ("  Input grid geometry:   %s\n", sub_str);

/* --------------------------------------------------------------------- */
/*! - Move file pointer until the first line that does not
      begin with a "#".                                                  */
/* --------------------------------------------------------------------- */

  success = 0;
  while(!success){
    fgetpos(fp, &file_pos);
    fgets(sline,512,fp);
    if (sline[0] != '#') success = 1;
  }

  fsetpos(fp, &file_pos);
  
/* --------------------------------------------------------------------- */
/*! - Start reading number of points and grid coordinates. For the
      input x1 direction these are stored inside the module variables
      ::id_nx1 and ::id_x1.                                              */
/* --------------------------------------------------------------------- */
   
  fscanf (fp,"%d \n",&id_nx1);
  id_x1 = ARRAY_1D(id_nx1, double);
  for (i = 0; i < id_nx1; i++){
    fscanf(fp,"%d  %lf %lf\n", &ip, &xl, &xr);
    id_x1[i] = 0.5*(xl + xr);
  }

  fscanf (fp,"%d \n",&id_nx2);
  id_x2 = ARRAY_1D(id_nx2, double);
  for (i = 0; i < id_nx2; i++){
    fscanf(fp,"%d  %lf %lf\n", &ip, &xl, &xr);
    id_x2[i] = 0.5*(xl + xr);
  }

  fscanf (fp,"%d \n",&id_nx3);
  id_x3 = ARRAY_1D(id_nx3, double);
  for (i = 0; i < id_nx3; i++){
    fscanf(fp,"%d  %lf %lf\n", &ip, &xl, &xr);
    id_x3[i] = 0.5*(xl + xr);
  }
  fclose(fp);

/* -- reset grid with 1 point -- */

  if (id_nx1 == 1) id_x1[0] = 0.0;
  if (id_nx2 == 1) id_x2[0] = 0.0;
  if (id_nx3 == 1) id_x3[0] = 0.0;
 
  print1 ("  Input grid extension:  x1 = [%12.3e, %12.3e] (%d points)\n",
             id_x1[0], id_x1[id_nx1-1], id_nx1);
  print1 ("\t\t\t x2 = [%12.3e, %12.3e] (%d points)\n",
             id_x2[0], id_x2[id_nx2-1], id_nx2);
  print1 ("\t\t\t x3 = [%12.3e, %12.3e] (%d points)\n",
             id_x3[0], id_x3[id_nx3-1], id_nx3);

  
/* --------------------------------------------------------------------- */
/*! - Find out how many and which variables we have to read (:id_nvar 
      and ::id_var_indx). 
      Stop counting variables as soon as the first occurrence of "-1" 
      in get_var is encountered                                          */
/* --------------------------------------------------------------------- */
   
  id_nvar = 0;
  for (nv = 0; nv < ID_MAX_NVAR; nv++){
    if (get_var[nv] != -1) {
      id_nvar++;
      id_var_indx[nv] = get_var[nv];
    }else{
      break;
    }
  }
  print1 ("  Number of variables:   %d\n",id_nvar);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void InternalBoundaryReset	(	const State_1D *	,
		Time_Step *	,
		int	,
		int	,
		Grid *
	)

Here is the caller graph for this function:

int IsLittleEndian

(

void

)

Return 1 if the current architecture has little endian order

Definition at line 40 of file tools.c.

{
  int TestEndian = 1;
  return *(char*)&TestEndian;
}

Here is the caller graph for this function:

double Length_1	(	int	i,
		int	j,
		int	k,
		Grid *
	)

Definition at line 156 of file set_geometry.c.

{
  return (grid[0].dx[i]);
}

Here is the caller graph for this function:

double Length_2	(	int	i,
		int	j,
		int	k,
		Grid *
	)

Definition at line 169 of file set_geometry.c.

{
  #if GEOMETRY == CARTESIAN || GEOMETRY == CYLINDRICAL
   return (grid[1].dx[j]);
  #elif GEOMETRY == POLAR ||  GEOMETRY == SPHERICAL
   return (fabs(grid[0].xgc[i])*grid[1].dx[j]);
  #endif
}

Here is the caller graph for this function:

double Length_3	(	int	i,
		int	j,
		int	k,
		Grid *
	)

Definition at line 186 of file set_geometry.c.

{
  #if GEOMETRY == CARTESIAN || GEOMETRY == POLAR
   return (grid[2].dx[k]);
  #elif GEOMETRY == CYLINDRICAL
   return (fabs(grid[0].xgc[i])*grid[2].dx[k]);
  #elif GEOMETRY == SPHERICAL
   return (fabs(grid[0].xgc[i]*sin(grid[1].xgc[j]))*grid[2].dx[k]);
  #endif
}

Here is the caller graph for this function:

int LocateIndex	(	double *	yarr,
		int	beg,
		int	end,
		double	y
	)

Given an array yarr[beg..end] and a given value y, returns the array index i such that yarr[i] < y < yarr[i+1] (for increasing arrays) or yarr[i+1] < y < yarr[i] (for decreasing arrays). yarr must be monotonically increasing or monotonically decreasing.

Parameters

[in]	yarr	the 1D array
[in]	beg	initial index of the array
[in]	end	final index of the array
[in]	y	the value to be searched for

Returns

On success return the index of the array. Otherwise returns -1.

Reference

• "Numerical Recipes in C", Sect. 3.4 "How to Search an Ordered Table"

Definition at line 144 of file math_table2D.c.

{
  int iu,im,il, ascnd;
  
  ascnd = (yarr[end] >= yarr[beg]);  /* ascnd = 1 if table is increasing */

/* --------------------------------------------
    Check if y is bounded between max and min 
   -------------------------------------------- */
   
  if ( (ascnd  && (y < yarr[beg] || y > yarr[end])) ||
       (!ascnd && (y > yarr[beg] || y < yarr[end]))){
/*    print ("! LocatIndex: element outside range ");
    print ("(%12.6e not in [%12.6e, %12.6e]\n",y,yarr[beg],yarr[end]);*/
    return -1;
  }
  
  il = beg;  /*  Initialize lower   */
  iu = end;  /*  and upper limits.  */

  while ( (iu - il) > 1) {     
    im = (iu + il) >> 1;      /* Compute midpoint */
    if ((y >= yarr[im]) == ascnd) il = im;  /* Replace lower limit   */
    else                          iu = im;  /* or upper limit        */
  }  
  if      (y == yarr[beg]) return beg;
  else if (y == yarr[end]) return end;
  else                     return il;    
}

Here is the caller graph for this function:

void MakeGeometry

(

Grid *

GXYZ

)

Parameters

[in,out]

GXYZ

Pointer to an array of Grid structures;

Definition at line 16 of file set_geometry.c.

{
  int     i, j, k, idim, ngh, ileft;
  int     iright;
  int     iend, jend, kend;
  double  xiL, xiR, dxi, dvol;
  double  x, dx, xr, xl;
  double  y, dy, yr, yl;
  struct  GRID *GG;

  iend = GXYZ[0].lend + GXYZ[0].nghost;
  jend = GXYZ[1].lend + GXYZ[1].nghost;
  kend = GXYZ[2].lend + GXYZ[2].nghost;

/*  --------------------------------------------------------------
     Memory allocation. All values are defined at the cell center 
     with the exception of the area element which is defined on a
     staggered mesh and therefore starts at [-1].
    ----------------------------------------------------------- */

  for (idim = 0; idim < 3; idim++) {
    (GXYZ + idim)->A       = ARRAY_1D (GXYZ[idim].np_tot+1, double)+1;
    (GXYZ + idim)->xgc     = ARRAY_1D (GXYZ[idim].np_tot, double);
    (GXYZ + idim)->dV      = ARRAY_1D (GXYZ[idim].np_tot, double);
    (GXYZ + idim)->r_1     = ARRAY_1D (GXYZ[idim].np_tot, double);
    (GXYZ + idim)->ct      = ARRAY_1D (GXYZ[idim].np_tot, double);
    (GXYZ + idim)->inv_dx  = ARRAY_1D (GXYZ[idim].np_tot, double);
    (GXYZ + idim)->inv_dxi = ARRAY_1D (GXYZ[idim].np_tot, double);
  }

/* ------------------------------------------------------------
    Define area (A), volume element (dV) and cell geometrical
    centers for each direction.
    
    Conventions:
    - G->dx: spacing (always > 0)
    - G->x:  cell-center. Can be > 0 or < 0
    - G->xgc: geometrical cell center.
    ----------------------------------------------------------- */  

/* ------------------------------------------------------------
                     X1 (IDIR) Direction
   ------------------------------------------------------------ */
 
  GG = GXYZ;
  for (i = 0; i <= iend; i++) {

    dx  = GG->dx[i];
    x   = GG->x[i];
    xr  = x + 0.5*dx;
    xl  = x - 0.5*dx;

    #if GEOMETRY == CARTESIAN
     GG->A[i]    = 1.0;
     if (i == 0) GG->A[-1] = 1.0;
     GG->dV[i]  = dx;
     GG->xgc[i] = x;
    #elif GEOMETRY == CYLINDRICAL || GEOMETRY == POLAR
     GG->A[i]   = fabs(xr); 
     if (i == 0) GG->A[-1] = fabs(xl);
     GG->dV[i]  = fabs(x)*dx;
     GG->xgc[i] = x + dx*dx/(12.0*x); 
     GG->r_1[i] = 1.0/x;
    #elif GEOMETRY == SPHERICAL
     GG->A[i]   = xr*xr;
     if (i == 0) GG->A[-1] = xl*xl;

     GG->dV[i]  = fabs(xr*xr*xr - xl*xl*xl)/3.0;
     GG->xgc[i] = x + 2.0*x*dx*dx/(12.0*x*x + dx*dx);
     GG->r_1[i] = 1.0/x;
    #endif
  }

/* ------------------------------------------------------------
                    X2 (JDIR) Direction
   ------------------------------------------------------------ */

  GG = GXYZ + 1;
  for (j = 0; j <= jend; j++) {

    dx  = GG->dx[j];
    x   = GG->x[j];
    xr  = x + 0.5*dx;
    xl  = x - 0.5*dx;
    #if GEOMETRY != SPHERICAL
     GG->A[j]   = 1.0;
     if (j == 0) GG->A[-1] = 1.0;
     GG->dV[j]  = dx;    
     GG->xgc[j] = x;
    
    #else
     GG->A[j]   = fabs(sin(xr));
     if (j == 0) GG->A[-1] = fabs(sin(xl));
     GG->dV[j]  = fabs(cos(xl) - cos(xr));

     GG->xgc[j]  = (sin(xr) - sin(xl) + xl*cos(xl) - xr*cos(xr));
     GG->xgc[j] /= cos(xl) - cos(xr);
     GG->ct[j]   = 1.0/tan(x);  /* (sin(xr) - sin(xl))/(cos(xl) - cos(xr)); */
    #endif
  }

/* ------------------------------------------------------------
                    X3 (KDIR) Direction
   ------------------------------------------------------------ */
  
  GG = GXYZ + 2;
  for (k = 0; k <= kend; k++) {
    dx  = GG->dx[k];
    x   = GG->x[k];
    xr  = x + 0.5*dx;
    xl  = x - 0.5*dx;

    GG->A[k]   = 1.0;
    if (k == 0) GG->A[-1] = 1.0;
    GG->dV[k]  = dx;
    GG->xgc[k] = x;
  }

/* ---------------------------------------------------------
    compute and store the reciprocal of cell spacing
    between interfaces (inv_dx) and cell centers (inv_dxi)
   --------------------------------------------------------- */

  for (idim = 0; idim < DIMENSIONS; idim++){
    for (i = 0; i < GXYZ[idim].np_tot; i++) {
      GXYZ[idim].inv_dx[i] = 1.0/(GXYZ[idim].dx[i]);
    }

    for (i = 0; i < GXYZ[idim].np_tot-1; i++) {
      GXYZ[idim].inv_dxi[i] = 2.0/(GXYZ[idim].dx[i] + GXYZ[idim].dx[i+1]);
    }
  }  
}

Here is the caller graph for this function:

void MakeState

(

State_1D *

state

)

Allocate memory areas for arrays inside the state structure.

Definition at line 51 of file tools.c.

{
  state->v       = ARRAY_2D(NMAX_POINT, NVAR, double);
  state->vp      = ARRAY_2D(NMAX_POINT, NVAR, double);
  state->vm      = ARRAY_2D(NMAX_POINT, NVAR, double);
  state->up      = ARRAY_2D(NMAX_POINT, NVAR, double);
  state->um      = ARRAY_2D(NMAX_POINT, NVAR, double);
  state->flux    = ARRAY_2D(NMAX_POINT, NVAR, double);

  state->src     = ARRAY_2D(NMAX_POINT, NVAR, double);

  state->visc_flux = ARRAY_2D(NMAX_POINT, NVAR, double);
  state->visc_src  = ARRAY_2D(NMAX_POINT, NVAR, double);
  state->tc_flux   = ARRAY_2D(NMAX_POINT, NVAR, double);    
  state->res_flux  = ARRAY_2D(NMAX_POINT, NVAR, double); 

  state->rhs     = ARRAY_2D(NMAX_POINT, NVAR, double);
  state->press   = ARRAY_1D(NMAX_POINT, double);
  state->bn      = ARRAY_1D(NMAX_POINT, double);
  state->SL      = ARRAY_1D(NMAX_POINT, double);
  state->SR      = ARRAY_1D(NMAX_POINT, double);

/* -- eigenvectors -- */

  state->Lp      = ARRAY_3D(NMAX_POINT, NFLX, NFLX, double);
  state->Rp      = ARRAY_3D(NMAX_POINT, NFLX, NFLX, double);
  state->lambda  = ARRAY_2D(NMAX_POINT, NFLX, double);
  state->lmax    = ARRAY_1D(NVAR, double);

  state->a2   = ARRAY_1D(NMAX_POINT, double);
  state->h    = ARRAY_1D(NMAX_POINT, double);

/*  state->dwlim   = ARRAY_2D(NMAX_POINT, NVAR, double);*/

  state->flag    = ARRAY_1D(NMAX_POINT, unsigned char);

/* --------------------------------------
     define shortcut pointers for
     left and right values with respect
     to the cell center
   -------------------------------------- */
   
  state->vL = state->vp;
  state->vR = state->vm + 1;

  state->uL = state->up;
  state->uR = state->um + 1;

  #if (TIME_STEPPING == HANCOCK) || (TIME_STEPPING == CHARACTERISTIC_TRACING)
   state->vh = ARRAY_2D(NMAX_POINT, NVAR, double);
  #else
   state->vh = state->v;
  #endif

}

Here is the caller graph for this function:

double MeanMolecularWeight

(

double *

v

)

Return the mean molecular weight.

Parameters

[in]

v

array of primitive variables (including ions)

Definition at line 178 of file radiat.modified_by_Bhargav.c.

{
  int nv;

  for (nv = NFLX;nv <(NFLX+NIONS);nv++){
    if (V[nv] < 0.0) V[nv] = 0.0;
    if (V[nv] > 1.0) V[nv] = 1.0;
  }

  double N_H  = V[RHO]*(UNIT_DENSITY/CONST_amu)*(X/A_H);  /* n(H) */
  double N_He = V[RHO]*(UNIT_DENSITY/CONST_amu)*(Y/A_He); /* n(He) */
  double N_Z  = V[RHO]*(UNIT_DENSITY/CONST_amu)*((1.0-X-Y)/A_Z);  /*/ n(metals) */

  double fracHe = N_He/N_H;
  double fracZ = N_Z/N_H;
  
  double fn = V[X_HI];
 
  double munum = 1.0 + A_He*(fracHe) + A_Z*(fracZ);
  double muden = 2 - fn + fracHe + fracZ + 0.5*A_Z*(fracZ);

  return munum/muden;


  /*
  return  ( (A_H + frac_He*A_He + frac_Z*A_Z) /
         (2.0 + frac_He + 2.0*frac_Z - V[X_HI]));
  */
}

Here is the call graph for this function:

Here is the caller graph for this function:

double Median	(	double	a,
		double	b,
		double	c
	)

Definition at line 264 of file fd_reconstruct.c.

{
  return (a + MINMOD(b-a,c-a));
}

Here is the caller graph for this function:

FILE* OpenBinaryFile	(	char *	filename,
		int	sz,
		char *	mode
	)

Open a file for write/reading in binary mode.

Parameters

[in]	filename	a valid file name
[in]	sz	the distributed array descriptor. This parameter replaces dsize in parallel mode
[in]	mode	a string giving the opening mode (only "w" or "r" are allowed)

Returns

The pointer to the file.

Definition at line 31 of file bin_io.c.

{
  FILE *fp;

/* ----------------------------------------------
    when reading, check if file exists
   ---------------------------------------------- */
   
  if (strcmp(mode,"r") == 0 && prank == 0){
    fp = fopen(filename, "rb");
    if (fp == NULL){
      print1 ("! OpenBinaryFile: file %s does not exists\n", filename);
      QUIT_PLUTO(1);
    }
    fclose(fp);
  }
  
/* ------------------------------------------------ 
          file exists, keep going
   ------------------------------------------------ */
  
  #ifdef PARALLEL
   AL_File_open(filename, sz); 
   return NULL;
  #else
   if      (strcmp(mode,"w") == 0) fp = fopen(filename, "wb");
   else if (strcmp(mode,"r") == 0) fp = fopen(filename, "rb");
   if (fp == NULL){
     print1 ("! Cannot find file %s\n",filename);
     QUIT_PLUTO(1);
   }
   return (fp);
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void OutflowBound	(	double ***	q,
		int	side,
		int	vpos,
		Grid *	grid
	)

Impose zero-gradient boundary conditions on 'q' on the boundary side specified by box->side. The staggered component of magnetic field is assigned using the div.B = 0 condition in a different loop.

Parameters

[in,out]	q	a 3D array representing a flow variable
[in]	box	pointer to a RBox structure defining the extent of the boundary region and the variable position inside the cell
[in]	grid	pointer to an array of Grid structures

Definition at line 295 of file boundary.c.

{
  int  i, j, k;
  double dB, *A, *dV;
  RBox *box = GetRBox (side, vpos);

  A  = grid->A;
  dV = grid->dV;

  if (side == X1_BEG) { 
    if (box->vpos != X1FACE){
      BOX_LOOP(box,k,j,i) q[k][j][i] = q[k][j][IBEG];   
    }else{
      BOX_LOOP(box,k,j,i){
        #if GEOMETRY == CARTESIAN
         q[k][j][i] = 2.0*q[k][j][i+1] - q[k][j][i+2];
        #else
         dB = (A[i+2]*q[k][j][i+2] - A[i+1]*q[k][j][i+1])/dV[i+2];
         q[k][j][i] = (q[k][j][i+1]*A[i+1] - dV[i+1]*dB)/A[i];
        #endif
      }
    }

  }else if (side == X1_END){

    if (box->vpos != X1FACE){
      BOX_LOOP(box,k,j,i) q[k][j][i] = q[k][j][IEND];   
    }else{
      BOX_LOOP(box,k,j,i){
        #if GEOMETRY == CARTESIAN
         q[k][j][i] = 2.0*q[k][j][i-1] - q[k][j][i-2];
        #else
         dB = (A[i-1]*q[k][j][i-1] - A[i-2]*q[k][j][i-2])/dV[i-1];
         q[k][j][i] = (q[k][j][i-1]*A[i-1] + dV[i]*dB)/A[i];
        #endif
      }
    }

  }else if (side == X2_BEG){

    if (box->vpos != X2FACE) {
      BOX_LOOP(box,k,j,i) q[k][j][i] = q[k][JBEG][i];
    }else{
      BOX_LOOP(box,k,j,i) {
        #if GEOMETRY == CARTESIAN
         q[k][j][i] = 2.0*q[k][j+1][i] - q[k][j+2][i];
        #else
         dB = (A[j+2]*q[k][j+2][i] - A[j+1]*q[k][j+1][i])/dV[j+2];
         q[k][j][i] = (q[k][j+1][i]*A[j+1] - dV[j+1]*dB)/A[j];
        #endif
      }
    }

  }else if (side == X2_END){

    if (box->vpos != X2FACE) {
      BOX_LOOP(box,k,j,i) q[k][j][i] = q[k][JEND][i];
    }else{
      BOX_LOOP(box,k,j,i){
        #if GEOMETRY == CARTESIAN
         q[k][j][i] = 2.0*q[k][j-1][i] - q[k][j-2][i];
        #else
         dB = (A[j-1]*q[k][j-1][i] - A[j-2]*q[k][j-2][i])/dV[j-1];
         q[k][j][i] = (q[k][j-1][i]*A[j-1] + dV[j]*dB)/A[j];
        #endif
      }
    }

  }else if (side == X3_BEG){

    if (box->vpos != X3FACE) {
      BOX_LOOP(box,k,j,i) q[k][j][i] = q[KBEG][j][i];
    }else{
      BOX_LOOP(box,k,j,i) {
        #if GEOMETRY == CARTESIAN
         q[k][j][i] = 2.0*q[k+1][j][i] - q[k+2][j][i];
        #else
         dB = (A[k+2]*q[k+2][j][i] - A[k+1]*q[k+1][j][i])/dV[k+2];
         q[k][j][i] = (q[k+1][j][i]*A[k+1] - dV[k+1]*dB)/A[k];
        #endif
      }
    }

  }else if (side == X3_END){

    if (box->vpos != X3FACE) {
      BOX_LOOP(box,k,j,i) q[k][j][i] = q[KEND][j][i];
    }else{
      BOX_LOOP(box,k,j,i) {
        #if GEOMETRY == CARTESIAN
         q[k][j][i] = 2.0*q[k-1][j][i] - q[k-2][j][i];  
        #else
         dB = (A[k-1]*q[k-1][j][i] - A[k-2]*q[k-2][j][i])/dV[k-1];
         q[k][j][i] = (q[k-1][j][i]*A[k-1] + dV[k]*dB)/A[k];
        #endif
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ParabolicFlux	(	Data_Arr	V,
		Data_Arr	J,
		double ***	T,
		const State_1D *	state,
		double **	dcoeff,
		int	beg,
		int	end,
		Grid *	grid
	)

Add the diffusion fluxes to the upwind fluxes for explicit time integration.

Parameters

[in]	V	pointer to the 3D array of cell-centered primitive variables
[in,out]	state	pointer to a State_1D structure
[out]	dcoeff	the diffusion coefficients 1D array
[in]	beg	initial index of computation
[in]	end	final index of computation
[in]	grid	pointer to an array of Grid structures

Definition at line 34 of file parabolic_flux.c.

{
  int i, j, k, nv;
  
/* -------------------------------------------------
   1. Viscosity 
   ------------------------------------------------- */
    
  #if VISCOSITY == EXPLICIT
   #ifdef FARGO
    print ("! ParabolicFlux: FARGO incompatible with explicit viscosity.\n");
    print ("                 Try STS or RKC instead\n");
    QUIT_PLUTO(1);
   #endif
   ViscousFlux (V, state->visc_flux, state->visc_src, dcoeff, beg, end, grid);
   for (i = beg; i <= end; i++){
     EXPAND(state->flux[i][MX1] -= state->visc_flux[i][MX1];  ,
            state->flux[i][MX2] -= state->visc_flux[i][MX2];  ,
            state->flux[i][MX3] -= state->visc_flux[i][MX3];  ) 
     #if HAVE_ENERGY
      state->flux[i][ENG] -= state->visc_flux[i][ENG];
     #endif

   }
  #endif 

/* -------------------------------------------------
   2. Thermal conduction
   ------------------------------------------------- */

  #if THERMAL_CONDUCTION == EXPLICIT
   TC_Flux (T, state, dcoeff, beg, end, grid);  
   for (i = beg; i <= end; i++) state->flux[i][ENG] -= state->tc_flux[i][ENG];
   /* !!!! tc_flux can be redefined as a 1D array since only the energy
           component is required !!! */
  #endif 

/* ----------------------------------------------------------------
   3. Resistivity.
      Note for the entropy flux: differently from viscosity and
      thermal conduction, the contribution to the entropy due to
      currents is given by J^2 and cannot be expressed as a simple
      two-point flux difference.
      This is done in a separate step (...)
   ---------------------------------------------------------------- */

  #if (RESISTIVITY == EXPLICIT) 
   ResistiveFlux (V, J, state->res_flux, dcoeff, beg, end, grid);
   for (i = beg; i <= end; i++){

   /* ------------------------------------------
       normal component of magnetic field does 
       not evolve during the current sweep. 
      ------------------------------------------ */

     state->res_flux[i][BXn] = 0.0;  

  /* ---------------------------------------------------
      add the parabolic part of the EMF, only for 
      cell-centered MHD. CT is handled in a truly
      multidimensional way.
     --------------------------------------------- */

     EXPAND(state->flux[i][BX1] += state->res_flux[i][BX1];  ,
            state->flux[i][BX2] += state->res_flux[i][BX2];  ,
            state->flux[i][BX3] += state->res_flux[i][BX3]; )
     #if HAVE_ENERGY
      state->flux[i][ENG] += state->res_flux[i][ENG];
     #endif
   }
  #endif 

}

Here is the call graph for this function:

Here is the caller graph for this function:

double ParabolicRHS	(	const Data *	d,
		Data_Arr	dU,
		double	dt,
		Grid *	grid
	)

Parameters

[in]	V	3D array containing primitive variables
[out]	dU	3D array containing the conservative right hand sides
[in]	dt	the time step
[in]	grid	a pointer to an array of Grid structure

Returns

On output it returns the maximum diffusion coefficients among all dissipative term over the local processor grid.

Definition at line 50 of file parabolic_rhs.c.

{
  int i, j, k, nv;
  double r, th, r_1, s_1;
  double dtdl, dtdV, dt_rdr;
  double *inv_dl, inv_dl2;
  double *rp, *A, *du, **vh, *C, **tc_flx;
  double dvp[NVAR], dvm[NVAR], dvl;
  double ****V;
  static double **res_flx; 
  static double **dcoeff, ***T;
  static double **ViF, **ViS;
  
  static Data_Arr C_dtp;
  static State_1D state;
  double max_inv_dtp[3],inv_dtp;

  i = j = k = 0;
  
  if (C_dtp == NULL) {
    C_dtp = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double);
    #if ADD_TC 
     MakeState (&state);
     #ifdef CH_SPACEDIM 
      i = j = k = 1;
      D_EXPAND(i = NMAX_POINT;, j = NMAX_POINT;, k = NMAX_POINT;)
      T = ARRAY_3D(k, j, i, double); 
     #else
      T = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, double);
     #endif
    #endif

    ViF = ARRAY_2D(NMAX_POINT, NVAR, double);
    ViS = ARRAY_2D(NMAX_POINT, NVAR, double); 
    res_flx = ARRAY_2D(NMAX_POINT, NVAR, double);
    dcoeff  = ARRAY_2D(NMAX_POINT, NVAR, double);
  }

  V = d->Vc;  /* -- set a pointer to the primitive vars array -- */
  
  #if ADD_RESISTIVITY && (defined STAGGERED_MHD)
   GetCurrent (d, -1, grid);
  #endif

/* ------------------------------------------------
    compute the temperature array if TC is needed
   ------------------------------------------------ */

  #if ADD_TC
   TOT_LOOP(k,j,i) T[k][j][i] = V[PRS][k][j][i]/V[RHO][k][j][i];
   vh     = state.vh;
   tc_flx = state.tc_flux;
  #endif

max_inv_dtp[0] = max_inv_dtp[1] = max_inv_dtp[2] = 0.0;

/* ----------------------------------------------------------------------   
         L O O P     O N    X1   D I R E C T I O N  ( I D I R )
   ---------------------------------------------------------------------- */

  g_dir = IDIR;
  A   = grid[g_dir].A;
  rp  = grid[g_dir].xr;
  #if ADD_RESISTIVITY  && !(defined STAGGERED_MHD)
   GetCurrent(d, g_dir, grid);
  #endif
  KDOM_LOOP (k){ 
  JDOM_LOOP (j){ 

    g_j = j; g_k = k;

  /* -------------------------------------------------------------------
      Compute viscous, resistive and thermal cond. fluxes in the x1 dir
     ------------------------------------------------------------------- */
     
    #if ADD_VISCOSITY
     ViscousFlux (V, ViF, ViS, dcoeff, IBEG-1, IEND, grid);
    #endif

    #if ADD_RESISTIVITY
     ResistiveFlux (V, d->J, res_flx, dcoeff, IBEG - 1, IEND, grid);
    #endif

    #if ADD_TC
     ITOT_LOOP (i) for (nv = NVAR; nv--; ) vh[i][nv] = V[nv][k][j][i];  

     for (nv = NVAR; nv--; ) dvm[nv] = vh[1][nv] - vh[0][nv];
     for(i=1; i<NX1_TOT-1; i++){
     for (nv = NVAR; nv--; ) {
       dvp[nv] = vh[i+1][nv] - vh[i][nv];
       dvl     = VAN_LEER(dvp[nv], dvm[nv]); 
       state.vp[i][nv] = vh[i][nv] + 0.5*dvl;
       state.vm[i][nv] = vh[i][nv] - 0.5*dvl;
       dvm[nv] = dvp[nv];
     }}
     TC_Flux (T, &state, dcoeff, IBEG - 1, IEND, grid);
    #endif

  /* ---------------------------
      compute inverse time-step
     --------------------------- */
     
    if (g_intStage == 1){ 
      inv_dl = GetInverse_dl(grid);
      IDOM_LOOP(i){
        C       = C_dtp[k][j][i];
        inv_dl2 = 0.5*inv_dl[i]*inv_dl[i];
        #if ADD_VISCOSITY
         C[MX1] = (dcoeff[i-1][MX1] + dcoeff[i][MX1])*inv_dl2;
        #endif
        #if ADD_RESISTIVITY
         EXPAND(C[BX1] = (dcoeff[i-1][BX1] + dcoeff[i][BX1])*inv_dl2;  ,
                C[BX2] = (dcoeff[i-1][BX2] + dcoeff[i][BX2])*inv_dl2;  ,
                C[BX3] = (dcoeff[i-1][BX3] + dcoeff[i][BX3])*inv_dl2;)
        #endif
        #if ADD_TC
         C[ENG] = (dcoeff[i-1][ENG] + dcoeff[i][ENG])*inv_dl2;
         inv_dtp = dcoeff[i][ENG]*inv_dl[i]*inv_dl[i];
         max_inv_dtp[g_dir] = MAX(max_inv_dtp[g_dir], inv_dtp);
        #endif
      }
    }

  /* ---------------------------
          Main X1-sweep
     --------------------------- */

    IDOM_LOOP (i){  

      du = dU[k][j][i];
      r  = grid[IDIR].x[i];
      dtdV = dt/grid[IDIR].dV[i];
      dtdl = dt/grid[IDIR].dx[i];

      #if HAVE_ENERGY
      du[ENG] = 0.0; /* energy contribution may come from any of the
                        dissipative terms. It's better to initialize it
                        to zero and then add contribution separately. */
      #endif

    /* -------------------------------------------
        VISCOSITY: build rhs in the x1 direction
       ------------------------------------------- */

      #if ADD_VISCOSITY
       r_1 = 1.0/grid[IDIR].x[i];
       #if GEOMETRY == CARTESIAN
        EXPAND(du[MX1] = (ViF[i][MX1] - ViF[i-1][MX1])*dtdl + dt*ViS[i][MX1];,
               du[MX2] = (ViF[i][MX2] - ViF[i-1][MX2])*dtdl + dt*ViS[i][MX2];,   
               du[MX3] = (ViF[i][MX3] - ViF[i-1][MX3])*dtdl + dt*ViS[i][MX3];)
        #if HAVE_ENERGY
         du[ENG] += (ViF[i][ENG] - ViF[i - 1][ENG])*dtdl;
        #endif
       #elif GEOMETRY == CYLINDRICAL
        EXPAND(du[MX1] = (A[i]*ViF[i][MX1] - A[i-1]*ViF[i-1][MX1])*dtdV 
                        + dt*ViS[i][MX1]; ,
               du[MX2] = (A[i]*ViF[i][MX2] - A[i-1]*ViF[i-1][MX2])*dtdV 
                        + dt*ViS[i][MX2]; ,   
               du[MX3] = (A[i]*A[i]*ViF[i][MX3] - A[i-1]*A[i-1]*ViF[i-1][MX3])*r_1*dtdV;)
        #if HAVE_ENERGY
         du[ENG] += (A[i]*ViF[i][ENG] - A[i-1]*ViF[i-1][ENG])*dtdV;
        #endif
       #elif GEOMETRY == POLAR
        EXPAND(du[MX1] = (A[i]*ViF[i][MX1] - A[i-1]*ViF[i-1][MX1])*dtdV 
                         + dt*ViS[i][MX1]; ,
               du[MX2] = (A[i]*A[i]*ViF[i][MX2] - A[i-1]*A[i-1]*ViF[i-1][MX2])*r_1*dtdV; ,   
               du[MX3] = (A[i]*ViF[i][MX3] - A[i-1]*ViF[i-1][MX3])*dtdV 
                         + dt*ViS[i][MX3];)
        #if HAVE_ENERGY
         du[ENG] += (A[i]*ViF[i][ENG] - A[i-1]*ViF[i-1][ENG])*dtdV;
        #endif
       #elif GEOMETRY == SPHERICAL
        EXPAND(du[MX1] = (A[i]*ViF[i][MX1] - A[i-1]*ViF[i-1][MX1])*dtdV 
                         + dt*ViS[i][MX1];,
               du[MX2] = (A[i]*ViF[i][MX2] - A[i-1]*ViF[i-1][MX2])*dtdV 
                         + dt*ViS[i][MX2];,   
               du[MX3] = (rp[i]*A[i]*ViF[i][MX3] - rp[i-1]*A[i-1]*ViF[i-1][MX3])*r_1*dtdV;)
        #if HAVE_ENERGY
         du[ENG] += (A[i]*ViF[i][ENG] - A[i-1]*ViF[i-1][ENG])*dtdV;
        #endif
       #endif
      #endif /* -- VISCOSITY -- */

    /* ----------------------------------------------
        RESISTIVITY: build rhs in the x1 direction
       ---------------------------------------------- */

      #if ADD_RESISTIVITY
       #if GEOMETRY == CARTESIAN    /* -- x coordinate -- */
        EXPAND(
          du[BX1] = 0.0;                                        ,
          du[BX2] = -(res_flx[i][BX2] - res_flx[i-1][BX2])*dtdl;  ,
          du[BX3] = -(res_flx[i][BX3] - res_flx[i-1][BX3])*dtdl; )
        #if EOS != ISOTHERMAL
         du[ENG] += -(res_flx[i][ENG] - res_flx[i-1][ENG])*dtdl; 
        #endif 

       #elif GEOMETRY == CYLINDRICAL  /* -- r coordinate -- */
        EXPAND(
          du[BX1] = 0.0;                                                   ,
          du[BX2] = -(A[i]*res_flx[i][BX2] - A[i-1]*res_flx[i-1][BX2])*dtdV; ,
          du[BX3] = -(res_flx[i][BX3] - res_flx[i-1][BX3])*dtdl;)
        #if EOS != ISOTHERMAL
         du[ENG] += -(A[i]*res_flx[i][ENG] - A[i-1]*res_flx[i-1][ENG])*dtdV; 
        #endif 

       #elif GEOMETRY == POLAR    /* -- r coordinate -- */
        EXPAND(
          du[BX1] = 0.0;                                                      ,
          du[BX2] = -(res_flx[i][BX2] - res_flx[i-1][BX2])*dtdl;                ,
          du[BX3] = -(A[i]*res_flx[i][BX3] - A[i-1]*res_flx[i-1][BX3])*dtdV; )
        #if EOS != ISOTHERMAL
         du[ENG] += -(A[i]*res_flx[i][ENG] - A[i-1]*res_flx[i-1][ENG])*dtdV; 
        #endif 

       #elif GEOMETRY == SPHERICAL  /* -- r coordinate -- */
        dt_rdr = dtdl/r;
        EXPAND(
          du[BX1] = 0.0;                                                      ,
          du[BX2] = -(rp[i]*res_flx[i][BX2] - rp[i-1]*res_flx[i-1][BX2])*dt_rdr; ,
          du[BX3] = -(rp[i]*res_flx[i][BX3] - rp[i-1]*res_flx[i-1][BX3])*dt_rdr; )
        #if EOS != ISOTHERMAL
         du[ENG] += -(A[i]*res_flx[i][ENG] - A[i-1]*res_flx[i-1][ENG])*dtdV; 
        #endif 
       #endif
      #endif /* -- RESISTIVITY -- */

    /* ---------------------------------------------------
        THERMAL_CONDUCTION: build rhs in the x1 direction
       --------------------------------------------------- */

      #if ADD_TC
       #if GEOMETRY == CARTESIAN 
        du[ENG] += (tc_flx[i][ENG] - tc_flx[i-1][ENG])*dtdl;
       #else
        du[ENG] += (A[i]*tc_flx[i][ENG] - A[i-1]*tc_flx[i-1][ENG])*dtdV;
       #endif
      #endif
    }
  }}

/* ----------------------------------------------------------------------   
         L O O P     O N    X2   D I R E C T I O N  ( J D I R )
   ---------------------------------------------------------------------- */

#if DIMENSIONS > 1
  g_dir = JDIR;
  A     = grid[g_dir].A;
  #if ADD_RESISTIVITY  && !(defined STAGGERED_MHD)
   GetCurrent(d, g_dir, grid);
  #endif
  KDOM_LOOP (k){
  IDOM_LOOP (i){

    g_i = i; g_k = k;

  /* -------------------------------------------------------------------
      Compute viscous, resistive and thermal cond. fluxes in the x2 dir
     ------------------------------------------------------------------- */

    #if ADD_VISCOSITY
     ViscousFlux (V, ViF, ViS, dcoeff, JBEG-1, JEND, grid);
    #endif
    #if ADD_RESISTIVITY
     ResistiveFlux (V, d->J, res_flx, dcoeff, JBEG - 1, JEND, grid);
    #endif

    #if ADD_TC
     JTOT_LOOP (j) for (nv = NVAR; nv--; ) vh[j][nv] = V[nv][k][j][i];  

     for (nv = NVAR; nv--; ) dvm[nv] = vh[1][nv] - vh[0][nv];
     for(j = 1; j < NX2_TOT-1; j++){
     for (nv = NVAR; nv--; ) {
       dvp[nv] = vh[j+1][nv] - vh[j][nv];
       dvl     = VAN_LEER(dvp[nv], dvm[nv]);
       state.vp[j][nv] = vh[j][nv] + 0.5*dvl;
       state.vm[j][nv] = vh[j][nv] - 0.5*dvl;
       dvm[nv] = dvp[nv];
     }}
     TC_Flux (T, &state, dcoeff, JBEG - 1, JEND, grid);
    #endif

  /* ---------------------------
      compute inverse time-step
     --------------------------- */

    if (g_intStage == 1){
      inv_dl = GetInverse_dl(grid);
      JDOM_LOOP(j){
        C       = C_dtp[k][j][i];
        inv_dl2 = 0.5*inv_dl[j]*inv_dl[j];
        #if ADD_VISCOSITY
         C[MX1] += (dcoeff[j-1][MX1] + dcoeff[j][MX1])*inv_dl2;
        #endif
        #if ADD_RESISTIVITY
         EXPAND(C[BX1] += (dcoeff[j-1][BX1] + dcoeff[j][BX1])*inv_dl2;  ,
                C[BX2] += (dcoeff[j-1][BX2] + dcoeff[j][BX2])*inv_dl2;  ,
                C[BX3] += (dcoeff[j-1][BX3] + dcoeff[j][BX3])*inv_dl2;)
        #endif
        #if ADD_TC
         C[ENG] += (dcoeff[j-1][ENG] + dcoeff[j][ENG])*inv_dl2;

         inv_dtp = dcoeff[j][ENG]*inv_dl[j]*inv_dl[j];
         max_inv_dtp[g_dir] = MAX(max_inv_dtp[g_dir], inv_dtp);
        #endif
      }
    }

  /* ---------------------------
          Main X2-sweep
     --------------------------- */

    r = grid[IDIR].x[i];
    JDOM_LOOP (j){   

      du   = dU[k][j][i];
      dtdV = dt/grid[JDIR].dV[j]; 
      dtdl = dt/grid[JDIR].dx[j];

      #if GEOMETRY == POLAR || GEOMETRY == SPHERICAL
       dtdl /= r;
       dtdV /= r;
      #endif

    /* ------------------------------------------
        VISCOSITY: build rhs in the x2 direction
       ------------------------------------------ */

      #if ADD_VISCOSITY
       s_1 = 1.0/sin(grid[JDIR].x[j]);
       #if GEOMETRY != SPHERICAL
        EXPAND(du[MX1] += (ViF[j][MX1] - ViF[j-1][MX1])*dtdl + dt*ViS[j][MX1];,
               du[MX2] += (ViF[j][MX2] - ViF[j-1][MX2])*dtdl + dt*ViS[j][MX2];,   
               du[MX3] += (ViF[j][MX3] - ViF[j-1][MX3])*dtdl + dt*ViS[j][MX3];)
        #if HAVE_ENERGY
         du[ENG] += (ViF[j][ENG] - ViF[j-1][ENG])*dtdl;
        #endif
       #elif GEOMETRY == SPHERICAL
        EXPAND(du[MX1] += (A[j]*ViF[j][MX1] - A[j-1]*ViF[j-1][MX1])*dtdV 
                          + dt*ViS[j][MX1];,
               du[MX2] += (A[j]*ViF[j][MX2] - A[j-1]*ViF[j-1][MX2])*dtdV 
                          + dt*ViS[j][MX2];,   
               du[MX3] += (A[j]*A[j]*ViF[j][MX3] - A[j-1]*A[j-1]*ViF[j-1][MX3])*s_1*dtdV;)
        #if HAVE_ENERGY
         du[ENG] += (A[j]*ViF[j][ENG] - A[j-1]*ViF[j-1][ENG])*dtdV;
        #endif
       #endif 
      #endif/* -- VISCOSITY -- */

    /* ----------------------------------------------
        RESISTIVITY: build rhs in the x2 direction
       ---------------------------------------------- */

      #if ADD_RESISTIVITY
       #if GEOMETRY != SPHERICAL  /* -- y coordinate -- */
        EXPAND(
          du[BX1] -= (res_flx[j][BX1] - res_flx[j-1][BX1])*dtdl;  ,
                                                              ,
          du[BX3] -= (res_flx[j][BX3] - res_flx[j-1][BX3])*dtdl; )
        #if HAVE_ENERGY
         du[ENG] -= (res_flx[j][ENG] - res_flx[j-1][ENG])*dtdl; 
        #endif 
       #elif GEOMETRY == SPHERICAL  /* -- theta coordinate -- */
        EXPAND(
          du[BX1] -= (A[j]*res_flx[j][BX1] - A[j-1]*res_flx[j-1][BX1])*dtdV;  ,
                                                                          ,
          du[BX3] -= (res_flx[j][BX3] - res_flx[j-1][BX3])*dtdl;)
        #if HAVE_ENERGY
         du[ENG] -= (A[j]*res_flx[j][ENG] - A[j-1]*res_flx[j-1][ENG])*dtdV; 
        #endif 
       #endif
      #endif /* -- RESISTIVE MHD -- */

    /* ---------------------------------------------------
        THERMAL_CONDUCTION: build rhs in the x2 direction
       --------------------------------------------------- */

      #if ADD_TC
       #if GEOMETRY != SPHERICAL
        du[ENG] += (tc_flx[j][ENG] - tc_flx[j-1][ENG])*dtdl;
       #else
        du[ENG] += (A[j]*tc_flx[j][ENG] - A[j-1]*tc_flx[j-1][ENG])*dtdV;
       #endif
      #endif
    }

  }}
#endif

/* ----------------------------------------------------------------------   
         L O O P     O N    X3   D I R E C T I O N  ( K D I R )
   ---------------------------------------------------------------------- */

#if DIMENSIONS == 3
  g_dir = KDIR;
  A   = grid[g_dir].A;
  #if ADD_RESISTIVITY && !(defined STAGGERED_MHD)
   GetCurrent(d, g_dir, grid);
  #endif
  JDOM_LOOP (j){
  IDOM_LOOP (i){

    g_i = i; g_j = j;

  /* -------------------------------------------------------------------
      Compute viscous, resistive and thermal cond. fluxes in the x3 dir
     ------------------------------------------------------------------- */

    #if ADD_VISCOSITY
     ViscousFlux (V, ViF, ViS, dcoeff, KBEG-1, KEND, grid);
    #endif
    #if ADD_RESISTIVITY
     ResistiveFlux (V, d->J, res_flx, dcoeff, KBEG - 1, KEND, grid);
    #endif

    #if ADD_TC
     KTOT_LOOP (k) for (nv = NVAR; nv--; ) vh[k][nv] = V[nv][k][j][i];  

     for (nv = NVAR; nv--; ) dvm[nv] = vh[1][nv] - vh[0][nv];
     for(k=1; k<NX3_TOT-1; k++){
     for (nv = NVAR; nv--; ) {
       dvp[nv] = vh[k+1][nv]- vh[k][nv];
       dvl     = VAN_LEER(dvp[nv], dvm[nv]);
       state.vp[k][nv] = vh[k][nv] + 0.5*dvl;
       state.vm[k][nv] = vh[k][nv] - 0.5*dvl;
       dvm[nv] = dvp[nv];
     }}
     TC_Flux (T, &state, dcoeff, KBEG - 1, KEND, grid);
    #endif

  /* ---------------------------
      compute inverse time-step
     --------------------------- */

    if (g_intStage == 1){
      inv_dl = GetInverse_dl(grid);
      KDOM_LOOP(k){
        C       = C_dtp[k][j][i];
        inv_dl2 = 0.5*inv_dl[k]*inv_dl[k];
        #if ADD_VISCOSITY
         C[MX1] += (dcoeff[k-1][MX1] + dcoeff[k][MX1])*inv_dl2;
        #endif
        #if ADD_RESISTIVITY
         EXPAND(C[BX1] += (dcoeff[k-1][BX1] + dcoeff[k][BX1])*inv_dl2;  ,
                C[BX2] += (dcoeff[k-1][BX2] + dcoeff[k][BX2])*inv_dl2;  ,
                C[BX3] += (dcoeff[k-1][BX3] + dcoeff[k][BX3])*inv_dl2;)
        #endif
        #if ADD_TC
         C[ENG] += (dcoeff[k-1][ENG] + dcoeff[k][ENG])*inv_dl2;

         inv_dtp = dcoeff[k][ENG]*inv_dl[k]*inv_dl[k];
         max_inv_dtp[g_dir] = MAX(max_inv_dtp[g_dir], inv_dtp);

        #endif
      }
    }

  /* ---------------------------
          Main X3-sweep
     --------------------------- */

    r  = grid[IDIR].x[i];
    th = grid[JDIR].x[j];
    KDOM_LOOP (k){  

      du   = dU[k][j][i];
      dtdV = dt/grid[KDIR].dV[k];
      dtdl = dt/grid[KDIR].dx[k];
      #if GEOMETRY == SPHERICAL
       dtdl /= r*sin(th);
      #endif

    /* ------------------------------------------
        VISCOSITY: build rhs in the x3 direction
       ------------------------------------------ */

      #if ADD_VISCOSITY
       du[MX1] += (ViF[k][MX1] - ViF[k-1][MX1])*dtdl + dt*ViS[k][MX1];
       du[MX2] += (ViF[k][MX2] - ViF[k-1][MX2])*dtdl + dt*ViS[k][MX2];
       du[MX3] += (ViF[k][MX3] - ViF[k-1][MX3])*dtdl + dt*ViS[k][MX3];
       #if HAVE_ENERGY
        du[ENG] += (ViF[k][ENG] - ViF[k-1][ENG])*dtdl;
       #endif
      #endif/* -- VISCOSITY -- */

    /* ----------------------------------------------
        RESISTIVITY: build rhs in the x3 direction
       ---------------------------------------------- */

      #if ADD_RESISTIVITY
       du[BX1] -= (res_flx[k][BX1] - res_flx[k-1][BX1])*dtdl;
       du[BX2] -= (res_flx[k][BX2] - res_flx[k-1][BX2])*dtdl;
       #if HAVE_ENERGY
        du[ENG] -= (res_flx[k][ENG] - res_flx[k-1][ENG])*dtdl; 
       #endif 
      #endif /* -- RESISTIVITY -- */
   
    /* ---------------------------------------------------
        THERMAL_CONDUCTION: build rhs in the x3 direction
       --------------------------------------------------- */

      #if ADD_TC
       du[ENG] += (tc_flx[k][ENG] - tc_flx[k-1][ENG])*dtdl;
      #endif
    }
  }}
#endif

/*  OLD VERSION 
D_EXPAND(th = max_inv_dtp[IDIR];            ,
         th = MAX(th, max_inv_dtp[JDIR]);  ,
         th = MAX(th, max_inv_dtp[KDIR]);)
return th; 
*/

/* --------------------------------------------------------------
     take the maximum of inverse dt over domain and zero 
     right hand side in the internal boundary zones.
   -------------------------------------------------------------- */

  th = 0.0;
  DOM_LOOP(k,j,i){
    #if ADD_VISCOSITY
     th = MAX(th, C_dtp[k][j][i][MX1]);   
    #endif
    #if ADD_RESISTIVITY
     EXPAND(th = MAX(th, C_dtp[k][j][i][BX1]);   ,  
            th = MAX(th, C_dtp[k][j][i][BX2]);   ,
            th = MAX(th, C_dtp[k][j][i][BX3]);)
    #endif
    #if ADD_TC
     th = MAX(th, C_dtp[k][j][i][ENG]);
    #endif
    #if INTERNAL_BOUNDARY == YES
     if (d->flag[k][j][i] & FLAG_INTERNAL_BOUNDARY) {
       for (nv = NVAR; nv--;  ) dU[k][j][i][nv] = 0.0;
     }
    #endif
  }
  return th;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ParamExist

(

const char *

label

)

Check whether *label exists in any of the lines (**fline).

Parameters

[in]

label

Returns

0 on success, 1 if label cannot be found.

Definition at line 159 of file parse_file.c.

{
  int    k;
  char   sline[512], *str;
  const char  delimiters[] = " \t\r\f";

/* ---------------------------------------
     search if label exists
   --------------------------------------- */

  for (k = 0; k < nlines; k++) {
    sprintf (sline,"%s",fline[k]);
    str = strtok(sline,delimiters);
    if (strcmp(str,label) == 0) return(1);
  }

  return (0);
}

Here is the caller graph for this function:

char* ParamFileGet	(	const char *	label,
		int	pos
	)

Search for *label in all the lines pointed to by **fline. If label exists, return a pointer to the string located pos words after label. Issue an error if this string cannot be located.

Parameters

[in]	label	the first word of a line to be searched
[in]	pos	an integer giving the position of the word

Returns

the n-th word contained in the same line

Definition at line 86 of file parse_file.c.

{
  int         k, nwords, nw;
  static char **words;

/* -------------------------------------------------------------
    Allocate memory and initialize words[][] string array with
    to avoid unpleasant situations occurring when there're
    empty words.
   ------------------------------------------------------------- */

  if (words == NULL) words = ARRAY_2D(128,128,char);
  for (k = 0; k < 127; k++) sprintf (words[k],"\0");

  for (k = 0; k < nlines; k++) {        /* Loop over lines */
    nwords = ParamFileGetWords(fline[k],words);  /* get words for k-th line */

    if (nwords > 0 && strcmp(words[0],label) == 0){  /* check if 1st word  */
      if (pos <= nwords) return words[pos];          /* matches label      */
      else {
        printf ("! ParamFileGet: field # %d does not exist\n",pos);
        QUIT_PLUTO(1);
      }
    }
  }

  printf ("! ParamFileGet: label '%s' was not found\n",label);
  QUIT_PLUTO(1);

  return NULL;    
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ParamFileHasBoth	(	const char *	label1,
		const char *	label2
	)

Locate the line beginning with label1 and return 1 if label2 can be found on the same line. Return 0 otherwise.

Parameters

[in]	label1	The first word of the line to be searched
[in]	label2	A word containined in the same line beginning with label1

Returns

1 If label2 and label1 are in the same line. 0 otherwise.

Definition at line 129 of file parse_file.c.

{ 
  int         k, nwords, nw;
  static char **words;

  if (words == NULL) words = ARRAY_2D(128,128,char);

  for (k = 0; k < nlines; k++) {                /* Loop over lines */
    nwords = ParamFileGetWords(fline[k],words); /* get words for k-th line */
    if (strcmp(words[0],label1) == 0){          
      for (nw = 1; nw < nwords; nw++){
        if (words[nw][0] == '#') break;  /* comment detected:
                                            no need to read any further */
        if (strcmp(words[nw], label2) == 0) return 1;
      }
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ParamFileRead

(

char *

fname

)

Parse file *fname and store its content line by line in *fline. Blank lines are excluded.

Parameters

[in]

fname

the name of the file to be read

Returns

the number of liens successfully read.

Definition at line 53 of file parse_file.c.

{
  char  sline[512];
  FILE *fp;

  if (fline == NULL) fline = ARRAY_2D(128,128,char);

  fp = fopen(fname,"r");
  if (fp == NULL) {
    printf ("! ParamFileRead: file %s not found\n", fname);
    QUIT_PLUTO(1);
  }
  nlines = 0;

  while ( fgets(sline, 512, fp) != NULL ) {
    if (strlen(sline) > 0) {
      strcpy (fline[nlines],sline); 
      nlines++;
    }
  }
  fclose(fp);

  return(nlines);
}

Here is the caller graph for this function:

void ParseCmdLineArgs	(	int	argc,
		char *	argv[],
		char *	ini_file,
		Cmd_Line *	cmd
	)

Parse command line options. Error messages will be output to stdout.

Parameters

[in]	argc	argument count
[in]	argv	argument vector
[in]	ini_file	a pointer to a string containing the name of the initialization file (default: "pluto.ini")
[out]	cmd	the command-line structure.

Definition at line 18 of file cmd_line_opt.c.

{
  int i,j;

/* -----------------------------------------------
           Set default values first
   ----------------------------------------------- */

  cmd->restart   = NO;
  cmd->h5restart = NO;
  cmd->maxsteps  = 0 ;
  cmd->write     = YES;
  cmd->makegrid  = NO; 
  cmd->jet       = -1; /* -- means no direction -- */
  cmd->show_dec  = NO;
  cmd->xres      = -1; /* -- means no grid resizing -- */

  cmd->nproc[IDIR] = -1; /* means autodecomp will be used */
  cmd->nproc[JDIR] = -1;
  cmd->nproc[KDIR] = -1;

  #ifdef PARALLEL
   cmd->parallel_dim[IDIR] = YES;  /* by default, we parallelize */
   cmd->parallel_dim[JDIR] = YES;  /* all directions             */
   cmd->parallel_dim[KDIR] = YES;
  #endif

/* --------------------------------------------------------------------
             Parse Command Line Options.

    Note: Since at this time the output directory is now known and
          "pluto.log" has not been opened yet, we use printf to issue
          error messages.
   -------------------------------------------------------------------- */

  for (i = 1; i < argc ; i++){

    if (!strcmp(argv[i],"-dec")) {

    /* -- start reading integers at i+1 -- */

      for (g_dir = 0; g_dir < DIMENSIONS; g_dir++){

        if ((++i) >= argc){
          if (prank == 0){
            D_SELECT(printf ("! You must specify -dec n1\n");  ,
                     printf ("! You must specify -dec n1  n2\n");  ,
                     printf ("! You must specify -dec n1  n2  n3\n");)
          }
          QUIT_PLUTO(1);
        }
        cmd->nproc[g_dir] = atoi(argv[i]);
        if (cmd->nproc[g_dir] == 0){
            if (prank == 0) {
              printf ("! Incorrect number of processor for g_dir = %d \n", g_dir);
            }
            QUIT_PLUTO(0);
        }
      }

    }else if (!strcmp(argv[i],"-i")) {

      sprintf (ini_file,"%s",argv[++i]);
    
    } else if (!strcmp(argv[i],"-makegrid")) {

      cmd->makegrid = YES;

    }else if (!strcmp(argv[i],"-maxsteps")){

      if ((++i) >= argc){
        if (prank == 0) printf ("! You must specify -maxsteps nn\n");
        QUIT_PLUTO(1);
      }else{
        cmd->maxsteps = atoi(argv[i]);
        if (cmd->maxsteps == 0) {
          if (prank == 0)
            printf ("! You must specify -maxsteps nn, with nn > 0 \n");
          QUIT_PLUTO(0);
        }
      }

    }else if (!strcmp(argv[i],"-no-write")) {

      cmd->write = NO;

    }else if (!strcmp(argv[i],"-no-x1par")) {

      cmd->parallel_dim[IDIR] = NO;

    }else if (!strcmp(argv[i],"-no-x2par")) {

      cmd->parallel_dim[JDIR] = NO;

    }else if (!strcmp(argv[i],"-no-x3par")) {

      cmd->parallel_dim[KDIR] = NO;

    } else if (!strcmp(argv[i],"-show-dec")) {

      cmd->show_dec = YES;

    } else if (!strcmp(argv[i],"-x1jet")) {

      cmd->jet = IDIR;

    } else if (!strcmp(argv[i],"-x2jet")) {

      cmd->jet = JDIR;

    } else if (!strcmp(argv[i],"-x3jet")) {

      cmd->jet = KDIR;

    }else if (!strcmp(argv[i],"-xres")){

      if ((++i) >= argc){
        if (prank == 0) printf ("! You must specify -xres nn\n");
        QUIT_PLUTO(1);
      }else{
        cmd->xres = atoi(argv[i]);
        if (cmd->xres <= 1) {
          if (prank == 0) printf ("! You must specify -xres nn, with nn > 1 \n");
          QUIT_PLUTO(0)
        }
      }

    }else  if (!strcmp(argv[i],"-restart") || !strcmp(argv[i],"-h5restart")) {

     /* --------------------------------------------- 
          default restart is last written file (-1)
        --------------------------------------------- */

      if (!strcmp(argv[i], "-restart")) cmd->restart   = YES;  /* can only take YES/NO values */
      else                              cmd->h5restart = YES;
      cmd->nrestart = -1;   /* the file number to restart from */

      if ((++i) < argc){
        char *endptr;
/*         cmd->restart = atoi(argv[i]); */
        cmd->nrestart = (int)strtol(argv[i], &endptr, 10);

      /* ----------------------------------------------
          if a non-numerical character is encountered, 
          cmd->nrestart should reset to -1
         ---------------------------------------------- */

        if (endptr == argv[i]){
          i--;
          cmd->nrestart = -1;
        }
      }

    }else if (!strcmp(argv[i],"--help")){

      PrintUsage();
      QUIT_PLUTO(1);

    }else{
      if (prank == 0) printf ("! Unknown option '%s'\n",argv[i]);
      QUIT_PLUTO(1);
    }
  }

/* -- disable domain decomposition in the 
      direction specified by -xnjet  -- */

  if      (cmd->jet == IDIR) cmd->parallel_dim[IDIR] = NO;
  else if (cmd->jet == JDIR) cmd->parallel_dim[JDIR] = NO;
  else if (cmd->jet == KDIR) cmd->parallel_dim[KDIR] = NO;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void PeriodicBound	(	double ***	q,
		int	side,
		int	vpos
	)

Implements periodic boundary conditions in serial mode.

Definition at line 568 of file boundary.c.

{
  int  i, j, k;
  RBox *box = GetRBox(side, vpos);

  if (side == X1_BEG){

    BOX_LOOP(box,k,j,i) q[k][j][i] = q[k][j][i + NX1];

  }else if (side == X1_END){

    BOX_LOOP(box,k,j,i) q[k][j][i] = q[k][j][i - NX1];
    
  }else if (side == X2_BEG){

    BOX_LOOP(box,k,j,i) q[k][j][i] = q[k][j + NX2][i];

  }else if (side == X2_END){

    BOX_LOOP(box,k,j,i) q[k][j][i] = q[k][j - NX2][i];

  }else if (side == X3_BEG){

    BOX_LOOP(box,k,j,i) q[k][j][i] = q[k + NX3][j][i];

  }else if (side == X3_END){

    BOX_LOOP(box,k,j,i) q[k][j][i] = q[k - NX3][j][i];

  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PlutoError	(	int	condition,
		char *	str
	)

If condition is true, issue an error and quit the code.

Definition at line 115 of file tools.c.

{
  char *str_err="! Error: ";

  if (condition) {
    print (str_err);
    print (str);
    print ("\n");
    QUIT_PLUTO(1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PrimToChar	(	double **	Lp,
		double *	v,
		double *	w
	)

Compute the matrix-vector multiplcation between the the L matrix (containing primitive left eigenvectors) and the vector v. The result containing the characteristic variables is stored in the vector w = L.v

For efficiency purpose, multiplication is done explicitly, so that only nonzero entries of the left primitive eigenvectors are considered.

Parameters

[in]	L	Left eigenvectors
[in]	v	(difference of) primitive variables
[out]	w	(difference of) characteristic variables

Compute the matrix-vector multiplcation between the the L matrix (containing primitive left eigenvectors) and the vector v. The result containing the characteristic variables is stored in the vector w = L.v

For efficiency purpose, multiplication is done explicitly, so that only nonzero entries of the left primitive eigenvectors are considered.

Parameters

[in]	Lp	Left eigenvectors
[in]	v	(difference of) primitive variables
[out]	w	(difference of) characteristic variables

Definition at line 593 of file eigenv.c.

{
  int nv;

  #if HAVE_ENERGY
   w[0] = L[0][VXn]*v[VXn] + L[0][PRS]*v[PRS];
   w[1] = L[1][VXn]*v[VXn] + L[1][PRS]*v[PRS];
   EXPAND( w[2] = v[RHO] + L[2][PRS]*v[PRS];  ,
           w[3] = v[VXt];                   ,
           w[4] = v[VXb];)
  #elif EOS == ISOTHERMAL
    w[0] = L[0][RHO]*v[RHO] + L[0][VXn]*v[VXn];
    w[1] = L[1][RHO]*v[RHO] + L[1][VXn]*v[VXn];
    EXPAND(                     ,
            w[2] = v[VXt];       ,
            w[3] = v[VXb];)
  #endif

/* ----------------------------------------------- 
     For passive scalars, the characteristic 
     variable is equal to the primitive one, 
     since  l = r = (0,..., 1 , 0 ,....)
   ----------------------------------------------- */          

#if NSCL > 0
  NSCL_LOOP(nv)  w[nv] = v[nv];
#endif   
}

Here is the caller graph for this function:

void PrimToCons3D	(	Data_Arr	V,
		Data_Arr	U,
		RBox *	box
	)

Convert a 3D array of primitive variables V to an array of conservative variables U. Note that [nv] is the fastest running index for U while it is the slowest running index for V.

Parameters

[in]	V	pointer to 3D array of primitive variables, with array indexing [nv][k][j][i]
[out]	U	pointer to 3D array of conserved variables, with array indexing [k][j][i][nv]
[in]	box	pointer to RBox structure containing the domain portion over which conversion must be performed.

Definition at line 86 of file mappers3D.c.

{
  int   i, j, k, nv;
  int   ibeg, iend, jbeg, jend, kbeg, kend;
  int   current_dir;
  static double **v, **u;

  if (v == NULL) {
    v = ARRAY_2D(NMAX_POINT, NVAR, double);
    u = ARRAY_2D(NMAX_POINT, NVAR, double);
  }

  current_dir = g_dir; /* save current direction */
  g_dir = IDIR;

/* -----------------------------------------------
    Set (beg,end) indices in ascending order for
    proper call to ConsToPrim()
   ----------------------------------------------- */

  ibeg = (box->ib <= box->ie) ? (iend=box->ie, box->ib):(iend=box->ib, box->ie);
  jbeg = (box->jb <= box->je) ? (jend=box->je, box->jb):(jend=box->jb, box->je);
  kbeg = (box->kb <= box->ke) ? (kend=box->ke, box->kb):(kend=box->kb, box->ke);

  for (k = kbeg; k <= kend; k++){ g_k = k;
  for (j = jbeg; j <= jend; j++){ g_j = j;
    for (i = ibeg; i <= iend; i++) VAR_LOOP(nv) v[i][nv] = V[nv][k][j][i];
#ifdef CHOMBO
    PrimToCons(v, u, ibeg, iend);
    for (i = ibeg; i <= iend; i++) VAR_LOOP(nv) U[nv][k][j][i] = u[i][nv];
#else      
    PrimToCons (v, U[k][j], ibeg, iend);
#endif
  }}
  g_dir = current_dir; /* restore current direction */

}

Here is the call graph for this function:

Here is the caller graph for this function:

void print	(	const char *	fmt,
			...
	)

Define print function for the static grid version of PLUTO. The Chombo version is defined in Chombo/amrPLUTO.cpp

Definition at line 497 of file amrPluto.cpp.

{
  char buffer[256];
  va_list args;
  va_start (args, fmt);
  vsprintf (buffer,fmt, args);
  pout() << buffer;
}

void print1	(	const char *	fmt,
			...
	)

Define print1 function

Definition at line 511 of file amrPluto.cpp.

{
  char buffer[256];

  if (prank != 0) return;
  va_list args;
  va_start (args, fmt);
  vsprintf (buffer,fmt, args);
  pout() << buffer;
}

void ReadBinaryArray	(	void *	V,
		size_t	dsize,
		int	sz,
		FILE *	fl,
		int	istag,
		int	swap_endian
	)

Read a double-precision array from binary file.

Parameters

[in]	V	pointer to a 3D array, V[k][j][i] –> V[i + NX1*j + NX1*NX2*k]. Must start with index 0
[in]	dsize	the size of the each buffer element (sizeof(double) or sizeof(float)). This parameter is used only in serial mode.
[in]	sz	the distributed array descriptor. This parameter replaces dsize in parallel mode
[in]	fl	a valid FILE pointer
[in]	istag	a flag to identify cell-centered (istag = -1) or staggered field data (istag = 0,1 or 2 for staggering in the x1, x2 or x3 directions)
[in]	swap_endian	a flag for swapping endianity

Returns

This function has no return value.

Remarks

The data array V is assumed to start always with index 0 for both cell-centered and staggered arrays.

Definition at line 143 of file bin_io.c.

{
  int i, j, k;
  int ioff, joff, koff;
  char *Vc;

/* ---------------------------------------
    parallel reading handled by ArrayLib
   --------------------------------------- */

  #ifdef PARALLEL 
   AL_Read_array (V, sz, istag);
  #else

/* ---------------------------------------
      serial reading
   --------------------------------------- */

   Vc = (char *) V;
   ioff = (istag == 0); 
   joff = (istag == 1); 
   koff = (istag == 2);

   for (k = KBEG; k <= KEND + koff; k++) {
   for (j = JBEG; j <= JEND + joff; j++) {
     i = IBEG + (NX1_TOT + ioff)*(j + (NX2_TOT + joff)*k);
     fread (Vc + i*dsize, dsize, NX1 + ioff, fl);
   }}
  #endif

/* -----------------------------------
     now swap endian if necessary
   ----------------------------------- */

  if (swap_endian){
    double *Vd;
    Vd = (double *) V;
    ioff = (istag == 0); 
    joff = (istag == 1); 
    koff = (istag == 2);

    for (k = KBEG-koff; k <= KEND + koff; k++) {
    for (j = JBEG-joff; j <= JEND + joff; j++) {
    for (i = IBEG-ioff; i <= IEND + ioff; i++) {
      SWAP_VAR(Vd[i + (NX1_TOT + ioff)*(j + (NX2_TOT + joff)*k)]);
    }}}     
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ReadHDF5	(	Output *	output,
		Grid *	grid
	)

Read data from disk using hdf5 format (double precision).

Parameters

[in]	output	the output structure associated with HDF5 format
[in]	grid	a pointer to an array of Grid structures

Returns

This function has no return value.

Definition at line 582 of file hdf5_io.c.

{
  hid_t dataspace, memspace, dataset;
  hid_t file_identifier, group, timestep;
  hid_t file_access = 0;
#if MPI_POSIX == NO
  hid_t plist_id_mpiio = 0; /* for collective MPI I/O */
#endif
  hid_t err;

  hsize_t dimens[DIMENSIONS];
  hsize_t start[DIMENSIONS];
  hsize_t stride[DIMENSIONS];
  hsize_t count[DIMENSIONS];

  char filename[128], tstepname[32];
  int ierr, rank, nd, nv, ns;
  Grid *wgrid[3];

/* --------------------------------------------------------------
     Since data is read in reverse order (Z-Y-X) it is
     convenient to define pointers to grid in reverse order
   -------------------------------------------------------------- */

  for (nd = 0; nd < DIMENSIONS; nd++) wgrid[nd] = grid + DIMENSIONS - nd - 1;

  print1 ("> restarting from file #%d (dbl.h5)\n",output->nfile);
  sprintf (filename, "%s/data.%04d.dbl.h5", output->dir, output->nfile);

  rank = DIMENSIONS;

  #ifdef PARALLEL
   file_access = H5Pcreate (H5P_FILE_ACCESS);
   #if MPI_POSIX == YES
    H5Pset_fapl_mpiposix(file_access, MPI_COMM_WORLD, 1);
   #else
    H5Pset_fapl_mpio(file_access,  MPI_COMM_WORLD, MPI_INFO_NULL);
   #endif
   file_identifier = H5Fopen(filename, H5F_ACC_RDONLY, file_access);
   H5Pclose(file_access);
  #else
   file_identifier = H5Fopen(filename, H5F_ACC_RDONLY, H5P_DEFAULT);
  #endif

  if (file_identifier < 0){
    print1 ("! HDF5_READ: file %s does not exist\n");
    QUIT_PLUTO(1);
  }

  sprintf (tstepname, "Timestep_%d", output->nfile);
  timestep = H5Gopen(file_identifier, tstepname);
  group = H5Gopen(timestep, "vars");

 #if MPI_POSIX == NO
  plist_id_mpiio = H5Pcreate(H5P_DATASET_XFER);
  H5Pset_dxpl_mpio(plist_id_mpiio,H5FD_MPIO_COLLECTIVE);
 #endif

  for (nv = 0; nv < output->nvar; nv++) {

  /* -- skip variable if excluded from output or if it is staggered -- */

    if (!output->dump_var[nv] || output->stag_var[nv] != -1) continue;

    dataset   = H5Dopen(group, output->var_name[nv]);
    dataspace = H5Dget_space(dataset);

    #ifdef PARALLEL
     for (nd = 0; nd < DIMENSIONS; nd++) {
       start[nd]  = wgrid[nd]->beg - wgrid[nd]->nghost;
       stride[nd] = 1;
       count[nd]  = wgrid[nd]->np_int;
     }
     err = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET, start, stride, count, NULL);  
    #endif

    for (nd = 0; nd < DIMENSIONS; nd++) dimens[nd] = wgrid[nd]->np_tot;

    memspace = H5Screate_simple(rank,dimens,NULL);

    for (nd = 0; nd < DIMENSIONS; nd++){
      start[nd]  = wgrid[nd]->nghost;
      stride[nd] = 1;
      count[nd]  = wgrid[nd]->np_int;
    }

    err = H5Sselect_hyperslab(memspace,H5S_SELECT_SET, start, stride, count, NULL);

     #if MPI_POSIX == NO
      err = H5Dread(dataset, H5T_NATIVE_DOUBLE, memspace, dataspace,
                    plist_id_mpiio, output->V[nv][0][0]);
     #else
      err = H5Dread(dataset, H5T_NATIVE_DOUBLE, memspace, dataspace,
                    H5P_DEFAULT, output->V[nv][0][0]);
     #endif

    H5Dclose(dataset);
    H5Sclose(memspace);
    H5Sclose(dataspace);
  }

 #if MPI_POSIX == NO
  H5Pclose(plist_id_mpiio);
 #endif
  H5Gclose(group);

  #ifdef STAGGERED_MHD
   group = H5Gopen(timestep, "stag_vars");

  #if MPI_POSIX == NO
   plist_id_mpiio = H5Pcreate(H5P_DATASET_XFER);
   H5Pset_dxpl_mpio(plist_id_mpiio,H5FD_MPIO_COLLECTIVE);
  #endif

   for (ns = 0; ns < DIMENSIONS; ns++) {
     dataset   = H5Dopen(group, output->var_name[NVAR+ns]);
     dataspace = H5Dget_space(dataset);

     #ifdef PARALLEL
      for (nd = 0; nd < DIMENSIONS; nd++) {
        start[nd]  = wgrid[nd]->beg - wgrid[nd]->nghost;
        stride[nd] = 1;
        count[nd]  = wgrid[nd]->np_int;
        if (ns == DIMENSIONS-1-nd){
           if (grid[ns].lbound != 0) count[nd] += 1;
           else                      start[nd] += 1;
        }
      }
      err = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET,
                                start, stride, count, NULL);
     #endif
 
     for (nd = 0; nd < DIMENSIONS; nd++)
       dimens[nd] = wgrid[nd]->np_tot + (ns == (DIMENSIONS-1-nd));

     memspace = H5Screate_simple(rank,dimens,NULL);

     for (nd = 0; nd < DIMENSIONS; nd++){ 
       start[nd]  = wgrid[nd]->nghost;
       stride[nd] = 1;
       count[nd]  = wgrid[nd]->np_int;
       if (ns == DIMENSIONS-1-nd && grid[ns].lbound != 0) {
         start[nd] -= 1;
         count[nd] += 1;
       }
     }

     err = H5Sselect_hyperslab(memspace,H5S_SELECT_SET,
                               start, stride, count, NULL); 
     #if MPI_POSIX == NO
      err = H5Dread(dataset, H5T_NATIVE_DOUBLE, memspace,
                    dataspace, plist_id_mpiio, output->V[NVAR+ns][0][0]);
     #else
      err = H5Dread(dataset, H5T_NATIVE_DOUBLE, memspace,
                    dataspace, H5P_DEFAULT, output->V[NVAR+ns][0][0]);
     #endif
     H5Dclose(dataset);
     H5Sclose(memspace); 
     H5Sclose(dataspace);
   }

  #if MPI_POSIX == NO
   H5Pclose(plist_id_mpiio);
  #endif
   H5Gclose(group);
  #endif

  H5Gclose(timestep);
  H5Fclose(file_identifier);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ReflectiveBound	(	double ***	q,
		int	s,
		int	side,
		int	vpos
	)

Make symmetric (s = 1) or anti-symmetric (s=-1) profiles with respect to the boundary plane specified by box->side. The sign is set by the FlipSign() function.

Parameters

[in,out]	q	a 3D flow quantity
[in]	box	pointer to box structure
[in]	s	an integer taking only the values +1 (symmetric profile) or -1 (antisymmetric profile)

Definition at line 501 of file boundary.c.

{
  int   i, j, k;
  RBox *box = GetRBox(side, vpos);

  if (side == X1_BEG) {   

    if (box->vpos != X1FACE){
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[k][j][2*IBEG-i-1];
    }else{
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[k][j][2*IBEG-i-2];
    }

  }else if (side == X1_END){  

    if (box->vpos != X1FACE){
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[k][j][2*IEND-i+1];
    }else{
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[k][j][2*IEND-i];
    }

  }else if (side == X2_BEG){  

    if (box->vpos != X2FACE){
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[k][2*JBEG-j-1][i];
    }else{
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[k][2*JBEG-j-2][i];
    }

  }else if (side == X2_END){

    if (box->vpos != X2FACE){
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[k][2*JEND-j+1][i];
    }else{
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[k][2*JEND-j][i];
    }
  }else if (side == X3_BEG){

    if (box->vpos != X3FACE){
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[2*KBEG-k-1][j][i];
    }else{
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[2*KBEG-k-2][j][i];
    }

  }else if (side == X3_END){

    if (box->vpos != X3FACE){
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[2*KEND-k+1][j][i];
    }else{
      BOX_LOOP(box,k,j,i) q[k][j][i] = s*q[2*KEND-k][j][i];
    }

  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ResetState	(	const Data *	d,
		State_1D *	state,
		Grid *	grid
	)

Initialize some of the elements of the State_1D structure to zero in order to speed up computations. These includes:

• source term
• left and right eigenvectors
• the maximum eigenvalue ???

Parameters

[in]	d	pointer to Data structure
[out]	state	pointer to a State_1D structure
[in]	grid	pointer to an array of Grid structures

Definition at line 163 of file set_indexes.c.

{
  int i, j, k, nv;
  double v[NVAR], lambda[NVAR];
  double a;

  for (i = 0; i < NMAX_POINT; i++){
    for (j = NVAR; j--;  ) state->src[i][j] = 0.0;

    for (j = NFLX; j--;  ){
    for (k = NFLX; k--;  ){
      state->Lp[i][j][k] = state->Rp[i][j][k] = 0.0;
    }}
  }  

/* ---------------------------------------------------------
     When using Finite Difference methods, we need to find,
     for each characteristic k, its maximum over the 
     whole computational domain (LF global splitting).
   --------------------------------------------------------- */

  #ifdef FINITE_DIFFERENCE
   FD_GetMaxEigenvalues (d, state, grid);
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void RestartDump

(

Runtime *

ini

)

Write restart information needed for later restarts.

Definition at line 251 of file restart.c.

{
  int n;
  char fout[512];
  Restart restart;
  FILE *fr;

/* --------------------------------------------------
    Define restart structure elements here
   -------------------------------------------------- */

  restart.t  = g_time;
  restart.dt = g_dt;
  restart.nstep = g_stepNumber;
  for (n = 0; n < MAX_OUTPUT_TYPES; n++){
    restart.nfile[n] = ini->output[n].nfile;
  }  

/* --------------------------------------------------
    Dump structure to disk
   -------------------------------------------------- */

  counter++;
  if (prank == 0) {
    sprintf (fout,"%s/restart.out",ini->output_dir);
    if (counter == 0) {
      fr = fopen (fout, "wb");
    }else {
      fr = fopen (fout, "r+b");
      fseek (fr, counter*sizeof(Restart), SEEK_SET); 
    }

    fwrite (&restart, sizeof(Restart), 1, fr);
    fclose(fr);
  }
}

Here is the caller graph for this function:

void RestartFromFile	(	Runtime *	ini,
		int	nrestart,
		int	type,
		Grid *	grid
	)

Read input binary / hdf5 data.

Parameters

[in]	ini
[in]	nrestart
[in]	type	specifies the output data type (type should be either DBL_OUTPUT or DBL_H5_OUTPUT).
[in]	grid	pointer to an array of Grid structures

Definition at line 17 of file restart.c.

{
  int     nv, single_file, origin, nlines=0;
  int     swap_endian=0;
  char    fname[512], fout[512], str[512];
  double  dbl;
  void   *Vpt;
  Output *output;
  FILE   *fbin;

/* ----------------------------------------------------------
    Get the pointer to the output format specified by "type"
   ---------------------------------------------------------- */

  for (nv = 0; nv < MAX_OUTPUT_TYPES; nv++){
    output = ini->output + nv;
    if (output->type == type) break;
  }

/* -------------------------------------------------------
    Compare the endianity of the restart file (by reading
    the corresponding entry in dbl.out or dbl.h5.out) 
    with that of the current architecture.
    Turn swap_endian to 1 if they're different.
   ------------------------------------------------------- */

  if (prank == 0){
    if (type == DBL_OUTPUT) {
      sprintf (fout,"%s/dbl.out",ini->output_dir);
      fbin = fopen (fout, "r");
    } else if (type == DBL_H5_OUTPUT) {
      sprintf (fout,"%s/dbl.h5.out",ini->output_dir);
      fbin = fopen (fout, "r");
    }
    if (fbin == NULL){
      print1 ("! Restart: cannot find dbl.out or dbl.h5.out\n");
      QUIT_PLUTO(1);
    }

    while (fgets(str, 512, fbin) != 0) nlines++;  /* -- count lines in dbl.out -- */
    rewind(fbin);
    if (nrestart > nlines-1){
      printf ("! Restart: position too large\n");
      QUIT_PLUTO(1);
    }
    origin = (nrestart >= 0 ? nrestart:(nlines+nrestart));
    for (nv = origin; nv--;   ) while ( fgetc(fbin) != '\n'){}
    fscanf(fbin, "%d  %lf  %lf  %d  %s  %s\n",&nv, &dbl, &dbl, &nv, str, str);
    if ( (!strcmp(str,"big")    &&  IsLittleEndian()) ||
         (!strcmp(str,"little") && !IsLittleEndian())) {
      swap_endian = 1;
      print1 ("> Restart: endianity is reversed\n");
    }
    fclose(fbin);
  }
  #ifdef PARALLEL
   MPI_Bcast (&swap_endian, 1, MPI_INT, 0, MPI_COMM_WORLD);
  #endif

/* ---------------------------------------------
    Read restart.out and get Restart structure
   --------------------------------------------- */

  RestartGet (ini, nrestart, type, swap_endian);
  if (type == DBL_H5_OUTPUT){
    #ifdef USE_HDF5
     ReadHDF5 (output, grid);
    #endif
    return;
  }

  print1 ("> restarting from file #%d (dbl)\n",output->nfile);
  single_file = strcmp(output->mode,"single_file") == 0;
  
/* -----------------------------------------------------------------
           For .dbl output, read data from disk
   ----------------------------------------------------------------- */

  if (single_file){ 
    int  sz;
    long long offset;

    sprintf (fname, "%s/data.%04d.dbl", output->dir, output->nfile);
    offset = 0;
    #ifndef PARALLEL
     fbin = OpenBinaryFile (fname, 0, "r");
    #endif
    for (nv = 0; nv < output->nvar; nv++) {
      if (!output->dump_var[nv]) continue;

      if      (output->stag_var[nv] == -1) {  /* -- cell-centered data -- */
        sz = SZ;
        Vpt = (void *)output->V[nv][0][0];
      } else if (output->stag_var[nv] == 0) { /* -- x-staggered data -- */
        sz  = SZ_stagx;
        Vpt = (void *)(output->V[nv][0][0]-1);
      } else if (output->stag_var[nv] == 1) { /* -- y-staggered data -- */
        sz = SZ_stagy;
        Vpt = (void *)output->V[nv][0][-1];
      } else if (output->stag_var[nv] == 2) { /* -- z-staggered data -- */
         sz = SZ_stagz;
         Vpt = (void *)output->V[nv][-1][0];
      }
      #ifdef PARALLEL
       fbin = OpenBinaryFile (fname, sz, "r");
       AL_Set_offset(sz, offset);
      #endif
      ReadBinaryArray (Vpt, sizeof(double), sz, fbin,
                       output->stag_var[nv], swap_endian);
      #ifdef PARALLEL
       offset = AL_Get_offset(sz);
       CloseBinaryFile(fbin, sz);
      #endif
    }
    #ifndef PARALLEL
     CloseBinaryFile(fbin, sz);
    #endif

  }else{

    int  sz;
    for (nv = 0; nv < output->nvar; nv++) {
      if (!output->dump_var[nv]) continue;
      sprintf (fname, "%s/%s.%04d.%s", output->dir, output->var_name[nv], 
                                       output->nfile, output->ext);

      if      (output->stag_var[nv] == -1) {  /* -- cell-centered data -- */
        sz = SZ;
        Vpt = (void *)output->V[nv][0][0];
      } else if (output->stag_var[nv] == 0) { /* -- x-staggered data -- */
        sz  = SZ_stagx;
        Vpt = (void *)(output->V[nv][0][0]-1);
      } else if (output->stag_var[nv] == 1) { /* -- y-staggered data -- */
        sz = SZ_stagy;
        Vpt = (void *)output->V[nv][0][-1];
      } else if (output->stag_var[nv] == 2) { /* -- z-staggered data -- */
         sz = SZ_stagz;
         Vpt = (void *)output->V[nv][-1][0];
      }
      fbin = OpenBinaryFile (fname, sz, "r");
      ReadBinaryArray (Vpt, sizeof(double), sz, fbin,
                       output->stag_var[nv], swap_endian);
      CloseBinaryFile (fbin, sz);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void RestartGet	(	Runtime *	ini,
		int	nrestart,
		int	out_type,
		int	swap_endian
	)

Collect restart information needed for (potential) later restarts.

Definition at line 177 of file restart.c.

{
  int  origin, n, k;
  char fout[512];
  Restart restart;
  FILE *fr;

  if (nrestart < 0){
    printf ("! negative restart file temporarily disabled\n");
    QUIT_PLUTO(1);
  }

/* -------------------------------------------------
    Open "restart.out" and scan line by line until
    the output type specified by "out_type" has
    nfile = nrestart.
    counter will contain the line number where this
    occurs. Processor 0 does the actual reading.
   ------------------------------------------------- */

  if (prank == 0) {
    sprintf (fout,"%s/restart.out",ini->output_dir);
    fr = fopen (fout, "rb");
    if (fr == NULL){
      print1 ("! RestartGet: cannot find restart.out\n");
      QUIT_PLUTO(1);
    }

    origin = (nrestart < 0 ? SEEK_END:SEEK_SET);
    k = 0;
    while (counter == -1){
      if (feof(fr)){
        print("! RestartGet: end of file encountered.\n");
        QUIT_PLUTO(1);
      }
      fseek (fr, k*sizeof(Restart), origin);
      fread (&restart, sizeof (Restart), 1, fr);
      for (n = 0; n < MAX_OUTPUT_TYPES; n++){
        if (swap_endian) SWAP_VAR(restart.nfile[n]);
        if (ini->output[n].type == out_type && restart.nfile[n] == nrestart){
          counter = k;
        }
      }
      k++;
    }
    fclose(fr);
    if (swap_endian){
      SWAP_VAR(restart.t);
      SWAP_VAR(restart.dt);
      SWAP_VAR(restart.nstep);
    }
  }

/* printf ("counter = %d\n",counter); */

  #ifdef PARALLEL
   MPI_Bcast (&restart, sizeof (Restart), MPI_BYTE, 0, MPI_COMM_WORLD);
  #endif

  g_time       = restart.t;
  g_dt         = restart.dt;
  g_stepNumber = restart.nstep;

  for (n = 0; n < MAX_OUTPUT_TYPES; n++){
    ini->output[n].nfile = restart.nfile[n];
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void RightHandSide	(	const State_1D *	state,
		Time_Step *	Dts,
		int	beg,
		int	end,
		double	dt,
		Grid *	grid
	)

Parameters

[in,out]	state	pointer to State_1D structure
[in]	Dts	pointer to time step structure
[in]	beg	initial index of computation
[in]	end	final index of computation
[in]	dt	time increment
[in]	grid	pointer to Grid structure

Returns

This function has no return value.

Note

–

Todo:

–

Definition at line 88 of file rhs.c.

{
  int    i, j, k, nv;
  double dtdx, dtdV, scrh, rhog;
  double *x1  = grid[IDIR].x,  *x2  = grid[JDIR].x,  *x3  = grid[KDIR].x;
  double *x1p = grid[IDIR].xr, *x2p = grid[JDIR].xr, *x3p = grid[KDIR].xr;
  double *dx1 = grid[IDIR].dx, *dx2 = grid[JDIR].dx, *dx3 = grid[KDIR].dx;
  double *dV1 = grid[IDIR].dV, *dV2 = grid[JDIR].dV, *dV3 = grid[KDIR].dV;
  double **rhs  = state->rhs;
  double **flux = state->flux, *p = state->press;
  double **vh   = state->vh, **vp = state->vp, **vm = state->vm;
  double *A     = grid[g_dir].A, *dV    = grid[g_dir].dV;
  
  double cl;
  double w, wp, vphi, phi_c;
  double g[3];
  static double **fA, *phi_p;
  static double **fvA;
#if ENTROPY_SWITCH
  double rhs_entr;
  double **visc_flux = state->visc_flux; 
  double **visc_src  = state->visc_src; 
  double **tc_flux   = state->tc_flux; 
  double **res_flux  = state->res_flux;   
  if (fvA == NULL) fvA = ARRAY_2D(NMAX_POINT, NVAR, double);
#endif

  #if GEOMETRY != CARTESIAN
   if (fA == NULL) fA = ARRAY_2D(NMAX_POINT, NVAR, double);
  #endif
  if (phi_p == NULL) phi_p = ARRAY_1D(NMAX_POINT, double);

/* --------------------------------------------------
   1. Compute fluxes for passive scalars and dust
   -------------------------------------------------- */

#if NSCL > 0
  AdvectFlux (state, beg - 1, end, grid);
#endif

#if DUST == YES
  Dust_Solver(state, beg - 1, end, Dts->cmax, grid);
#endif

  i = g_i;  /* will be redefined during x1-sweep */
  j = g_j;  /* will be redefined during x2-sweep */
  k = g_k;  /* will be redefined during x3-sweep */
  
/* ------------------------------------------------
     Add pressure to normal component of 
     momentum flux if necessary.
   ------------------------------------------------ */

#if USE_PR_GRADIENT == NO
  for (i = beg - 1; i <= end; i++) flux[i][MXn] += p[i];
#endif

/* -----------------------------------------------------
     Compute gravitational potential at cell interfaces
   -----------------------------------------------------  */

#if (BODY_FORCE & POTENTIAL)
  if (g_dir == IDIR) {
    for (i = beg-1; i <= end; i++) {
      phi_p[i] = BodyForcePotential(x1p[i], x2[j], x3[k]);
    }
  }else if (g_dir == JDIR){
    for (j = beg-1; j <= end; j++) {
      phi_p[j] = BodyForcePotential(x1[i], x2p[j], x3[k]);
    }
  }else if (g_dir == KDIR){
    for (k = beg-1; k <= end; k++) {
      phi_p[k] = BodyForcePotential(x1[i], x2[j], x3p[k]);
    }
  }
#endif
  
/* -----------------------------------------------------
    Compute total flux
   -----------------------------------------------------  */

  #if (defined FARGO && !defined SHEARINGBOX) ||\
      (ROTATING_FRAME == YES) || (BODY_FORCE & POTENTIAL)
   TotalFlux(state, phi_p, beg-1, end, grid);
  #endif

#if GEOMETRY == CARTESIAN

  if (g_dir == IDIR){

    for (i = beg; i <= end; i++) {
      dtdx = dt/dx1[i];

    /* -- I1. initialize rhs with flux difference -- */

      NVAR_LOOP(nv) rhs[i][nv] = -dtdx*(flux[i][nv] - flux[i-1][nv]);
      #if USE_PR_GRADIENT == YES
       rhs[i][MX1] -= dtdx*(p[i] - p[i-1]);
      #endif

    /* -- I5. Add dissipative terms to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       rhog = vh[i][RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma);
 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (visc_flux[i][ENG] - visc_flux[i-1][ENG]);
        rhs_entr -= EXPAND(  vh[i][VX1]*(visc_flux[i][MX1] - visc_flux[i-1][MX1])  ,
                           + vh[i][VX2]*(visc_flux[i][MX2] - visc_flux[i-1][MX2])  ,
                           + vh[i][VX3]*(visc_flux[i][MX3] - visc_flux[i-1][MX3]));
       #endif

       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (tc_flux[i][ENG] - tc_flux[i-1][ENG]);       
       #endif
       rhs[i][ENTR] += rhs_entr*dtdx*rhog;              
      #endif

    }
  } else if (g_dir == JDIR){

    for (j = beg; j <= end; j++) {
      dtdx = dt/dx2[j];

    /* -- J1. initialize rhs with flux difference -- */

      NVAR_LOOP(nv) rhs[j][nv] = -dtdx*(flux[j][nv] - flux[j-1][nv]);
      #if USE_PR_GRADIENT == YES
       rhs[j][MX2] -= dtdx*(p[j] - p[j-1]);
      #endif

    /* -- J5. Add dissipative terms to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       rhog = vh[j][RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma);
 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (visc_flux[j][ENG] - visc_flux[j-1][ENG]);
        rhs_entr -= EXPAND(  vh[j][VX1]*(visc_flux[j][MX1] - visc_flux[j-1][MX1])  ,
                           + vh[j][VX2]*(visc_flux[j][MX2] - visc_flux[j-1][MX2])  ,
                           + vh[j][VX3]*(visc_flux[j][MX3] - visc_flux[j-1][MX3]));
       #endif

       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (tc_flux[j][ENG] - tc_flux[j-1][ENG]);       
       #endif
       rhs[j][ENTR] += rhs_entr*dtdx*rhog;              
      #endif
      
    }

  }else if (g_dir == KDIR){

    for (k = beg; k <= end; k++) {
      dtdx = dt/dx3[k];

    /* -- K1. initialize rhs with flux difference -- */

      NVAR_LOOP(nv) rhs[k][nv] = -dtdx*(flux[k][nv] - flux[k-1][nv]);
      #if USE_PR_GRADIENT == YES
       rhs[k][MX3] -= dtdx*(p[k] - p[k-1]);
      #endif

    /* -- K5. Add dissipative terms to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       rhog = vh[k][RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma); 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (visc_flux[k][ENG] - visc_flux[k-1][ENG]);
        rhs_entr -= EXPAND(  vh[k][VX1]*(visc_flux[k][MX1] - visc_flux[k-1][MX1])  ,
                           + vh[k][VX2]*(visc_flux[k][MX2] - visc_flux[k-1][MX2])  ,
                           + vh[k][VX3]*(visc_flux[k][MX3] - visc_flux[k-1][MX3]));
       #endif

       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (tc_flux[k][ENG] - tc_flux[k-1][ENG]);
       #endif
       rhs[k][ENTR] += rhs_entr*dtdx*rhog;              
      #endif
    }
  }

#elif GEOMETRY == CYLINDRICAL

{
  double R, z, phi, R_1; 

#if DUST == YES
  #error "DUST not implemented in CYLINDRICAL coordinates"
#endif

  if (g_dir == IDIR) {  
    double vc[NVAR];

    GetAreaFlux (state, fA, fvA, beg, end, grid);
    for (i = beg; i <= end; i++){ 
      R    = x1[i];
      dtdV = dt/dV1[i];
      dtdx = dt/dx1[i];
      R_1  = 1.0/R;

    /* -- I1. initialize rhs with flux difference -- */

      rhs[i][RHO] = -dtdV*(fA[i][RHO] - fA[i-1][RHO]);
      EXPAND(rhs[i][iMR]   = - dtdV*(fA[i][iMR]   - fA[i-1][iMR]);  ,
             rhs[i][iMZ]   = - dtdV*(fA[i][iMZ]   - fA[i-1][iMZ]);  ,
             rhs[i][iMPHI] = - dtdV*(fA[i][iMPHI] - fA[i-1][iMPHI])*fabs(R_1);)
      #if USE_PR_GRADIENT == YES
       rhs[i][iMR] -= dtdx*(p[i] - p[i-1]);  
      #endif
      #if PHYSICS == MHD
       EXPAND(rhs[i][iBR]   = - dtdV*(fA[i][iBR]   - fA[i-1][iBR]);  ,
              rhs[i][iBZ]   = - dtdV*(fA[i][iBZ]   - fA[i-1][iBZ]);  ,
              rhs[i][iBPHI] = - dtdx*(flux[i][iBPHI] - flux[i-1][iBPHI]);)
       #ifdef GLM_MHD
        rhs[i][iBR]     = - dtdx*(flux[i][iBR]   - flux[i-1][iBR]);
        rhs[i][PSI_GLM] = - dtdV*(fA[i][PSI_GLM] - fA[i-1][PSI_GLM]);
       #endif
      #endif
      IF_ENERGY(rhs[i][ENG] = -dtdV*(fA[i][ENG] - fA[i-1][ENG]);)
      NSCL_LOOP(nv)  rhs[i][nv] = -dtdV*(fA[i][nv] - fA[i-1][nv]);
      
    /* -- I5. Add dissipative terms to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       NVAR_LOOP(nv) vc[nv] = 0.5*(vp[i][nv] + vm[i][nv]); 
       rhog = vc[RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma);
 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (fvA[i][ENG] - fvA[i-1][ENG]);
        rhs_entr -= EXPAND(  vc[VX1]*(fvA[i][MX1] - fvA[i-1][MX1])      ,
                           + vc[VX2]*(fvA[i][MX2] - fvA[i-1][MX2])      ,
                           + vc[VX3]*(fvA[i][MX3] - fvA[i-1][MX3])*fabs(R_1));
                    
        rhs_entr -= EXPAND(  vc[VX1]*visc_src[i][MX1], 
                           + vc[VX2]*visc_src[i][MX2],
                           + vc[VX3]*visc_src[i][MX3]);
       #endif

       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (A[i]*tc_flux[i][ENG] - A[i-1]*tc_flux[i-1][ENG]);       
       #endif
       rhs[i][ENTR] += rhs_entr*dtdV*rhog;              
      #endif
    }
     
  } else if (g_dir == JDIR) { 

    for (j = beg; j <= end; j++){ 
      dtdx = dt/dx2[j];

    /* -- J1. initialize rhs with flux difference -- */

      NVAR_LOOP(nv) rhs[j][nv] = -dtdx*(flux[j][nv] - flux[j-1][nv]);
      #if USE_PR_GRADIENT == YES
       rhs[j][iMZ] += - dtdx*(p[j] - p[j-1]);
      #endif

    /* -- J5. Add dissipative terms to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       rhog = vh[j][RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma);
 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (visc_flux[j][ENG] - visc_flux[j-1][ENG]);
        rhs_entr -= EXPAND(  vc[VX1]*(visc_flux[j][MX1] - visc_flux[j-1][MX1])  ,
                           + vc[VX2]*(visc_flux[j][MX2] - visc_flux[j-1][MX2])  ,
                           + vc[VX3]*(visc_flux[j][MX3] - visc_flux[j-1][MX3]));
       #endif
       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (tc_flux[j][ENG] - tc_flux[j-1][ENG]);
       #endif
       rhs[j][ENTR] += rhs_entr*dtdx*rhog;              
      #endif
    }
  }
}

#elif GEOMETRY == POLAR
{
  double R, phi, z; 
  double R_1;
   
  if (g_dir == IDIR) { 
    double vc[NVAR];

    GetAreaFlux (state, fA, fvA, beg, end, grid);
    for (i = beg; i <= end; i++) {
      R    = x1[i];
      dtdV = dt/dV1[i];
      dtdx = dt/dx1[i];
      R_1  = grid[IDIR].r_1[i];

    /* -- I1. initialize rhs with flux difference -- */

      rhs[i][RHO] = -dtdV*(fA[i][RHO] - fA[i-1][RHO]);
      EXPAND(rhs[i][iMR]   = - dtdV*(fA[i][iMR]   - fA[i-1][iMR])
                             - dtdx*(p[i] - p[i-1]);                      ,      
             rhs[i][iMPHI] = - dtdV*(fA[i][iMPHI] - fA[i-1][iMPHI])*R_1;  ,
             rhs[i][iMZ]   = - dtdV*(fA[i][iMZ]   - fA[i-1][iMZ]);)
  #if PHYSICS == MHD 
      EXPAND(rhs[i][iBR]   = -dtdV*(fA[i][iBR]     - fA[i-1][iBR]);      ,
             rhs[i][iBPHI] = -dtdx*(flux[i][iBPHI] - flux[i-1][iBPHI]);  ,
             rhs[i][iBZ]   = -dtdV*(fA[i][iBZ]     - fA[i-1][iBZ]);)
    #ifdef GLM_MHD
      rhs[i][iBR]     = -dtdx*(flux[i][iBR]   - flux[i-1][iBR]);
      rhs[i][PSI_GLM] = -dtdV*(fA[i][PSI_GLM] - fA[i-1][PSI_GLM]);
    #endif
  #endif
      IF_ENERGY(rhs[i][ENG] = -dtdV*(fA[i][ENG] - fA[i-1][ENG]);)

      NSCL_LOOP(nv)  rhs[i][nv] = -dtdV*(fA[i][nv] - fA[i-1][nv]);

      IF_DUST(NDUST_LOOP(nv) rhs[i][nv] = -dtdV*(fA[i][nv] - fA[i-1][nv]);  
              rhs[i][MX2_D] *= R_1;)

    /* -- I5. Add dissipative terms to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       for (nv = NVAR; nv--;  ) vc[nv] = 0.5*(vp[i][nv] + vm[i][nv]); 
       rhog = vc[RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma);
 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (fvA[i][ENG] - fvA[i-1][ENG]);
        rhs_entr -= EXPAND(  vc[VX1]*(fvA[i][iMR]   - fvA[i-1][iMR])        ,
                           + vc[VX2]*(fvA[i][iMPHI] - fvA[i-1][iMPHI])*R_1  ,
                           + vc[VX3]*(fvA[i][iMZ]   - fvA[i-1][iMZ]));
                    
        rhs_entr -= EXPAND(  vc[VX1]*visc_src[i][MX1], 
                           + vc[VX2]*visc_src[i][MX2],
                           + vc[VX3]*visc_src[i][MX3]);
       #endif

       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (A[i]*tc_flux[i][ENG] - A[i-1]*tc_flux[i-1][ENG]);       
       #endif
       rhs[i][ENTR] += rhs_entr*dtdV*rhog;              
      #endif

    }
     
  } else if (g_dir == JDIR) {

    scrh = dt/x1[i];
    for (j = beg; j <= end; j++){ 
      dtdx = scrh/dx2[j];

    /* -- J1. Compute equations rhs for phi-contributions -- */

      NVAR_LOOP(nv) rhs[j][nv] = -dtdx*(flux[j][nv] - flux[j-1][nv]);
      rhs[j][iMPHI] -= dtdx*(p[j] - p[j-1]);

    /* -- J5. Add dissipative terms to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       rhog = vh[j][RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma);
 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (visc_flux[j][ENG] - visc_flux[j-1][ENG]);
        rhs_entr -= EXPAND(  vh[j][VX1]*(visc_flux[j][MX1] - visc_flux[j-1][MX1]) ,
                           + vh[j][VX2]*(visc_flux[j][MX2] - visc_flux[j-1][MX2]) ,
                           + vh[j][VX3]*(visc_flux[j][MX3] - visc_flux[j-1][MX3]));
                    
        rhs_entr -= EXPAND(  vh[j][VX1]*visc_src[j][MX1], 
                           + vh[j][VX2]*visc_src[j][MX2],
                           + vh[j][VX3]*visc_src[j][MX3]);
       #endif
       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (tc_flux[j][ENG] - tc_flux[j-1][ENG]);
       #endif
       rhs[j][ENTR] += rhs_entr*dtdx*rhog;              
      #endif
      
    }

  } else if (g_dir == KDIR) { 

    for (k = beg; k <= end; k++){ 
      dtdx = dt/dx3[k];

    /* -- K1. initialize rhs with flux difference -- */

      VAR_LOOP(nv) rhs[k][nv] = -dtdx*(flux[k][nv] - flux[k-1][nv]);
      rhs[k][MX3] -= dtdx*(p[k] - p[k-1]);

    /* -- K5. Add dissipative terms to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       rhog = vh[k][RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma);
 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (visc_flux[k][ENG] - visc_flux[k-1][ENG]);
        rhs_entr -= EXPAND(  vh[j][VX1]*(visc_flux[k][MX1] - visc_flux[k-1][MX1])  ,
                           + vh[j][VX2]*(visc_flux[k][MX2] - visc_flux[k-1][MX2])  ,
                           + vh[j][VX3]*(visc_flux[k][MX3] - visc_flux[k-1][MX3]));
       #endif

       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (tc_flux[k][ENG] - tc_flux[k-1][ENG]);
       #endif
       rhs[k][ENTR] += rhs_entr*dtdx*rhog;              
      #endif
 
    }
  }
}
#elif GEOMETRY == SPHERICAL
{
  double r_1, th, s, s_1;

  if (g_dir == IDIR) { 
    double vc[NVAR], dVdx;

    GetAreaFlux (state, fA, fvA, beg, end, grid);
    for (i = beg; i <= end; i++) { 
      dtdV = dt/dV1[i];
      dtdx = dt/dx1[i];
      r_1  = grid[IDIR].r_1[i];

    /* -- I1. initialize rhs with flux difference -- */

/* Alternative sequence 
dVdx = dV1[i]/dx1[i];
NVAR_LOOP(nv) rhs[i][nv] = -dtdV*(fA[i][nv] - fA[i-1][nv]);
rhs[i][MX1] -= dtdx*(p[i] - p[i-1]);
rhs[i][MX3] *= r_1;
#if PHYSICS == MHD
 EXPAND(             
                               ,
      rhs[i][iBTH]  *= dVrdx;  ,
      rhs[i][iBPHI] *= dVrdx;
  )
 #ifdef GLM_MHD
   rhs[i][iBR]     *= dVdx;
 #endif
#endif
IF_DUST(rhs[i][MX3_D] *= r_1;)
*/

      rhs[i][RHO] = -dtdV*(fA[i][RHO] - fA[i-1][RHO]);
      EXPAND(
        rhs[i][iMR]   = - dtdV*(fA[i][iMR] - fA[i-1][iMR])
                        - dtdx*(p[i] - p[i-1]);                    ,
        rhs[i][iMTH]  = -dtdV*(fA[i][iMTH]  - fA[i-1][iMTH]);      ,
        rhs[i][iMPHI] = -dtdV*(fA[i][iMPHI] - fA[i-1][iMPHI])*r_1; 
      )
      #if PHYSICS == MHD
       EXPAND(                                                     
         rhs[i][iBR]   = -dtdV*(fA[i][iBR]   - fA[i-1][iBR]);       ,
         rhs[i][iBTH]  = -dtdx*(fA[i][iBTH]  - fA[i-1][iBTH])*r_1;  ,
         rhs[i][iBPHI] = -dtdx*(fA[i][iBPHI] - fA[i-1][iBPHI])*r_1;
       )
       #ifdef GLM_MHD
        rhs[i][iBR]     = -dtdx*(flux[i][iBR]   - flux[i-1][iBR]);
        rhs[i][PSI_GLM] = -dtdV*(fA[i][PSI_GLM] - fA[i-1][PSI_GLM]);
       #endif
      #endif
      IF_ENERGY(rhs[i][ENG] = -dtdV*(fA[i][ENG] - fA[i-1][ENG]);)

      NSCL_LOOP(nv) rhs[i][nv] = -dtdV*(fA[i][nv] - fA[i-1][nv]);
      IF_DUST(NDUST_LOOP(nv) rhs[i][nv] = -dtdV*(fA[i][nv] - fA[i-1][nv]);  
              rhs[i][MX3_D] *= r_1;)

    /* -- I5. Add dissipative terms to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       NVAR_LOOP(nv) vc[nv] = 0.5*(vp[i][nv] + vm[i][nv]);
     
       rhog = vc[RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma);
 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (fvA[i][ENG] - fvA[i-1][ENG]);
        rhs_entr -= EXPAND(  vc[VX1]*(fvA[i][iMR]   - fvA[i-1][iMR])        ,
                           + vc[VX2]*(fvA[i][iMTH]  - fvA[i-1][iMTH])       ,
                           + vc[VX3]*(fvA[i][iMPHI] - fvA[i-1][iMPHI])*r_1);
                    
        rhs_entr -= EXPAND(  vc[VX1]*visc_src[i][MX1], 
                           + vc[VX2]*visc_src[i][MX2],
                           + vc[VX3]*visc_src[i][MX3]);
       #endif
       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (A[i]*tc_flux[i][ENG] - A[i-1]*tc_flux[i-1][ENG]);       
       #endif
       rhs[i][ENTR] += rhs_entr*dtdV*rhog;              
      #endif
    }

  } else if (g_dir == JDIR) {

    GetAreaFlux (state, fA, fvA, beg, end, grid);
    r_1 = 0.5*(x1p[i]*x1p[i] - x1p[i-1]*x1p[i-1])/dV1[i];
    scrh = dt*r_1;
    for (j = beg; j <= end; j++){
      th   = x2[j];
      dtdV = scrh/dV2[j];
      dtdx = scrh/dx2[j];
      s    = sin(th);
      s_1  = 1.0/s;   

    /* -- J1. initialize rhs with flux difference -- */

      rhs[j][RHO] = -dtdV*(fA[j][RHO] - fA[j-1][RHO]);
      EXPAND(
        rhs[j][iMR]   = - dtdV*(fA[j][iMR] - fA[j-1][iMR]);  , 
        rhs[j][iMTH]  = - dtdV*(fA[j][iMTH] - fA[j-1][iMTH])
                        - dtdx*(p[j] - p[j-1]);              , 
        rhs[j][iMPHI] = - dtdV*(fA[j][iMPHI] - fA[j-1][iMPHI])*fabs(s_1);
      )       
      #if PHYSICS == MHD
       EXPAND(                                                     
         rhs[j][iBR]   = -dtdV*(fA[j][iBR]   - fA[j-1][iBR]);   ,
         rhs[j][iBTH]  = -dtdV*(fA[j][iBTH]  - fA[j-1][iBTH]);  ,
         rhs[j][iBPHI] = -dtdx*(flux[j][iBPHI] - flux[j-1][iBPHI]);
       )
       #ifdef GLM_MHD
        rhs[j][iBTH]    = -dtdx*(flux[j][iBTH] - flux[j-1][iBTH]);
        rhs[j][PSI_GLM] = -dtdV*(fA[j][PSI_GLM] - fA[j-1][PSI_GLM]);
       #endif
      #endif
      IF_ENERGY(rhs[j][ENG] = -dtdV*(fA[j][ENG] - fA[j-1][ENG]);)
      
      NSCL_LOOP(nv) rhs[j][nv] = -dtdV*(fA[j][nv] - fA[j-1][nv]);

      IF_DUST(NDUST_LOOP(nv) rhs[j][nv] = -dtdV*(fA[j][nv] - fA[j-1][nv]);
              rhs[j][MX3_D] *= fabs(s_1);)
      
    /* -- J5. Add TC dissipative term to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       rhog = vh[j][RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma);
 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (fvA[j][ENG] - fvA[j-1][ENG]);
        rhs_entr -= EXPAND(  vc[VX1]*(fvA[j][iMR]   - fvA[j-1][iMR])        ,
                           + vc[VX2]*(fvA[j][iMTH]  - fvA[j-1][iMTH])       ,
                           + vc[VX3]*(fvA[j][iMPHI] - fvA[j-1][iMPHI])*fabs(s_1));
                    
        rhs_entr -= EXPAND(  vc[VX1]*visc_src[j][MX1], 
                           + vc[VX2]*visc_src[j][MX2],
                           + vc[VX3]*visc_src[j][MX3]);
       #endif
       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (A[j]*tc_flux[j][ENG] - A[j-1]*tc_flux[j-1][ENG]);
       #endif
       rhs[j][ENTR] += rhs_entr*dtdV*rhog;              
      #endif

    }

  } else if (g_dir == KDIR) {

    r_1  = 0.5*(x1p[i]*x1p[i] - x1p[i-1]*x1p[i-1])/dV1[i];
    scrh = dt*r_1*dx2[j]/dV2[j];
    for (k = beg; k <= end; k++) {
      dtdx = scrh/dx3[k];

    /* -- K1.  initialize rhs with flux difference -- */

      VAR_LOOP(nv) rhs[k][nv] = -dtdx*(flux[k][nv] - flux[k-1][nv]);
      rhs[k][iMPHI] -= dtdx*(p[k] - p[k-1]); 

    /* -- K5. Add dissipative terms to entropy equation -- */

      #if (ENTROPY_SWITCH) && (PARABOLIC_FLUX & EXPLICIT)
       rhog = vh[k][RHO];
       rhog = (g_gamma - 1.0)*pow(rhog,1.0-g_gamma);
 
       rhs_entr = 0.0;
       #if VISCOSITY == EXPLICIT
        rhs_entr += (visc_flux[k][ENG] - visc_flux[k-1][ENG]);
        rhs_entr -= EXPAND(  vc[VX1]*(visc_flux[k][MX1] - visc_flux[k-1][MX1])  ,
                           + vc[VX2]*(visc_flux[k][MX2] - visc_flux[k-1][MX2])  ,
                           + vc[VX3]*(visc_flux[k][MX3] - visc_flux[k-1][MX3]));
       #endif
       #if THERMAL_CONDUCTION == EXPLICIT
        rhs_entr += (tc_flux[k][ENG] - tc_flux[k-1][ENG]);
       #endif
       rhs[k][ENTR] += rhs_entr*dtdx*rhog;              
      #endif      
    }
  }
}
#endif  /* GEOMETRY == SPHERICAL */

/* --------------------------------------------------------------
    Add source terms
   -------------------------------------------------------------- */

  RightHandSideSource (state, Dts, beg, end, dt, phi_p, grid);

/* --------------------------------------------------
    Reset right hand side in internal boundary zones
   -------------------------------------------------- */
   
  #if INTERNAL_BOUNDARY == YES
   InternalBoundaryReset(state, Dts, beg, end, grid);
  #endif
  
/* --------------------------------------------------
           Time step determination
   -------------------------------------------------- */

#if !GET_MAX_DT
return;
#endif

  cl = 0.0;
  for (i = beg-1; i <= end; i++) {
    scrh = Dts->cmax[i]*grid[g_dir].inv_dxi[i];
    cl = MAX(cl, scrh);   
  }
  #if GEOMETRY == POLAR || GEOMETRY == SPHERICAL
   if (g_dir == JDIR) {
     cl /= fabs(grid[IDIR].xgc[g_i]);
   }
   #if GEOMETRY == SPHERICAL
    if (g_dir == KDIR){
      cl /= fabs(grid[IDIR].xgc[g_i])*sin(grid[JDIR].xgc[g_j]);
    }
   #endif
  #endif
  Dts->inv_dta = MAX(cl, Dts->inv_dta);  
}

Here is the call graph for this function:

Here is the caller graph for this function:

void RightHandSideSource	(	const State_1D *	state,
		Time_Step *	Dts,
		int	beg,
		int	end,
		double	dt,
		double *	phi_p,
		Grid *	grid
	)

Parameters

[in,out]	state	pointer to State_1D structure
[in]	Dts	pointer to time step structure
[in]	beg	initial index of computation
[in]	end	final index of computation
[in]	dt	time increment
[in]	phi_p	force potential at interfaces
[in]	grid	pointer to Grid structure

Returns

This function has no return value.

Definition at line 68 of file rhs_source.c.

{
  int    i, j, k, nv;
  double r_1, g[3];

  double dtdx, scrh, th, ct, s;
  double Sm;
  double *x1  = grid[IDIR].x,  *x2  = grid[JDIR].x,  *x3  = grid[KDIR].x;
  double *x1p = grid[IDIR].xr, *x2p = grid[JDIR].xr, *x3p = grid[KDIR].xr;
  double *dx1 = grid[IDIR].dx, *dx2 = grid[JDIR].dx, *dx3 = grid[KDIR].dx;
  double *dV1 = grid[IDIR].dV, *dV2 = grid[JDIR].dV, *dV3 = grid[KDIR].dV;

  double **rhs  = state->rhs;
  double **flux = state->flux;
  double **vh   = state->vh;
  double **vp   = state->vp;
  double **vm   = state->vm;
  double *p;
  double *A, *dV;
  double cl;
  double **Bg0, **wA, w, wp, vphi, phi_c;
  double vphi_d, Sm_d;
  double vc[NVAR], *vg;

#ifdef FARGO
  wA = FARGO_GetVelocity();
#endif

#if (PHYSICS == MHD) && (BACKGROUND_FIELD == YES)
  Bg0 = GetBackgroundField (beg, end, CELL_CENTER, grid);
#endif

/* --------------------------
      pointer shortcuts
   -------------------------- */

  p  = state->press;
  A  = grid[g_dir].A;
  dV = grid[g_dir].dV;
  
  i = g_i;  /* will be redefined during x1-sweep */
  j = g_j;  /* will be redefined during x2-sweep */
  k = g_k;  /* will be redefined during x3-sweep */
  
  if (g_dir == IDIR){

#if GEOMETRY == SPHERICAL
    th = x2[j];
    s  = sin(th);
#endif

    for (i = beg; i <= end; i++) {
      dtdx = dt/dx1[i];

    /* --------------------------------------------
       I1. Add geometrical source term
       -------------------------------------------- */

#if GEOMETRY == CARTESIAN

      vg = state->vh[i];
  #ifdef SHEARINGBOX  /* Include Coriolis term for x-momentum */
      rhs[i][MX1] += dt*2.0*vh[i][RHO]*vh[i][VX2]*SB_OMEGA;
  #endif

  #if (defined FARGO && !defined SHEARINGBOX) 
      w = wA[k][i];
  #endif
  
#elif GEOMETRY == CYLINDRICAL

      r_1 = 1.0/x1[i];
      vg  = vc;
      NFLX_LOOP(nv) vc[nv] = 0.5*(vp[i][nv] + vm[i][nv]);       
      #if COMPONENTS == 3
       vphi = vc[iVPHI];
       IF_ROTATING_FRAME(w     = g_OmegaZ*x1[i];
                         vphi += w;)
       rhs[i][MX1] += dt*(vc[RHO]*vphi*vphi - TotBB(vc, Bg0[i], iBPHI, iBPHI))*r_1;
      #endif

#elif GEOMETRY == POLAR

      r_1 = grid[IDIR].r_1[i];
      vg  = vc;
      NFLX_LOOP(nv) vc[nv] = 0.5*(vp[i][nv] + vm[i][nv]); 
      vphi = vc[iVPHI];
  #if (defined FARGO) || (ROTATING_FRAME == YES)
      w = 0.0;
      IF_FARGO         (w += wA[k][i];)
      IF_ROTATING_FRAME(w += g_OmegaZ*x1[i];)
      vphi += w;
  #endif
      rhs[i][MX1] += dt*(  vc[RHO]*vphi*vphi 
                         - TotBB(vc, Bg0[i], iBPHI, iBPHI))*r_1;

      IF_DUST(vphi_d = SELECT(0.0, vc[VX3_D], 0.0);
              #if (defined FARGO) || (ROTATING_FRAME == YES)
              vphi_d += w;
              #endif
              rhs[i][MX1_D] += dt*vc[RHO_D]*vphi_d*vphi_d*r_1;)

#elif GEOMETRY == SPHERICAL

      r_1 = 1.0/x1[i];
      vg  = vc;
      NFLX_LOOP(nv) vc[nv] = 0.5*(vp[i][nv] + vm[i][nv]);
      vphi = SELECT(0.0, 0.0, vc[iVPHI]);
  #if (defined FARGO) || (ROTATING_FRAME == YES)
      w = 0.0;
      IF_FARGO         (w += wA[j][i];)
      IF_ROTATING_FRAME(w += g_OmegaZ*x1[i]*s;)
      vphi += w;
  #endif
      Sm = vc[RHO]*(EXPAND(  0.0, + vc[VX2]*vc[VX2], + vphi*vphi));
      Sm += EXPAND(  0.0, - TotBB(vc, Bg0[i], iBTH, iBTH), 
                          - TotBB(vc, Bg0[i], iBPHI,iBPHI));
      rhs[i][MX1] += dt*Sm*r_1;

      IF_DUST(vphi_d = SELECT(0.0, 0.0, vc[VX3_D]);
              #if (defined FARGO) || (ROTATING_FRAME == YES)
              vphi_d += w;
              #endif    
              Sm_d = vc[RHO_D]*(EXPAND(  0.0, + vc[VX2_D]*vc[VX2_D], + vphi_d*vphi_d));
              rhs[i][MX1_D] += dt*Sm_d*r_1;)  
#endif

    /* ----------------------------------------------------
       I2. Modify rhs to enforce conservation
       ---------------------------------------------------- */

#if ((defined FARGO && !defined SHEARINGBOX) || (ROTATING_FRAME == YES)) 
      rhs[i][iMPHI] -= w*rhs[i][RHO];
      IF_DUST  (rhs[i][iMPHI_D] -= w*rhs[i][RHO_D];)
      IF_ENERGY(rhs[i][ENG] -= w*(rhs[i][iMPHI] + 0.5*w*rhs[i][RHO]);)
#endif

    /* ----------------------------------------------------
       I3. Include body forces
       ---------------------------------------------------- */

#if (BODY_FORCE & VECTOR)
      BodyForceVector(vg, g, x1[i], x2[j], x3[k]);
      rhs[i][MX1]   += dt*vg[RHO]*g[IDIR];
      IF_DUST  (rhs[i][MX1_D] += dt*vg[RHO_D]*g[IDIR];)
      IF_ENERGY(rhs[i][ENG] += dt*0.5*(flux[i][RHO] + flux[i-1][RHO])*g[IDIR];) 
#endif
      
#if (BODY_FORCE & POTENTIAL)
      rhs[i][MX1]   -= dtdx*vg[RHO]*(phi_p[i] - phi_p[i-1]);
      IF_DUST  (rhs[i][MX1_D] -= dtdx*vg[RHO_D]*(phi_p[i] - phi_p[i-1]);)
      IF_ENERGY(phi_c       = BodyForcePotential(x1[i], x2[j], x3[k]); 
                rhs[i][ENG] -= phi_c*rhs[i][RHO];)
#endif


    }
    
  } else if (g_dir == JDIR){

    scrh = 1.0;
#if GEOMETRY == POLAR
    scrh = 1.0/x1[i];
#elif GEOMETRY == SPHERICAL
    scrh = r_1 = 0.5*(x1p[i]*x1p[i] - x1p[i-1]*x1p[i-1])/dV1[i];
#endif
    for (j = beg; j <= end; j++) {
      dtdx = dt/dx2[j]*scrh;

    /* --------------------------------------------
       J1. Add geometrical source terms
       -------------------------------------------- */

#if GEOMETRY != SPHERICAL

      vg = state->vh[j];

#ifdef SHEARINGBOX /* Include Coriolis term for y-momentum */
    #ifdef FARGO 
      rhs[j][MX2] += dt*(SB_Q-2.0)*vh[j][RHO]*vh[j][VX1]*SB_OMEGA;
    #else
      rhs[j][MX2] -= dt*2.0*vh[j][RHO]*vh[j][VX1]*SB_OMEGA;
    #endif
#endif


#elif GEOMETRY == SPHERICAL

      th = x2[j];
      s  = sin(th);
      ct = grid[JDIR].ct[j];

      vg = vc;
      NFLX_LOOP(nv) vc[nv] = state->vh[j][nv];
      vphi = SELECT(0.0, 0.0, vc[iVPHI]);
  #if (defined FARGO) || (ROTATING_FRAME == YES)
      w = 0.0; 
      IF_FARGO         (w += wA[j][i];)
      IF_ROTATING_FRAME(w += g_OmegaZ*x1[i]*s;)
      vphi += w;
  #endif
      Sm = vc[RHO]*(EXPAND(  0.0, - vc[iVTH]*vc[iVR], + ct*vphi*vphi));
      Sm += EXPAND(0.0, +    TotBB(vc, Bg0[j], iBTH, iBR), 
                        - ct*TotBB(vc, Bg0[j], iBPHI, iBPHI));
      rhs[j][MX2] += dt*Sm*r_1;

      IF_DUST(vphi_d = SELECT(0.0, 0.0, vc[VX3_D]);
              #if (defined FARGO) || (ROTATING_FRAME == YES)
              vphi_d += w;
              #endif
              Sm_d = vc[RHO_D]*(EXPAND(  0.0, - vc[VX2_D]*vc[VX1_D], + ct*vphi_d*vphi_d));
              rhs[j][MX2_D] += dt*Sm_d*r_1;)

    /* ----------------------------------------------------
       J2. Modify rhs to enforce conservation
       ---------------------------------------------------- */

  #if (defined FARGO) || (ROTATING_FRAME == YES)
      rhs[j][MX3] -= w*rhs[j][RHO];
      IF_DUST  (rhs[j][MX3_D] -= w*rhs[j][RHO_D];)
      IF_ENERGY(rhs[j][ENG]  -= w*(rhs[j][MX3] + 0.5*w*rhs[j][RHO]);)
  #endif

#endif  /* GEOMETRY == SPHERICAL */

    /* ----------------------------------------------------
       J3. Include Body force
       ---------------------------------------------------- */

#if (BODY_FORCE & VECTOR)
      BodyForceVector(vg, g, x1[i], x2[j], x3[k]);
      rhs[j][MX2]   += dt*vg[RHO]*g[JDIR];
      IF_DUST  (rhs[j][MX2_D] += dt*vg[RHO_D]*g[JDIR];)
      IF_ENERGY(rhs[j][ENG] += dt*0.5*(flux[j][RHO] + flux[j-1][RHO])*g[JDIR];)
#endif

#if (BODY_FORCE & POTENTIAL)
      rhs[j][MX2]   -= dtdx*vg[RHO]*(phi_p[j] - phi_p[j-1]);
      IF_DUST   (rhs[j][MX2_D] -= dtdx*vg[RHO_D]*(phi_p[j] - phi_p[j-1]);)
      IF_ENERGY(phi_c        = BodyForcePotential(x1[i], x2[j], x3[k]); 
                rhs[j][ENG] -= phi_c*rhs[j][RHO];)
#endif
    }

  }else if (g_dir == KDIR){

    scrh = dt;
#if GEOMETRY == SPHERICAL
    r_1  = 0.5*(x1p[i]*x1p[i] - x1p[i-1]*x1p[i-1])/dV1[i];
    scrh = dt*r_1*dx2[j]/dV2[j];
#endif

    for (k = beg; k <= end; k++) {
      dtdx = scrh/dx3[k];
      vg   = state->vh[k];

#if (GEOMETRY == CARTESIAN) || (GEOMETRY == POLAR)
    /* ------------------------------------------------------
       K2. modify rhs to enforce conservation (FARGO only)
           (solid body rotations are not included the
            velocity depends on the cylindrical radius only)
       ------------------------------------------------------ */

  #if (defined FARGO && !defined SHEARINGBOX) 
       w = wA[k][i];
       rhs[k][MX2] -= w*rhs[k][RHO];
       IF_DUST  (rhs[k][MX2_D] -= w*rhs[k][RHO_D];)
       IF_ENERGY(rhs[k][ENG] -= w*(rhs[k][MX2] + 0.5*w*rhs[k][RHO]);)
  #endif
#endif

    /* ----------------------------------------------------
       K3. Include body forces
       ---------------------------------------------------- */

#if (BODY_FORCE & VECTOR)
      BodyForceVector(vg, g, x1[i], x2[j], x3[k]);
      rhs[k][MX3]   += dt*vg[RHO]*g[KDIR];
      IF_DUST(rhs[k][MX3_D] += dt*vg[RHO_D]*g[KDIR];)
      IF_ENERGY(rhs[k][ENG] += dt*0.5*(flux[k][RHO] + flux[k-1][RHO])*g[KDIR];)
#endif

#if (BODY_FORCE & POTENTIAL)
      rhs[k][MX3]   -= dtdx*vg[RHO]*(phi_p[k] - phi_p[k-1]);
      IF_DUST  (rhs[k][MX3_D] -= dtdx*vg[RHO_D]*(phi_p[k] - phi_p[k-1]);)
      IF_ENERGY(phi_c        = BodyForcePotential(x1[i], x2[j], x3[k]);
                rhs[k][ENG] -= phi_c*rhs[k][RHO];)
#endif
    }
  }

/* ---------------------------------------------------------------
    Source terms coming from tensor discretazion of parabolic
    terms in curvilinear coordinates (only for viscosity)
  ---------------------------------------------------------------- */

#if (VISCOSITY == EXPLICIT) && (GEOMETRY != CARTESIAN)
  for (i = beg; i <= end; i++) {
    EXPAND(rhs[i][MX1] += dt*state->visc_src[i][MX1];  ,
           rhs[i][MX2] += dt*state->visc_src[i][MX2];  ,
           rhs[i][MX3] += dt*state->visc_src[i][MX3];)
  }
#endif

/* --------------------------------------------------
    Dust drag force term 
   -------------------------------------------------- */
  
#if DUST == YES    
  Dust_DragForce(state, beg, end, dt, grid);
#endif

/* --------------------------------------------------
              Powell's source terms
   -------------------------------------------------- */

#if (PHYSICS == MHD) && (DIVB_CONTROL == EIGHT_WAVES)
  for (i = beg; i <= end; i++) {
    EXPAND(rhs[i][MX1] += dt*state->src[i][MX1];  ,
           rhs[i][MX2] += dt*state->src[i][MX2];  ,
           rhs[i][MX3] += dt*state->src[i][MX3];)

    EXPAND(rhs[i][BX1] += dt*state->src[i][BX1];  ,
           rhs[i][BX2] += dt*state->src[i][BX2];  ,
           rhs[i][BX3] += dt*state->src[i][BX3];)
  #if HAVE_ENERGY
    rhs[i][ENG] += dt*state->src[i][ENG];
  #endif
  }
#endif

/* -------------------------------------------------
            Extended GLM source terms
   ------------------------------------------------- */

#if (defined GLM_MHD) && (GLM_EXTENDED == YES)
  GLM_ExtendedSource (state, dt, beg, end, grid);
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

void RKC	(	const Data *	d,
		Time_Step *	Dts,
		Grid *	grid
	)

Solve diffusion equation using Runge-Kutta-Chebyshev (RKC) method

Parameters

[in,out]	d	pointer to Data structure
[in,out]	Dts	pointer to Time_Step structure
[in]	grid	pointer to an array of Grid structures

Definition at line 58 of file rkc.c.

{
  int    i, j, k, nv, s, s_RKC = 0;
  int    nv_indx, var_list[NVAR], nvar_rkc;
  double kappa_dl2, eta_dl2, nu_dl2;
  double absh, sprad, Y;
  double epsilon = 2./13.;
  double w_0, w_1;
  double scrh, scr1, scr2;
  double mu_j, nu_j, mu_tilde,a_jm1;
  double Tj, dTj, d2Tj, Tjm1, Tjm2, dTjm1, dTjm2, d2Tjm1, d2Tjm2;
  double b_j, b_jm1, b_jm2, arg;
  double dt_par; 
  static Data_Arr Y_jm1, Y_jm2, UU_0, F_0, F_jm1;
  static double **v;
  static unsigned char *flag;
  
  if (Y_jm1 == NULL) { 
    Y_jm1  = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double);  
    Y_jm2  = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double);
    UU_0   = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double);
    F_0    = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double);
    F_jm1  = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double);
    flag   = ARRAY_1D(NMAX_POINT, unsigned char);
    v      = ARRAY_2D(NMAX_POINT, NVAR, double);
  }

/* -------------------------------------------------------
     set the number of variables to be evolved with RKC
   ------------------------------------------------------- */
   
  i = 0;
  for (nv = 0; nv < NVAR; nv++) var_list[nv] = 0;
  #if VISCOSITY == RK_CHEBYSHEV
   EXPAND(var_list[i++] = MX1;  ,
          var_list[i++] = MX2;  ,
          var_list[i++] = MX3;)
  #endif

  #if RESISTIVITY == RK_CHEBYSHEV
   EXPAND(var_list[i++] = BX1;  ,
          var_list[i++] = BX2;  ,
          var_list[i++] = BX3;)
  #endif
  #if    (THERMAL_CONDUCTION == RK_CHEBYSHEV)  \
      || (VISCOSITY     == RK_CHEBYSHEV && EOS == IDEAL) \
      || (RESISTIVITY == RK_CHEBYSHEV && EOS == IDEAL)
   
   var_list[i++] = ENG;
  #endif
  nvar_rkc = i;
  
/* -------------------------------------------------
          get conservative vector UU 
   ------------------------------------------------- */

  KDOM_LOOP(k){
  JDOM_LOOP(j){
    IDOM_LOOP(i){
    for (nv = NVAR; nv--;   ) {
      v[i][nv] = d->Vc[nv][k][j][i];
    }}
    PrimToCons (v, UU_0[k][j], IBEG, IEND);
  }}   
  
/* -------------------------------------------------
    Compute the parabolic time step by calling 
    the RHS function once outside the main loop.
   ------------------------------------------------- */

  g_intStage = 1;
  Boundary(d, ALL_DIR, grid);
  #if SHOCK_FLATTENING == MULTID
   FindShock (d, grid);
  #endif

  Dts->inv_dtp  = ParabolicRHS(d, F_0, 1.0, grid);
  Dts->inv_dtp /= (double) DIMENSIONS;  
  #ifdef PARALLEL
   MPI_Allreduce (&Dts->inv_dtp, &scrh, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
   Dts->inv_dtp = scrh;
  #endif
  dt_par = Dts->cfl_par/(2.0*Dts->inv_dtp); /* -- explicit parabolic time step -- */   

/* -----------------------------------------------------
      Compute spectral radius (placeholder for now...)
   -----------------------------------------------------*/  

  D_EXPAND( sprad = 4.*Dts->inv_dtp;,
            sprad = 8.*Dts->inv_dtp;,
            sprad = 12.*Dts->inv_dtp;)

D_EXPAND( sprad = 2./dt_par; ,
          sprad = 4./dt_par; ,
          sprad = 6./dt_par;)

/* ----------------------------------------------------- 
    Compute number of RKC steps from sprad
   -----------------------------------------------------*/   

  absh = g_dt;   
  s_RKC = 1 + (int)(sqrt(1.54*absh*sprad + 1));
  Dts->Nrkc = s_RKC;    
/* limit dt */
  if(absh > 0.653*s_RKC*s_RKC/sprad){
    print1 ("! RKC: outside parameter range\n");
    QUIT_PLUTO(1);
  }    

/* ------------------------------------------------------------------ 
                     RKC main stage loop 
   ------------------------------------------------------------------ */

/* -- define coefficients -- */

  w_0 = 1. + epsilon/(1.*s_RKC)/(1.*s_RKC);      
  scr1 = w_0*w_0 - 1.;
  scr2 = sqrt(scr1);
  arg = s_RKC*log(w_0 + scr2);
  w_1 = sinh(arg)*scr1/(cosh(arg)*s_RKC*scr2 - w_0*sinh(arg));
  b_jm1 = 1./(2.*w_0)/(2.*w_0);
  b_jm2 = b_jm1;
  mu_tilde = w_1*b_jm1;

/* -------------------------------------------------------------
     First RKC stage here:
     - take one step in conservative variables,
     - convert to primitive 
   ------------------------------------------------------------- */

  DOM_LOOP (k,j,i){
    for (nv = 0; nv < NVAR; nv++) {
      Y_jm1[k][j][i][nv] = Y_jm2[k][j][i][nv] = UU_0[k][j][i][nv];
    }
    for (nv_indx = 0; nv_indx < nvar_rkc; nv_indx++){
      nv = var_list[nv_indx];
      Y_jm1[k][j][i][nv] = Y_jm2[k][j][i][nv] + mu_tilde*absh*F_0[k][j][i][nv];
    }
  }
    
  KDOM_LOOP(k){
  JDOM_LOOP(j){
    ConsToPrim (Y_jm1[k][j], v, IBEG, IEND, flag);
    IDOM_LOOP(i){
    for (nv = NVAR; nv--;   ){
      d->Vc[nv][k][j][i] = v[i][nv];
    }}
  }}
  
/* ----------------------------------------------------------------- 
    Loop over remaining RKC stages s = 2,..,s_RKC steps 
   ----------------------------------------------------------------- */

/* -- Initialize Chebyshev polynomials (recursive) -- */

  Tjm1   = w_0; Tjm2   = 1.0; dTjm1  = 1.0;
  dTjm2  = 0.0; d2Tjm1 = 0.0; d2Tjm2 = 0.0;
  
  for (s = 2; s <= s_RKC; s++){
  
  /* ---- compute coefficients ---- */
  
    Tj    =   2.*w_0*Tjm1 - Tjm2;
    dTj   =   2.*w_0*dTjm1 - dTjm2 + 2.*Tjm1;
    d2Tj  =   2.*w_0*d2Tjm1 - d2Tjm2 + 4.*dTjm1;
    b_j   =   d2Tj/dTj/dTj;
    a_jm1 =   1. - Tjm1*b_jm1;
    mu_j  =   2.*w_0*b_j/b_jm1;
    nu_j  = - b_j/b_jm2;
    mu_tilde   =   mu_j*w_1/w_0;
    
  /* -- call again boundary and take a new step -- */
  
    g_intStage = s;
    Boundary(d, ALL_DIR, grid);
    ParabolicRHS (d, F_jm1, 1.0, grid);
    DOM_LOOP (k,j,i){
      for (nv_indx = 0; nv_indx < nvar_rkc; nv_indx++){
        nv = var_list[nv_indx];
        Y                  = mu_j*Y_jm1[k][j][i][nv] + nu_j*Y_jm2[k][j][i][nv];
        Y_jm2[k][j][i][nv] = Y_jm1[k][j][i][nv];
        Y_jm1[k][j][i][nv] = Y + (1. - mu_j - nu_j)*UU_0[k][j][i][nv]
                               + absh*mu_tilde*(F_jm1[k][j][i][nv] 
                                              - a_jm1*F_0[k][j][i][nv]);
      }                                              
    } /* END DOM_LOOP  */    
    
  /* -- Put parameters of s -> s-1 (outside of dom loop) -- */
    
    b_jm2  = b_jm1;    b_jm1 = b_j;    Tjm2 = Tjm1;
    Tjm1   = Tj;       dTjm2 = dTjm1;  dTjm1 = dTj;    
    d2Tjm2 = d2Tjm1;  d2Tjm1 = d2Tj;

  /* ----------------------------------------------------------
      convert conservative variables to primitive for the next 
      s steps  (or timestep if s == s_RKC)
     ---------------------------------------------------------- */

    KDOM_LOOP(k){
    JDOM_LOOP(j){
      ConsToPrim (Y_jm1[k][j], v, IBEG, IEND, flag);
      IDOM_LOOP(i){
      for (nv = NVAR; nv--;   ){
        d->Vc[nv][k][j][i] = v[i][nv];
      }}
    }}   
  }/* s loop */
}/* func */

Here is the call graph for this function:

Here is the caller graph for this function:

Runtime* RuntimeGet

(

void

)

Definition at line 498 of file runtime_setup.c.

{
  return &q;
}

Here is the caller graph for this function:

void RuntimeSet

(

Runtime *

runtime

)

Store a static copy of the runtime structure for later access.

Definition at line 491 of file runtime_setup.c.

{
  q = *runtime;
}

Here is the caller graph for this function:

int RuntimeSetup	(	Runtime *	runtime,
		Cmd_Line *	cmd_line,
		char *	ini_file
	)

Open and parse the runtime initialization file. Assign values to the runtime structure.

Parameters

[out]	runtime	pointer to a Runtime structure
[in]	cmd_line	pointer to a Cmd_Line structure (useful, e.g., to resize the domain using the -xres option)
[in]	ini_file	the name of the initialization file (default is "pluto.ini") specified with the -i option.

Definition at line 22 of file runtime_setup.c.

{
  int    idim, ip, ipos, itype, nlines;
  char   *bound_opt[NOPT], str_var[512], *str;
  char  *glabel[]     = {"X1-grid", "X2-grid","X3-grid"};
  char  *bbeg_label[] = {"X1-beg", "X2-beg","X3-beg"};
  char  *bend_label[] = {"X1-end", "X2-end","X3-end"};
  double dbl_var, rx;
  Output *output;
  FILE *fp;

  for (itype = 0; itype < NOPT; itype++) {
    bound_opt[itype] = "0000";
  }

/*  ---------------------------------------------------
      available options are given as two set of names;
      This facilitates when updating the code and
      people are too lazy to read the manual !
    --------------------------------------------------- */

  bound_opt[OUTFLOW]      = "outflow";
  bound_opt[REFLECTIVE]   = "reflective";
  bound_opt[AXISYMMETRIC] = "axisymmetric";
  bound_opt[EQTSYMMETRIC] = "eqtsymmetric";
  bound_opt[PERIODIC]     = "periodic";
  bound_opt[SHEARING]     = "shearingbox";
  bound_opt[USERDEF]      = "userdef";

  runtime->log_freq = 1; /* -- default -- */
 
  nlines = ParamFileRead(ini_file);

/* ------------------------------------------------------------
   [Grid] Section 
   ------------------------------------------------------------ */

  for (idim = 0; idim < 3; idim++){
    runtime->npatch[idim] = atoi(ParamFileGet(glabel[idim], 1));
    runtime->npoint[idim] = 0;

    ipos = 1;
    for (ip = 1; ip <= runtime->npatch[idim]; ip++) {

      runtime->patch_left_node[idim][ip] = atof(ParamFileGet(glabel[idim], ++ipos));
      runtime->patch_npoint[idim][ip]    = atoi(ParamFileGet(glabel[idim], ++ipos));
      runtime->npoint[idim]             += runtime->patch_npoint[idim][ip];
      runtime->grid_is_uniform[idim]     = 0;

      strcpy (str_var, ParamFileGet(glabel[idim], ++ipos)); 
/*
printf ("%f  %d %s\n",runtime->patch_left_node[idim][ip],runtime->patch_npoint[idim][ip],str_var);
*/
      if (strcmp(str_var,"u") == 0 || strcmp(str_var,"uniform") == 0) {
        runtime->patch_type[idim][ip] = UNIFORM_GRID;
        if (runtime->npatch[idim] == 1) runtime->grid_is_uniform[idim] = 1;        
      }else if (strcmp(str_var,"s") == 0 || strcmp(str_var,"strecthed") == 0) { 
        runtime->patch_type[idim][ip] = STRETCHED_GRID;
      }else if (strcmp(str_var,"l+") == 0){
        runtime->patch_type[idim][ip] = LOGARITHMIC_INC_GRID;
      }else if (strcmp(str_var,"l-") == 0){
        runtime->patch_type[idim][ip] = LOGARITHMIC_DEC_GRID;
      }else{ 
        printf ("\nSetup: You must specify either 'u', 's', 'l+' or 'l-' as grid-type in %s\n",
                ini_file);
        QUIT_PLUTO(1);
      }
    }
    
    runtime->patch_left_node[idim][ip] = atof(ParamFileGet(glabel[idim], ++ipos));

    if ( (ipos+1) != (runtime->npatch[idim]*3 + 3)) {
      printf ("! Setup: domain #%d setup is not properly defined \n", idim);
      QUIT_PLUTO(1);
    }
    if (idim >= DIMENSIONS && runtime->npoint[idim] != 1) {
      printf ("! Setup: %d point(s) on dim. %d is NOT valid, resetting to 1\n",
              runtime->npoint[idim],idim+1);
      runtime->npoint[idim]          = 1;
      runtime->npatch[idim]          = 1;
      runtime->patch_npoint[idim][1] = 1;
    }
  }

/* ------------------------------------------------------------
      Change the resolution if cmd_line->xres has been given
   ------------------------------------------------------------ */

  if (cmd_line->xres > 1) {
    rx =  (double)cmd_line->xres/(double)runtime->patch_npoint[IDIR][1];
    for (idim = 0; idim < DIMENSIONS; idim++){
      if (runtime->npatch[idim] > 1){  
        printf ("! Setup: -xres option works on uniform, single patch grid\n");
        QUIT_PLUTO(1);
      }
      
      dbl_var = (double)runtime->patch_npoint[idim][1];
      runtime->patch_npoint[idim][1] = MAX( (int)(dbl_var*rx), 1);
      dbl_var = (double)runtime->npoint[idim];
      runtime->npoint[idim] = MAX( (int)(dbl_var*rx), 1); 
    }  
  }

/* ------------------------------------------------------------
   [Time] Section 
   ------------------------------------------------------------ */

  runtime->cfl         = atof(ParamFileGet("CFL", 1));

  if (ParamExist ("CFL_par")) runtime->cfl_par = atof(ParamFileGet("CFL_par", 1));
  else                        runtime->cfl_par = 0.8/(double)DIMENSIONS;

  if (ParamExist ("rmax_par")) runtime->rmax_par = atof(ParamFileGet("rmax_par", 1));
  else                         runtime->rmax_par = 100.0;

  runtime->cfl_max_var = atof(ParamFileGet("CFL_max_var", 1));
  runtime->tstop       = atof(ParamFileGet("tstop", 1));
  runtime->first_dt    = atof(ParamFileGet("first_dt", 1));

/* ------------------------------------------------------------
   [Solver] Section 
   ------------------------------------------------------------ */

  sprintf (runtime->solv_type,"%s",ParamFileGet("Solver",1));

/* ------------------------------------------------------------
   [Boundary] Section 
   ------------------------------------------------------------ */

  for (idim = 0; idim < 3; idim++){

    str = ParamFileGet(bbeg_label[idim], 1);
    COMPARE (str, bound_opt[itype], itype);
    if (itype == NOPT) {
      printf ("! Setup: don't know how to put left boundary '%s'  \n", str);
      QUIT_PLUTO(1);
    }
    runtime->left_bound[idim] = itype;
  }

  for (idim = 0; idim < 3; idim++){

    str = ParamFileGet(bend_label[idim], 1);
    COMPARE (str, bound_opt[itype], itype);
    if (itype == NOPT) {
      printf ("! Setup: don't know how to put left boundary '%s'  \n", str);
      QUIT_PLUTO(1);
    }
    runtime->right_bound[idim] = itype;
  }

/* ------------------------------------------------------------
   [Static Grid Output] Section 
   ------------------------------------------------------------ */

#ifndef CHOMBO
  runtime->user_var = atoi(ParamFileGet("uservar", 1));
  for (ip = 0; ip < runtime->user_var; ip++){
    if ( (str = ParamFileGet("uservar", 2 + ip)) != NULL){
      sprintf (runtime->user_var_name[ip], "%s", str);
    }else{
      printf ("! Setup: missing name after user var name '%s'\n", 
              runtime->user_var_name[ip-1]);
      QUIT_PLUTO(1);
    } 
  }

/* ---- set output directory ---- */

  sprintf (runtime->output_dir, "%s","./");  /* default value is current directory */
  if (ParamExist("output_dir")){
    str = ParamFileGet("output_dir",1);
    sprintf (runtime->output_dir, "%s",str);
  }

/* -- check if we have write access and if the directory exists -- */

  sprintf (str_var,"%s/tmp09123.txt",runtime->output_dir); /* -- test file -- */
  fp = fopen(str_var,"w");  /* -- open test file for writing -- */
  if (fp == NULL){
    printf ("! Setup: cannot access directory '%s'.\n", runtime->output_dir);
    printf ("!        Please check that the directory exists\n");
    printf ("!        and you have write permission.\n");
    QUIT_PLUTO(1);
  }else{
    fclose(fp);
    remove(str_var);  /* -- remove file -- */
  }

/* ---- dbl output ---- */

  ipos = 0;
  output = runtime->output + (ipos++);
  output->type  = DBL_OUTPUT;
  output->cgs   = 0;  /* cannot write .dbl using cgs units */
  GetOutputFrequency(output, "dbl");

  sprintf (output->mode,"%s",ParamFileGet("dbl",3));
  #ifdef USE_ASYNC_IO
   if (    strcmp(output->mode,"single_file") 
        && strcmp(output->mode,"single_file_async")
        && strcmp(output->mode,"multiple_files")){
      printf ("! Setup: expecting 'single_file', 'single_file_async' ");
      printf ("or 'multiple_files' in dbl output\n");
      QUIT_PLUTO(1);
   }
  #else
   if (   strcmp(output->mode,"single_file")
       && strcmp(output->mode,"multiple_files")){
      printf (
      "! Setup: expecting 'single_file' or 'multiple_files' in dbl output\n");
      QUIT_PLUTO(1);
   }     
  #endif

 /* ---- flt output ---- */

  if (ParamExist("flt")){
    output = runtime->output + (ipos++);
    output->type  = FLT_OUTPUT;
    GetOutputFrequency(output, "flt");

    sprintf (output->mode,"%s",ParamFileGet("flt",3));  
    #ifdef USE_ASYNC_IO
     if (    strcmp(output->mode,"single_file") 
          && strcmp(output->mode,"single_file_async")
          && strcmp(output->mode,"multiple_files")){
        printf ("! Setup: expecting 'single_file', 'single_file_async' ");
        printf ("or 'multiple_files' in flt output\n");
        QUIT_PLUTO(1);
     }
    #else
     if (    strcmp(output->mode,"single_file") 
          && strcmp(output->mode,"multiple_files")){
        printf (
        "! Setup: expecting 'single_file' or 'multiple_files' in flt output\n");
        QUIT_PLUTO(1);
     }  
    #endif
    if (ParamFileHasBoth ("flt","cgs")) output->cgs = 1;
    else                                output->cgs = 0;
  }

 /* -- hdf5 output -- */

  if (ParamExist("dbl.h5")){
    output = runtime->output + (ipos++);
    output->type  = DBL_H5_OUTPUT;
    output->cgs   = 0;  /* cannot write .h5 using cgs units */
    GetOutputFrequency(output, "dbl.h5");
  }
  if (ParamExist("flt.h5")){
    output = runtime->output + (ipos++);
    output->type  = FLT_H5_OUTPUT;
    output->cgs   = 0;  /* cannot write .h5 using cgs units */
    GetOutputFrequency(output, "flt.h5");
  }

 /* -- vtk output -- */

  if (ParamExist ("vtk")){
    output = runtime->output + (ipos++);
    output->type  = VTK_OUTPUT;
    GetOutputFrequency(output, "vtk");

    if (ParamFileGet("vtk",3) == NULL){
      printf ("! Setup: extra field missing in vtk output\n");
      QUIT_PLUTO(1);
    }
    sprintf (output->mode,"%s",ParamFileGet("vtk",3));
    if (   strcmp(output->mode,"single_file")
        && strcmp(output->mode,"multiple_files")){
       printf ("! Setup: expecting 'single_file' or 'multiple_files' in\n");
       printf ("         vtk output\n");
       QUIT_PLUTO(1);
    }
    if (ParamFileHasBoth ("vtk","cgs")) output->cgs = 1;
    else                                output->cgs = 0;
  }

 /* -- tab output -- */

  if (ParamExist ("tab")){
    output = runtime->output + (ipos++);
    output->type  = TAB_OUTPUT;
    GetOutputFrequency(output, "tab");
    if (ParamFileHasBoth ("tab","cgs")) output->cgs = 1;
    else                                output->cgs = 0;
  }

 /* -- ppm output -- */

  if (ParamExist ("ppm")){
    output = runtime->output + (ipos++);
    output->type  = PPM_OUTPUT;
    output->cgs   = 0;   /* Cannot write ppm in cgs units */
    GetOutputFrequency(output, "ppm");
  }

 /* -- png output -- */

  if (ParamExist ("png")){
    output = runtime->output + (ipos++);
    output->type  = PNG_OUTPUT;
    output->cgs   = 0;   /* Cannot write png in cgs units */
    GetOutputFrequency(output, "png");
  }


 /* -- log frequency -- */

  runtime->log_freq = atoi(ParamFileGet("log", 1));
  runtime->log_freq = MAX(runtime->log_freq, 1);
  
 /* -- set default for remaining output type -- */

  while (ipos < MAX_OUTPUT_TYPES){
    output = runtime->output + ipos;
    output->type   = -1;
    output->cgs    =  0;
    output->dt     = -1.0;
    output->dn     = -1;
    output->dclock = -1.0;
    ipos++;
  }

 /* -- analysis -- */

  if (ParamExist ("analysis")){
    runtime->anl_dt = atof(ParamFileGet("analysis", 1));
    runtime->anl_dn = atoi(ParamFileGet("analysis", 2));
  }else{
    runtime->anl_dt = -1.0;   /* -- defaults -- */
    runtime->anl_dn = -1;
  }
#endif

#ifdef CHOMBO

/* ------------------------------------------------------------
   [Chombo HDF5 output] section
   ------------------------------------------------------------ */

/* ---- set output directory ---- */

  sprintf (runtime->output_dir, "%s","./");  /* default value is current directory */
  if (ParamExist("Output_dir")){
    str = ParamFileGet("Output_dir",1);
    sprintf (runtime->output_dir, "%s",str);
  }

/* -- check if we have write access and if the directory exists -- */

  sprintf (str_var,"%s/tmp09123.txt",runtime->output_dir); /* -- test file -- */
  fp = fopen(str_var,"w");  /* -- open test file for writing -- */
  if (fp == NULL){
    printf ("! Setup: cannot access directory '%s'.\n", runtime->output_dir);
    printf ("!        Please check that the directory exists\n");
    printf ("!        and you have write permission.\n");
    QUIT_PLUTO(1);
  }else{
    fclose(fp);
    remove(str_var);  /* -- remove file -- */
  }
#endif

/* ------------------------------------------------------------
   [Parameters] Section 
   ------------------------------------------------------------ */

  fp = fopen(ini_file,"r");
  
/* -- find position at "[Parameters" -- */

  for (ipos = 0; ipos <= nlines; ipos++){ 
    fgets(str_var, 512, fp);
    
    if (strlen(str_var) > 0) {
      str = strtok (str_var,"]");
      if (strcmp(str,"[Parameters") == 0) break;
    }
  }

  fgets(str_var, 512, fp); 
  
  for (ip = 0; ip < USER_DEF_PARAMETERS; ip++){
    fscanf (fp,"%s \n", str_var);
    dbl_var = atof(ParamFileGet(str_var,1));
    runtime->aux[ip] = dbl_var;
    fgets(str_var, sizeof(str_var), fp); /* use fgets to advance to next line */
  }
  fclose(fp);

  return(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SetColorMap	(	unsigned char *	,
		unsigned char *	,
		unsigned char *	,
		char *
	)

Definition at line 11 of file colortable.c.

{
  int  ii;

  if      (!strcmp(map_name,"bw"))    ct_bw(r,g,b);
  else if (!strcmp(map_name,"red"))   ct_red(r,g,b);
  else if (!strcmp(map_name,"br"))    ct_br(r,g,b);
  else if (!strcmp(map_name,"blue"))  ct_blue(r,g,b);
  else if (!strcmp(map_name,"green")) ct_green(r,g,b);
  else if (!strcmp(map_name,"jet"))   ct_jet(r,g,b);
  else { 
    printf (" ? Colormap is not defined, using B&W\n");
    ct_bw(r,g,b);
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void SetDefaultVarNames

(

Output *

)

Definition at line 4 of file var_names.c.

{
  int nv;

/* ----------------------------------------------
    Physics module file names; 
    these pertain to the physics module ONLY
   ---------------------------------------------- */

  output->var_name[RHO] = "rho";
  EXPAND(output->var_name[VX1] = "vx1";  ,
         output->var_name[VX2] = "vx2";  ,
         output->var_name[VX3] = "vx3";)
#if HAVE_ENERGY
  output->var_name[PRS] = "prs";
#endif
  
#if PHYSICS == MHD || PHYSICS == RMHD
  EXPAND(output->var_name[BX1] = "bx1";  ,
         output->var_name[BX2] = "bx2";  ,
         output->var_name[BX3] = "bx3";)
#endif
  
  /* (staggered field names are set in SetOutput) */

#ifdef GLM_MHD
  output->var_name[PSI_GLM] = "psi_glm";
#endif
 
/* ------------------------------------------------
    Dust
   ------------------------------------------------ */

#if DUST == YES
  output->var_name[RHO_D] = "rho_d";
  EXPAND(output->var_name[VX1_D] = "vx1_d";  ,
         output->var_name[VX2_D] = "vx2_d";  ,
         output->var_name[VX3_D] = "vx3_d";)
#endif

/* ------------------------------------------------
                   Tracers 
   ------------------------------------------------ */

  NTRACER_LOOP(nv) sprintf (output->var_name[nv],"tr%d",nv - TRC + 1);

  #if ENTROPY_SWITCH
   sprintf (output->var_name[ENTR],"entropy");
  #endif

/* ------------------------------------------------
               Cooling vars
   ------------------------------------------------ */

#if COOLING == MINEq
  {
    static char *ion_name[] = {"X_HI", "X_HeI", "X_HeII" 
                        C_EXPAND("X_CI","X_CII", "X_CIII", "X_CIV", "X_CV")
                        N_EXPAND("X_NI","X_NII", "X_NIII", "X_NIV", "X_NV")
                        O_EXPAND("X_OI","X_OII", "X_OIII", "X_OIV", "X_OV")
                       Ne_EXPAND("X_NeI","X_NeII", "X_NeIII", "X_NeIV", "X_NeV")
                        S_EXPAND("X_SI","X_SI I", "X_SIII", "X_SIV", "X_SV")
                       Fe_EXPAND("X_FeI", "X_FeII", "X_FeIII")};

    NIONS_LOOP(nv) output->var_name[nv] = ion_name[nv-NFLX];  
  }
#elif COOLING == SNEq

   output->var_name[X_HI] = "X_HI";

#elif COOLING == H2_COOL
  {
    static char *molnames[] = {"X_HI", "X_H2", "X_HII"};
    NIONS_LOOP(nv) output->var_name[nv] = molnames[nv-NFLX];
  }  

#endif

}

Here is the caller graph for this function:

int SetDumpVar	(	char *	var_name,
		int	out_type,
		int	flag
	)

Include ('flag == YES') or exclude ('flag == NO') the variable associated to 'var_name' in or from the output type 'out_type'. If 'out_type' corresponds to an image (ppm or png), create a correspdonding Image structure.

Parameters

[in]	var_name	the name of the variable (e.g. "rho", "vx1",...)
[in]	out_type	select the output type (e.g., DBL_OUTPUT, VTK_OUTPUT, and so forth)
[in]	flag	an integer values (YES/NO).

Definition at line 211 of file set_output.c.

{
  int k, nv;
  Output *output;

  for (k = 0; k < MAX_OUTPUT_TYPES; k++){ 
    output = all_outputs + k;
    if (output->type == out_type) break;
  }

  for (nv = output->nvar; nv--; ) { 
    if (strcmp(output->var_name[nv], var_name) == 0) { 
      output->dump_var[nv] = flag;
      if (flag == YES){
        if (out_type == PPM_OUTPUT || out_type == PNG_OUTPUT){
          CreateImage (var_name);
        }
      }
      return(0);
    }
  }

  print1 ("! var_name '%s' cannot be set/unset for writing\n",var_name);
  return(1);
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SetGrid	(	Runtime *	rtime,
		Grid *	GXYZ
	)

Parameters

[in]	rtime	pointer to a Runtime structure
[out]	GXYZ	pointer to array of Grid structures

Definition at line 21 of file set_grid.c.

{
  int  i, idim;
  int  iL, iR, ngh;
  char fname[512];
  double *dx, *xlft, *xrgt;
  Grid *G;
  FILE *fg;
  double xpatch_lft, xpatch_rgt;

  InitializeGrid(rtime, GXYZ);

  i    = MAX(rtime->npoint[0], MAX(rtime->npoint[1], rtime->npoint[2]));
  dx   = ARRAY_1D(i + 2, double);
  xlft = ARRAY_1D(i + 2, double);
  xrgt = ARRAY_1D(i + 2, double);

  for (idim = 0; idim < 3; idim++) {
     
    G   = GXYZ + idim;
    ngh = G->nghost;

    iL = ngh - 1;
    MakeGrid (idim, rtime, xlft, xrgt, dx);
/*MakeGrid (idim, rtime, G->xl_glob + iL, G->xr_glob + iL, G->dx_glob + iL); */

  /* ---- Assign values to grid structure members ----  */

    for (i = 1; i <= rtime->npoint[idim]; i++) {
      G->dx_glob[i + ngh - 1] = dx[i];
      G->xl_glob[i + ngh - 1] = xlft[i];
      G->xr_glob[i + ngh - 1] = xrgt[i];
    }

    iL = ngh;
    iR = rtime->npoint[idim] + ngh - 1;
    if (idim < DIMENSIONS){
      G->xr_glob[iL - 1] = G->xl_glob[iL];
      G->xl_glob[iR + 1] = G->xr_glob[iR];
    }
/*  ----  fill boundary values by copying adjacent cells  ---- */

    for (i = 0; i < ngh; i++) {
        
     /*  ---- left boundary  ----  */        
     
      G->dx_glob[i] = G->dx_glob[iL];
      G->xl_glob[i] = G->xl_glob[iL] - (ngh - i)*G->dx_glob[iL];
      G->xr_glob[i] = G->xl_glob[i] + G->dx_glob[iL];
      
     /*  ---- right boundary  ----  */   
          
      G->dx_glob[iR + i + 1] = G->dx_glob[iR];
      G->xl_glob[iR + i + 1] = G->xl_glob[iR] + (i + 1.0)*G->dx_glob[iR];
      G->xr_glob[iR + i + 1] = G->xl_glob[iR] + (i + 2.0)*G->dx_glob[iR];
    }

/*  ----  define geometrical cell center  ----  */

    for (i = 0; i <= iR + ngh; i++) {
      G->x_glob[i] = 0.5*(G->xl_glob[i] + G->xr_glob[i]);
    }
    
/*  ---- define leftmost and rightmost domain extrema  ---- */
    
    G->xi = G->xl_glob[iL];
    G->xf = G->xr_glob[iR];

    g_domBeg[idim] = G->xl_glob[iL];
    g_domEnd[idim] = G->xr_glob[iR];
  }

/*  ----  free memory  ----  */

  FreeArray1D(dx);
  FreeArray1D(xlft);
  FreeArray1D(xrgt);

/* ---------------------------------------------------------------------
                       Write grid file 
   --------------------------------------------------------------------- */

  sprintf (fname,"%s/grid.out", rtime->output_dir);
#ifdef PLUTO3_Grid
  fg = fopen(fname,"w");
  for (idim = 0; idim < 3; idim++) {
    G   = GXYZ + idim;
    ngh = G->nghost;
    iL  = G->gbeg;
    iR  = G->gend;
    
    fprintf (fg, "%d \n", iR - iL + 1);
    for (i = iL; i <= iR; i++) {
      fprintf (fg, " %d   %12.6e    %12.6e  %12.6e  %12.6e\n", 
        i-ngh+1, G->xl_glob[i], G->x_glob[i], G->xr_glob[i], G->dx_glob[i]);
    }
  }
  fclose(fg);
#else
  if (prank == 0){
    time_t time_now;
    time(&time_now);

    fg = fopen(fname,"w");
    fprintf (fg, "# ******************************************************\n");
  #ifdef CHOMBO  
    fprintf (fg, "# PLUTO-Chombo %s (Base) Grid File\n",PLUTO_VERSION);
  #else
    fprintf (fg, "# PLUTO %s Grid File\n",PLUTO_VERSION);
  #endif

    fprintf (fg, "# Generated on  %s",asctime(localtime(&time_now)));

/*    fprintf (fg, "# %s\n", getenv("PWD")); */

    fprintf (fg, "# \n");
    fprintf (fg,"# DIMENSIONS: %d\n",DIMENSIONS);
    #if GEOMETRY == CARTESIAN 
     fprintf (fg, "# GEOMETRY:   CARTESIAN\n");
    #elif GEOMETRY == CYLINDRICAL
     fprintf (fg, "# GEOMETRY:   CYLINDRICAL\n");
    #elif GEOMETRY == POLAR
     fprintf (fg, "# GEOMETRY:   POLAR\n");
    #elif GEOMETRY == SPHERICAL
     fprintf (fg, "# GEOMETRY:   SPHERICAL\n");
    #endif
    for (idim = 0; idim < DIMENSIONS; idim++){
     fprintf (fg, "# X%d: [% f, % f], %d point(s), %d ghosts\n", idim+1,
              g_domBeg[idim], g_domEnd[idim], 
              GXYZ[idim].np_int_glob, GXYZ[idim].nghost);
    }
    fprintf (fg, "# ******************************************************\n");
    for (idim = 0; idim < 3; idim++) {
      G   = GXYZ + idim;
      ngh = G->nghost;
      iL  = G->gbeg;
      iR  = G->gend;
    
      fprintf (fg, "%d \n", iR - iL + 1);
      for (i = iL; i <= iR; i++) {
       fprintf (fg, " %d   %18.12e    %18.12e\n", 
          i-ngh+1, G->xl_glob[i], G->xr_glob[i]);
      }
    }
    fclose(fg);
  }
#endif

/*  ----  define geometry factors, vol, area, etc...  ----  */

  MakeGeometry(GXYZ);

/* ----------------------------------------
         print domain specifications
   ---------------------------------------- */

  for (idim = 0; idim < DIMENSIONS; idim++){
   print1 ("  X%d: [% f, % f], %d point(s), %d ghosts\n", idim+1,
            g_domBeg[idim], g_domEnd[idim], 
            GXYZ[idim].np_int_glob, GXYZ[idim].nghost);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SetIndexes	(	Index *	indx,
		Grid *	grid
	)

Set vector indices and integration index range.

Parameters

[out]	indx	pointer to an Index structure
[in]	grid	pointer to an array of Grid structures

Definition at line 49 of file set_indexes.c.

{
  IBEG = grid[IDIR].lbeg; IEND = grid[IDIR].lend;
  JBEG = grid[JDIR].lbeg; JEND = grid[JDIR].lend;
  KBEG = grid[KDIR].lbeg; KEND = grid[KDIR].lend;

  if (g_dir == IDIR) {   /* -- Order: X-Y-Z  {in,t1,t2 = i,j,k} -- */

    EXPAND(VXn = MXn = VX1; , 
           VXt = MXt = VX2; , 
           VXb = MXb = VX3;)
#if PHYSICS == MHD || PHYSICS == RMHD
    EXPAND(BXn = BX1; , 
           BXt = BX2; ,  
           BXb = BX3;)
#endif
#if DUST == YES
    EXPAND(VXn_D = MXn_D = VX1_D; , 
           VXt_D = MXt_D = VX2_D; ,  
           VXb_D = MXb_D = VX3_D;)
#endif

    indx->ntot   = grid[IDIR].np_tot;
    indx->beg    = IBEG; indx->end    = IEND;
    indx->t1_beg = JBEG; indx->t1_end = JEND;
    indx->t2_beg = KBEG; indx->t2_end = KEND;

  }else if (g_dir == JDIR){ /* -- Order: Y-X-Z  {in,t1,t2 = j,i,k} -- */

    EXPAND(VXn = MXn = VX2;  , 
           VXt = MXt = VX1;  , 
           VXb = MXb = VX3;)
#if PHYSICS == MHD || PHYSICS == RMHD
    EXPAND(BXn = BX2; , 
           BXt = BX1; ,  
           BXb = BX3;)
#endif
#if DUST == YES
    EXPAND(VXn_D = MXn_D = VX2_D; , 
           VXt_D = MXt_D = VX1_D; ,  
           VXb_D = MXb_D = VX3_D;)
#endif
    
    indx->ntot   = grid[JDIR].np_tot;
    indx->beg    = JBEG; indx->end    = JEND;
    indx->t1_beg = IBEG; indx->t1_end = IEND;
    indx->t2_beg = KBEG; indx->t2_end = KEND;

  }else if (g_dir == KDIR){ /* -- Order: Z-X-Y  {in,t1,t2 = k,i,j} -- */

    VXn = MXn = VX3;
    VXt = MXt = VX1;
    VXb = MXb = VX2;
    #if PHYSICS == MHD || PHYSICS == RMHD
     BXn = BX3;
     BXt = BX1;
     BXb = BX2;
    #endif
#if DUST == YES
    EXPAND(VXn_D = MXn_D = VX3_D; , 
           VXt_D = MXt_D = VX1_D; ,  
           VXb_D = MXb_D = VX2_D;)
#endif

    indx->ntot   = grid[KDIR].np_tot;
    indx->beg    = KBEG; indx->end    = KEND;
    indx->t1_beg = IBEG; indx->t1_end = IEND;
    indx->t2_beg = JBEG; indx->t2_end = JEND;

  }

/* -------------------------------------------------------
    Expand grid one further zone to account for proper 
    flux computation. This is necessary to obtain the EMF 
    in the boundary zones and to get transverse rhs for 
    corner coupled states.
   ------------------------------------------------------- */

  #ifdef STAGGERED_MHD
   D_EXPAND(                              ;  ,
            indx->t1_beg--; indx->t1_end++;  ,
            indx->t2_beg--; indx->t2_end++;)
   #ifdef CTU
    if (g_intStage == 1){
      indx->beg--;
      indx->end++; 
      D_EXPAND(                              ;  ,
               indx->t1_beg--; indx->t1_end++;  ,
               indx->t2_beg--; indx->t2_end++;)
    }
   #endif
  #else
   #ifdef CTU 
    if (g_intStage == 1){
      #if (PARABOLIC_FLUX & EXPLICIT)
       indx->beg--;
       indx->end++; 
      #endif
      D_EXPAND(                                 ,
               indx->t1_beg--; indx->t1_end++;  ,
               indx->t2_beg--; indx->t2_end++;) 
    }
   #endif
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SetJetDomain	(	const Data *	d,
		int	dir,
		int	log_freq,
		Grid *	grid
	)

Adjust the size of computational domain by reducing the final computationa index in the direction of propagation.

Parameters

[in]	d	pointer to Data structure
[in]	dir	the direction of propagation
[in]	log_freq	the output log frequency
[in,out]	grid	pointer to array of Grid structures

Definition at line 29 of file jet_domain.c.

{
  int i, j, k, ngh;
  int n, n_glob;
  static int first_call = 1;
  double ***pr, ***dn, dp;

  dn = d->Vc[RHO];
  #if HAVE_ENERGY
   pr = d->Vc[PRS];
  #else
   pr = d->Vc[RHO];
  #endif

  ngh = grid[dir].nghost;

/* -- save original domain offsets 
      and return for the first time -- */

  if (first_call){
    if (dir == IDIR) {
      jd_nbeg = IBEG; jd_nend = IEND; 
      jd_npt  = NX1;  jd_ntot = NX1_TOT;
    }else if (dir == JDIR){
      jd_nbeg = JBEG; jd_nend = JEND; 
      jd_npt  = NX2;  jd_ntot = NX2_TOT;
    }else if (dir == KDIR){
      jd_nbeg = KBEG; jd_nend = KEND; 
      jd_npt  = NX3;  jd_ntot = NX3_TOT;
    }

    rbound = grid[dir].rbound;
    first_call = 0;
    return;
  }

/* --------------------------------------
    find where grad(p) is not zero and 
    add safety guard cells 
   -------------------------------------- */

  n = GetRightmostIndex(dir, pr) + 2*ngh;

  if (n < jd_nbeg + ngh) n = jd_nbeg + ngh;
  if (n > jd_nend)       n = jd_nend;

  #ifdef PARALLEL
   MPI_Allreduce (&n, &n_glob, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
   n = n_glob;
  #endif

  if (g_stepNumber%log_freq==0){
/*    print1 ("- SetJetDomain: index %d / %d\n",n,jd_nend); */
  }

/* ------------------------------------------------------------------
    Change global integer variables giving the rightmost integration 
    indexes. Also, suppress the rightmost physics boundary (rbound) 
    if solution has not yet reached it. 
   ------------------------------------------------------------------ */

  if (dir == IDIR) {
    IEND = grid[IDIR].lend = n;
    NX1_TOT = IEND + ngh;
    NX1     = IEND - ngh;

    grid[IDIR].rbound = rbound;
    if (jd_nend != IEND) grid[IDIR].rbound = 0;  
    
  } else if (dir == JDIR){

    JEND = grid[JDIR].lend = n;
    NX2_TOT = JEND + ngh;
    NX2     = JEND - ngh;
    grid[JDIR].rbound = rbound;
    if (jd_nend != JEND) grid[JDIR].rbound = 0;  

  }else if (dir == KDIR){

    KEND = grid[KDIR].lend = n;
    NX3_TOT = KEND + ngh;
    NX3     = KEND - ngh;

    grid[KDIR].rbound = rbound;
    if (jd_nend != KEND) grid[KDIR].rbound = 0;  
  }
  
/* ------------------------------------------------------
    Recompute RBox(es) after indices have been changed
   ------------------------------------------------------ */

  SetRBox();

/*
  print1 ("Box = %d/%d\n", n, jd_nend);
  {
    double t0, t1, i0, i1;
    FILE *fp;
    t0 = g_time;
    t1 = t0 + g_dt;
    i0 = (int)(t0/0.5);
    i1 = (int)(t1/0.5);

    if (i0 != i1){
      fp = fopen("box.out","w");
      fprintf (fp,"%f  %f  %f  %f\n",0.0, grid[IDIR].x[IEND], 
                                     0.0, grid[JDIR].x[JEND]);
      fclose(fp);
    } 
  }
*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

int SetLogFile	(	char *	output_dir,
		Cmd_Line *	cmd
	)

Set the name of the log file and open in write or append mode depending on whether restart is enabled or not.

Parameters

[in]	output_dir	the name of the output directory
[in]	cmd	pointer to cmd line option structure.

Definition at line 321 of file tools.c.

{
#if PRINT_TO_FILE == YES
  FILE *fl;

/* ------------------------------------------------
    All processors set log file name
   ------------------------------------------------ */

  sprintf (log_file_name, "%s/pluto.log",output_dir);    

/* ------------------------------------------------
    Proc. #0 opens log file for writing if 
    -restart or -h5restart have not been given.
    Otherwise, open in append mode.
   ------------------------------------------------ */
  
  if (prank == 0){
    if (cmd->restart == NO && cmd->h5restart == NO){
      fl = fopen(log_file_name,"w");
    }else{
      fl = fopen(log_file_name,"aw");
    } 

  /* -- check that we have a valid directory name -- */

    if (fl == NULL){
      printf ("! SetLogFile: pluto.log cannot be written.\n");
      QUIT_PLUTO(1);
    }
    fprintf(fl,"\n");
    fclose(fl);
  }
#endif
}

Here is the caller graph for this function:

void SetOutput	(	Data *	d,
		Runtime *	runtime
	)

Set default attributes (variable names, pointers to data structures, filename extensions, etc...) of the output structures.

Parameters

[in]	d	pointer to Data structure
[in]	runtime	pointer to Runtime structure

Definition at line 37 of file set_output.c.

{
  int nv, i, k;
  Output *output;

  if (runtime->user_var > 0)
    d->Vuser = ARRAY_4D(runtime->user_var, NX3_TOT, NX2_TOT, NX1_TOT, double);
  else
    d->Vuser = NULL;

  all_outputs = runtime->output;

/* ---------------------------------------------
          Loop on output types 
   --------------------------------------------- */

  for (k = 0; k < MAX_OUTPUT_TYPES; k++){ 
    output = runtime->output + k;
    output->var_name = ARRAY_2D(64,128,char);
    output->stag_var = ARRAY_1D(64, int);
    output->dump_var = ARRAY_1D(64, int);
    strcpy(output->dir, runtime->output_dir); /* output directory is the same     */
                                            /* for all outputs (easy to change) */
    output->nfile    = -1;  

  /* -- set variables names -- */

    SetDefaultVarNames(output);

  /* -- Set array pointers -- */

    for (nv = 0; nv < NVAR; nv++){
      output->V[nv]        = d->Vc[nv];
      output->stag_var[nv] = -1; /* -- means cell centered -- */ 
    }
    nv = NVAR;
    #ifdef STAGGERED_MHD
     D_EXPAND(
       output->var_name[nv]   = "bx1s"; 
       output->V[nv]          = d->Vs[BX1s]; 
       output->stag_var[nv++] = 0;           ,

       output->var_name[nv]   = "bx2s"; 
       output->V[nv]          = d->Vs[BX2s]; 
       output->stag_var[nv++] = 1;           ,

       output->var_name[nv]   = "bx3s"; 
       output->V[nv]          = d->Vs[BX3s]; 
       output->stag_var[nv++] = 2; 
     )
    #endif

    #if UPDATE_VECTOR_POTENTIAL == YES
     #if DIMENSIONS == 3   
      output->var_name[nv]   = "Ax1";
      output->V[nv]          = d->Ax1;
      output->stag_var[nv++] = -1;  /* -- vector potential is 
                                          computed at cell center -- */

      output->var_name[nv]   = "Ax2";
      output->V[nv]          = d->Ax2;
      output->stag_var[nv++] = -1;  
     #endif
     output->var_name[nv]   = "Ax3";
     output->V[nv]          = d->Ax3;
     output->stag_var[nv++] = -1;  
    #endif
    output->nvar = nv;

  /* -- repeat for user defined vars -- */

    for (i = 0; i < runtime->user_var; i++){
      sprintf (output->var_name[i + nv], "%s", runtime->user_var_name[i]);
      output->V[i + nv] = d->Vuser[i];
      output->stag_var[i + nv] = -1; /* -- assume cell-centered -- */
    }

  /* -- add user vars to total number of variables -- */

    output->nvar += runtime->user_var;
 
  /* -- select which variables are going to be dumped to disk  -- */

    for (nv = output->nvar; nv--; ) output->dump_var[nv] = YES;
    #if ENTROPY_SWITCH
     output->dump_var[ENTR] = NO;
    #endif

    switch (output->type){
      case DBL_OUTPUT:   /* -- dump ALL variables -- */
        sprintf (output->ext,"dbl");
        break;
      case FLT_OUTPUT:   /* -- do not dump staggered fields (below)-- */
        sprintf (output->ext,"flt");
        break;
      case DBL_H5_OUTPUT:   /* -- dump ALL variables -- */
        sprintf (output->ext,"dbl.h5");
        break;
      case FLT_H5_OUTPUT:   /* -- do not dump staggered fields (below)-- */
        sprintf (output->ext,"flt.h5");
        break;
      case VTK_OUTPUT:   /* -- do not dump staggered fields (below) -- */
        sprintf (output->ext,"vtk");
        #if VTK_VECTOR_DUMP == YES
         D_EXPAND(output->dump_var[VX1] = VTK_VECTOR;  ,
                  output->dump_var[VX2] = NO;          ,
                  output->dump_var[VX3] = NO;)
         #if PHYSICS == MHD || PHYSICS == RMHD
          D_EXPAND(output->dump_var[BX1] = VTK_VECTOR;  ,
                   output->dump_var[BX2] = NO;          ,
                   output->dump_var[BX3] = NO;)
         #endif
        #endif
        break;
      case TAB_OUTPUT:   /* -- do not dump staggered fields -- */
        sprintf (output->ext,"tab");
        break;
      case PPM_OUTPUT:   /* -- dump density only  -- */
        sprintf (output->ext,"ppm");
        for (nv = output->nvar; nv--; ) output->dump_var[nv] = NO;
        break;
      case PNG_OUTPUT:   /* -- dump density only  -- */
        sprintf (output->ext,"png");
        for (nv = output->nvar; nv--; ) output->dump_var[nv] = NO;
        break;
    }
    
  /* ---------------------------------------------------------------
      for divergence cleaning never dump the scalar psi unless
      the output type can be potentially used for restart
     --------------------------------------------------------------- */
   
    #ifdef GLM_MHD
     if (output->type == DBL_OUTPUT || output->type == DBL_H5_OUTPUT)  
       output->dump_var[PSI_GLM] = YES;
     else
       output->dump_var[PSI_GLM] = NO;
    #endif
  }
 
/* -- exclude stag components from all output except .dbl -- */

  #ifdef STAGGERED_MHD
   D_EXPAND( SetDumpVar ("bx1s", VTK_OUTPUT, NO);  ,
             SetDumpVar ("bx2s", VTK_OUTPUT, NO);  ,
             SetDumpVar ("bx3s", VTK_OUTPUT, NO);)
   D_EXPAND( SetDumpVar ("bx1s", FLT_OUTPUT, NO);  ,
             SetDumpVar ("bx2s", FLT_OUTPUT, NO);  ,
             SetDumpVar ("bx3s", FLT_OUTPUT, NO);)
   D_EXPAND( SetDumpVar ("bx1s", FLT_H5_OUTPUT, NO);  ,
             SetDumpVar ("bx2s", FLT_H5_OUTPUT, NO);  ,
             SetDumpVar ("bx3s", FLT_H5_OUTPUT, NO);)
   D_EXPAND( SetDumpVar ("bx1s", TAB_OUTPUT, NO);  ,
             SetDumpVar ("bx2s", TAB_OUTPUT, NO);  ,
             SetDumpVar ("bx3s", TAB_OUTPUT, NO);)
  #endif

/* -- defaults: dump density only in ppm and png formats -- */

  SetDumpVar ("rho", PPM_OUTPUT, YES);
  SetDumpVar ("rho", PNG_OUTPUT, YES);
  
  ChangeDumpVar();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SetRBox

(

void

)

Definition at line 33 of file rbox.c.

{
  int s;

/* ---------------------------------------------------
    0. Set X1_BEG grid index ranges
   --------------------------------------------------- */

  s = X1_BEG; s -= X1_BEG;

  rbox_center[s].vpos = CENTER;

  rbox_center[s].ib = IBEG-1; rbox_center[s].ie =         0;
  rbox_center[s].jb =      0; rbox_center[s].je = NX2_TOT-1;
  rbox_center[s].kb =      0; rbox_center[s].ke = NX3_TOT-1;

  rbox_x1face[s] = rbox_x2face[s] = rbox_x3face[s] = rbox_center[s];

  #ifndef CHOMBO /* -- useless for AMR -- */
   rbox_x1face[s].vpos = X1FACE;
   rbox_x2face[s].vpos = X2FACE;
   rbox_x3face[s].vpos = X3FACE;

   D_EXPAND(rbox_x1face[s].ib--; rbox_x1face[s].ie--;  ,
            rbox_x2face[s].jb--;                       ,
            rbox_x3face[s].kb--;)
  #endif

/* ---------------------------------------------------
    1. set X1_END grid index ranges
   --------------------------------------------------- */
  
  s = X1_END; s -= X1_BEG;

  rbox_center[s].vpos = CENTER;

  rbox_center[s].ib = IEND+1; rbox_center[s].ie = NX1_TOT-1;
  rbox_center[s].jb =      0; rbox_center[s].je = NX2_TOT-1;
  rbox_center[s].kb =      0; rbox_center[s].ke = NX3_TOT-1;

  rbox_x1face[s] = rbox_x2face[s] = rbox_x3face[s] = rbox_center[s];

  #ifndef CHOMBO /* -- useless for AMR -- */
   rbox_x1face[s].vpos = X1FACE;
   rbox_x2face[s].vpos = X2FACE;
   rbox_x3face[s].vpos = X3FACE;

   D_EXPAND(                   ;   ,
            rbox_x2face[s].jb--;   ,
            rbox_x3face[s].kb--;)
  #endif

/* ---------------------------------------------------
    2. set X2_BEG grid index ranges
   --------------------------------------------------- */

  s = X2_BEG; s -= X1_BEG;

  rbox_center[s].vpos = CENTER;

  rbox_center[s].ib =      0; rbox_center[s].ie = NX1_TOT-1;
  rbox_center[s].jb = JBEG-1; rbox_center[s].je =         0;
  rbox_center[s].kb =      0; rbox_center[s].ke = NX3_TOT-1;

  rbox_x1face[s] = rbox_x2face[s] = rbox_x3face[s] = rbox_center[s];

  #ifndef CHOMBO /* -- useless for AMR -- */
   rbox_x1face[s].vpos = X1FACE;
   rbox_x2face[s].vpos = X2FACE;
   rbox_x3face[s].vpos = X3FACE;

   D_EXPAND(rbox_x1face[s].ib--;                       ,
            rbox_x2face[s].jb--; rbox_x2face[s].je--;  ,
            rbox_x3face[s].kb--;)
  #endif

/* ---------------------------------------------------
    3. set X2_END grid index ranges
   --------------------------------------------------- */
  
  s = X2_END; s -= X1_BEG;

  rbox_center[s].vpos = CENTER;

  rbox_center[s].ib =      0; rbox_center[s].ie = NX1_TOT-1;
  rbox_center[s].jb = JEND+1; rbox_center[s].je = NX2_TOT-1;
  rbox_center[s].kb =      0; rbox_center[s].ke = NX3_TOT-1;

  rbox_x1face[s] = rbox_x2face[s] = rbox_x3face[s] = rbox_center[s];

  #ifndef CHOMBO /* -- useless for AMR -- */
   rbox_x1face[s].vpos = X1FACE;
   rbox_x2face[s].vpos = X2FACE;
   rbox_x3face[s].vpos = X3FACE;

   D_EXPAND(rbox_x1face[s].ib--;    ,
                               ;    ,
            rbox_x3face[s].kb--;)
  #endif

/* ---------------------------------------------------
    4. set X3_BEG grid index ranges
   --------------------------------------------------- */

  s = X3_BEG; s -= X1_BEG;

  rbox_center[s].vpos = CENTER;

  rbox_center[s].ib =      0; rbox_center[s].ie = NX1_TOT-1;
  rbox_center[s].jb =      0; rbox_center[s].je = NX2_TOT-1;
  rbox_center[s].kb = KBEG-1; rbox_center[s].ke =         0;

  rbox_x1face[s] = rbox_x2face[s] = rbox_x3face[s] = rbox_center[s];

  #ifndef CHOMBO /* -- useless for AMR -- */
   rbox_x1face[s].vpos = X1FACE;
   rbox_x2face[s].vpos = X2FACE;
   rbox_x3face[s].vpos = X3FACE;

   D_EXPAND(rbox_x1face[s].ib--;   ,
            rbox_x2face[s].jb--;   ,
            rbox_x3face[s].kb--; rbox_x3face[s].ke--;)
  #endif

/* ---------------------------------------------------
    5.  set X3_END grid index ranges
   --------------------------------------------------- */
  
  s = X3_END; s -= X1_BEG;

  rbox_center[s].vpos = CENTER;

  rbox_center[s].ib =      0; rbox_center[s].ie = NX1_TOT-1; 
  rbox_center[s].jb =      0; rbox_center[s].je = NX2_TOT-1; 
  rbox_center[s].kb = KEND+1; rbox_center[s].ke = NX3_TOT-1; 

  rbox_x1face[s] = rbox_x2face[s] = rbox_x3face[s] = rbox_center[s];

  #ifndef CHOMBO /* -- useless for AMR -- */
   rbox_x1face[s].vpos = X1FACE;
   rbox_x2face[s].vpos = X2FACE;
   rbox_x3face[s].vpos = X3FACE;

   D_EXPAND(rbox_x1face[s].ib--;      ,
            rbox_x2face[s].jb--;      ,
                               ;)
  #endif

/* ---------------------------------------------------
    6. set DOM index ranges
   --------------------------------------------------- */
  
  s = DOM; s -= X1_BEG;

  rbox_center[s].vpos = CENTER;
  rbox_center[s].ib = IBEG; rbox_center[s].ie = IEND; 
  rbox_center[s].jb = JBEG; rbox_center[s].je = JEND; 
  rbox_center[s].kb = KBEG; rbox_center[s].ke = KEND; 

  rbox_x1face[s] = rbox_x2face[s] = rbox_x3face[s] = rbox_center[s];

  #ifndef CHOMBO /* -- useless for AMR -- */
   rbox_x1face[s].vpos = X1FACE;
   rbox_x2face[s].vpos = X2FACE;
   rbox_x3face[s].vpos = X3FACE;

   D_EXPAND(rbox_x1face[s].ib--;   ,
            rbox_x2face[s].jb--;   ,
            rbox_x3face[s].kb--;)
  #endif

/* ---------------------------------------------------
    7. set TOT index ranges
   --------------------------------------------------- */
  
  s = TOT; s -= X1_BEG;

  rbox_center[s].vpos = CENTER;
  rbox_center[s].ib = 0; rbox_center[s].ie = NX1_TOT-1; 
  rbox_center[s].jb = 0; rbox_center[s].je = NX2_TOT-1; 
  rbox_center[s].kb = 0; rbox_center[s].ke = NX3_TOT-1; 

  rbox_x1face[s] = rbox_x2face[s] = rbox_x3face[s] = rbox_center[s];

  #ifndef CHOMBO /* -- useless for AMR -- */
   rbox_x1face[s].vpos = X1FACE;
   rbox_x2face[s].vpos = X2FACE;
   rbox_x3face[s].vpos = X3FACE;

   D_EXPAND(rbox_x1face[s].ib--;   ,
            rbox_x2face[s].jb--;   ,
            rbox_x3face[s].kb--;)
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

Riemann_Solver* SetSolver

(

const char *

solver

)

PURPOSE

return a pointer to a riemann solver function

Depending on the choice of the Riemann solver specified in pluto.ini, return a pointer to the corresponding Riemann solver function

Definition at line 4 of file set_solver.c.

{
  
  #ifdef FINITE_DIFFERENCE
   return (&FD_Flux);
  #endif

/* ------------------------------------------------------
       Set Pointers for SOLVERS 
   ------------------------------------------------------ */

  #if EOS == IDEAL
   if ( !strcmp(solver, "two_shock"))  return (&TwoShock_Solver);
   else if (!strcmp(solver, "tvdlf"))  return (&LF_Solver);
   else if (!strcmp(solver, "roe"))    return (&Roe_Solver);
   else if (!strcmp(solver, "ausm+"))  return (&AUSMp_Solver);
   else if (!strcmp(solver, "hlle") || 
            !strcmp(solver, "hll"))    return (&HLL_Solver);
   else if (!strcmp(solver, "hllc"))   return (&HLLC_Solver);
/*
   else if (!strcmp(solver, "rusanov_dw")) return (&RusanovDW_Solver);
*/
  #elif EOS == PVTE_LAW
   if (!strcmp(solver, "tvdlf"))       return (&LF_Solver);
   else if (!strcmp(solver, "hlle") || 
            !strcmp(solver, "hll"))    return (&HLL_Solver);
   else if (!strcmp(solver, "hllc"))   return (&HLLC_Solver);
/*
   else if (!strcmp(solver, "rusanov_dw")) return (&RusanovDW_Solver);
*/
  #elif EOS == ISOTHERMAL
   if (!strcmp(solver, "tvdlf"))       return (&LF_Solver);
   else if (!strcmp(solver, "roe"))    return (&Roe_Solver);
   else if (!strcmp(solver, "hlle") || 
            !strcmp(solver, "hll"))    return (&HLL_Solver);
   else if (!strcmp(solver, "hllc"))   return (&HLLC_Solver);
/*
   else if (!strcmp(solver, "rusanov_dw")) return (&RusanovDW_Solver);
*/
  #endif

  print1 ("\n! SetSolver: '%s' not available with this configuration.\n", 
          solver);
  QUIT_PLUTO(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Show	(	double **	a,
		int	ip
	)

Print the component of the array a at grid index ip

Definition at line 132 of file tools.c.

{
  int nv, ix, iy, iz;

  if (g_dir == IDIR) {
    print ("X-sweep");
    ix = ip;
    iy = g_j;
    iz = g_k;
  } else if (g_dir == JDIR) {
    print ("Y-sweep");
    ix = g_i;
    iy = ip;
    iz = g_k;
  } else if (g_dir == KDIR) {
    print ("Z-sweep");
    ix = g_i;
    iy = g_j;
    iz = ip;
  }

  D_SELECT( print (" (%d)> ", ix);     ,
            print (" (%d,%d)> ", ix, iy);  ,
            print (" (%d,%d,%d)> ", ix, iy, iz);  )


  for (nv = 0; nv < NVAR; nv++) {
    print ("%12.6e  ", a[ip][nv]);
  }
  print ("\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ShowConfig	(	int	argc,
		char *	argv[],
		char *	ini_file
	)

Write a summary of the selected options

---

/ _ \/ / / / / /_ __/ __ \ / ___/ /__/ /_/ / / / / /_/ /

/ / /____/____/ /_/ ____/

Definition at line 16 of file show_config.c.

{
  int  n;
  FILE *fp;
  time_t time_now;
  char  str1[128], str2[128], str3[128], sline[512];

  CheckConfig();

  print1 ("\n");
  print1("   ___  __   __  ____________   \n");
  print1("  / _ \\/ /  / / / /_  __/ __ \\ \n");
  print1(" / ___/ /__/ /_/ / / / / /_/ /  \n");
  print1("/_/  /____/\\____/ /_/  \\____/   \n");
  print1("=============================    v. %s  \n", PLUTO_VERSION);
  
  print1 ("\n> System:\n\n");

  if ( (fp = fopen("sysconf.out","r")) != NULL){

    while (fscanf (fp, "%s %s %s\n", str1, str2, str3) != EOF) {
      if (!strcmp(str1,"USER")) 
        print1 ("  %s:             %s\n",str1, str3);
      else if (!strcmp(str1,"WORKING_g_dir"))
        print1 ("  %s:      %s\n",str1, str3);
      else if (!strcmp(str1,"SYSTEM_NAME"))
        print1 ("  %s:      %s\n",str1, str3);
      else if (!strcmp(str1,"NODE_NAME"))
        print1 ("  %s:        %s\n",str1, str3);
      else if (!strcmp(str1,"ARCH"))
        print1 ("  %s:             %s\n",str1, str3);
      else if (!strcmp(str1,"BYTE_ORDER"))
        print1 ("  %s:       %s\n\n",str1, str3);
    }
    fclose(fp);

  }else{
    print1 ("! sysconf.out file not found \n\n");
  }
 
  time(&time_now);
  print1("> Local time:       %s\n",asctime(localtime(&time_now)));
      
  if (COMPONENTS < DIMENSIONS) {
    print1 ("Sorry, but the number of vector components can\n");
    print1 ("not be less than the dimension number.\n");
    print1 ("Please edit definitions.h and fix this.\n");
    QUIT_PLUTO(1);
  }

/* -- print command line arguments -- */

  print1 ("> Cmd line args:    ");
  for (n = 1; n < argc; n++) print1 ("%s ",argv[n]);
  print1 ("\n\n");

/* -- print problem configuration -- */

  print1 ("> Header configuration:\n\n");

  if (PHYSICS == ADVECTION) print1 ("  PHYSICS:          ADVECTION\n");
  if (PHYSICS == HD)        print1 ("  PHYSICS:          HD\n");
  if (PHYSICS == RHD)       print1 ("  PHYSICS:          RHD\n");
  if (PHYSICS == MHD)       print1 ("  PHYSICS:          MHD [div.B: ");
  if (PHYSICS == RMHD)      print1 ("  PHYSICS:          RMHD [div.B: ");
#if PHYSICS == MHD || PHYSICS == RMHD
  #if DIVB_CONTROL == NO
  print1 ("None]\n");
  #elif DIVB_CONTROL == EIGHT_WAVES
    print1 ("Powell's 8wave]\n");
  #elif DIVB_CONTROL == DIV_CLEANING
    #if GLM_EXTENDED == NO 
    print1 ("Divergence Cleaning (GLM)]\n");
    #elif GLM_EXTENDED == YES
    print1 ("Divergence Cleaning (Extended GLM)]\n");
    #endif
    
  #elif DIVB_CONTROL == CONSTRAINED_TRANSPORT
    print1 ("CT/");
    #if CT_EMF_AVERAGE == ARITHMETIC
    print1 ("Ar. average]\n");
    #elif CT_EMF_AVERAGE == UCT_CONTACT
    print1 ("UCT_CONTACT]\n");
    #elif CT_EMF_AVERAGE == UCT0
    print1 ("UCT0]\n");
    #elif CT_EMF_AVERAGE == UCT_HLL
    print1 ("UCT_HLL]\n");
    #endif
  #endif
#endif

  print1 ("  DIMENSIONS:       %d\n", DIMENSIONS);
  print1 ("  COMPONENTS:       %d\n", COMPONENTS);

  print1 ("  GEOMETRY:         ");
  if (GEOMETRY == CARTESIAN)    print1 ("Cartesian\n");
  if (GEOMETRY == CYLINDRICAL)  print1 ("Cylindrical\n");
  if (GEOMETRY == POLAR)        print1 ("Polar\n");
  if (GEOMETRY == SPHERICAL)    print1 ("Spherical\n");

  print1 ("  BODY_FORCE:       ");
  print1 (BODY_FORCE == NO ? "NO\n":"EXPLICIT\n");

  print1 ("  RECONSTRUCTION:   ");
#ifndef FINITE_DIFFERENCE
   if (RECONSTRUCTION == FLAT)          print1 ("Flat");
   if (RECONSTRUCTION == LINEAR)        print1 ("Linear TVD");
   if (RECONSTRUCTION == LINEAR_MULTID) print1 ("Linear_Multid");
   if (RECONSTRUCTION == LimO3)         print1 ("LimO3");
   if (RECONSTRUCTION == WENO3)         print1 ("WENO 3rd order");
   if (RECONSTRUCTION == PARABOLIC)     print1 ("Parabolic");
 #ifdef CHAR_LIMITING
   if (CHAR_LIMITING == YES) print1 (" (Characteristic lim)\n");
   else                      print1 (" (Primitive lim)\n");
 #endif
#endif

#ifdef FINITE_DIFFERENCE
  if (RECONSTRUCTION == LIMO3_FD)     print1 ("LimO3 (FD), 3rd order\n");
  if (RECONSTRUCTION == WENO3_FD)     print1 ("WENO3 (FD), 3rd order\n");
  if (RECONSTRUCTION == WENOZ_FD)     print1 ("WENOZ (FD) 5th order\n");
  if (RECONSTRUCTION == MP5_FD)       print1 ("MP5 (FD), 5th order\n");
#endif

  print1 ("  TRACERS:          %d\n", NTRACER);
  print1 ("  VARIABLES:        %d\n", NVAR);
  print1 ("  ENTROPY_SWITCH:   %s\n",(ENTROPY_SWITCH != NO ? "ENABLED":"NO"));
#if PHYSICS == MHD 
  print1 ("  BACKGROUND_FIELD: %s\n",(BACKGROUND_FIELD == YES ? "YES":"NO"));
#endif

  print1 ("  LOADED MODULES:\n");
  #if PHYSICS == MHD
   #ifdef SHEARINGBOX
    print1 ("\n  o [SHEARINGBOX]\n");
    print1 ("     - Order:             %d\n", SB_ORDER);
    print1 ("     - Sym Hydro Flux:    %s\n", 
             (SB_SYMMETRIZE_HYDRO == YES ? "YES":"NO"));
    print1 ("     - Sym Ey:            %s\n", 
             (SB_SYMMETRIZE_EY == YES ? "YES":"NO"));
    print1 ("     - Sym Ez:            %s\n", 
             (SB_SYMMETRIZE_EZ == YES ? "YES":"NO"));
    print1 ("     - Force EMF periods: %s\n", 
             (SB_FORCE_EMF_PERIODS == YES ? "YES":"NO"));
   #endif
  #endif
  #ifdef FARGO
   print1 ("\n  o [FARGO]\n");
   print1 ("     - Order:         %d\n", FARGO_ORDER);
   print1 ("     - Average Speed: %s\n", 
            (FARGO_AVERAGE_VELOCITY == YES ? "YES":"NO"));
   print1 ("     - Av. Frequency: %d\n", FARGO_NSTEP_AVERAGE);

  #endif
  print1 ("\n");

  print1 ("  ROTATION:         ");
  print1(ROTATING_FRAME == YES ? "YES\n":"NO\n");

  print1 ("  EOS:              ");
  if      (EOS == IDEAL)        print1 ("Ideal\n");
  else if (EOS == PVTE_LAW)     print1 ("PVTE_LAW\n");
  else if (EOS == BAROTROPIC)   print1 ("Barotropic\n");
  else if (EOS == ISOTHERMAL)   print1 ("Isothermal\n");
  else if (EOS == TAUB)         print1 ("Taub - TM\n");
  else                          print1 ("None\n");

  print1 ("  TIME INTEGRATOR:  ");
  if (TIME_STEPPING == EULER)            print1 ("Euler\n");
  if (TIME_STEPPING == RK2)              print1 ("Runga-Kutta II\n");
  if (TIME_STEPPING == RK3)              print1 ("Runga_Kutta III\n");
  if (TIME_STEPPING == CHARACTERISTIC_TRACING)
                                         print1 ("Characteristic Tracing\n");
  if (TIME_STEPPING == HANCOCK)          print1 ("Hancock\n");

  print1 ("  DIM. SPLITTING:   ");
  if (DIMENSIONAL_SPLITTING == YES)  print1 ("Yes\n");
  else                               print1 ("No\n");
  

  #if PARABOLIC_FLUX != NO
   print1 ("  DIFFUSION TERMS:");
   #if (RESISTIVITY == EXPLICIT) 
    print1 ("  Resistivity  [EXPLICIT]\n");  
   #elif (RESISTIVITY == SUPER_TIME_STEPPING)
    print1 ("  Resistivity  [STS]\n");  
   #endif

   #if (THERMAL_CONDUCTION == EXPLICIT) 
    print1 ("  Thermal Conduction [EXPLICIT]\n");  
   #elif (THERMAL_CONDUCTION == SUPER_TIME_STEPPING)
    print1 ("  Thermal Conduction [STS]\n");  
   #endif

   #if (VISCOSITY == EXPLICIT) 
    print1 ("  Viscosity [EXPLICIT]\n");  
   #elif (VISCOSITY == SUPER_TIME_STEPPING)
    print1 ("  Viscosity [STS]\n");  
   #endif
  #endif

  print1 ("\n");

/* -----------------------------------------------------
    Print runtime configuration info (definitions.h 
    and from pluto.ini)
   ----------------------------------------------------- */
/*   
  print1 ("> Header file configuration (definitions.h):\n\n");
  print1 ("  +----------------------------------------------------------\n");
  fp = fopen("definitions.h","r");
  while ( fgets(sline, 512, fp) != NULL ) {
    print1 ("  | %s",sline);
  }
  fclose(fp);
  print1 ("  +---------------------------------------------------------\n\n");
*/
  print1 ("> Runtime configuration (%s):\n\n", ini_file);
  print1 ("  +----------------------------------------------------------\n");
  fp = fopen(ini_file,"r");
  while ( fgets(sline, 512, fp) != NULL ) {
    print1 ("  | %s",sline);
  }
  fclose(fp);
  print1 ("  +---------------------------------------------------------\n");


}

Here is the call graph for this function:

Here is the caller graph for this function:

void ShowDomainDecomposition	(	int	nprocs,
		Grid *	GXYZ
	)

Show the parallel domain decomposition by having each processor print its own computational domain. This is activated with the -show-dec command line argument. It may be long for several thousand processors.

Parameters

[in]	nprocs	the total number of processors
[in]	GXYZ	a pointer to an array of grid structures

Definition at line 295 of file show_config.c.

{
  int p;
  int ib, ie, jb, je, kb, ke;
  int nxp, nyp, nzp;
  int nghx, nghy, nghz;

  static int *ib_proc, *ie_proc;
  static int *jb_proc, *je_proc;
  static int *kb_proc, *ke_proc;

  double xb, xe, yb, ye, zb, ze;

  double *xb_proc, *xe_proc;
  double *yb_proc, *ye_proc;
  double *zb_proc, *ze_proc;

  Grid *Gx, *Gy, *Gz;
  
  Gx = GXYZ;
  Gy = GXYZ + 1;
  Gz = GXYZ + 2;

/* ---- Allocate memory ---- */

  ib_proc = ARRAY_1D(nprocs, int); ie_proc = ARRAY_1D(nprocs, int);
  jb_proc = ARRAY_1D(nprocs, int); je_proc = ARRAY_1D(nprocs, int);
  kb_proc = ARRAY_1D(nprocs, int); ke_proc = ARRAY_1D(nprocs, int);
  xb_proc = ARRAY_1D(nprocs, double); xe_proc = ARRAY_1D(nprocs, double);
  yb_proc = ARRAY_1D(nprocs, double); ye_proc = ARRAY_1D(nprocs, double);
  zb_proc = ARRAY_1D(nprocs, double); ze_proc = ARRAY_1D(nprocs, double);

#ifdef PARALLEL  
  nxp = Gx->np_tot;
  nyp = Gy->np_tot;
  nzp = Gz->np_tot;

/* -- Local beg and end indices -- */

  ib = nghx = Gx->nghost; ie = ib + Gx->np_int - 1;  
  jb = nghy = Gy->nghost; je = jb + Gy->np_int - 1;
  kb = nghz = Gz->nghost; ke = kb + Gz->np_int - 1;

/* -- Leftmost and rightmost processor coordinates -- */

  xb = Gx->xl[ib]; xe = Gx->xr[ie];
  yb = Gy->xl[jb]; ye = Gy->xr[je];
  zb = Gz->xl[kb]; ze = Gz->xr[ke];

  D_EXPAND(
    MPI_Gather (&xb, 1, MPI_DOUBLE, xb_proc, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    MPI_Gather (&xe, 1, MPI_DOUBLE, xe_proc, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);  ,
    
    MPI_Gather (&yb, 1, MPI_DOUBLE, yb_proc, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    MPI_Gather (&ye, 1, MPI_DOUBLE, ye_proc, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);  ,
    
    MPI_Gather (&zb, 1, MPI_DOUBLE, zb_proc, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    MPI_Gather (&ze, 1, MPI_DOUBLE, ze_proc, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
  )

/* -- Global beg and end indices -- */

  ib  = Gx->beg; ie += Gx->beg - nghx;
  jb  = Gy->beg; je += Gy->beg - nghy;
  kb  = Gz->beg; ke += Gz->beg - nghz;

  D_EXPAND(
    MPI_Gather (&ib, 1, MPI_INT, ib_proc, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Gather (&ie, 1, MPI_INT, ie_proc, 1, MPI_INT, 0, MPI_COMM_WORLD);  ,
    
    MPI_Gather (&jb, 1, MPI_INT, jb_proc, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Gather (&je, 1, MPI_INT, je_proc, 1, MPI_INT, 0, MPI_COMM_WORLD);  ,
    
    MPI_Gather (&kb, 1, MPI_INT, kb_proc, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Gather (&ke, 1, MPI_INT, ke_proc, 1, MPI_INT, 0, MPI_COMM_WORLD);
  )

  print1 ("> Domain Decomposition (%d procs):\n\n", nprocs);

  for (p = 0; p < nprocs; p++){ 
    D_EXPAND(
      print1 ("  - Proc # %d, X1: [%f, %f], i: [%d, %d], NX1: %d\n",
              p, xb_proc[p], xe_proc[p], 
                 ib_proc[p], ie_proc[p], 
                 ie_proc[p]-ib_proc[p]+1);    ,
      print1 ("              X2: [%f, %f], j: [%d, %d]; NX2: %d\n",
                 yb_proc[p], ye_proc[p], 
                 jb_proc[p], je_proc[p],
                 je_proc[p]-jb_proc[p]+1);    ,
      print1 ("              X3: [%f, %f], k: [%d, %d], NX3: %d\n\n",  
                 zb_proc[p], ze_proc[p], 
                 kb_proc[p], ke_proc[p],
                 ke_proc[p]-kb_proc[p]+1);
    )
  }

  MPI_Barrier (MPI_COMM_WORLD);
#endif

/* ---- Free memory ---- */

  FreeArray1D((void *) ib_proc); FreeArray1D((void *) ie_proc);
  FreeArray1D((void *) jb_proc); FreeArray1D((void *) je_proc);
  FreeArray1D((void *) kb_proc); FreeArray1D((void *) ke_proc);
  FreeArray1D((void *) xb_proc); FreeArray1D((void *) xe_proc);
  FreeArray1D((void *) yb_proc); FreeArray1D((void *) ye_proc);
  FreeArray1D((void *) zb_proc); FreeArray1D((void *) ze_proc);

  print1 ("\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ShowMatrix	(	double **	A,
		int	n,
		double	eps
	)

Make a nice printing of a 2D matrix A[0..n-1][0..n-1] Entries with values below eps will display "0.0"

Definition at line 182 of file tools.c.

{
  int k1,k2;

  print ("----------------------------------------------------------------\n");
  for (k1 = 0; k1 < n; k1++){
    for (k2 = 0; k2 < n; k2++){
      print ("%12.3e   ", fabs(A[k1][k2]) > eps ? A[k1][k2]:0.0);
    }
    printf ("\n");
  }
  print ("----------------------------------------------------------------\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ShowUnits

(

)

Show units when cooling is enabled.

Definition at line 260 of file show_config.c.

{

#if COOLING != NO
  print1 ("> Cooling Module:    ");
  if (COOLING == SNEq)  print1 (" SNEq\n");
  if (COOLING == MINEq) print1 (" MINEq\n");
  if (COOLING == TABULATED) print1 (" TABULATED\n");
  if (COOLING == H2_COOL) print1 (" H2_COOL \n");
#endif

  print1 ("> Normalization Units:\n\n");
  print1 ("  [Density]:      %8.3e (gr/cm^3), %8.3e (1/cm^3)\n",
          UNIT_DENSITY,UNIT_DENSITY/CONST_mp);
  print1 ("  [Pressure]:     %8.3e (dyne/cm^2)\n",
          UNIT_DENSITY*UNIT_VELOCITY*UNIT_VELOCITY);
  print1 ("  [Velocity]:     %8.3e (cm/s)\n",UNIT_VELOCITY);
  print1 ("  [Length]:       %8.3e (cm)\n",UNIT_LENGTH);
  print1 ("  [Temperature]:  %8.3e X (p/rho*mu) (K)\n",KELVIN);
  print1 ("  [Time]:         %8.3e (sec), %8.3e (yrs) \n",
       UNIT_LENGTH/UNIT_VELOCITY, UNIT_LENGTH/UNIT_VELOCITY/86400./365.);
#if PHYSICS == MHD || PHYSICS == RMHD
  print1 ("  [Mag Field]:    %8.3e (Gauss)\n",
           UNIT_VELOCITY*sqrt(4.0*CONST_PI*UNIT_DENSITY));
#endif

  print1 (" \n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ShowVector	(	double *	v,
		int	n
	)

Print the component of the array a at grid index ip

Definition at line 169 of file tools.c.

{
  int k;

  for (k = 0; k < n; k++)  print ("%12.6e  ", v[k]);
  print ("\n");
}

Here is the call graph for this function:

void SoundSpeed2	(	double **	v,
		double *	cs2,
		double *	h,
		int	beg,
		int	end,
		int	pos,
		Grid *	grid
	)

Define the square of the sound speed.

Parameters

[in]	v	1D array of primitive quantities
[out]	cs2	1D array containing the square of the sound speed
[in]	h	1D array of enthalpy values
[in]	beg	initial index of computation
[in]	end	final index of computation
[in]	pos	an integer specifying the spatial position inside the cell (only for spatially-dependent EOS)
[in]	grid	pointer to an array of Grid structures

Returns

This function has no return value.

Definition at line 16 of file eos.c.

{
  int  i;

  #if PHYSICS == HD || PHYSICS == MHD
   for (i = beg; i <= end; i++) cs2[i] = g_gamma*v[i][PRS]/v[i][RHO];
  #elif PHYSICS == RHD || PHYSICS == RMHD
   double theta;
   Enthalpy(v, h, beg, end);
   for (i = beg; i <= end; i++) {
     theta = v[i][PRS]/v[i][RHO];
     cs2[i] = g_gamma*theta/h[i];
   }
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SplitSource	(	const Data *	d,
		double	dt,
		Time_Step *	Dts,
		Grid *	grid
	)

Take one step on operator-split source terms.

Parameters

[in,out]	d	pointer to PLUTO Data structure containing the solution array updated from the most recent call
[in]	dt	the time step used to integrate the source terms
[in]	Dts	pointer to the time step structure
[in]	grid	pointer to an array of grid structures

Definition at line 25 of file split_source.c.

{
/*  ---- GLM source term treated in main ----  */
/*
  #ifdef GLM_MHD
   GLM_SOURCE (d->Vc, dt, grid);
  #endif
*/
/*  ---------------------------------------------
             Cooling/Heating losses
    ---------------------------------------------  */

  #if COOLING != NO
   #if COOLING == POWER_LAW  /* -- solve exactly -- */
    PowerLawCooling (d->Vc, dt, Dts, grid);
   #else
    CoolingSource (d, dt, Dts, grid);
   #endif
  #endif

/* ----------------------------------------------
    Parabolic terms using STS:

    - resistivity 
    - thermal conduction
    - viscosity 
   ---------------------------------------------- */

  #if (PARABOLIC_FLUX & SUPER_TIME_STEPPING)
   STS (d, Dts, grid);
  #endif

  #if (PARABOLIC_FLUX & RK_CHEBYSHEV)
   RKC (d, Dts, grid);
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Startup	(	Data *	,
		Grid *
	)

Definition at line 17 of file startup.c.

{
  int i, j, k;
  int isub, jsub, ksub, nsub = 5;
  int nv,  l_convert;
  static double **ucons, **uprim;
  double x1,  x2,  x3;
  double x1p, x2p, x3p;
  double x1s, x2s, x3s;
  double dx1, dx2, dx3;
  double us[256], u_av[256], b[3]; 
  double scrh;
  struct GRID *GX, *GY, *GZ;

  GX = G;
  GY = G + 1;
  GZ = G + 2;

  if (uprim == NULL){
    uprim = ARRAY_2D(NMAX_POINT, NVAR, double);
    ucons = ARRAY_2D(NMAX_POINT, NVAR, double); 
  }

/* ----  set labels  ---- */

  EXPAND(MXn = VXn = VX1;  ,
         MXt = VXt = VX2;  ,
         MXb = VXb = VX3;)

  #if PHYSICS == MHD || PHYSICS == RMHD
   EXPAND(BXn = BX1;  ,
          BXt = BX2;  ,
          BXb = BX3;)
  #endif

/* ----------------------------------------------------------
    If the -input-data-file command line argument is given, 
    try to read initial conditions from external files.
   ---------------------------------------------------------- */
    
  print1 ("> Assigning initial conditions (Startup) ...\n");

/* --------------------------------------------------------------
                    Assign initial conditions   
   -------------------------------------------------------------- */

  KTOT_LOOP(k) { 
  JTOT_LOOP(j) { 
  ITOT_LOOP(i) { 

    #if GEOMETRY == CYLINDRICAL
     x1 = GX->xgc[i]; x1p = GX->xr[i]; dx1 = GX->dx[i];
     x2 = GY->xgc[j]; x2p = GY->xr[j]; dx2 = GY->dx[j];
     x3 = GZ->xgc[k]; x3p = GZ->xr[k]; dx3 = GZ->dx[k];
    #else
     x1 = GX->x[i]; x1p = GX->xr[i]; dx1 = GX->dx[i];
     x2 = GY->x[j]; x2p = GY->xr[j]; dx2 = GY->dx[j];
     x3 = GZ->x[k]; x3p = GZ->xr[k]; dx3 = GZ->dx[k];
    #endif
    
    for (nv = NVAR; nv--; ) d->Vc[nv][k][j][i] = u_av[nv] = 0.0;

/*  ----------------------------------------------------------------
                Compute volume averages      
    ---------------------------------------------------------------- */

    #ifdef PSI_GLM
     u_av[PSI_GLM] = us[PSI_GLM] = 0.0;
    #endif

    #if INITIAL_SMOOTHING == YES

     for (ksub = 0; ksub < nsub; ksub++){ 
     for (jsub = 0; jsub < nsub; jsub++){ 
     for (isub = 0; isub < nsub; isub++){ 
            
       x1s = x1 + (double)(1.0 - nsub + 2.0*isub)/(double)(2.0*nsub)*dx1;
       x2s = x2 + (double)(1.0 - nsub + 2.0*jsub)/(double)(2.0*nsub)*dx2;
       x3s = x3 + (double)(1.0 - nsub + 2.0*ksub)/(double)(2.0*nsub)*dx3;

       Init (us, x1s, x2s, x3s);
       for (nv = 0; nv < NVAR; nv++) {
         u_av[nv] += us[nv]/(double)(nsub*nsub*nsub);
       }
     }}}

    #else

     Init (u_av, x1, x2, x3);
  
    #endif

    for (nv = NVAR; nv--;  ) d->Vc[nv][k][j][i] = u_av[nv];

/* -----------------------------------------------------
        Initialize cell-centered vector potential 
        (only for output purposes)
   ----------------------------------------------------- */

    #if PHYSICS == MHD || PHYSICS == RMHD
     #if UPDATE_VECTOR_POTENTIAL == YES
      D_EXPAND(                     ,
        d->Ax3[k][j][i] = u_av[AX3];  ,
        d->Ax1[k][j][i] = u_av[AX1];  
        d->Ax2[k][j][i] = u_av[AX2];)
     #endif
    #endif

 /* -------------------------------------------------------------
     Assign staggered components;
     If a vector potential is used (ASSIGN_VECTOR_POTENTIAL == YES),
     use the STAGGERED_INIT routine;
     otherwise assign staggered components directly from 
     the init.c and ignore the vector potential.

     NOTE: in N dimensions only N components are assigned 
             through this call.
    ------------------------------------------------------------- */    

    #if PHYSICS == MHD || PHYSICS == RMHD
     #if ASSIGN_VECTOR_POTENTIAL == YES
      VectorPotentialDiff(b, i, j, k, G);

      #ifdef STAGGERED_MHD
       for (nv = 0; nv < DIMENSIONS; nv++) {
         d->Vs[nv][k][j][i] = b[nv];
       }
      #else
       for (nv = 0; nv < DIMENSIONS; nv++) {
         d->Vc[BX1+nv][k][j][i] = b[nv];
       }
      #endif

     #else

      #ifdef STAGGERED_MHD
       D_EXPAND(
         Init (u_av, x1p, x2, x3);
         d->Vs[BX1s][k][j][i] = u_av[BX1];       ,

         Init (u_av, x1, x2p, x3);
         d->Vs[BX2s][k][j][i] = u_av[BX2];       ,

         Init (u_av, x1, x2, x3p);
         d->Vs[BX3s][k][j][i] = u_av[BX3];
       )
      #endif
     #endif  /* ASSIGN_VECTOR_POTENTIAL */
    #endif /* PHYSICS == MHD || PHYSICS == RMHD */

  }}}

  #ifdef STAGGERED_MHD

  /* ---------------------------------------------------
       Compute cell-centered magnetic field  
       by simple arithmetic averaging. This 
       is useful only for saving the first 
       output, since the average will be 
       re-computed at the beginning of the computation.
     --------------------------------------------------- */

   DOM_LOOP(k,j,i){
     D_EXPAND( 
       d->Vc[BX1][k][j][i] = 0.5*(d->Vs[BX1s][k][j][i] + d->Vs[BX1s][k][j][i-1]); , 
       d->Vc[BX2][k][j][i] = 0.5*(d->Vs[BX2s][k][j][i] + d->Vs[BX2s][k][j-1][i]); ,
       d->Vc[BX3][k][j][i] = 0.5*(d->Vs[BX3s][k][j][i] + d->Vs[BX3s][k-1][j][i]);
     )
   }

  #endif

/* --------------------------------------------------------------------
         Check if values have physical meaning...
   -------------------------------------------------------------------- */

#if PHYSICS != ADVECTION
  KDOM_LOOP(k){ x3 = GZ->x[k];
  JDOM_LOOP(j){ x2 = GY->x[j];
  IDOM_LOOP(i){ x1 = GX->x[i];

    for (nv = NVAR; nv--;  ) us[nv] = d->Vc[nv][k][j][i];

    if (us[RHO] <= 0.0) {
      print ("! Startup(): negative density, zone [%f, %f, %f]\n", x1,x2,x3);
      QUIT_PLUTO(1);
    }
    #if HAVE_ENERGY
     if (us[PRS] <= 0.0) {
       print ("! Startup(): negative pressure, zone [%f, %f, %f]\n",x1,x2,x3);
       QUIT_PLUTO(1);
     }
    #endif

    #if (PHYSICS == RHD || PHYSICS == RMHD) 
     scrh = EXPAND(us[VX1]*us[VX1], + us[VX2]*us[VX2], + us[VX3]*us[VX3]);
     if (scrh >= 1.0){
       print ("! Startup(): total velocity exceeds 1\n"); 
       QUIT_PLUTO(1);
     }
    #endif
  }}}
#endif

/* --------------------------------------------------------------------
     Convert primitive variables to conservative ones
   -------------------------------------------------------------------- */

  Boundary (d, -1, G);
  
/* --------------------------------------------------------------------
                    Convert to conservative
   -------------------------------------------------------------------- */
/*
  KDOM_LOOP(k) {
  JDOM_LOOP(j){
    IDOM_LOOP(i) {
    for (nv = NVAR; nv--;  ) {
      uprim[i][nv] = d->Vc[nv][k][j][i];
    }}
    PrimToCons(uprim, d->Uc[k][j], IBEG, IEND);
  }}
*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

void States	(	const State_1D *	state,
		int	beg,
		int	end,
		Grid *	grid
	)

Compute 1D left and right interface states using piecewise linear reconstruction and the characteristic decomposition of the quasi-linear form of the equations.

This is done by first extrapolating the cell center value to the interface using piecewise limited linear reconstruction on the characteristic variables.

Left and right states are then evolved for the half time step using characteristic tracing if necessary.

Compute states using piecewise linear interpolation.

Parameters

[in]	state	pointer to a State_1D structure
[in]	beg	starting point where vp and vm must be computed
[in]	end	final point where vp and vm must be computed
[in]	grid	pointer to array of Grid structures

Returns

This function has no return value.

Compute 1D left and right interface states using piecewise linear reconstruction and the characteristic decomposition of the quasi-linear form of the equations.

This is done by first extrapolating the cell center value to the interface using piecewise limited linear reconstruction on the characteristic variables.

Left and right states are then evolved for the half time step using characteristic tracing if necessary.

Parameters

[in]	state	pointer to State_1D structure
[in]	beg	initial index of computation
[in]	end	final index of computation
[in]	grid	pointer to an array of Grid structures

Definition at line 430 of file plm_states.c.

{
  int    i, j, k, nv;
  double dvp[NVAR], dvm[NVAR], dv_lim[NVAR], dvc[NVAR], d2v;
  double dw_lim[NVAR], dwp[NVAR], dwm[NVAR];
  double dp, dm, dc;
  double **vp, **vm, **v;
  double **L, **R, *lambda;
  double cp, cm, wp, wm, cpk[NVAR], cmk[NVAR];
  double kstp[NVAR];
  PLM_Coeffs plm_coeffs;
  static double **dv;

/* ---------------------------------------------
   0. Allocate memory and set pointer shortcuts
   --------------------------------------------- */

  if (dv == NULL) {
    dv = ARRAY_2D(NMAX_POINT, NVAR, double);
  }

  v  = state->v; 
  vp = state->vp;
  vm = state->vm;

  #if UNIFORM_CARTESIAN_GRID == NO
   PLM_CoefficientsGet(&plm_coeffs, g_dir);
  #endif

/* ---------------------------------------------
    Compute sound speed and then convert 
    to 4-vel if necessary. 
   --------------------------------------------- */
 
  SoundSpeed2 (state->v, state->a2, state->h, beg, end, CELL_CENTER, grid);

#if RECONSTRUCT_4VEL
   ConvertTo4vel (state->v, beg-1, end+1); /* From now up to the end of the
                                            * function, v contains the 4-vel */
#endif

  for (i = beg-1; i <= end; i++){
    NVAR_LOOP(nv) dv[i][nv] = v[i+1][nv] - v[i][nv];
  }

/* --------------------------------------------------------------
    Set the amount of steepening for each characteristic family.
    Default is 2, but nonlinear fields may be safely set to 1
    for strongly nonlinear problems.
   -------------------------------------------------------------- */

  for (k = NVAR; k--;  ) kstp[k] = 2.0;
  #if PHYSICS == HD || PHYSICS == RHD
   kstp[0] = kstp[1] = 1.0;
  #elif PHYSICS == MHD
   kstp[KFASTP] = kstp[KFASTM] = 1.0;
   #if COMPONENTS > 1
    kstp[KSLOWP] = kstp[KSLOWM] = 1.0; 
   #endif
  #endif

/* --------------------------------------------------------------
   2. Start main spatial loop
   -------------------------------------------------------------- */

  for (i = beg; i <= end; i++){    

    L      = state->Lp[i];
    R      = state->Rp[i];
    lambda = state->lambda[i];

    PrimEigenvectors(v[i], state->a2[i], state->h[i], lambda, L, R);

  /* ---------------------------------------------------------------
     2a. Project forward, backward (and centered) undivided 
         differences of primitive variables along characteristics, 
         dw(k) = L(k).dv
     --------------------------------------------------------------- */

    #if UNIFORM_CARTESIAN_GRID == YES
     cp = cm = 2.0;
     wp = wm = 1.0;
     dp = dm = 0.5;
     NVAR_LOOP(nv) {
       dvp[nv] = dv[i][nv];
       dvm[nv] = dv[i-1][nv];

       k = nv;
       cpk[k] = cmk[k] = kstp[k];
     }
    #else
     cp = plm_coeffs.cp[i]; cm = plm_coeffs.cm[i];
     wp = plm_coeffs.wp[i]; wm = plm_coeffs.wm[i];
     dp = plm_coeffs.dp[i]; dm = plm_coeffs.dm[i];
     NVAR_LOOP(nv) {
       dvp[nv] = dv[i][nv]*wp;
       dvm[nv] = dv[i-1][nv]*wm;

     /* -- Map 1 < kstp < 2  ==>  1 < ck < c -- */

       k = nv;
       cpk[k] = (2.0 - cp) + (cp - 1.0)*kstp[k]; /* used only for general */
       cmk[k] = (2.0 - cm) + (cm - 1.0)*kstp[k]; /* minmod limiter        */
     }
    #endif

    PrimToChar(L, dvm, dwm);
    PrimToChar(L, dvp, dwp);

  /* ----------------------------------------------------------
     2b. Apply slope limiter to characteristic differences for
         nv < NFLX, dw = Limiter(dwp, dwm). 
     ------------------------------------------------------- */

    #if SHOCK_FLATTENING == MULTID
     if (state->flag[i] & FLAG_FLAT) {
       for (k = NFLX; k--;   )   dw_lim[k] = 0.0;
     } else if (state->flag[i] & FLAG_MINMOD) {
       for (k = NFLX; k--;   ){
         SET_MM_LIMITER(dw_lim[k], dwp[k], dwm[k], cp, cm);
       }
     } else
    #endif
    for (k = NFLX; k--;    ){
      #if LIMITER == DEFAULT
       SET_GM_LIMITER(dw_lim[k], dwp[k], dwm[k], cpk[k], cmk[k]);
      #else 
       SET_LIMITER(dw_lim[k], dwp[k], dwm[k], cp, cm);
      #endif
    }

  /* ------------------------------------------------------------------
     2c. Project limited slopes in characteristic variables on right 
         eigenvectors to obtain primitive slopes: dv = \sum dw.R

         Also, enforce monotonicity in primitive variables as well.
     ------------------------------------------------------------------ */

    for (nv = NFLX; nv--;   ){
      dc = 0.0;
      for (k = 0; k < NFLX; k++) dc += dw_lim[k]*R[nv][k];

      if (dvp[nv]*dvm[nv] > 0.0){
        d2v        = ABS_MIN(cp*dvp[nv], cm*dvm[nv]);
        dv_lim[nv] = MINMOD(d2v, dc);
      }else dv_lim[nv] = 0.0;
    }

  /* -----------------------------------------------------------------
     2d. Repeat construction for passive scalars (tracers).
         For a passive scalar, the primitive variable is the same as
         the characteristic one. We use the MC limiter always.
     ----------------------------------------------------------------- */
     
    #if NFLX != NVAR
     for (nv = NFLX; nv < NVAR; nv++ ){
       #if LIMITER == DEFAULT
        SET_MC_LIMITER(dv_lim[nv], dvp[nv], dvm[nv], cp, cm);
       #else
        SET_LIMITER(dv_lim[nv], dvp[nv], dvm[nv], cp, cm);
       #endif
     }
    #endif

  /* --------------------------------------------------------------------
     2e. Build L/R states at time level t^n
     -------------------------------------------------------------------- */

    for (nv = NVAR; nv--;   ) {
      vp[i][nv] = v[i][nv] + dv_lim[nv]*dp;
      vm[i][nv] = v[i][nv] - dv_lim[nv]*dm;
    }

    #if (PHYSICS == RHD || PHYSICS == RMHD)
     VelocityLimiter (v[i], vp[i], vm[i]);
    #endif

  }  /* -- end main loop on grid points -- */

/* ----------------------------------------------------
   3a. Check monotonicity
   ---------------------------------------------------- */ 

  #if CHECK_MONOTONICITY == YES
   MonotonicityTest(state->v, state->vp, state->vm, beg, end);
  #endif

/*  -------------------------------------------
    3b. Shock flattening (only 1D)
    -------------------------------------------  */

  #if SHOCK_FLATTENING == ONED
   Flatten (state, beg, end, grid);
  #endif

/*  -------------------------------------------
    4. Assign face-centered magnetic field
    -------------------------------------------  */

  #ifdef STAGGERED_MHD
   for (i = beg-1; i <= end; i++) {
     state->vR[i][BXn] = state->vL[i][BXn] = state->bn[i];
   }
  #endif

/* --------------------------------------------------------
   5. Evolve L/R states and center value by dt/2
   -------------------------------------------------------- */

  #if TIME_STEPPING == CHARACTERISTIC_TRACING
   CharTracingStep(state, beg, end, grid);
  #elif TIME_STEPPING == HANCOCK
   HancockStep(state, beg, end, grid);
  #endif

/* --------------------------------------------------------
   6. Convert back to 3-velocity
   -------------------------------------------------------- */

#if RECONSTRUCT_4VEL
  ConvertTo3vel (state->v, beg-1, end+1);
  ConvertTo3vel (state->vp, beg, end);
  ConvertTo3vel (state->vm, beg, end);  
#endif

/* ----------------------------------------------
   7. Obtain L/R states in conservative variables
   ---------------------------------------------- */

  PrimToCons (state->vp, state->up, beg, end);
  PrimToCons (state->vm, state->um, beg, end);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void STS	(	const Data *	d,
		Time_Step *	Dts,
		Grid *	grid
	)

Solve diffusion equation(s) using Super-Time-Stepping.

Parameters

[in,out]	d	pointer to Data structure
[in,out]	Dts	pointer to Time_Step structure
[in]	grid	pointer to an array of Grid structures

Definition at line 55 of file sts.c.

{
  int    i, j, k, nv, n, m;
  double N, ts[STS_MAX_STEPS];
  double dt_par, tau, tsave, inv_dtp;
  static Data_Arr rhs;
  RBox *box = GetRBox(DOM, CENTER);

  if (rhs == NULL) rhs  = ARRAY_4D(NX3_TOT, NX2_TOT, NX1_TOT, NVAR, double); 

/* -------------------------------------------------------------
    Compute the conservative vector in order to start the cycle. 
    This step will be useless if the data structure 
    contains Vc as well as Uc (for future improvements).
   ------------------------------------------------------------- */

  PrimToCons3D(d->Vc, d->Uc, box);
  tsave = g_time;

/* ------------------------------------------------------------
               Main STS Loop starts here
   ------------------------------------------------------------ */

  m = 0;
  n = STS_MAX_STEPS;
  while (m < n){

    g_intStage = m + 1;
    Boundary(d, ALL_DIR, grid);
    inv_dtp = ParabolicRHS(d, rhs, 1.0, grid); 
    
  /* --------------------------------------------------------------
      At the first step (m=0) compute (explicit) parabolic time 
      step. Restriction on explicit time step should be
      
       [2*eta_x/dx^2 + 2*eta_y/dy^2 + 2*eta_z/dz^2]*dt < 1

      which in PLUTO is normally written as 
      
       [2/dtp_x + 2/dtp_y + 2/dtp_z]*dt/Ndim = 1/Ndim = cfl_par

      where Ndim is the number of spatial dimensions.
     -------------------------------------------------------------- */

    if (m == 0){
      Dts->inv_dtp = inv_dtp/(double)DIMENSIONS;  
      #ifdef PARALLEL
       MPI_Allreduce (&Dts->inv_dtp, &tau, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
       Dts->inv_dtp = tau;
      #endif
      Dts->inv_dtp = MAX(Dts->inv_dtp, 1.e-18);
      dt_par = Dts->cfl_par/(2.0*Dts->inv_dtp); /* explicit parabolic 
                                                   time step          */
    /* -------------------------------------------
        Compute the number of steps needed to fit 
        the supertimestep with the advection one.
       ------------------------------------------- */

      N = STS_FindRoot(1.0, dt_par, g_dt);
      N = floor(N+1.0);
      n = (int)N;

      Dts->Nsts = n;
      if (n > STS_MAX_STEPS){
        print1 ("! STS: the number of substeps (%d) is > %d\n",n, STS_MAX_STEPS); 
        QUIT_PLUTO(1);
      }

    /* ------------------------------------------
        Adjust explicit timestep to make Nsts an 
        integer number and compute the substeps.
       ------------------------------------------ */

      if (Dts->Nsts > 1){
        dt_par = STS_CorrectTimeStep(Dts->Nsts, g_dt);
        STS_ComputeSubSteps(dt_par, ts, Dts->Nsts);
      }
    
      if (Dts->Nsts == 1) ts[0] = g_dt;

    }   /* end if m == 0 */

    tau = ts[n-m-1];

  /* -----------------------------------------------
      Update cell-centered conservative variables
     ----------------------------------------------- */
     
    DOM_LOOP (k,j,i){
      #if VISCOSITY == SUPER_TIME_STEPPING
       EXPAND(d->Uc[k][j][i][MX1] += tau*rhs[k][j][i][MX1];  ,
              d->Uc[k][j][i][MX2] += tau*rhs[k][j][i][MX2];  ,
              d->Uc[k][j][i][MX3] += tau*rhs[k][j][i][MX3];)
      #endif
      #if (RESISTIVITY == SUPER_TIME_STEPPING)
       EXPAND(d->Uc[k][j][i][BX1] += tau*rhs[k][j][i][BX1];  ,
              d->Uc[k][j][i][BX2] += tau*rhs[k][j][i][BX2];  ,
              d->Uc[k][j][i][BX3] += tau*rhs[k][j][i][BX3];)
      #endif
      #if HAVE_ENERGY
       #if (THERMAL_CONDUCTION == SUPER_TIME_STEPPING) || \
           (RESISTIVITY      == SUPER_TIME_STEPPING) || \
           (VISCOSITY          == SUPER_TIME_STEPPING) 
        d->Uc[k][j][i][ENG] += tau*rhs[k][j][i][ENG]; 
       #endif
      #endif
    }
    #if (defined STAGGERED_MHD) && (RESISTIVITY == SUPER_TIME_STEPPING)

  /* -----------------------------------------------
      Update staggered magnetic field variables
     ----------------------------------------------- */

/* This piece of code should be used for simple Cartesian 2D
   configurations with constant resistivity.
   It shows that the stability limit of the resistive part of the
   induction equation is larger if the right hand side is written 
   as Laplacian(B) rather than curl(J) 
   
double ***Bx, ***By, ***Bz, Jz, dx, dy, dt;
static double ***Ez, ***Rx, ***Ry;
if (Ez == NULL) {
  Ez = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, double);
  Rx = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, double);
  Ry = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, double);
}
Bx = d->Vs[BX1s];
By = d->Vs[BX2s];
dx = grid[IDIR].dx[IBEG];
dy = grid[JDIR].dx[JBEG];

dt = tau;
k=0;
for (j = 1; j < NX2_TOT-1; j++) for (i = 1; i < NX1_TOT-1; i++){
 Jz = (By[k][j][i+1] - By[k][j][i])/dx - (Bx[k][j+1][i] - Bx[k][j][i])/dy;
 Ez[k][j][i] = Jz*g_inputParam[ETAZ];
 Rx[k][j][i] =  (Bx[k][j][i+1] - 2.0*Bx[k][j][i] + Bx[k][j][i-1])/(dx*dx)
              + (Bx[k][j+1][i] - 2.0*Bx[k][j][i] + Bx[k][j-1][i])/(dy*dy);

 Ry[k][j][i] =   (By[k][j][i+1] - 2.0*By[k][j][i] + By[k][j][i-1])/(dx*dx)
               + (By[k][j+1][i] - 2.0*By[k][j][i] + By[k][j-1][i])/(dy*dy);
}

JDOM_LOOP(j) for (i = IBEG-1; i <= IEND; i++){
// Bx[k][j][i] += - dt/dy*(Ez[k][j][i] - Ez[k][j-1][i]);
 Bx[k][j][i] +=   dt*g_inputParam[ETAZ]*Rx[k][j][i];
}

for (j = JBEG-1; j <= JEND; j++) IDOM_LOOP(i){
// By[k][j][i] += dt/dx*(Ez[k][j][i] - Ez[k][j][i-1]);
 By[k][j][i] +=   dt*g_inputParam[ETAZ]*Ry[k][j][i];
}
*/
     CT_Update  (d, d->Vs, tau, grid);
     CT_AverageMagneticField (d->Vs, d->Uc, grid);
    #endif

  /* --------------------------------------------------
      Unflag zone tagged with the ENTROPY_SWITCH since
      only total energy can be evolved using STS
     -------------------------------------------------- */

    #if ENTROPY_SWITCH
     TOT_LOOP(k,j,i) d->flag[k][j][i] &= ~FLAG_ENTROPY;
    #endif

  /* ----------------------------------------------
      convert conservative variables to primitive 
      for next iteration. Increment loop index.
     ---------------------------------------------- */

    ConsToPrim3D(d->Uc, d->Vc, d->flag, box);
    g_time += ts[n-m-1];
    m++;
  }
  g_time = tsave;  /* restore initial time step */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SwapEndian	(	void *	x,
		const int	nbytes
	)

Swap the byte order of x.

Parameters

[in]	x	pointer to the variable being swapped
[in]	nbytes	data type size

Returns

This function has no return value.

Definition at line 203 of file tools.c.

{
  int k;
  static char Swapped[16];
  char *c;

  c = (char *) x;

  for (k = nbytes; k--; ) Swapped[k] = *(c + nbytes - 1 - k);
  for (k = nbytes; k--; ) c[k] = Swapped[k];
}

void Trace

(

double

xx

)

Print a number xx and the number of times it has been called.

Definition at line 223 of file tools.c.

{
  static int ik;

  printf ("Trace ------> %f ,  %d\n", xx, ++ik);
}

void UnsetJetDomain	(	const Data *	d,
		int	dir,
		Grid *	grid
	)

Restore original (full domain) indexes.

Definition at line 154 of file jet_domain.c.

{

  if (dir == IDIR){
    IBEG = grid[IDIR].lbeg = jd_nbeg;
    IEND = grid[IDIR].lend = jd_nend;
    NX1_TOT = jd_ntot;
    NX1     = jd_npt;
    grid[IDIR].rbound = rbound;
  }

  if (dir == JDIR){
    JBEG = grid[JDIR].lbeg = jd_nbeg;
    JEND = grid[JDIR].lend = jd_nend;
    NX2_TOT = jd_ntot;
    NX2     = jd_npt;
    grid[JDIR].rbound = rbound;
  }

  if (dir == KDIR){
    KBEG = grid[KDIR].lbeg = jd_nbeg;
    KEND = grid[KDIR].lend = jd_nend;
    NX3_TOT = jd_ntot;
    NX3     = jd_npt;
    grid[KDIR].rbound = rbound;
  }

/* ------------------------------------------------------
    Recompute RBox(es) after indices have been changed
   ------------------------------------------------------ */

  SetRBox();

}

Here is the call graph for this function:

Here is the caller graph for this function:

void UpdateStage	(	const Data *	d,
		Data_Arr	UU,
		double **	aflux,
		Riemann_Solver *	Riemann,
		double	dt,
		Time_Step *	Dts,
		Grid *	grid
	)

Parameters

[in,out]	d	pointer to PLUTO Data structure
[in,out]	UU	data array containing conservative variables at the previous time step to be updated
[out]	aflux	interface fluxes needed for refluxing operations (only with AMR)
[in]	Riemann	pointer to a Riemann solver function
[in]	dt	the time step for the current update step
[in,out]	Dts	pointer to time step structure
[in]	grid	pointer to array of Grid structures

Definition at line 38 of file update_stage.c.

{
  int  i, j, k;
  int  nv, dir, beg_dir, end_dir;
  int  *ip;
  double *inv_dl, dl2;
  static double ***T, ***C_dt[NVAR], **dcoeff;
  static State_1D state;
  Index indx;
  intList cdt_list;

  #if DIMENSIONAL_SPLITTING == YES
   beg_dir = end_dir = g_dir;
  #else
   beg_dir = 0;
   end_dir = DIMENSIONS-1;
  #endif

  cdt_list = TimeStepIndexList();

/* --------------------------------------------------------------
   1. Allocate memory
   -------------------------------------------------------------- */

  if (state.v == NULL){
    MakeState (&state);
    #if (PARABOLIC_FLUX & EXPLICIT)
     dcoeff = ARRAY_2D(NMAX_POINT, NVAR, double);
    #endif
  }

/* --------------------------------------------------------------
   2. Reset arrays.
      C_dt is an array used to store the inverse time step for
      advection and diffusion.
      We use C_dt[RHO] for advection, 
             C_dt[MX1] for viscosity,
             C_dt[BX1...BX3] for resistivity and
             C_dt[ENG] for thermal conduction.
   --------------------------------------------------------------- */

  #if DIMENSIONAL_SPLITTING == NO
   if (C_dt[RHO] == NULL){
     FOR_EACH(nv, 0, (&cdt_list)) {
       C_dt[nv] = ARRAY_3D(NX3_MAX, NX2_MAX, NX1_MAX, double);
     }
   }

   if (g_intStage == 1) KTOT_LOOP(k) JTOT_LOOP(j){
     FOR_EACH(nv, 0, (&cdt_list)) {
       memset ((void *)C_dt[nv][k][j],'\0', NX1_TOT*sizeof(double));
     }
   }
  #endif

/* ------------------------------------------------
   2a. Compute current arrays 
   ------------------------------------------------ */

  #if (RESISTIVITY == EXPLICIT) && (defined STAGGERED_MHD)
   GetCurrent (d, -1, grid);
  #endif

/* ------------------------------------------------
   2b. Compute Temperature array
   ------------------------------------------------ */

  #if THERMAL_CONDUCTION == EXPLICIT
   if (T == NULL) T = ARRAY_3D(NX3_MAX, NX2_MAX, NX1_MAX, double);
   TOT_LOOP(k,j,i) T[k][j][i] = d->Vc[PRS][k][j][i]/d->Vc[RHO][k][j][i];
  #endif

/* ----------------------------------------------------------------
   3. Main loop on directions
   ---------------------------------------------------------------- */

  for (dir = beg_dir; dir <= end_dir; dir++){

    g_dir = dir;  
    SetIndexes (&indx, grid);  /* -- set normal and transverse indices -- */
    ResetState (d, &state, grid);

    #if (RESISTIVITY == EXPLICIT) && !(defined STAGGERED_MHD)
     GetCurrent(d, dir, grid);
    #endif

    TRANSVERSE_LOOP(indx,ip,i,j,k){
      g_i = i;  g_j = j;  g_k = k;
      for ((*ip) = 0; (*ip) < indx.ntot; (*ip)++) {
        VAR_LOOP(nv) state.v[(*ip)][nv] = d->Vc[nv][k][j][i];
        state.flag[*ip] = d->flag[k][j][i];
        #ifdef STAGGERED_MHD
         state.bn[(*ip)] = d->Vs[g_dir][k][j][i];
        #endif
      }
      CheckNaN (state.v, 0, indx.ntot-1,0);
      States  (&state, indx.beg - 1, indx.end + 1, grid); 
      Riemann (&state, indx.beg - 1, indx.end, Dts->cmax, grid);
      #ifdef STAGGERED_MHD
       CT_StoreEMF (&state, indx.beg - 1, indx.end, grid);
      #endif
      #if (PARABOLIC_FLUX & EXPLICIT)
       ParabolicFlux(d->Vc, d->J, T, &state, dcoeff, indx.beg-1, indx.end, grid);
      #endif
      #if UPDATE_VECTOR_POTENTIAL == YES
       VectorPotentialUpdate (d, NULL, &state, grid);
      #endif
      #ifdef SHEARINGBOX
       SB_SaveFluxes (&state, grid);
      #endif
      RightHandSide (&state, Dts, indx.beg, indx.end, dt, grid);

    /* -- update:  U = U + dt*R -- */

      #ifdef CHOMBO
       for ((*ip) = indx.beg; (*ip) <= indx.end; (*ip)++) { 
         VAR_LOOP(nv) UU[nv][k][j][i] += state.rhs[*ip][nv];
       }
       SaveAMRFluxes (&state, aflux, indx.beg-1, indx.end, grid);
      #else
       for ((*ip) = indx.beg; (*ip) <= indx.end; (*ip)++) { 
         VAR_LOOP(nv) UU[k][j][i][nv] += state.rhs[*ip][nv];
       }
      #endif

      if (g_intStage > 1) continue;

    /* -- compute inverse dt coefficients when g_intStage = 1 -- */

      inv_dl = GetInverse_dl(grid);
      for ((*ip) = indx.beg; (*ip) <= indx.end; (*ip)++) { 
        #if DIMENSIONAL_SPLITTING == NO

         #if !GET_MAX_DT
          C_dt[0][k][j][i] += 0.5*(  Dts->cmax[(*ip)-1] 
                                   + Dts->cmax[*ip])*inv_dl[*ip];
         #endif
         #if (PARABOLIC_FLUX & EXPLICIT)
          dl2 = 0.5*inv_dl[*ip]*inv_dl[*ip];
          FOR_EACH(nv, 1, (&cdt_list)) {  
            C_dt[nv][k][j][i] += (dcoeff[*ip][nv]+dcoeff[(*ip)-1][nv])*dl2;
          }
         #endif

        #elif DIMENSIONAL_SPLITTING == YES

         #if !GET_MAX_DT
          Dts->inv_dta = MAX(Dts->inv_dta, Dts->cmax[*ip]*inv_dl[*ip]);
         #endif
         #if (PARABOLIC_FLUX & EXPLICIT)
          dl2 = inv_dl[*ip]*inv_dl[*ip];
          FOR_EACH(nv, 1, (&cdt_list)) {
            Dts->inv_dtp = MAX(Dts->inv_dtp, dcoeff[*ip][nv]*dl2);
          }
         #endif
        #endif 
      }
    }
  }

/* -------------------------------------------------------------------
   4. Additional terms here
   ------------------------------------------------------------------- */

  #if (ENTROPY_SWITCH)  && (RESISTIVITY == EXPLICIT)
   EntropyOhmicHeating(d, UU, dt, grid);
  #endif

  #ifdef SHEARINGBOX
   SB_CorrectFluxes (UU, 0.0, dt, grid);
  #endif

  #ifdef STAGGERED_MHD
   CT_Update(d, d->Vs, dt, grid);
  #endif

  #if DIMENSIONAL_SPLITTING == YES
   return;
  #endif

/* -------------------------------------------------------------------
   5. Reduce dt for dimensionally unsplit schemes.
   ------------------------------------------------------------------- */

  if (g_intStage > 1) return;

  for (k = KBEG; k <= KEND; k++){ g_k = k;
  for (j = JBEG; j <= JEND; j++){ g_j = j;
    for (i = IBEG; i <= IEND; i++){
      #if !GET_MAX_DT
       Dts->inv_dta = MAX(Dts->inv_dta, C_dt[0][k][j][i]);
      #endif
      #if (PARABOLIC_FLUX & EXPLICIT)
       FOR_EACH(nv, 1, (&cdt_list)) { 
         Dts->inv_dtp = MAX(Dts->inv_dtp, C_dt[nv][k][j][i]);
       }
      #endif
    }
  }}
  #if !GET_MAX_DT
   Dts->inv_dta /= (double)DIMENSIONS;
  #endif
  #if (PARABOLIC_FLUX & EXPLICIT)
   Dts->inv_dtp /= (double)DIMENSIONS;
  #endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

void UserDefBoundary	(	const Data *	d,
		RBox *	box,
		int	side,
		Grid *	grid
	)

Assign user-defined boundary conditions.

Parameters

[in,out]	d	pointer to the PLUTO data structure containing cell-centered primitive quantities (d->Vc) and staggered magnetic fields (d->Vs, when used) to be filled.
[in]	box	pointer to a RBox structure containing the lower and upper indices of the ghost zone-centers/nodes or edges at which data values should be assigned.
[in]	side	specifies the boundary side where ghost zones need to be filled. It can assume the following pre-definite values: X1_BEG, X1_END, X2_BEG, X2_END, X3_BEG, X3_END. The special value side == 0 is used to control a region inside the computational domain.
[in]	grid	pointer to an array of Grid structures.

Assign user-defined boundary conditions in the lower boundary ghost zones. The profile is top-hat:

where and M is the flow Mach number (the unit velocity is the jet sound speed, so ).

Assign user-defined boundary conditions:

• left side (x beg): constant shocked values
• bottom side (y beg): constant shocked values for x < 1/6 and reflective boundary otherwise.
• top side (y end): time-dependent boundary: for we use fixed (post-shock) values. Unperturbed values otherwise.

Assign user-defined boundary conditions at inner and outer radial boundaries. Reflective conditions are applied except for the azimuthal velocity which is fixed.

Assign user-defined boundary conditions.

Parameters

	[in/out]	d pointer to the PLUTO data structure containing cell-centered primitive quantities (d->Vc) and staggered magnetic fields (d->Vs, when used) to be filled.
[in]	box	pointer to a RBox structure containing the lower and upper indices of the ghost zone-centers/nodes or edges at which data values should be assigned.
[in]	side	specifies on which side boundary conditions need to be assigned. side can assume the following pre-definite values: X1_BEG, X1_END, X2_BEG, X2_END, X3_BEG, X3_END. The special value side == 0 is used to control a region inside the computational domain.
[in]	grid	pointer to an array of Grid structures.

Set the injection boundary condition at the lower z-boundary (X2-beg must be set to userdef in pluto.ini). For we set constant input values (given by the GetJetValues() function while for $ R > 1 $ the solution has equatorial symmetry with respect to the z=0 plane. To avoid numerical problems with a "top-hat" discontinuous jump, we smoothly merge the inlet and reflected value using a profile function Profile().

Provide inner radial boundary condition in polar geometry. Zero gradient is prescribed on density, pressure and magnetic field. For the velocity, zero gradient is imposed on v/r (v = vr, vphi).

The user-defined boundary is used to impose stress-free boundary and purely vertical magnetic field at the top and bottom boundaries, as done in Bodo et al. (2012). In addition, constant temperature and hydrostatic balance are imposed. For instance, at the bottom boundary, one has:

where is the value of gravity at the lower boundary. Solving for at the bottom boundary where gives:

where, for simplicity, we keep constant temperature in the ghost zones rather than at the boundary interface (this seems to give a more stable behavior and avoids negative densities). A similar treatment holds at the top boundary.

Assign user-defined boundary conditions. At the inner boundary we use outflow conditions, except for velocity which we reset to zero when there's an inflow

Definition at line 98 of file init.c.

{
  int   i, j, k, nv;
  double  *x1, *x2, *x3;

  x1 = grid[IDIR].x;
  x2 = grid[JDIR].x;
  x3 = grid[KDIR].x;

  if (side == 0) {    /* -- check solution inside domain -- */
    DOM_LOOP(k,j,i){};
  }

  if (side == X1_BEG){  /* -- X1_BEG boundary -- */
    if (box->vpos == CENTER) {
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X1FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X2FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X3FACE){
      BOX_LOOP(box,k,j,i){  }
    }
  }

  if (side == X1_END){  /* -- X1_END boundary -- */
    if (box->vpos == CENTER) {
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X1FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X2FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X3FACE){
      BOX_LOOP(box,k,j,i){  }
    }
  }

  if (side == X2_BEG){  /* -- X2_BEG boundary -- */
    if (box->vpos == CENTER) {
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X1FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X2FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X3FACE){
      BOX_LOOP(box,k,j,i){  }
    }
  }

  if (side == X2_END){  /* -- X2_END boundary -- */
    if (box->vpos == CENTER) {
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X1FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X2FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X3FACE){
      BOX_LOOP(box,k,j,i){  }
    }
  }

  if (side == X3_BEG){  /* -- X3_BEG boundary -- */
    if (box->vpos == CENTER) {
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X1FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X2FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X3FACE){
      BOX_LOOP(box,k,j,i){  }
    }
  }

  if (side == X3_END){  /* -- X3_END boundary -- */
    if (box->vpos == CENTER) {
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X1FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X2FACE){
      BOX_LOOP(box,k,j,i){  }
    }else if (box->vpos == X3FACE){
      BOX_LOOP(box,k,j,i){  }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void VectorPotentialDiff	(	double *	,
		int	,
		int	,
		int	,
		Grid *
	)

Here is the caller graph for this function:

void VectorPotentialUpdate	(	const Data *	d,
		const void *	vp,
		const State_1D *	state,
		const Grid *	grid
	)

Here is the caller graph for this function:

void Where	(	int	i,
		Grid *	grid
	)

Print the location of a particular zone (i,j,k) in the computational domain.

Note

This function must be initialized before using it to store grid information. This is done by calling Where(i, grid) the very first time. Subsequent calls can be then done by simply using Where(i,NULL).

Definition at line 235 of file tools.c.

{
  int    ii=0, jj=0, kk=0;
  double x1, x2, x3;
  static Grid *grid1, *grid2, *grid3;

/* --------------------------------------------------
    Keep a local copy of grid for subsequent calls
   -------------------------------------------------- */
 
  if (grid != NULL){
    grid1 = grid + IDIR;
    grid2 = grid + JDIR;
    grid3 = grid + KDIR;
    return;
  }

  #ifdef CH_SPACEDIM
   if (g_intStage < 0) return; /* HOT FIX used by CHOMBO
                             (g_intStage = -1) when writing HDF5 file */
  #endif

/* -- ok, proceed normally -- */
  
  if (g_dir == IDIR){
    D_EXPAND(ii = i;, jj = g_j;, kk = g_k;)
  }else if (g_dir == JDIR){
    D_EXPAND(ii = g_i;, jj = i;, kk = g_k;)
  }else if (g_dir == KDIR){
    D_EXPAND(ii = g_i;, jj = g_j;, kk = i;)
  }

  D_EXPAND(
    x1 = grid1->x[ii];  ,
    x2 = grid2->x[jj];  ,
    x3 = grid3->x[kk];
  )

  D_SELECT(
    print ("zone [x1(%d) = %f]",
            ii, grid1->x[ii]);  ,

    print ("zone [x1(%d) = %f, x2(%d) = %f]",
            ii, grid1->x[ii], 
            jj, grid2->x[jj]);  ,

    print ("zone [x1(%d) = %f, x2(%d) = %f, x3(%d) = %f]",
            ii, grid1->x[ii], 
            jj, grid2->x[jj],
            kk, grid3->x[kk]);
  )

  #ifdef CHOMBO
   print (", Level = %d\n", grid1->level);
   return;
  #endif
  #ifdef PARALLEL
   print (", proc %d\n", prank);
   return;
  #else
   print ("\n");
   return;
  #endif  
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WriteAsciiFile	(	char *	fname,
		double *	q,
		int	nvar
	)

Write one row a multi-column ascii file

Definition at line 416 of file tools.c.

{
  int n;
  static char old_file[64] = "\0";
  FILE *fp;
  
/* --------------------------------------------------------
    If the old file name matches the new one, then open 
    in append mode. Otherwise, open in write mode.
   -------------------------------------------------------- */
   
  if (strcmp (fname,old_file) == 0){  
    fp = fopen(fname,"a");
  }else{
    fp = fopen(fname,"w");
    sprintf (old_file,"%s",fname);
  }
  
  for (n = 0; n < nvar; n++) fprintf (fp,"%12.6e  ",q[n]);
  fprintf (fp,"\n");
  fclose(fp);
  
}

void WriteBinaryArray	(	void *	V,
		size_t	dsize,
		int	sz,
		FILE *	fl,
		int	istag
	)

Write an array to disk in binary format.

Parameters

[in]	V	single pointer to a 3D array, V[k][j][i] –> V[i + NX1*j + NX1*NX2*k]. Must start with index 0
[in]	dsize	the size of the each buffer element (sizeof(double) or sizeof(float)). This parameter is used only in serial mode.
[in]	sz	the distributed array descriptor. This parameter replaces dsize in parallel mode
[in]	fl	a valid FILE pointer
[in]	istag	a flag to identify cell-centered (istag = -1) or staggered field data (istag = 0,1 or 2 for staggering in the x1, x2 or x3 directions)

Returns

This function has no return value.

Remarks

The data array is assumed to start always with index 0 for both cell-centered and staggered arrays.

Definition at line 98 of file bin_io.c.

{
  int i, j, k;
  int ioff, joff, koff;
  char *Vc;

  #ifdef PARALLEL
   MPI_Barrier (MPI_COMM_WORLD);
   AL_Write_array (V, sz, istag);
   return;
  #else
   Vc = (char *) V;
   ioff = (istag == 0); 
   joff = (istag == 1); 
   koff = (istag == 2);

   for (k = KBEG; k <= KEND + koff; k++) {
   for (j = JBEG; j <= JEND + joff; j++) {
     i = IBEG + (NX1_TOT + ioff)*(j + (NX2_TOT + joff)*k);
     fwrite (Vc + i*dsize, dsize, NX1 + ioff, fl);
   }}
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WriteData	(	const Data *	d,
		Output *	output,
		Grid *	grid
	)

Write data to disk using any of the available formats.

Parameters

[in]	d	pointer to PLUTO Data structre
[in]	output	the output structure corresponding to a given format
[in]	grid	pointer to an array of Grid structures

• DBL output: Double-precision data files can be written using single or multiple file mode.
  • for single file, serial: we open the file just once before the main variable loop, dump variables and then close.
  • for single file, parallel the distributed array descriptor sz is different for cell-centered or staggered data type and we thus have to open and close the file after each variable has been dumped.
  • when writing multiple files we open, write to and close the file one each loop cycle.

    Note

    In all cases, the pointer to the data array that has to be written must be cast into (void *) and the starting index of the array must be zero.

• VTK output: in order to enable parallel writing, files must be closed and opened again for scalars, since the distributed array descriptors used by ArrayLib (Float_Vect) and (float) are different. This is done using the AL_Get_offset() and AL_Set_offset() functions.

Definition at line 29 of file write_data.c.

{
  int    i, j, k, nv;
  int    single_file;
  size_t dsize;
  char   filename[512], sline[512];
  static int last_computed_var = -1;
  double units[MAX_OUTPUT_VARS]; 
  float ***Vpt3;
  void *Vpt;
  FILE *fout, *fbin;
  time_t tbeg, tend;
  long long offset;

/* -----------------------------------------------------------
            Increment the file number and initialize units
   ----------------------------------------------------------- */

  output->nfile++;

  print1 ("> Writing file #%d (%s) to disk...", output->nfile, output->ext);

  #ifdef PARALLEL
   MPI_Barrier (MPI_COMM_WORLD);
   if (prank == 0) time(&tbeg);
  #endif

  for (nv = 0; nv < MAX_OUTPUT_VARS; nv++) units[nv] = 1.0;
  if (output->cgs) GetCGSUnits(units);

/* --------------------------------------------------------
            Get user var if necessary 
   -------------------------------------------------------- */

  if (last_computed_var != g_stepNumber && d->Vuser != NULL) {
    ComputeUserVar (d, grid);
    last_computed_var = g_stepNumber;
  }

/* --------------------------------------------------------
            Select the output type 
   -------------------------------------------------------- */

  if (output->type == DBL_OUTPUT) {

  /* ------------------------------------------------------------------- */
  /*! - \b DBL output:
        Double-precision data files can be written using single or
        multiple file mode. 
        - for single file, serial: we open the file just once before
          the main variable loop, dump variables and then close.
        - for single file, parallel the distributed array descriptor sz is
          different for cell-centered or staggered data type and we
          thus have to open and close the file after each variable
          has been dumped.
        - when writing multiple files we open, write to and close the
          file one each loop cycle.
        \note In all cases, the pointer to the data array that has to be 
              written must be cast into (void *) and the starting index of 
              the array must be zero.
  */
  /* ------------------------------------------------------------------- */

    int sz;
    single_file = strcmp(output->mode,"single_file") == 0;
    dsize = sizeof(double);

    if (single_file){  /* -- single output file -- */

      sprintf (filename, "%s/data.%04d.%s", output->dir,output->nfile, 
                                            output->ext);
      offset = 0;
      #ifndef PARALLEL
       fbin = OpenBinaryFile (filename, 0, "w");
      #endif
      for (nv = 0; nv < output->nvar; nv++) {
        if (!output->dump_var[nv]) continue;

        if      (output->stag_var[nv] == -1) {  /* -- cell-centered data -- */
          sz = SZ;
          Vpt = (void *)output->V[nv][0][0];
        } else if (output->stag_var[nv] == 0) { /* -- x-staggered data -- */
          sz  = SZ_stagx;
          Vpt = (void *)(output->V[nv][0][0]-1);
        } else if (output->stag_var[nv] == 1) { /* -- y-staggered data -- */
          sz = SZ_stagy;
          Vpt = (void *)output->V[nv][0][-1];
        } else if (output->stag_var[nv] == 2) { /* -- z-staggered data -- */
           sz = SZ_stagz;
           Vpt = (void *)output->V[nv][-1][0];
        }
        #ifdef PARALLEL
         fbin = OpenBinaryFile (filename, sz, "w");
         AL_Set_offset(sz, offset);
        #endif
        WriteBinaryArray (Vpt, dsize, sz, fbin, output->stag_var[nv]);
        #ifdef PARALLEL
         offset = AL_Get_offset(sz);
         CloseBinaryFile(fbin, sz);
        #endif
      }
      #ifndef PARALLEL
       CloseBinaryFile(fbin, sz);
      #endif

    }else{              /* -- multiple files -- */

      for (nv = 0; nv < output->nvar; nv++) {
        if (!output->dump_var[nv]) continue;
        sprintf (filename, "%s/%s.%04d.%s", output->dir, output->var_name[nv], 
                                            output->nfile, output->ext);

        if      (output->stag_var[nv] == -1) {  /* -- cell-centered data -- */
          sz = SZ;
          Vpt = (void *)output->V[nv][0][0];
        } else if (output->stag_var[nv] == 0) { /* -- x-staggered data -- */
          sz  = SZ_stagx;
          Vpt = (void *)(output->V[nv][0][0]-1);
        } else if (output->stag_var[nv] == 1) { /* -- y-staggered data -- */
          sz = SZ_stagy;
          Vpt = (void *)output->V[nv][0][-1];
        } else if (output->stag_var[nv] == 2) { /* -- z-staggered data -- */
           sz = SZ_stagz;
           Vpt = (void *)output->V[nv][-1][0];
        }
        fbin = OpenBinaryFile (filename, sz, "w");
        WriteBinaryArray (Vpt, dsize, sz, fbin, output->stag_var[nv]);
        CloseBinaryFile (fbin, sz);
      }
    }

  } else if (output->type == FLT_OUTPUT) {

  /* ----------------------------------------------------------
                 FLT output for cell-centered data
     ---------------------------------------------------------- */

    single_file = strcmp(output->mode,"single_file") == 0;

    if (single_file){  /* -- single output file -- */
      sprintf (filename, "%s/data.%04d.%s", output->dir, output->nfile, 
                                            output->ext);
      fbin = OpenBinaryFile (filename, SZ_float, "w");
      for (nv = 0; nv < output->nvar; nv++) {
        if (!output->dump_var[nv]) continue;
/*        Vpt = (void *)(Convert_dbl2flt(output->V[nv],0))[0][0];  */
        Vpt3 = Convert_dbl2flt(output->V[nv], units[nv],0);
        Vpt = (void *)Vpt3[0][0];
        WriteBinaryArray (Vpt, sizeof(float), SZ_float, fbin, 
                          output->stag_var[nv]);
      }
      CloseBinaryFile(fbin, SZ_float);
/*
BOV_Header(output, filename);
*/
    }else{              /* -- multiple files -- */

      for (nv = 0; nv < output->nvar; nv++) {
        if (!output->dump_var[nv]) continue;
        sprintf (filename, "%s/%s.%04d.%s", output->dir, output->var_name[nv], 
                                            output->nfile, output->ext);

        fbin = OpenBinaryFile (filename, SZ_float, "w");
/*        Vpt = (void *)(Convert_dbl2flt(output->V[nv],0))[0][0];   */
        Vpt3 = Convert_dbl2flt(output->V[nv], units[nv],0);
        Vpt = (void *)Vpt3[0][0];
        WriteBinaryArray (Vpt, sizeof(float), SZ_float, fbin, 
                          output->stag_var[nv]);
        CloseBinaryFile (fbin, SZ_float);
      }
    }

  }else if (output->type == DBL_H5_OUTPUT || output->type == FLT_H5_OUTPUT){

  /* ------------------------------------------------------
       HDF5 (static grid) output (single/double precision)
     ------------------------------------------------------ */

    #ifdef USE_HDF5 
     single_file = YES;
     WriteHDF5 (output, grid);
    #else
     print1 ("! WriteData: HDF5 library not available\n");
     return;
    #endif

  }else if (output->type == VTK_OUTPUT) { 

  /* ------------------------------------------------------------------- */
  /*! - \b VTK output:  
      in order to enable parallel writing, files must be closed and
      opened again for scalars, since the distributed array descriptors 
      used by ArrayLib (Float_Vect) and (float) are different. This is
      done using the AL_Get_offset() and AL_Set_offset() functions.      */
  /* ------------------------------------------------------------------- */
    
    single_file = strcmp(output->mode,"single_file") == 0;
    sprintf (filename, "%s/data.%04d.%s", output->dir, output->nfile,
                                          output->ext);

    if (single_file){  /* -- single output file -- */

      fbin  = OpenBinaryFile(filename, SZ_Float_Vect, "w");
      WriteVTK_Header(fbin, grid);
      for (nv = 0; nv < output->nvar; nv++) {  /* -- write vectors -- */
        if (output->dump_var[nv] != VTK_VECTOR) continue;
        WriteVTK_Vector (fbin, output->V + nv, units[nv],
                         output->var_name[nv], grid);
      }

      #ifdef PARALLEL
       offset = AL_Get_offset(SZ_Float_Vect);
       CloseBinaryFile(fbin, SZ_Float_Vect);
       fbin  = OpenBinaryFile(filename, SZ_float, "w");
       AL_Set_offset(SZ_float, offset);
      #endif
      
      for (nv = 0; nv < output->nvar; nv++) { /* -- write scalars -- */
        if (output->dump_var[nv] != YES) continue;
        WriteVTK_Scalar (fbin, output->V[nv], units[nv],
                         output->var_name[nv], grid);
      }
      CloseBinaryFile(fbin, SZ_float);

    }else{          /* -- multiple output files -- */

      for (nv = 0; nv < output->nvar; nv++) { /* -- write vectors -- */
        if (output->dump_var[nv] != VTK_VECTOR) continue;
        if (strcmp(output->var_name[nv],"vx1") == 0) {
          sprintf (filename, "%s/vfield.%04d.%s", output->dir, output->nfile, 
                                                  output->ext);
        }else if (strcmp(output->var_name[nv],"bx1") == 0) {
          sprintf (filename, "%s/bfield.%04d.%s", output->dir, output->nfile, 
                                                  output->ext);
        }else{
          print1 ("! WriteData: unknown vector type in VTK output\n"); 
          QUIT_PLUTO(1);
        }

        fbin = OpenBinaryFile(filename, SZ_Float_Vect, "w");
        WriteVTK_Header(fbin, grid);
        WriteVTK_Vector(fbin, output->V + nv, units[nv],
                        output->var_name[nv], grid);
        CloseBinaryFile(fbin, SZ_Float_Vect);
      }

      for (nv = 0; nv < output->nvar; nv++) {  /* -- write scalars -- */
        if (output->dump_var[nv] != YES) continue;
        sprintf (filename, "%s/%s.%04d.%s", output->dir, output->var_name[nv], 
                                            output->nfile,  output->ext);
        fbin = OpenBinaryFile(filename, SZ_Float_Vect, "w");
        WriteVTK_Header(fbin, grid);
        #ifdef PARALLEL
         offset = AL_Get_offset(SZ_Float_Vect);
         CloseBinaryFile(fbin, SZ_Float_Vect);
         fbin  = OpenBinaryFile(filename, SZ_float, "w");
         AL_Set_offset(SZ_float, offset);
        #endif
        WriteVTK_Scalar(fbin, output->V[nv], units[nv],
                        output->var_name[nv], grid);
        CloseBinaryFile (fbin, SZ_float);
      }
    }

  }else if (output->type == TAB_OUTPUT) { 

  /* ------------------------------------------------------
               Tabulated (ASCII) output
     ------------------------------------------------------ */

    single_file = YES;
    sprintf (filename,"%s/data.%04d.%s", output->dir, output->nfile,
                                         output->ext);
    WriteTabArray (output, filename, grid);

  }else if (output->type == PPM_OUTPUT) { 

  /* ------------------------------------------------------
                   PPM output
     ------------------------------------------------------ */

    single_file = NO;
    for (nv = 0; nv < output->nvar; nv++) {
      if (!output->dump_var[nv]) continue;
      sprintf (filename, "%s/%s.%04d.%s", output->dir, output->var_name[nv], 
                                          output->nfile, output->ext);
      WritePPM (output->V[nv], output->var_name[nv], filename, grid);
    }

  }else if (output->type == PNG_OUTPUT) { 

  /* ------------------------------------------------------
                   PNG  output
     ------------------------------------------------------ */

    #ifdef USE_PNG
     single_file = NO;
     for (nv = 0; nv < output->nvar; nv++) {
       if (!output->dump_var[nv]) continue;
       sprintf (filename, "%s/%s.%04d.%s", output->dir, output->var_name[nv], 
                                           output->nfile, output->ext);
       WritePNG (output->V[nv], output->var_name[nv], filename, grid);
     }
    #else
     print1 ("! PNG library not available\n");
     return;
    #endif

  }

/* -------------------------------------------------------------
           Update corresponding ".out" file
   ------------------------------------------------------------- */

  sprintf (filename,"%s/%s.out",output->dir, output->ext);

  if (prank == 0) {
    if (output->nfile == 0) {
      fout = fopen (filename, "w");
    }else {
      fout = fopen (filename, "r+");
      for (nv = 0; nv < output->nfile; nv++) fgets (sline, 512, fout);
      fseek (fout, ftell(fout), SEEK_SET);
    }

  /* -- write a multi-column file -- */

    fprintf (fout, "%d %12.6e %12.6e %ld ",
             output->nfile, g_time, g_dt, g_stepNumber);

    if (single_file) fprintf (fout,"single_file ");
    else             fprintf (fout,"multiple_files ");

    if (IsLittleEndian()) fprintf (fout, "little ");
    else                  fprintf (fout, "big ");

    for (nv = 0; nv < output->nvar; nv++) { 
      if (output->dump_var[nv]) fprintf (fout, "%s ", output->var_name[nv]);
    }

    fprintf (fout,"\n");
    fclose (fout);
  }

  #ifdef PARALLEL
   MPI_Barrier (MPI_COMM_WORLD);
   if (prank == 0){
     time(&tend);
     print1 (" [%5.2f sec]",difftime(tend,tbeg));
   }
  #endif
  print1 ("\n");

}

Here is the call graph for this function:

Here is the caller graph for this function:

void WriteHDF5	(	Output *	output,
		Grid *	grid
	)

Write data to disk using hdf5 format in single or double precision.

Parameters

[in]	output	the output structure associated with HDF5 format
[in]	grid	a pointer to an array of Grid structures

Returns

This function has no return value.

Note

Writing of staggered magnetic fields: Here we follow the same convention used by ArrayLib, where internal points that lie on the grid boundary between processors are owned by the left processor. For this reason, only the leftmost processor writes one additional point in the direction of staggering while the other processors write the same amount of zones as for cell-centered data. Also, keep in mind that the data array Vs starts from -1 (instead of 0) in the staggered direction.

Writing of staggered magnetic fields: Here we follow the same convention used by ArrayLib, where internal points that lie on the grid boundary between processors are owned by the left processor. For this reason, only the leftmost processor writes one additional point in the direction of staggering while the other processors write the same amount of zones as for cell-centered data. Also, keep in mind that the data array Vs starts from -1 (instead of 0) in the staggered direction.

Definition at line 45 of file hdf5_io.c.

{
  hid_t dataspace, memspace, dataset;
  hid_t strspace, stratt, string_type;
  hid_t tspace, tattr;
  hid_t file_identifier, group, timestep;
  hid_t file_access = 0;
 #if MPI_POSIX == NO
  hid_t plist_id_mpiio = 0; /* for collective MPI I/O */
 #endif
  hid_t err;

  hsize_t dimstr;
  hsize_t dimens[DIMENSIONS];
  hsize_t start[DIMENSIONS];
  hsize_t stride[DIMENSIONS];
  hsize_t count[DIMENSIONS];

  time_t tbeg, tend;
  static float ****node_coords, ****cell_coords;
  char filename[512], filenamexmf[512], tstepname[32];
  char *coords = "/cell_coords/X /cell_coords/Y /cell_coords/Z ";
  char *cname[] = {"X", "Y", "Z"};
  char xmfext[8];
  int  rank, nd, nv, ns, nc, ngh, ii, jj, kk;
  int n1p, n2p, n3p, nprec;
  Grid *wgrid[3];
  FILE *fxmf;
 
/* ----------------------------------------------------------------
                 compute coordinates just once
   ---------------------------------------------------------------- */

  if (node_coords == NULL) {
    double x1, x2, x3;

    n1p = NX1 + (grid[IDIR].rbound != 0);
    n2p = NX2 + (grid[JDIR].rbound != 0);
    n3p = NX3 + (grid[KDIR].rbound != 0);

    node_coords = ARRAY_4D(3, n3p, n2p, n1p, float);
    cell_coords = ARRAY_4D(3, NX3, NX2, NX1, float);
    
    for (kk = 0; kk < n3p; kk++) {  x3 = grid[KDIR].xl[KBEG+kk];
    for (jj = 0; jj < n2p; jj++) {  x2 = grid[JDIR].xl[JBEG+jj];
    for (ii = 0; ii < n1p; ii++) {  x1 = grid[IDIR].xl[IBEG+ii];

      node_coords[JDIR][kk][jj][ii] = 0.0;
      node_coords[KDIR][kk][jj][ii] = 0.0;
     
      #if GEOMETRY == CARTESIAN || GEOMETRY == CYLINDRICAL
       D_EXPAND(node_coords[IDIR][kk][jj][ii] = (float)x1;  ,
                node_coords[JDIR][kk][jj][ii] = (float)x2;  ,
                node_coords[KDIR][kk][jj][ii] = (float)x3;)
      #elif GEOMETRY == POLAR
       D_EXPAND(node_coords[IDIR][kk][jj][ii] = (float)(x1*cos(x2)); ,
                node_coords[JDIR][kk][jj][ii] = (float)(x1*sin(x2)); ,
                node_coords[KDIR][kk][jj][ii] = (float)(x3);)
      #elif GEOMETRY == SPHERICAL
       #if DIMENSIONS <= 2
        D_EXPAND(node_coords[IDIR][kk][jj][ii] = (float)(x1*sin(x2)); ,
                 node_coords[JDIR][kk][jj][ii] = (float)(x1*cos(x2)); ,
                 node_coords[KDIR][kk][jj][ii] = 0.0;)
       #else
        D_EXPAND(node_coords[IDIR][kk][jj][ii] = (float)(x1*sin(x2)*cos(x3)); ,
                 node_coords[JDIR][kk][jj][ii] = (float)(x1*sin(x2)*sin(x3)); ,
                 node_coords[KDIR][kk][jj][ii] = (float)(x1*cos(x2));)
       #endif
      #else
       print1 ("! HDF5_IO: Unknown geometry\n");
       QUIT_PLUTO(1);
      #endif
    }}}

    for (kk = 0; kk < NX3; kk++) {  x3 = grid[KDIR].x[KBEG+kk];
    for (jj = 0; jj < NX2; jj++) {  x2 = grid[JDIR].x[JBEG+jj];
    for (ii = 0; ii < NX1; ii++) {  x1 = grid[IDIR].x[IBEG+ii];

      cell_coords[JDIR][kk][jj][ii] = 0.0;
      cell_coords[KDIR][kk][jj][ii] = 0.0;

      #if GEOMETRY == CARTESIAN || GEOMETRY == CYLINDRICAL
       D_EXPAND(cell_coords[IDIR][kk][jj][ii] = (float)x1;  ,
                cell_coords[JDIR][kk][jj][ii] = (float)x2;  ,
                cell_coords[KDIR][kk][jj][ii] = (float)x3;)
      #elif GEOMETRY == POLAR
       D_EXPAND(cell_coords[IDIR][kk][jj][ii] = (float)(x1*cos(x2)); ,
                cell_coords[JDIR][kk][jj][ii] = (float)(x1*sin(x2)); ,
                cell_coords[KDIR][kk][jj][ii] = (float)(x3);)
      #elif GEOMETRY == SPHERICAL
       #if DIMENSIONS <= 2
        D_EXPAND(cell_coords[IDIR][kk][jj][ii] = (float)(x1*sin(x2)); ,
                 cell_coords[JDIR][kk][jj][ii] = (float)(x1*cos(x2)); ,
                 cell_coords[KDIR][kk][jj][ii] = 0.0;)
       #else
        D_EXPAND(cell_coords[IDIR][kk][jj][ii] = (float)(x1*sin(x2)*cos(x3)); ,
                 cell_coords[JDIR][kk][jj][ii] = (float)(x1*sin(x2)*sin(x3)); ,
                 cell_coords[KDIR][kk][jj][ii] = (float)(x1*cos(x2));)
       #endif
      #else
       print1 ("! HDF5_IO: Unknown geometry\n");
       QUIT_PLUTO(1);
      #endif
    }}}

  } 

/* --------------------------------------------------------------
     Since data is written in reverse order (Z-Y-X) it is
     convenient to define pointers to grid in reverse order
   -------------------------------------------------------------- */

  for (nd = 0; nd < DIMENSIONS; nd++) wgrid[nd] = grid + DIMENSIONS - nd - 1;

  #ifdef PARALLEL
   MPI_Barrier (MPI_COMM_WORLD);
   if (prank == 0)time(&tbeg);
  #endif

  sprintf (filename, "%s/data.%04d.%s", output->dir,output->nfile, output->ext);

  rank   = DIMENSIONS;
  dimstr = 3;

  #ifdef PARALLEL
   file_access = H5Pcreate(H5P_FILE_ACCESS);
   #if MPI_POSIX == YES
    H5Pset_fapl_mpiposix(file_access, MPI_COMM_WORLD, 1); 
   #else
    H5Pset_fapl_mpio(file_access,  MPI_COMM_WORLD, MPI_INFO_NULL);
   #endif
   file_identifier = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, file_access);
   H5Pclose(file_access);
  #else
   file_identifier = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
  #endif

  sprintf (tstepname, "Timestep_%d", output->nfile);
  timestep = H5Gcreate(file_identifier, tstepname, 0);

  tspace  = H5Screate(H5S_SCALAR);
  tattr   = H5Acreate(timestep, "Time", H5T_NATIVE_DOUBLE, tspace, H5P_DEFAULT);
  err = H5Awrite(tattr, H5T_NATIVE_DOUBLE, &g_time);
  H5Aclose(tattr);
  H5Sclose(tspace);

  group = H5Gcreate(timestep, "vars", 0); /* Create group "vars" (cell-centered vars) */

/* Define "coords" attribute of group "vars" */

  strspace = H5Screate_simple(1, &dimstr, NULL);
  string_type = H5Tcopy(H5T_C_S1);
  H5Tset_size(string_type, strlen("/cell_coords/X "));
  H5Tset_strpad(string_type,H5T_STR_SPACEPAD);
  stratt = H5Acreate(group,"coords",string_type,strspace, H5P_DEFAULT);
  err = H5Awrite(stratt, string_type, coords);
  H5Aclose(stratt);
  H5Sclose(strspace);

  for (nd = 0; nd < DIMENSIONS; nd++) dimens[nd] = wgrid[nd]->np_int_glob;
 
  dataspace = H5Screate_simple(rank, dimens, NULL);

  #ifdef PARALLEL 
   for (nd = 0; nd < DIMENSIONS; nd++) {
     start[nd]  = wgrid[nd]->beg - wgrid[nd]->nghost;
     stride[nd] = 1;
     count[nd]  = wgrid[nd]->np_int;
   }

   err = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET, start, stride, count, NULL);
  #endif

  for (nd = 0; nd < DIMENSIONS; nd++) dimens[nd] = wgrid[nd]->np_tot;

  memspace = H5Screate_simple(rank,dimens,NULL);

  for (nd = 0; nd < DIMENSIONS; nd++){
    start[nd]  = wgrid[nd]->nghost;
    stride[nd] = 1;
    count[nd]  = wgrid[nd]->np_int;
  }
  err = H5Sselect_hyperslab(memspace,H5S_SELECT_SET, start, stride, count, NULL);

/* ------------------------------------
      write cell-centered data
   ------------------------------------ */

 #if MPI_POSIX == NO
  plist_id_mpiio = H5Pcreate(H5P_DATASET_XFER);
  H5Pset_dxpl_mpio(plist_id_mpiio,H5FD_MPIO_COLLECTIVE);
 #endif

  for (nv = 0; nv < output->nvar; nv++) {
  
  /* -- skip variable if excluded from output or if it is staggered -- */

    if (!output->dump_var[nv] || output->stag_var[nv] != -1) continue;

    if (output->type == DBL_H5_OUTPUT){
      dataset = H5Dcreate(group, output->var_name[nv], H5T_NATIVE_DOUBLE,
                          dataspace, H5P_DEFAULT);
     #if MPI_POSIX == NO
      err = H5Dwrite(dataset, H5T_NATIVE_DOUBLE, memspace, dataspace,
                     plist_id_mpiio, output->V[nv][0][0]);
     #else
      err = H5Dwrite(dataset, H5T_NATIVE_DOUBLE, memspace, dataspace,
                     H5P_DEFAULT, output->V[nv][0][0]);
     #endif
    }else if (output->type == FLT_H5_OUTPUT){
      void *Vpt;
      Vpt = (void *)(Convert_dbl2flt(output->V[nv],1.0, 0))[0][0];

      dataset = H5Dcreate(group, output->var_name[nv], H5T_NATIVE_FLOAT,
                          dataspace, H5P_DEFAULT);

     #if MPI_POSIX == NO
      err = H5Dwrite(dataset, H5T_NATIVE_FLOAT, memspace,
                     dataspace, plist_id_mpiio, Vpt);
     #else
      err = H5Dwrite(dataset, H5T_NATIVE_FLOAT, memspace,
                     dataspace, H5P_DEFAULT, Vpt);
     #endif
    }
    H5Dclose(dataset);
  }

 #if MPI_POSIX == NO
  H5Pclose(plist_id_mpiio);
 #endif
  H5Sclose(memspace);
  H5Sclose(dataspace);
  H5Gclose(group); /* Close group "vars" */

/*  --------------------------------------------------------------------- */
/*! \note Writing of staggered magnetic fields:
    Here we follow the same convention used by ArrayLib, where internal
    points that lie on the grid boundary between processors are owned
    by the \b left processor.
    For this reason, only the leftmost processor writes one additional
    point in the direction of staggering while the other processors
    write the same amount of zones as for cell-centered data.
    Also, keep in mind that the data array Vs starts from -1
    (instead of 0) in the staggered direction.                           */
/*  --------------------------------------------------------------------- */

 #ifdef STAGGERED_MHD
  if (output->type == DBL_H5_OUTPUT){
   group = H5Gcreate(timestep, "stag_vars", 0); /* Create group "stag_vars" (staggered vars) */

  #if MPI_POSIX == NO
   plist_id_mpiio = H5Pcreate(H5P_DATASET_XFER);
   H5Pset_dxpl_mpio(plist_id_mpiio,H5FD_MPIO_COLLECTIVE);
  #endif

   for (ns = 0; ns < DIMENSIONS; ns++) {

  /* -- skip variable if excluded from output or if it is cell-centered -- */
 
     if (!output->dump_var[NVAR+ns] || output->stag_var[NVAR+ns] == -1) continue;
     for (nd = 0; nd < DIMENSIONS; nd++) {
       dimens[nd] = wgrid[nd]->np_int_glob + (ns == (DIMENSIONS-1-nd));
     }
     dataspace = H5Screate_simple(rank, dimens, NULL);

     #ifdef PARALLEL
      for (nd = 0; nd < DIMENSIONS; nd++) {
        start[nd]  = wgrid[nd]->beg - wgrid[nd]->nghost;
        stride[nd] = 1;
        count[nd]  = wgrid[nd]->np_int;
        if (ns == DIMENSIONS-1-nd){
           if (grid[ns].lbound != 0) count[nd] += 1;
           else                      start[nd] += 1;
        }
      }
      err = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET,
                                start, stride, count, NULL);
     #endif

     for (nd = 0; nd < DIMENSIONS; nd++){
       dimens[nd] = wgrid[nd]->np_tot + (ns==(DIMENSIONS-1-nd));
     }
     memspace = H5Screate_simple(rank,dimens,NULL);

     for (nd = 0; nd < DIMENSIONS; nd++){
       start[nd]  = wgrid[nd]->nghost;
       stride[nd] = 1;
       count[nd]  = wgrid[nd]->np_int;
       if (ns == (DIMENSIONS-1-nd) && grid[ns].lbound != 0) {
         start[nd] -= 1;
         count[nd] += 1;
       }
     }

     err = H5Sselect_hyperslab(memspace,H5S_SELECT_SET, start, stride, count, NULL);

     if (output->type == DBL_H5_OUTPUT){
       dataset = H5Dcreate(group, output->var_name[NVAR+ns], H5T_NATIVE_DOUBLE,
                           dataspace, H5P_DEFAULT);
      #if MPI_POSIX == NO
       err = H5Dwrite(dataset, H5T_NATIVE_DOUBLE, memspace, dataspace,
                      plist_id_mpiio, output->V[NVAR+ns][0][0]);
      #else
       err = H5Dwrite(dataset, H5T_NATIVE_DOUBLE, memspace, dataspace,
                      H5P_DEFAULT, output->V[NVAR+ns][0][0]);
      #endif
     }else if (output->type == FLT_H5_OUTPUT){
       void *Vpt;
       Vpt = (void *)(Convert_dbl2flt(output->V[NVAR+ns],1.0, 0))[0][0];
       dataset = H5Dcreate(group, output->var_name[NVAR+ns], H5T_NATIVE_FLOAT,
                           dataspace, H5P_DEFAULT);

      #if MPI_POSIX == NO
       err = H5Dwrite(dataset, H5T_NATIVE_FLOAT, memspace,
                      dataspace, plist_id_mpiio, Vpt);
      #else
       err = H5Dwrite(dataset, H5T_NATIVE_FLOAT, memspace,
                      dataspace, H5P_DEFAULT, Vpt);
      #endif
     }

     H5Dclose(dataset);
     H5Sclose(memspace);
     H5Sclose(dataspace);
   }

  #if MPI_POSIX == NO
   H5Pclose(plist_id_mpiio);
  #endif
   H5Gclose(group);} /* Close group "stag_vars" */
  #endif  /* STAGGERED_MHD */

  H5Gclose(timestep);

  group = H5Gcreate(file_identifier, "cell_coords", 0); /* Create group "cell_coords" (centered mesh) */ 
   
  for (nd = 0; nd < DIMENSIONS; nd++) dimens[nd] = wgrid[nd]->np_int_glob;
  dataspace = H5Screate_simple(rank, dimens, NULL);

  #ifdef PARALLEL
   for (nd = 0; nd < DIMENSIONS; nd++) {
     start[nd]  = wgrid[nd]->beg - wgrid[nd]->nghost;
     stride[nd] = 1;
     count[nd]  = wgrid[nd]->np_int;
   }
   err = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET,
                             start, stride, count, NULL);
  #endif

  for (nd = 0; nd < DIMENSIONS; nd++) dimens[nd] = wgrid[nd]->np_int;
  memspace = H5Screate_simple(rank,dimens,NULL);

/* ------------------------------------
       write cell centered mesh
   ------------------------------------ */

 #if MPI_POSIX == NO
  plist_id_mpiio = H5Pcreate(H5P_DATASET_XFER);
  H5Pset_dxpl_mpio(plist_id_mpiio,H5FD_MPIO_COLLECTIVE);
 #endif

  for (nc = 0; nc < 3; nc++) {
    dataset = H5Dcreate(group, cname[nc], H5T_NATIVE_FLOAT, dataspace, H5P_DEFAULT);

   #if MPI_POSIX == NO
    err = H5Dwrite(dataset, H5T_NATIVE_FLOAT, memspace,
                   dataspace, plist_id_mpiio, cell_coords[nc][0][0]);
   #else
    err = H5Dwrite(dataset, H5T_NATIVE_FLOAT, memspace,
                   dataspace, H5P_DEFAULT, cell_coords[nc][0][0]);
   #endif

    H5Dclose(dataset);
  }

 #if MPI_POSIX == NO
  H5Pclose(plist_id_mpiio);
 #endif
  H5Sclose(memspace);
  H5Sclose(dataspace);
  H5Gclose(group); /* Close group "cell_coords" */

  group = H5Gcreate(file_identifier, "node_coords", 0); /* Create group "node_coords" (node mesh) */

  for (nd = 0; nd < DIMENSIONS; nd++) dimens[nd] = wgrid[nd]->np_int_glob+1;

  dataspace = H5Screate_simple(rank, dimens, NULL);

  #ifdef PARALLEL
   for (nd = 0; nd < DIMENSIONS; nd++) {
     start[nd]  = wgrid[nd]->beg - wgrid[nd]->nghost;
     stride[nd] = 1;
     count[nd]  = wgrid[nd]->np_int;
     if (wgrid[nd]->rbound != 0) count[nd] += 1;
   }

   err = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET,
                             start, stride, count, NULL);
  #endif

  for (nd = 0; nd < DIMENSIONS; nd++) {
   dimens[nd] = wgrid[nd]->np_int;
   if (wgrid[nd]->rbound != 0) dimens[nd] += 1;
  }
  memspace = H5Screate_simple(rank,dimens,NULL);

/* ------------------------------------
          write node centered mesh
   ------------------------------------ */

 #if MPI_POSIX == NO
  plist_id_mpiio = H5Pcreate(H5P_DATASET_XFER);
  H5Pset_dxpl_mpio(plist_id_mpiio,H5FD_MPIO_COLLECTIVE);
 #endif

  for (nc = 0; nc < 3; nc++) {
    dataset = H5Dcreate(group, cname[nc], H5T_NATIVE_FLOAT, dataspace, H5P_DEFAULT);

   #if MPI_POSIX == NO
    err = H5Dwrite(dataset, H5T_NATIVE_FLOAT, memspace,
                   dataspace, plist_id_mpiio, node_coords[nc][0][0]);
   #else
    err = H5Dwrite(dataset, H5T_NATIVE_FLOAT, memspace,
                   dataspace, H5P_DEFAULT, node_coords[nc][0][0]);
   #endif

    H5Dclose(dataset);
  }

 #if MPI_POSIX == NO
  H5Pclose(plist_id_mpiio);
 #endif
  H5Sclose(memspace);
  H5Sclose(dataspace);
  H5Gclose(group); /* Close group "node_coords" */

  H5Fclose(file_identifier);

/* Create XDMF file to read HDF5 output (Visit or Paraview) */

  if (prank == 0) {

    if (output->type == DBL_H5_OUTPUT){
      sprintf(xmfext,"dbl.xmf");
      nprec = 8;
    } else if (output->type == FLT_H5_OUTPUT){
      sprintf(xmfext,"flt.xmf");
      nprec = 4;
    }
 
    sprintf (filenamexmf, "%s/data.%04d.%s", output->dir, output->nfile, xmfext);
   
    fxmf = fopen(filenamexmf, "w");
    fprintf(fxmf, "<?xml version=\"1.0\" ?>\n");
    fprintf(fxmf, "<!DOCTYPE Xdmf SYSTEM \"Xdmf.dtd\" []>\n");
    fprintf(fxmf, "<Xdmf Version=\"2.0\">\n");
    fprintf(fxmf, " <Domain>\n");
    fprintf(fxmf, "   <Grid Name=\"node_mesh\" GridType=\"Uniform\">\n");
    fprintf(fxmf, "    <Time Value=\"%12.6e\"/>\n",g_time);
    #if DIMENSIONS == 2
     fprintf(fxmf,"     <Topology TopologyType=\"2DSMesh\" NumberOfElements=\"%d %d\"/>\n",
             wgrid[0]->np_int_glob+1, wgrid[1]->np_int_glob+1);
     fprintf(fxmf, "     <Geometry GeometryType=\"X_Y\">\n");
     for (nd = 0; nd < DIMENSIONS; nd++) {
       fprintf(fxmf,"       <DataItem Dimensions=\"%d %d\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">\n",
              wgrid[0]->np_int_glob+1, wgrid[1]->np_int_glob+1 );
       fprintf(fxmf, "        %s:/node_coords/%s\n",filename,cname[nd]);
       fprintf(fxmf, "       </DataItem>\n");
     }
    #elif DIMENSIONS == 3
     fprintf(fxmf, "     <Topology TopologyType=\"3DSMesh\" NumberOfElements=\"%d %d %d\"/>\n",
             wgrid[0]->np_int_glob+1, wgrid[1]->np_int_glob+1, wgrid[2]->np_int_glob+1);
     fprintf(fxmf, "     <Geometry GeometryType=\"X_Y_Z\">\n");
     for (nd = 0; nd < DIMENSIONS; nd++) {
       fprintf(fxmf, "       <DataItem Dimensions=\"%d %d %d\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">\n",
               wgrid[0]->np_int_glob+1, wgrid[1]->np_int_glob+1, wgrid[2]->np_int_glob+1 );
       fprintf(fxmf, "        %s:/node_coords/%s\n",filename,cname[nd]);
       fprintf(fxmf, "       </DataItem>\n");
     }
    #endif
    fprintf(fxmf, "     </Geometry>\n");
    for (nv = 0; nv < output->nvar; nv++) { /* Write cell-centered variables */
      if (!output->dump_var[nv] || output->stag_var[nv] != -1) continue; /* -- skip variable if excluded from output or if it is staggered */
      fprintf(fxmf, "     <Attribute Name=\"%s\" AttributeType=\"Scalar\" Center=\"Cell\">\n",
              output->var_name[nv]);
      #if DIMENSIONS == 2
       fprintf(fxmf, "       <DataItem Dimensions=\"%d %d\" NumberType=\"Float\" Precision=\"%d\" Format=\"HDF\">\n",
               wgrid[0]->np_int_glob, wgrid[1]->np_int_glob, nprec);
      #elif DIMENSIONS == 3
       fprintf(fxmf, "       <DataItem Dimensions=\"%d %d %d\" NumberType=\"Float\" Precision=\"%d\" Format=\"HDF\">\n",
               wgrid[0]->np_int_glob, wgrid[1]->np_int_glob, wgrid[2]->np_int_glob, nprec);
      #endif
      fprintf(fxmf, "        %s:%s/vars/%s\n",filename,tstepname,output->var_name[nv]);
      fprintf(fxmf, "       </DataItem>\n");
      fprintf(fxmf, "     </Attribute>\n");
    }
    for (nd = 0; nd < DIMENSIONS; nd++) { /* Write cell center coordinates (as cell-centerd variables) */
      fprintf(fxmf, "     <Attribute Name=\"%s\" AttributeType=\"Scalar\" Center=\"Cell\">\n",
              cname[nd]);
      #if DIMENSIONS == 2
       fprintf(fxmf, "       <DataItem Dimensions=\"%d %d\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">\n",
               wgrid[0]->np_int_glob, wgrid[1]->np_int_glob);
      #elif DIMENSIONS == 3
       fprintf(fxmf, "       <DataItem Dimensions=\"%d %d %d\" NumberType=\"Float\" Precision=\"4\" Format=\"HDF\">\n",
               wgrid[0]->np_int_glob, wgrid[1]->np_int_glob, wgrid[2]->np_int_glob);
      #endif
      fprintf(fxmf, "        %s:/cell_coords/%s\n",filename,cname[nd]);
      fprintf(fxmf, "       </DataItem>\n");
      fprintf(fxmf, "     </Attribute>\n");
    } 
    fprintf(fxmf, "   </Grid>\n");
    fprintf(fxmf, " </Domain>\n");
    fprintf(fxmf, "</Xdmf>\n");
    fclose(fxmf);
  } /* if (prank == 0) */

/* XDMF file */

  #ifdef PARALLEL
   MPI_Barrier (MPI_COMM_WORLD);
   if (prank == 0){
     time(&tend);
     print1 (" [%5.2f sec]",difftime(tend,tbeg));
   }
  #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WritePNG	(	double ***	,
		char *	,
		char *	,
		Grid *
	)

Here is the caller graph for this function:

void WritePPM	(	double ***	,
		char *	,
		char *	,
		Grid *
	)

Definition at line 10 of file write_img.c.

{
  int  ic, ir;
  FILE *fl;
  char header[512];
  Image *ppm;

  ppm = GetImage (var_name);
  SetColorMap (ppm->r, ppm->g, ppm->b, ppm->colormap);
  GetSlice (Vdbl, ppm, grid);
  if (prank != 0) return;

  sprintf (header,"P6\n%d %d\n255\n", ppm->ncol, ppm->nrow);
  fl  = fopen (filename,"w");
  fprintf(fl,"%s",header);
  for (ir = 0; ir < ppm->nrow; ir++){
    fwrite (ppm->rgb[ir], sizeof(RGB), ppm->ncol, fl);
  } 
  fclose(fl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WriteTabArray	(	Output *	output,
		char *	filename,
		Grid *	grid
	)

Write tabulated array.

Parameters

[in]	output	a pointer to the output structure corresponding to the tab format
[in]	filename	the output file name
[in]	grid	pointer to an array of Grid structures

Definition at line 31 of file write_tab.c.

{
  int  nv, i, j, k;
  FILE *fout;

  #ifdef PARALLEL
   print1 ("! WriteTabArray: tab output not supported in parallel\n");
   return;
  #endif

  #if DIMENSIONS == 3
   print1 ("! WriteTabArray: tab output not supported in 3D\n");
   return;
  #endif

/* ------------------------------------------
      dump arrays in ascii format to disk 
   ------------------------------------------ */

  fout = fopen (filename, "w");
  k = 0;
  IDOM_LOOP (i){
    JDOM_LOOP(j){
      fprintf (fout, "%f %f ", grid[IDIR].x[i], grid[JDIR].x[j]);
      for (nv = 0; nv < output->nvar; nv++) {
        if (output->dump_var[nv]) 
          fprintf (fout, "%12.6e ", output->V[nv][k][j][i]);
      }
      fprintf (fout, "\n");   /* newline */
    }
    #if DIMENSIONS > 1
     fprintf (fout, "\n");   /* skip one more empty line in 2D */
    #endif
  }
  fclose (fout);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WriteVTK_Header	(	FILE *	fvtk,
		Grid *	grid
	)

Write VTK header in parallel or serial mode. In parallel mode only processor 0 does the actual writing (see al_io.c/AL_Write_header).

Parameters

[in]	fvtk	pointer to file
[in]	grid	pointer to an array of Grid structures

Todo:

Write the grid using several processors.

Definition at line 91 of file write_vtk.c.

{
  int    i, j, k;
  int    nx1, nx2, nx3;
  char   header[1024];
  float  x1, x2, x3;
  static float  ***node_coord, *xnode, *ynode, *znode;

/* ------------------------------------------------
          get global dimensions
   ------------------------------------------------ */

  nx1 = grid[IDIR].gend + 1 - grid[IDIR].nghost;
  nx2 = grid[JDIR].gend + 1 - grid[JDIR].nghost;
  nx3 = grid[KDIR].gend + 1 - grid[KDIR].nghost;

/* -------------------------------------------------------------
     Allocate memory and define node coordinates only once.
   ------------------------------------------------------------- */

  if (node_coord == NULL){
    node_coord = ARRAY_3D(nx2 + JOFFSET, nx1 + IOFFSET, 3, float);

    #if VTK_FORMAT == RECTILINEAR_GRID
     xnode = ARRAY_1D(nx1 + IOFFSET, float);
     ynode = ARRAY_1D(nx2 + JOFFSET, float);
     znode = ARRAY_1D(nx3 + KOFFSET, float);

     for (i = 0; i < nx1 + IOFFSET; i++){
       x1 = (float)(grid[IDIR].xl_glob[i+IBEG]);
       if (IsLittleEndian()) SWAP_VAR(x1);
       xnode[i] = x1;
     }
     for (j = 0; j < nx2 + JOFFSET; j++){
       x2 = (float)(grid[JDIR].xl_glob[j+JBEG]);
       if (IsLittleEndian()) SWAP_VAR(x2);
       ynode[j] = x2;
     }
     for (k = 0; k < nx3 + KOFFSET; k++){
       x3 = (float)(grid[KDIR].xl_glob[k+KBEG]);
       if (IsLittleEndian()) SWAP_VAR(x3);
       #if DIMENSIONS == 2
        znode[k] = 0.0;
       #else
        znode[k] = x3;
       #endif
     }
    #endif
  }

/* ----------------------------------------------------------
    Part I, II, III: 
    Write file header on string "header" 
   ---------------------------------------------------------- */

  sprintf(header,"# vtk DataFile Version 2.0\n"); 
  sprintf(header+strlen(header),"PLUTO %s VTK Data\n",PLUTO_VERSION);
  sprintf(header+strlen(header),"BINARY\n");
  #if VTK_FORMAT == RECTILINEAR_GRID
   sprintf(header+strlen(header),"DATASET %s\n","RECTILINEAR_GRID");
  #elif VTK_FORMAT == STRUCTURED_GRID
   sprintf(header+strlen(header),"DATASET %s\n","STRUCTURED_GRID");
  #endif

  VTK_HEADER_WRITE_STRING(header);

  /* -- generate time info -- */

  #if VTK_TIME_INFO == YES
   sprintf (header,"FIELD FieldData 1\n");
   sprintf (header+strlen(header),"TIME 1 1 double\n");
   double tt=g_time;
   if (IsLittleEndian()) SWAP_VAR(tt);
   VTK_HEADER_WRITE_STRING(header);
   VTK_HEADER_WRITE_DBLARR(&tt, 1);
   VTK_HEADER_WRITE_STRING("\n");

  #endif /* VTK_TIME_INFO */

  sprintf(header,"DIMENSIONS %d %d %d\n",
                  nx1 + IOFFSET, nx2 + JOFFSET, nx3 + KOFFSET);
  VTK_HEADER_WRITE_STRING(header);
  
#if VTK_FORMAT == RECTILINEAR_GRID

  /* -- reset header string and keep going -- */

   sprintf(header,"X_COORDINATES %d float\n", nx1 + IOFFSET);
   VTK_HEADER_WRITE_STRING(header);
   VTK_HEADER_WRITE_FLTARR(xnode, nx1 + IOFFSET);

   sprintf(header,"\nY_COORDINATES %d float\n", nx2 + JOFFSET);
   VTK_HEADER_WRITE_STRING(header);
   VTK_HEADER_WRITE_FLTARR(ynode, nx2 + JOFFSET);

   sprintf(header,"\nZ_COORDINATES %d float\n", nx3 + KOFFSET);
   VTK_HEADER_WRITE_STRING(header);
   VTK_HEADER_WRITE_FLTARR(znode, nx3 + KOFFSET);

   sprintf (header,"\nCELL_DATA %d\n", nx1*nx2*nx3);
   VTK_HEADER_WRITE_STRING (header);

#elif VTK_FORMAT == STRUCTURED_GRID

  sprintf(header,"POINTS %d float\n", (nx1+IOFFSET)*(nx2+JOFFSET)*(nx3+KOFFSET));
  VTK_HEADER_WRITE_STRING(header);

/* ---------------------------------------------------------------
    Part IV: (structured) grid information 
   --------------------------------------------------------------- */

  x1 = x2 = x3 = 0.0;
  for (k = 0; k < nx3 + KOFFSET; k++){
    for (j = 0; j < nx2 + JOFFSET; j++){ 
    for (i = 0; i < nx1 + IOFFSET; i++){
      D_EXPAND(x1 = grid[IDIR].xl_glob[IBEG + i];  ,
               x2 = grid[JDIR].xl_glob[JBEG + j];  ,
               x3 = grid[KDIR].xl_glob[KBEG + k];)
       
      #if (GEOMETRY == CARTESIAN) || (GEOMETRY == CYLINDRICAL)
       node_coord[j][i][0] = x1;
       node_coord[j][i][1] = x2;
       node_coord[j][i][2] = x3;
      #elif GEOMETRY == POLAR
       node_coord[j][i][0] = x1*cos(x2);
       node_coord[j][i][1] = x1*sin(x2);
       node_coord[j][i][2] = x3;
      #elif GEOMETRY == SPHERICAL
       #if DIMENSIONS == 2
        node_coord[j][i][0] = x1*sin(x2);
        node_coord[j][i][1] = x1*cos(x2);
        node_coord[j][i][2] = 0.0;
       #elif DIMENSIONS == 3
        node_coord[j][i][0] = x1*sin(x2)*cos(x3);
        node_coord[j][i][1] = x1*sin(x2)*sin(x3);
        node_coord[j][i][2] = x1*cos(x2);
       #endif
      #endif
      
      if (IsLittleEndian()){
        SWAP_VAR(node_coord[j][i][0]);
        SWAP_VAR(node_coord[j][i][1]);
        SWAP_VAR(node_coord[j][i][2]);
      }
    }}
    VTK_HEADER_WRITE_FLTARR(node_coord[0][0],3*(nx1+IOFFSET)*(nx2+JOFFSET));
  }

  sprintf (header,"\nCELL_DATA %d\n", nx1*nx2*nx3);
  VTK_HEADER_WRITE_STRING(header);

#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WriteVTK_Scalar	(	FILE *	fvtk,
		double ***	V,
		double	unit,
		char *	var_name,
		Grid *	grid
	)

Write VTK scalar field.

Parameters

[in]	fvtk	pointer to file (handle)
[in]	V	pointer to 3D data array
[in]	unit	the corresponding cgs unit (if specified, 1 otherwise)
[in]	var_name	the variable name appearing in the VTK file
[in]	grid	pointer to an array of Grid structures

Definition at line 341 of file write_vtk.c.

{
  int i,j,k;
  char header[512];
  float ***Vflt;

  sprintf (header,"\nSCALARS %s float\n", var_name);
  sprintf (header,"%sLOOKUP_TABLE default\n",header);

  #ifdef PARALLEL
   MPI_Barrier (MPI_COMM_WORLD);
   AL_Write_header (header, strlen(header), MPI_CHAR, SZ_float);
  #else
   fprintf (fvtk, "%s",header);
  #endif

  Vflt = Convert_dbl2flt(V, unit, IsLittleEndian());
  WriteBinaryArray (Vflt[0][0], sizeof(float), SZ_float, fvtk, -1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WriteVTK_Vector	(	FILE *	fvtk,
		Data_Arr	V,
		double	unit,
		char *	var_name,
		Grid *	grid
	)

Write VTK vector field data. This is enabled only when VTK_VECTOR_DUMP is set to YES. For generality purposes, vectors are written always with 3 components, even when there're only 2 being used.

The following Maple script has been used to find vector components from cyl/sph to cartesian:

restart;
with(linalg);
Acyl := matrix (3,3,[ cos(phi), sin(phi),  0,
                   -sin(phi), cos(phi),  0,
                     0     ,    0    , 1]);
Asph := matrix (3,3,[ sin(theta)*cos(phi), sin(theta)*sin(phi),  cos(theta),
                cos(theta)*cos(phi), cos(theta)*sin(phi), -sin(theta),
                -sin(phi)          , cos(phi)           , 0]);
Bcyl := simplify(inverse(Acyl));
Bsph := simplify(inverse(Asph));

Parameters

[in]	fvtk	pointer to file
[in]	V	a 4D array [nv][k][j][i] containing the vector components (nv) defined at cell centers (k,j,i). The index nv = 0 marks the vector first component.
[in]	unit	the corresponding cgs unit (if specified, 1 otherwise)
[in]	var_name	the variable name appearing in the VTK file
[in]	grid	pointer to an array of Grid structures

Definition at line 259 of file write_vtk.c.

{
  int i,j,k;
  int vel_field, mag_field;
  char header[512];
  static Float_Vect ***vect3D;
  double v[3], x1, x2, x3;

  if (vect3D == NULL){
    vect3D = ARRAY_3D(NX3_TOT, NX2_TOT, NX1_TOT, Float_Vect);
  }

/* --------------------------------------------------------
               Write VTK vector fields 
   -------------------------------------------------------- */

  v[0] = v[1] = v[2] = 0.0;
  x1 = x2 = x3 = 0.0;

  vel_field = (strcmp(var_name,"vx1") == 0);
  mag_field = (strcmp(var_name,"bx1") == 0);
  if (vel_field || mag_field) { 
    DOM_LOOP(k,j,i){ 
      D_EXPAND(v[0] = V[0][k][j][i]; x1 = grid[IDIR].x[i]; ,
               v[1] = V[1][k][j][i]; x2 = grid[JDIR].x[j]; ,
               v[2] = V[2][k][j][i]; x3 = grid[KDIR].x[k];)
   
      VectorCartesianComponents(v, x1, x2, x3);
      vect3D[k][j][i].v1 = (float)v[0]*unit;
      vect3D[k][j][i].v2 = (float)v[1]*unit;
      vect3D[k][j][i].v3 = (float)v[2]*unit;

      if (IsLittleEndian()){
        SWAP_VAR(vect3D[k][j][i].v1);
        SWAP_VAR(vect3D[k][j][i].v2);
        SWAP_VAR(vect3D[k][j][i].v3);
      }

    } /* endfor DOM_LOOP(k,j,i) */

    if (vel_field)
      sprintf (header,"\nVECTORS %dD_Velocity_Field float\n", DIMENSIONS);
    else
      sprintf (header,"\nVECTORS %dD_Magnetic_Field float\n", DIMENSIONS);

    VTK_HEADER_WRITE_STRING(header);
    WriteBinaryArray (vect3D[0][0], sizeof(Float_Vect), SZ_Float_Vect, fvtk, -1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: