/*@@
   @file      IndexArrays.c
   @date      Mon Jun  3 13:15:30 2002
   @author    Ian Hawke
   @desc 
   Routines for dealing with the index arrays in 
   @seefile ExternalVariables.h
   @enddesc 
   @version   $Header$
 @@*/

#include "cctk.h"
#include "cctk_Arguments.h"
#include "cctk_Parameters.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "ExternalVariables.h"

static const char *rcsid = "$Header$";

CCTK_FILEVERSION(CactusBase_MoL_IndexArrays_c);

/********************************************************************
 *********************     Local Data Types   ***********************
 ********************************************************************/

/********************************************************************
 ********************* Local Routine Prototypes *********************
 ********************************************************************/

/********************************************************************
 ***************** Scheduled Routine Prototypes *********************
 ********************************************************************/

void MoL_SetupIndexArrays(CCTK_ARGUMENTS);

void MoL_FreeIndexArrays(CCTK_ARGUMENTS);

/********************************************************************
 ********************* Other Routine Prototypes *********************
 ********************************************************************/

/********************************************************************
 *********************     Local Data   *****************************
 ********************************************************************/

/********************************************************************
 *********************     External Routines   **********************
 ********************************************************************/

 /*@@
   @routine    MoL_SetupIndexArrays
   @date       Mon Jun  3 13:24:05 2002
   @author     Ian Hawke
   @desc 
   Allocates sufficient space for the index arrays.
   These arrays are defined in the external file
   @seefile ExternalVariables.h
   @enddesc 
   @calls     
   @calledby   
   @history 
 
   @endhistory 

@@*/

