/*@@
   @file      FillcGH.C
   @date      Tue Apr 20 14:24:34 1999
   @author    Tom Goodale
   @desc 
   Routines to fill a cGH structure
   @enddesc 
 @@*/

#include <math.h>
#include "cctk.h"
#include "cctk_Flesh.h"
#include "cctk_Groups.h"
#include "GrACEDefs.h"
#include "GrACE_extension.h"


static char *rcsid = "$Header: /mnt/data2/cvs2svn/cvs-repositories/projects/CactusGrACE/GrACE/src/FillcGH.C,v 1.8 1999-10-12 12:45:30 goodale Exp $";

void grace_FillScalar(cGH* cgh, const int groupid);
void grace_FillGF(cGH* cgh,
		  const int t,
		  const int idt,
		  const int l,
		  const int c,
		  const int ident,
		  const int groupid);

 /*@@
   @routine    grace_FillcGH
   @date       Tue Apr 20 17:04:34 1999
   @author     Tom Goodale
   @desc 
   
   @enddesc 
   @calls     
   @calledby   
   @history 
 
   @endhistory 

@@*/
void grace_FillcGH(cGH* cgh,
		  const int iteration,
		  const int l,
		  const int c,
		  const int ident)
{
  GrACEGH* ggh = (GrACEGH*) cgh->extensions[GrACE_GHExtension];
  GridHierarchy& GH = *ggh->theGH;
  
  INTEGER t = CurrentTime(GH,l,DAGH_Main);
  INTEGER idt = TimeStep(GH,l,DAGH_Main);

  GridFunction(3)<DOUBLE> &tempGF = *((GridFunction(3)<DOUBLE> *)ggh->tempGF);

  cgh->cctk_dim = GH.rank;
  cgh->cctk_iteration = iteration;

  for (int r=0; r<GH.rank; r++) 
  {
    /* FIXME: Next line probably wrong, multidimensional levfac, Gab */
    cgh->cctk_levfac[r] = pow(GH.refinefactor(), l);
    cgh->cctk_gsh[r] = tempGF(t,0,0,ident).extents(r);
    cgh->cctk_lsh[r] = tempGF(t,l,c,ident).extents(r);
    cgh->cctk_lbnd[r] = tempGF(t,l,c,ident).lower(r);
    cgh->cctk_ubnd[r] = tempGF(t,l,c,ident).upper(r);
    cgh->cctk_bbox[2*r] = tempGF.boundary_flag(t,l,c,2*r);
    cgh->cctk_bbox[2*r+1] = tempGF.boundary_flag(t,l,c,2*r+1);
  }

  for(int group = 0; group < CCTK_NumGroups(); group++) 
  {
    switch(ggh->theGFS[group]->gtype)
    {
      case GROUP_SCALAR : grace_FillScalar(cgh, group); break;
      case GROUP_GF :
	grace_FillGF(cgh, t,idt, l, c, ident, group);
	  break;
	default :
	  fprintf(stderr, "Unknown group type in %s at %d\n", __FILE__, __LINE__);
	  exit(99);
    }
  }

  

}


 /*@@
   @file      FillcGH.C
   @date      Tue Apr 20 17:35:49 1999
   @author    Manish Parashar & Tom Goodale
   @desc 
   Fills the data for a scalar group into the cGH
   @enddesc 
 @@*/
