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

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

static void pdedef(Integer, double, double, const double[], const double[], 
                   double[], double[], double[], Integer *, 
                   Nag_Comm *);

static void bndary(Integer, double, const double[], const double[], Integer, 
                   double[], double[], Integer *, Nag_Comm *);

static int uinit(double *, double *, Integer, Integer, double);
 
  
# 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(void)
{
  const Integer npts=20, npde=2, neqn=npts*npde, intpts=6, 
    itype=1, nwk=(10+6*npde)*neqn, lisave=neqn+24, 
    lrsave=nwk+(21+3*npde)*npde+7*npts+54;
  Integer exit_status, 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;

  /* 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)) )
    {
      Vprintf("Allocation failure\n");
      exit_status = 1;
      goto END;
    }
    
  INIT_FAIL(fail);
  exit_status = 0;

  Vprintf("d03pcc Example Program Results\n\n");
  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;
    
  Vprintf("Accuracy requirement  = %12.5f\n", acc);
  Vprintf("Parameter alpha =       %12.3f\n\n",alpha);
  Vprintf("   t  /  x  ");

  for (i = 0; i < 6; ++i) {
    Vprintf("%8.4f", xout[i]);
    Vprintf((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 */

    d03pcc(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)
      {
        Vprintf("Error from d03pcc.\n%s\n", fail.message);
        exit_status = 1;
        goto END;
      }

    /* Interpolate at required spatial points */

    d03pzc(npde, m, u, npts, x, xout, intpts, 1, uout, &fail);

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

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

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

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

  /* Print integration statistics */

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

 END:
  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 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 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 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;
}