void MoL_SetupIndexArrays(CCTK_ARGUMENTS) 
{

  DECLARE_CCTK_ARGUMENTS;
  DECLARE_CCTK_PARAMETERS;

  char *infoline;

  /* Initialize the time variables */

  *Original_Time = cctkGH->cctk_time;
  *Original_Delta_Time = cctkGH->cctk_delta_time;

  /* 
     We only want to set up the index arrays once.
     With mesh refinement this routine could be scheduled
     multiple times, leading to multiple copies of the
     index arrays used at different times!!!
  */

  if (EvolvedVariableIndex)
  {
    return;
  }


  if (MoL_Num_Evolved_Vars)
  {
    EvolvedVariableIndex = (CCTK_INT *)malloc(MoL_Num_Evolved_Vars * 
					      sizeof(CCTK_INT));
    if (!EvolvedVariableIndex)
      {
	CCTK_WARN(0,"Failed to allocate the evolved variable index array");
      }

    RHSVariableIndex = (CCTK_INT *)malloc(MoL_Num_Evolved_Vars * 
					  sizeof(CCTK_INT));
    if (!RHSVariableIndex)
      {
	CCTK_WARN(0,"Failed to allocate the RHS variable index array");
      }
  }

  if (MoL_Num_Constrained_Vars)
  {
    ConstrainedVariableIndex = (CCTK_INT *)malloc(MoL_Num_Constrained_Vars * 
						  sizeof(CCTK_INT));
    if (!ConstrainedVariableIndex)
      {
	CCTK_WARN(0,"Failed to allocate the constrained variable index array");
      }
  }

  if (MoL_Num_SaveAndRestore_Vars)
  {
    SandRVariableIndex = (CCTK_INT *)malloc(MoL_Num_SaveAndRestore_Vars * 
					    sizeof(CCTK_INT));
    if (!SandRVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the save and restore "
		"variable index array");
    }
  }

  if (EvolvedComplexVariableIndex)
  {
    return;
  }

  if (MoL_Num_ComplexEvolved_Vars)
  {
    EvolvedComplexVariableIndex = (CCTK_INT *)malloc(MoL_Num_ComplexEvolved_Vars * 
						     sizeof(CCTK_INT));
    if (!EvolvedComplexVariableIndex)
      {
	CCTK_WARN(0,"Failed to allocate the evolved complex variable index array");
      }
    
    RHSComplexVariableIndex = (CCTK_INT *)malloc(MoL_Num_ComplexEvolved_Vars * 
						 sizeof(CCTK_INT));
    if (!RHSComplexVariableIndex)
    {
	CCTK_WARN(0,"Failed to allocate the RHS complex variable index array");
    }
  }

  if (MoL_Num_ComplexConstrained_Vars)
  {
    ConstrainedComplexVariableIndex = (CCTK_INT *)malloc(MoL_Num_ComplexConstrained_Vars * 
							 sizeof(CCTK_INT));
    if (!ConstrainedComplexVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the constrained complex "
		"variable index array");
    }
  }

  if (MoL_Num_ComplexSaveAndRestore_Vars)
  {
    SandRComplexVariableIndex = (CCTK_INT *)malloc(MoL_Num_ComplexSaveAndRestore_Vars * 
						   sizeof(CCTK_INT));
    if (!SandRComplexVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the save and restore complex "
		"variable index array");
    }
  }  

  if (EvolvedArrayVariableIndex)
  {
    return;
  }

  if (MoL_Num_ArrayEvolved_Vars)
  {
    EvolvedArrayVariableIndex = (CCTK_INT *)malloc(MoL_Num_ArrayEvolved_Vars * 
						   sizeof(CCTK_INT));
    if (!EvolvedArrayVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the evolved array variable index array");
    }
  
    RHSArrayVariableIndex = (CCTK_INT *)malloc(MoL_Num_ArrayEvolved_Vars * 
					       sizeof(CCTK_INT));
    if (!RHSArrayVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the RHS array variable index array");
    }
  }

  if (MoL_Num_ArrayConstrained_Vars)
  {
    ConstrainedArrayVariableIndex = (CCTK_INT *)malloc(MoL_Num_ArrayConstrained_Vars * 
						       sizeof(CCTK_INT));
    if (!ConstrainedArrayVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the constrained array "
		"variable index array");
    }
  }

  if (MoL_Num_ArraySaveAndRestore_Vars)
  {
    SandRArrayVariableIndex = (CCTK_INT *)malloc(MoL_Num_ArraySaveAndRestore_Vars * 
						 sizeof(CCTK_INT));
    if (!SandRArrayVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the save and restore "
		"array variable index array");
    }
  }

  if (EvolvedComplexArrayVariableIndex)
  {
    return;
  }

  if (MoL_Num_ComplexArrayEvolved_Vars)
  {
    EvolvedComplexArrayVariableIndex = (CCTK_INT *)malloc(MoL_Num_ComplexArrayEvolved_Vars * 
							  sizeof(CCTK_INT));
    if (!EvolvedComplexArrayVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the evolved complex "
		"array variable index array");
    }
    
    RHSComplexArrayVariableIndex = (CCTK_INT *)malloc(MoL_Num_ComplexArrayEvolved_Vars * 
						      sizeof(CCTK_INT));
    if (!RHSComplexArrayVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the RHS complex array "
		"variable index array");
    }
  }

  if (MoL_Num_ComplexArrayConstrained_Vars)
  {
    ConstrainedComplexArrayVariableIndex = (CCTK_INT *)malloc(MoL_Num_ComplexArrayConstrained_Vars * 
							      sizeof(CCTK_INT));
    if (!ConstrainedComplexArrayVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the constrained complex "
		"array variable index array");
    }
  }

  if (MoL_Num_ComplexArraySaveAndRestore_Vars)
  {
    SandRComplexArrayVariableIndex = (CCTK_INT *)malloc(MoL_Num_ComplexArraySaveAndRestore_Vars * 
							sizeof(CCTK_INT));
    if (!SandRComplexArrayVariableIndex)
    {
      CCTK_WARN(0,"Failed to allocate the save and restore "
		"complex array variable index array");
    }
  }

  infoline = (char *)malloc((strlen(Generic_Method_Descriptor)+100)*
                            sizeof(char));
  if (!infoline) 
  {
    CCTK_WARN(0, "Failed to malloc 100 characters!");
  }
  if (CCTK_EQUALS(ODE_Method,"Generic")) 
  {
    if (CCTK_EQUALS(Generic_Type,"ICN"))
    {
      sprintf(infoline,"Generic Iterative Crank Nicholson with %i iterations", 
              MoL_Intermediate_Steps);
    }
    else if (CCTK_EQUALS(Generic_Type,"RK"))
    {
      sprintf(infoline, "Generic Runge-Kutta %i",MoL_Intermediate_Steps);
    }
    else if (CCTK_EQUALS(Generic_Type,"Table"))
    {
      sprintf(infoline, "Generic method, options:\n %s\n",
              Generic_Method_Descriptor);
    }
    else if (CCTK_EQUALS(Generic_Type,"Classic RK3")) 
    {
      sprintf(infoline, "Classic Runge-Kutta 3");
    }
    else
    {
      CCTK_WARN(0, "Generic_Type not recognized!");
    }
  }
  else if (CCTK_EQUALS(ODE_Method,"RK2")) 
  {
    sprintf(infoline, "Runge-Kutta 2");
  }
  else if (CCTK_EQUALS(ODE_Method,"RK3")) 
  {
    sprintf(infoline, "Runge-Kutta 3");
  }
  else if (CCTK_EQUALS(ODE_Method,"RK4")) 
  {
    sprintf(infoline, "Runge-Kutta 4");
  }
  else if (CCTK_EQUALS(ODE_Method,"RK45")) 
  {
    sprintf(infoline, "Runge-Kutta 45 (Fehlberg)");
  }
  else if (CCTK_EQUALS(ODE_Method,"RK45CK")) 
  {
    sprintf(infoline, "Runge-Kutta 45 (Cash-Karp)");
  }
  else if (CCTK_EQUALS(ODE_Method,"RK65")) 
  {
    sprintf(infoline, "Runge-Kutta 65");
  }
  else if (CCTK_EQUALS(ODE_Method,"RK87")) 
  {
    sprintf(infoline, "Runge-Kutta 87");
  }
  else if (CCTK_EQUALS(ODE_Method,"ICN"))
  {
    sprintf(infoline, "Iterative Crank Nicholson with %i iterations", 
            MoL_Intermediate_Steps);
  }
  else if (CCTK_EQUALS(ODE_Method,"ICN-avg"))
  {
    sprintf(infoline,
            "Averaging iterative Crank Nicholson with %i iterations", 
            MoL_Intermediate_Steps);
  }
  else 
  {
    CCTK_WARN(0, "ODE_Method not recognized!");
  }
  
  CCTK_VInfo(CCTK_THORNSTRING, "Using %s as the time integrator.", infoline);
  
  free(infoline);
  infoline = NULL;

  return;

}

 /*@@
   @routine    MoL_FreeIndexArrays
   @date       Mon Jun  3 13:26:15 2002
   @author     Ian Hawke
   @desc 
   Frees the external index arrays. 
   These arrays are defined in the external file
   @seefile ExternalVariables.h
   @enddesc 
   @calls     
   @calledby   
   @history 
 
   @endhistory 

@@*/

