/*@@
   @file      SetupGroup.c
   @date      Mon Feb  8 19:31:45 1999
   @author    Tom Goodale
   @desc 
   Subroutines for setting up a group on a pGH.
   @enddesc 
   @version $Header$
 @@*/

#include <stdio.h>
#include <stdlib.h>

#include "cctk.h"
#include "pugh.h"

static char *rcisd = "$Header$";

pGExtras *pugh_SetupPGExtras(int dim, 
			     int *perme,
			     int stagger,
			     int *sh,
			     int *nghosts,
			     int total_procs,
			     int *nprocs,
			     int this_proc);

pConnectivity *pugh_SetupConnectivity(int dim, 
				      int total_procs, 
				      int *nprocs,
				      int *perme);

/*pGF *SetupPGF(pGH          *GH, 
	      const char   *name, 
	      int           dim, 
	      int           varsize, 
	      int           vtype, 
	      int           staggercode);
*/
pGA *SetupPGA
  (
   void          *parent,
   pGExtras      *extras,
   pConnectivity *connectivity,
   const char    *name,
   int            id,
   int            varsize, 
   int            vtype, 
   int            stagger
  );      

  
 /*@@
   @routine    pugh_SetupScalarGroup
   @date       Wed Feb 17 04:45:49 1999
   @author     Tom Goodale
   @desc 
   Set up a group of scalar variables on a pGH.
   @enddesc 
   @calls     
   @calledby   
   @history 
 
   @endhistory 

@@*/

int pugh_SetupScalarGroup
  (
   pGH *newGH, 
   int vtype, 
   int n_variables, 
   int n_timelevels
  )
{
  int retval=PUGH_SUCCESS;
  int variable;
  int var_size = CCTK_VarTypeSize(vtype);
  int level;
  void ***temp;

  temp = (void ***)realloc
    (newGH->variables, (newGH->nvariables+n_variables)*sizeof(void **));

  if(temp)
  {
    newGH->variables = temp;

    for(variable = 0; variable < n_variables; variable++)
    {
      newGH->variables[newGH->nvariables] = 
        (void **)malloc(n_timelevels*sizeof(void *));

      if(newGH->variables[newGH->nvariables])
      {
        for(level = 0; level < n_timelevels; level++)
        {
          newGH->variables[newGH->nvariables][level] = (void *)malloc(var_size);
        }
        newGH->nvariables++;
      }
      else
      {
        CCTK_WARN(1,"Memory error in SetupScalarGroup");
        retval = PUGH_ERRORMEMORY;
        break;
      }
    }
  }
  else
  {
    CCTK_WARN(1,"Memory error in SetupScalarGroup");
    retval = PUGH_ERRORMEMORY;
  }

  return retval;
}


 /*@@
   @routine    pugh_SetupArrayGroup
   @date       January 19 2000
   @author     Gabrielle Allen
   @desc 
   Set up a group of array variables on a pGH.
   @enddesc 
   @calls     
   @calledby   
   @history 
 
   @endhistory 

@@*/

