/* nag_pde_parab_1d_fd (d03pcc) Example Program.
 *
 * Copyright 2001 Numerical Algorithms Group.
 *
 * Mark 7, 2001.
 * Mark 7b revised, 2004.
 */

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <nag.h>
#include <nagx04.h>
#include <nag_stdlib.h>
#include <nagd03.h>
#include <nagx01.h>

#ifdef __cplusplus
extern "C" {
#endif
static void NAG_CALL pdedef(Integer, double, double, const double[],
                            const double[], double[], double[], double[],
                            Integer *, Nag_Comm *);
static void NAG_CALL bndary(Integer, double, const double[], const double[],
                            Integer, double[], double[], Integer *, Nag_Comm *);
static int NAG_CALL uinit(double *, double *, Integer, Integer, double);
#ifdef __cplusplus
}
#endif


#define U(I, J)       u[npde*((J) -1)+(I) -1]
#define P(I, J)       p[npde*((J) -1)+(I) -1]
#define UOUT(I, J, K) uout[npde*(intpts*((K) -1)+(J) -1)+(I) -1]

int main(int argc, char *argv[])
{
  FILE          *fpout;
  const Integer npts = 20, npde = 2, neqn = npts*npde, intpts = 6, itype = 1;
  const Integer nwk = (10+6*npde)*neqn, lisave = neqn+24;
  const Integer lrsave = nwk+(21+3*npde)*npde+7*npts+54;
  Integer       exit_status = 0, i, ind, it, itask, itrace, m;
  double        acc, alpha, hx, piby2, tout, ts;
  double        xout[6] = { 0., .4, .6, .8, .9, 1. };
  double        *rsave = 0, *u = 0, *uout = 0, *x = 0;
  Integer       *isave = 0;
  NagError      fail;
  Nag_Comm      comm;
  Nag_D03_Save  saved;

  INIT_FAIL(fail);

  /* Check for command-line IO options */
  fpout = nag_example_file_io(argc, argv, "-results", NULL);

  fprintf(fpout, "nag_pde_parab_1d_fd (d03pcc) Example Program Results\n\n");

  /* Allocate memory */
  if (!(rsave = NAG_ALLOC(lrsave, double)) ||
      !(u = NAG_ALLOC(npde*npts, double)) ||
      !(uout = NAG_ALLOC(npde*intpts*itype, double)) ||
      !(x = NAG_ALLOC(npts, double)) ||
      !(isave = NAG_ALLOC(lisave, Integer)))
    {
      fprintf(fpout, "Allocation failure\n");
      exit_status = 1;
      goto END;
    }

  acc = 0.001;
  m = 1;
  itrace = 0;
  alpha = 1.0;
  comm.p = (Pointer)&alpha;
  ind = 0;
  itask = 1;

  /* Set spatial mesh points */

  piby2 = 0.5*nag_pi;
  hx = piby2/19;
  x[0] = 0.0;
  x[19] = 1.0;
  for (i = 1; i < 19; ++i)
    {
      x[i] = sin(hx*i);
    }

  /* Set initial conditions */

  ts = 0.0;
  tout = 1e-5;

  fprintf(fpout, "Accuracy requirement  = %12.5f\n", acc);
  fprintf(fpout, "Parameter alpha =       %12.3f\n\n", alpha);
  fprintf(fpout, "   t  /  x  ");

  for (i = 0; i < 6; ++i)
    {
      fprintf(fpout, "%8.4f", xout[i]);
      fprintf(fpout, (i+1)%6 == 0 || i == 5?"\n":"");
    }

  /* Set the initial values */

  uinit(u, x, npde, npts, alpha);
  for (it = 0; it < 5; ++it)
    {
      tout *= 10.0;

      /* Solve for next iteration step */

      /* nag_pde_parab_1d_fd (d03pcc).
       * General system of parabolic PDEs, method of lines, finite
       * differences, one space variable
       */
      nag_pde_parab_1d_fd(npde, m, &ts, tout, pdedef, bndary, u, npts, x,
                          acc, rsave, lrsave, isave, lisave, itask, itrace,
                          0, &ind, &comm, &saved, &fail);

      if (fail.code != NE_NOERROR)
        {
          fprintf(fpout, "Error from nag_pde_parab_1d_fd (d03pcc).\n%s\n",
                  fail.message);
          exit_status = 1;
          goto END;
        }

      /* Interpolate at required spatial points */

      /* nag_pde_interp_1d_fd (d03pzc).
       * PDEs, spatial interpolation with nag_pde_parab_1d_fd (d03pcc),
       * nag_pde_parab_1d_keller (d03pec),
       * nag_pde_parab_1d_cd (d03pfc),
       * nag_pde_parab_1d_fd_ode (d03phc),
       * nag_pde_parab_1d_keller_ode (d03pkc),
       * nag_pde_parab_1d_cd_ode (d03plc),
       * nag_pde_parab_1d_fd_ode_remesh (d03ppc),
       * nag_pde_parab_1d_keller_ode_remesh (d03prc) or
       * nag_pde_parab_1d_cd_ode_remesh (d03psc)
       */
      nag_pde_interp_1d_fd(npde, m, u, npts, x, xout, intpts, 1, uout, &fail);

      if (fail.code != NE_NOERROR)
        {
          fprintf(fpout, "Error from nag_pde_interp_1d_fd (d03pzc).\n%s\n",
                  fail.message);
          exit_status = 1;
          goto END;
        }

      fprintf(fpout, "\n %6.4f u(1)", tout);

      for (i = 1; i <= 6; ++i)
        {
          fprintf(fpout, "%8.4f", UOUT(1, i, 1));
          fprintf(fpout, i%6 == 0 || i == 6?"\n":"");
        }

      fprintf(fpout, "        u(2)");

      for (i = 1; i <= 6; ++i)
        {
          fprintf(fpout, "%8.4f", UOUT(2, i, 1));
          fprintf(fpout, i%6 == 0 || i == 6?"\n":"");
        }
    }


  /* Print integration statistics */

  fprintf(fpout, "\n");
  fprintf(fpout, " Number of integration steps in time                    ");
  fprintf(fpout, "%4ld\n", isave[0]);
  fprintf(fpout, " Number of residual evaluations of resulting ODE system ");
  fprintf(fpout, "%4ld\n", isave[1]);
  fprintf(fpout, " Number of Jacobian evaluations                         ");
  fprintf(fpout, "%4ld\n", isave[2]);
  fprintf(fpout, " Number of iterations of nonlinear solver               ");
  fprintf(fpout, "%4ld\n", isave[4]);

 END:
  if (fpout != stdout) fclose(fpout);
  if (rsave) NAG_FREE(rsave);
  if (u) NAG_FREE(u);
  if (uout) NAG_FREE(uout);
  if (x) NAG_FREE(x);
  if (isave) NAG_FREE(isave);

  return exit_status;
}