void MoL_FreeIndexArrays(CCTK_ARGUMENTS)
{
  
  if (EvolvedVariableIndex)
  {
    free(EvolvedVariableIndex);
    EvolvedVariableIndex = NULL;
  }

  if (RHSVariableIndex)
  {
    free(RHSVariableIndex);  
    RHSVariableIndex = NULL;
  }

  if (ConstrainedVariableIndex)
  {
    free(ConstrainedVariableIndex);
    ConstrainedVariableIndex = NULL;
  }

  if (SandRVariableIndex)
  {
    free(SandRVariableIndex);
    SandRVariableIndex = NULL;
  }
  
  if (EvolvedComplexVariableIndex)
  {
    free(EvolvedComplexVariableIndex);
    EvolvedComplexVariableIndex = NULL;
  }

  if (RHSComplexVariableIndex)
  {
    free(RHSComplexVariableIndex);  
    RHSComplexVariableIndex = NULL;
  }

  if (ConstrainedComplexVariableIndex)
  {
    free(ConstrainedComplexVariableIndex);
    ConstrainedComplexVariableIndex = NULL;
  }

  if (SandRComplexVariableIndex)
  {
    free(SandRComplexVariableIndex);
    SandRComplexVariableIndex = NULL;
  }
  
  if (EvolvedArrayVariableIndex)
  {
    free(EvolvedArrayVariableIndex);
    EvolvedArrayVariableIndex = NULL;
  }

  if (RHSArrayVariableIndex)
  {
    free(RHSArrayVariableIndex);  
    RHSArrayVariableIndex = NULL;
  }

  if (ConstrainedArrayVariableIndex)
  {
    free(ConstrainedArrayVariableIndex);
    ConstrainedArrayVariableIndex = NULL;
  }

  if (SandRArrayVariableIndex)
  {
    free(SandRArrayVariableIndex);
    SandRArrayVariableIndex = NULL;
  }
  
  if (EvolvedComplexArrayVariableIndex)
  {
    free(EvolvedComplexArrayVariableIndex);
    EvolvedComplexArrayVariableIndex = NULL;
  }

  if (RHSComplexArrayVariableIndex)
  {
    free(RHSComplexArrayVariableIndex);  
    RHSComplexArrayVariableIndex = NULL;
  }

  if (ConstrainedComplexArrayVariableIndex)
  {
    free(ConstrainedComplexArrayVariableIndex);
    ConstrainedComplexArrayVariableIndex = NULL;
  }

  if (SandRComplexArrayVariableIndex)
  {
    free(SandRComplexArrayVariableIndex);
    SandRComplexArrayVariableIndex = NULL;
  }

  if (ArrayScratchSizes)
  {
    free(ArrayScratchSizes);
    ArrayScratchSizes = NULL;
  }
  
  if (ArrayScratchSpace)
  {
    free(ArrayScratchSpace);
    ArrayScratchSpace = NULL;
  }

  return;
  
}

/********************************************************************
 *********************     Local Routines   *************************
 ********************************************************************/