void grace_FillScalar(cGH* cgh, const int groupid)
{
  GrACEGH* ggh = (GrACEGH*) cgh->extensions[GrACE_GHExtension];
  GridHierarchy& GH = *ggh->theGH;
  const int dim = GH.rank;

  GrACEGFGrp* gfgrp = ggh->theGFS[groupid];
  List<GrACEScalarVoid*>& scalarlist = gfgrp->scalarlist;
  
  GrACEScalarVoid** gsvs = 0;
  int ngsvs = 0;
  scalarlist.array(gsvs,ngsvs);

  for (int id=0; id<ngsvs; id++) {
    int gsid = gfgrp->startgfid +id;
    int vtype = gfgrp->vtype;
    //    const int tidx = gsvs[id]->dagh_timeindex(t,l,ident);
      
    GrACEScalar<char>* gschar;
    GrACEScalar<INTEGER>* gsint;
    GrACEScalar<DOUBLE>* gsdbl;
    
    switch(vtype) {
    case CCTK_VARIABLE_CHAR    : 
      gschar = (GrACEScalar<char>*) gsvs[id];
      cgh->data[gsid][0] = (*gschar).data();
      break;
    case CCTK_VARIABLE_INT : 
      gsint = (GrACEScalar<INTEGER>*) gsvs[id];
      cgh->data[gsid][0] = (*gsint).data();
      break;
    case CCTK_VARIABLE_REAL    : 
      gsdbl = (GrACEScalar<DOUBLE>*) gsvs[id];
      cgh->data[gsid][0] = (*gsdbl).data();
      break;
    case CCTK_VARIABLE_COMPLEX : 
      cerr << "Not defined in GrACE !" << endl << flush;
      assert(0);
      break;
    default : 
      fprintf(stderr,"Unknown variable type in\n");
      break;
    }
  } 
}

 /*@@
   @routine    grace_FillGF
   @date       Tue Apr 20 17:36:46 1999
   @author     Tom Goodale
   @desc 
   Fills the data for a GF group into a cGH.
   @enddesc 
   @calls     
   @calledby   
   @history 
 
   @endhistory 

@@*/
void grace_FillGF(cGH* cgh,
		  const int t,
		  const int idt,
		  const int l,
		  const int c,
		  const int ident,
		  const int groupid)
{
  GrACEGH* ggh = (GrACEGH*) cgh->extensions[GrACE_GHExtension];
  GridHierarchy& GH = *ggh->theGH;
  const int dim = GH.rank;

  GrACEGFGrp* gfgrp = ggh->theGFS[groupid];
  List<GridFunctionVoid*>& gflist = gfgrp->gflist;

  GridFunctionVoid** gfvs = 0;
  int ngfvs = 0;
  gflist.array(gfvs,ngfvs);
  int done_bounds = 0;

  int vtype = gfgrp->vtype;

  for (int id=0; id<ngfvs; id++) 
  {
    int gfid = gfgrp->startgfid + id;
    int tidx;
    
    if (dim == 3) {
      GridFunction(3)<char>* gf3char;
      GridFunction(3)<INTEGER>* gf3int;
      GridFunction(3)<DOUBLE>* gf3dbl;

      switch(vtype) {
      case CCTK_VARIABLE_CHAR    : 
	gf3char = (GridFunction(3)<char>*) gfvs[id];
	tidx = gf3char->dagh_timeindex(t,l,ident);
	cgh->data[gfid][tidx] = (*gf3char)(t,l,c,ident).data();
	break;
      case CCTK_VARIABLE_INT : 
	gf3int = (GridFunction(3)<INTEGER>*) gfvs[id];
	tidx = gf3int->dagh_timeindex(t,l,ident);
	cgh->data[gfid][tidx] = (*gf3int)(t,l,c,ident).data();
	break;
      case CCTK_VARIABLE_REAL    : 
	gf3dbl = (GridFunction(3)<DOUBLE>*) gfvs[id];
	tidx = gf3dbl->dagh_timeindex(t,l,ident);
	cgh->data[gfid][0] = (*gf3dbl)(t,l,c,ident).data();
	break;
      case CCTK_VARIABLE_COMPLEX : 
	cerr << "Not defined in GrACE !" << endl << flush;
	assert(0);
	break;
      default : 
	fprintf(stderr,"Unknown variable type in\n");
	break;
      }
    }
    if (dim == 2) {
      GridFunction(2)<char>* gf2char;
      GridFunction(2)<INTEGER>* gf2int;
      GridFunction(2)<DOUBLE>* gf2dbl;

      switch(vtype) {
      case CCTK_VARIABLE_CHAR    : 
	gf2char = (GridFunction(2)<char>*) gfvs[id];
	tidx = gf2char->dagh_timeindex(t,l,ident);
	cgh->data[gfid][tidx] = (*gf2char)(t,l,c,ident).data();
	break;
      case CCTK_VARIABLE_INT : 
	gf2int = (GridFunction(2)<INTEGER>*) gfvs[id];
	tidx = gf2int->dagh_timeindex(t,l,ident);
	cgh->data[gfid][tidx] = (*gf2int)(t,l,c,ident).data();
	break;
      case CCTK_VARIABLE_REAL    : 
	gf2dbl = (GridFunction(2)<DOUBLE>*) gfvs[id];
	tidx = gf2dbl->dagh_timeindex(t,l,ident);
	cgh->data[gfid][tidx] = (*gf2dbl)(t,l,c,ident).data();
	break;
      case CCTK_VARIABLE_COMPLEX : 
	cerr << "Not defined in GrACE !" << endl << flush;
	assert(0);
	break;
      default : 
	fprintf(stderr,"Unknown variable type\n");
	break;
      }
    }
    if (dim == 1) {
      GridFunction(1)<char>* gf1char;
      GridFunction(1)<INTEGER>* gf1int;
      GridFunction(1)<DOUBLE>* gf1dbl;

      switch(vtype) {
      case CCTK_VARIABLE_CHAR    : 
	gf1char = (GridFunction(1)<char>*) gfvs[id];
	tidx = gf1char->dagh_timeindex(t,l,ident);
	cgh->data[gfid][tidx] = (*gf1char)(t,l,c,ident).data();
	break;
      case CCTK_VARIABLE_INT : 
	gf1int = (GridFunction(1)<INTEGER>*) gfvs[id];
	tidx = gf1int->dagh_timeindex(t,l,ident);
	cgh->data[gfid][tidx] = (*gf1int)(t,l,c,ident).data();
	break;
      case CCTK_VARIABLE_REAL    : 
	gf1dbl = (GridFunction(1)<DOUBLE>*) gfvs[id];
	tidx = gf1dbl->dagh_timeindex(t,l,ident);
	cgh->data[gfid][tidx] = (*gf1dbl)(t,l,c,ident).data();
	break;
      case CCTK_VARIABLE_COMPLEX : 
	cerr << "Not defined in GrACE !" << endl << flush;
	assert(0);
	break;
      default : 
	fprintf(stderr,"Unknown variable type\n");
	break;
      }
    }
  }
}