static int NAG_CALL uinit(double *u, double *x, Integer npde, Integer npts,
                          double alpha)
{
  /* PDE initial conditon */

  Integer i;

  for (i = 1; i <= npts; ++i)
    {
      U(1, i) = alpha*2.0*x[i-1];
      U(2, i) = 1.0;
    }

  return 0;
}


static void NAG_CALL pdedef(Integer npde, double t, double x, const double u[],
                            const double ux[], double p[], double q[],
                            double r[], Integer *ires, Nag_Comm *comm)
{
  /* PDE coefficients */

  double *alpha = (double *) comm->p;

  q[0] = *alpha*4.0*(u[1]+x*ux[1]);
  q[1] = 0.0;
  r[0] = x*ux[0];
  r[1] = ux[1] - u[0] * u[1];
  P(1, 1) = 0.0;
  P(1, 2) = 0.0;
  P(2, 1) = 0.0;
  P(2, 2) = 1.0-x*x;
  return;
}

static void NAG_CALL bndary(Integer npde, double t, const double u[],
                            const double ux[], Integer ibnd, double beta[],
                            double gamma[], Integer *ires, Nag_Comm *comm)
{
  /* Boundary conditions */

  if (ibnd == 0)
    {
      beta[0] = 0.0;
      beta[1] = 1.0;
      gamma[0] = u[0];
      gamma[1] = -u[0]*u[1];
    }
  else
    {
      beta[0] = 1.0;
      beta[1] = 0.0;
      gamma[0] = -u[0];
      gamma[1] = u[1];
    }
  return;
}