int pugh_SetupArrayGroup
  (
   pGH *newGH, 
   int *nsize, 
   int *ghostsize,
   int vtype, 
   int dim, 
   int n_variables, 
   int staggercode, 
   int n_timelevels
  )
{

  int           i;
  int           variable;
  int           var_size = CCTK_VarTypeSize(vtype);
  int           retval = PUGH_SUCCESS;
  int           level;
  void       ***temp;
  pConnectivity *connectivity;
  pGExtras      *extras;

  int *perme;
  int *nprocs;

  /* Arrays can't (yet) have periodicity */
  perme = (int *) malloc(dim*sizeof(int));
  if (perme)
  {
    for (i=0;i<dim;i++)
    {
      perme[i]=0;
    }
  }
  else
  {
    CCTK_WARN(0,"Memory error in PUGH");
  }

  /* Arrays can't (yet) have manual set up */
  nprocs = (int *) malloc(dim*sizeof(int));
  if (nprocs)
  {
    for (i=0;i<dim;i++)
    {
      nprocs[i]=0;
    }
  }
  else
  {
    CCTK_WARN(0,"Memory error in PUGH");
  }


  connectivity = pugh_SetupConnectivity(dim,newGH->nprocs,nprocs,perme);

  extras = pugh_SetupPGExtras(dim, 
                              perme,
                              staggercode,
                              nsize,
                              ghostsize,
                              newGH->nprocs,
                              connectivity->nprocs,
                              newGH->myproc);

  free(nprocs);
  free(perme);

  temp = (void ***)realloc
    (newGH->variables,(newGH->nvariables+n_variables)*sizeof(void **));

  if(temp)
  {
    newGH->variables = temp;

    for(variable = 0; variable < n_variables; variable++)
    {
      newGH->variables[newGH->nvariables] = 
        (void **)malloc(n_timelevels*sizeof(void *));

      if(newGH->variables[newGH->nvariables])
      {
        for(level = 0; level < n_timelevels; level++)
        {
          newGH->variables[newGH->nvariables][level] = 
	    SetupPGA(newGH,
		     extras,
		     connectivity,
		     CCTK_VarName(newGH->nvariables), 
		     newGH->nvariables,
		     var_size,
		     vtype,
		     staggercode);
        }
        newGH->nvariables++;
      }
      else
      {
        CCTK_WARN(1,"Memory error in SetupArrayGroup");
        retval = PUGH_ERRORMEMORY;
        break;
      }
    }
  }
  else
  {
    CCTK_WARN(1,"Memory error in SetupArrayGroup");
    retval = PUGH_ERRORMEMORY;
  }
  
  return retval;
}


 /*@@
   @routine    pugh_SetupGFGroup
   @date       Wed Feb 17 04:45:49 1999
   @author     Tom Goodale
   @desc 
   Set up a group of GF variables on a pGH.
   @enddesc 
   @calls     
   @calledby   
   @history 
 
   @endhistory 

@@*/
int pugh_SetupGFGroup(pGH *newGH, 
                      int vtype, 
                      int dim, 
                      int n_variables,
                      int staggercode,
                      int n_timelevels)
{

  int variable;
  int var_size=CCTK_VarTypeSize(vtype);
  int retval=PUGH_SUCCESS;
  int level;
  void ***temp;

  temp = (void ***)realloc(newGH->variables, 
                           (newGH->nvariables+n_variables)*sizeof(void **));

  if(temp)
  {
    newGH->variables = temp;

    for(variable = 0; variable < n_variables; variable++)
    {
      newGH->variables[newGH->nvariables] = 
        (void **)malloc(n_timelevels*sizeof(void *));

      if(newGH->variables[newGH->nvariables])
      {
        for(level = 0; level < n_timelevels; level++)
        {
	    newGH->variables[newGH->nvariables][level] = 
	      SetupPGA(newGH,
		       newGH->GFExtras[dim-1],
		       newGH->Connectivity[dim-1],
		       CCTK_VarName(newGH->nvariables), 
		       newGH->nvariables,
		       var_size,
		       vtype,
		       staggercode);
        }
        newGH->nvariables++;
      }
      else
      {
        CCTK_WARN(1,"Memory error in SetupGFGroup");
        retval = PUGH_ERRORMEMORY;
        break;
      }
    }
  }
  else
  {
    CCTK_WARN(1,"Memory error in SetupGFGroup");
    retval = PUGH_ERRORMEMORY;
  }

  return retval;

}


 /*@@
   @routine    pugh_SetupGroup
   @date       Mon Feb  8 19:37:55 1999
   @author     Tom Goodale
   @desc 
   Sets up a group on a pGH
   @enddesc 
   @calls     
   @calledby   
   @history 
 
   @endhistory 

@@*/

int PUGH_SetupGroup
  (
   pGH *newGH, 
   int *nsize, 
   int *nghostsize,
   int  gtype, 
   int  vtype, 
   int  dim, 
   int  n_variables, 
   int  staggercode, 
   int  n_timelevels
  )
{

  int returncode=PUGH_SUCCESS;

  switch(gtype)
  {
    case CCTK_SCALAR : 
      returncode = pugh_SetupScalarGroup(newGH, 
                                         vtype, 
                                         n_variables,
                                         n_timelevels); 
      break;
    case CCTK_ARRAY  :
      returncode = pugh_SetupArrayGroup(newGH, 
                                        nsize,
                                        nghostsize,
                                        vtype,
                                        dim,
                                        n_variables,
                                        staggercode,
                                        n_timelevels); 
      break;
    case CCTK_GF     : 
      returncode = pugh_SetupGFGroup(newGH, 
                                     vtype,
                                     dim,
                                     n_variables,
                                     staggercode,
                                     n_timelevels); 
      break;
    default : 
      CCTK_WARN(0, "Unknown group type in pugh_SetupGroup");
      returncode = PUGH_ERROR;
  }

  return returncode;

}