Add support for evolving complex GFs and (real and complex) GAs.

Only works with ICN or RK2 for now - in fact this commit may break the generic RK methods temporarily.

Note the documentation isn't quite right - there's no longer a seperate function for each different type...


git-svn-id: http://svn.cactuscode.org/arrangements/CactusNumerical/MoL/trunk@12 578cdeb0-5ea1-4b81-8215-5a3b8777ee0b

1 files changed, 205 insertions, 6 deletions

diff --git a/src/InitialCopy.c b/src/InitialCopy.c
index 0a6a54b..9004f37 100644
--- a/src/InitialCopy.c
+++ b/src/InitialCopy.c
@@ -11,6 +11,8 @@
    @version   $Header$
  @@*/
 
+#include <string.h>
+
 #include "cctk.h"
 #include "cctk_Arguments.h"
 #include "cctk_Parameters.h"
@@ -54,10 +56,14 @@ void MoL_InitialCopy(CCTK_ARGUMENTS)
 
   DECLARE_CCTK_ARGUMENTS
   DECLARE_CCTK_PARAMETERS
+  
+  cGroupDynamicData arraydata;
+  CCTK_INT groupindex, ierr;
+  CCTK_INT arraytotalsize, arraydim;
 
   CCTK_INT var;
-  CCTK_INT index;
-  CCTK_INT i,j,k;
+/*    CCTK_INT index; */
+/*    CCTK_INT i,j,k; */
   CCTK_INT totalsize;
 
   CCTK_REAL *CurrentVar;
@@ -65,6 +71,10 @@ void MoL_InitialCopy(CCTK_ARGUMENTS)
   CCTK_REAL *ScratchVar;
   CCTK_INT StorageOn;
 
+  CCTK_COMPLEX *CurrentComplexVar;
+  CCTK_COMPLEX *PreviousComplexVar;
+  CCTK_COMPLEX *ScratchComplexVar;
+
   totalsize = cctk_lsh[0]*cctk_lsh[1]*cctk_lsh[2];
 
   for (var = 0; var < MoLNumEvolvedVariables; var++)
@@ -100,6 +110,77 @@ void MoL_InitialCopy(CCTK_ARGUMENTS)
     }
 
   }
+    
+  for (var = 0; var < MoLNumEvolvedArrayVariables; var++)
+  {
+    PreviousVar = (CCTK_REAL*)CCTK_VarDataPtrI(cctkGH, 1,
+                                               EvolvedArrayVariableIndex[var]);
+    CurrentVar = (CCTK_REAL*)CCTK_VarDataPtrI(cctkGH, 0,
+                                              EvolvedArrayVariableIndex[var]);
+    
+    groupindex = CCTK_GroupIndexFromVarI(EvolvedArrayVariableIndex[var]);
+    ierr = CCTK_GroupDynamicData(cctkGH, groupindex,
+                                 &arraydata);
+    if (ierr)
+    {
+      CCTK_VWarn(0, __LINE__, __FILE__, "MoL", 
+                 "The driver does not return group information for group '%s'.", 
+                 CCTK_GroupName(groupindex));
+    }
+    arraytotalsize = 1;
+    for (arraydim = 0; arraydim < arraydata.dim; arraydim++)
+    {
+      arraytotalsize *= arraydata.lsh[arraydim];
+    }
+
+    if (PreviousVar && CurrentVar)
+    {      
+      memcpy(CurrentVar, PreviousVar, arraytotalsize * sizeof(CCTK_REAL));
+    }
+    else
+    {
+      printf("The pointers are %p (prev) and %p (curr)\n.",
+             PreviousVar, CurrentVar);
+      CCTK_VWarn(0,__LINE__,__FILE__,"MoL","Null pointer for variable %s", 
+                 CCTK_VarName(EvolvedArrayVariableIndex[var]));
+    }
+
+  }
+
+
+  for (var = 0; var < MoLNumEvolvedComplexVariables; var++)
+  {
+    
+    StorageOn = CCTK_QueryGroupStorage(cctkGH,
+                                       CCTK_GroupNameFromVarI(EvolvedComplexVariableIndex[var]));
+    
+    if (StorageOn < 0)
+    {
+      CCTK_VWarn(1,__LINE__,__FILE__,"MoL","Warning for index %i", 
+                 EvolvedComplexVariableIndex[var]);
+      CCTK_WARN(0, "The index passed does not correspond to a GF.");
+    }
+    else if (StorageOn == 0) {
+      CCTK_VWarn(1,__LINE__,__FILE__,"MoL","Warning for GF %s", 
+                 CCTK_VarName(EvolvedComplexVariableIndex[var]));
+      CCTK_WARN(0, "The grid function does not have storage assigned.");
+    }
+    
+    PreviousComplexVar = (CCTK_COMPLEX*)CCTK_VarDataPtrI(cctkGH, 1, 
+                                               EvolvedComplexVariableIndex[var]);
+    CurrentComplexVar = (CCTK_COMPLEX*)CCTK_VarDataPtrI(cctkGH, 0, 
+                                              EvolvedComplexVariableIndex[var]);
+    if (PreviousComplexVar && CurrentComplexVar)
+    {      
+      memcpy(CurrentComplexVar, PreviousComplexVar, totalsize * sizeof(CCTK_COMPLEX));
+    }
+    else
+    {
+      CCTK_VWarn(0,__LINE__,__FILE__,"MoL","Null pointer for variable %s", 
+                 CCTK_VarName(EvolvedComplexVariableIndex[var]));
+    }
+
+  }
   
   /* 
      Now the Save and Restore variables. Shift the data in the 
@@ -145,7 +226,7 @@ void MoL_InitialCopy(CCTK_ARGUMENTS)
     else
     {
       CCTK_VWarn(0,__LINE__,__FILE__,"MoL","Null pointer for variable %s", 
-                 CCTK_VarName(SandRScratchSpace[var]));
+                 CCTK_VarName(SandRVariableIndex[var]));
     }
 #ifdef MOLDEBUG
     printf("Init2:Variable %s, current %g, previous %g, scratch %g\n",
@@ -154,6 +235,46 @@ void MoL_InitialCopy(CCTK_ARGUMENTS)
 #endif
   }
   
+
+  for (var = 0; var < MoLNumSandRComplexVariables; var++)
+  {
+
+    StorageOn = CCTK_QueryGroupStorage(cctkGH,
+                                       CCTK_GroupNameFromVarI(SandRComplexVariableIndex[var]));
+    
+    if (StorageOn < 0)
+    {
+      CCTK_VWarn(1,__LINE__,__FILE__,"MoL","Warning for index %i", 
+                 SandRComplexVariableIndex[var]);
+      CCTK_WARN(0, "The index passed does not correspond to a GF.");
+    }
+    else if (StorageOn == 0) {
+      CCTK_VWarn(1,__LINE__,__FILE__,"MoL","Warning for GF %s", 
+                 CCTK_VarName(SandRComplexVariableIndex[var]));
+      CCTK_WARN(0, "The grid function does not have storage assigned.");
+    }
+
+    PreviousComplexVar = (CCTK_COMPLEX*)CCTK_VarDataPtrI(cctkGH, 1, 
+                                               SandRComplexVariableIndex[var]);
+    CurrentComplexVar = (CCTK_COMPLEX*)CCTK_VarDataPtrI(cctkGH, 0, 
+                                              SandRComplexVariableIndex[var]);
+    ScratchComplexVar = &ComplexSandRScratchSpace[var*totalsize];
+#ifdef MOLDEBUG
+    printf("Pointers for the SandR vars are to %ld, %ld and %ld.\n",
+           PreviousComplexVar, CurrentComplexVar, ScratchComplexVar);
+#endif
+    if (PreviousComplexVar && CurrentComplexVar && ScratchComplexVar)
+    {      
+      memcpy(ScratchComplexVar, CurrentComplexVar, totalsize * sizeof(CCTK_COMPLEX));
+      memcpy(CurrentComplexVar, PreviousComplexVar, totalsize * sizeof(CCTK_COMPLEX));
+    }
+    else
+    {
+      CCTK_VWarn(0,__LINE__,__FILE__,"MoL","Null pointer for variable %s", 
+                 CCTK_VarName(SandRComplexVariableIndex[var]));
+    }
+  }
+  
   /*
     Now do the constrained variables.
   */
@@ -193,6 +314,42 @@ void MoL_InitialCopy(CCTK_ARGUMENTS)
     
   }
   
+
+  for (var = 0; var < MoLNumConstrainedComplexVariables; var++)
+  {
+
+    StorageOn = CCTK_QueryGroupStorage(cctkGH,
+                                       CCTK_GroupNameFromVarI(ConstrainedComplexVariableIndex[var]));
+    
+    if (StorageOn < 0)
+    {
+      CCTK_VWarn(1,__LINE__,__FILE__,"MoL","Warning for index %i", 
+                 ConstrainedComplexVariableIndex[var]);
+      CCTK_WARN(0, "The index passed does not correspond to a GF.");
+    }
+    else if (StorageOn == 0) {
+      CCTK_VWarn(1,__LINE__,__FILE__,"MoL","Warning for GF %s", 
+                 CCTK_VarName(ConstrainedComplexVariableIndex[var]));
+      CCTK_WARN(0, "The grid function does not have storage assigned.");
+    }
+
+    PreviousComplexVar = (CCTK_COMPLEX*)CCTK_VarDataPtrI(cctkGH, 1, 
+                                               ConstrainedComplexVariableIndex[var]);
+    CurrentComplexVar = (CCTK_COMPLEX*)CCTK_VarDataPtrI(cctkGH, 0, 
+                                              ConstrainedComplexVariableIndex[var]);
+
+    if (PreviousComplexVar && CurrentComplexVar)
+    {     
+      memcpy(CurrentComplexVar, PreviousComplexVar, totalsize * sizeof(CCTK_COMPLEX));
+    }
+    else
+    {
+      CCTK_VWarn(0,__LINE__,__FILE__,"MoL","Null pointer for variable %s", 
+                 CCTK_VarName(ConstrainedComplexVariableIndex[var]));
+    }
+    
+  }
+  
   return;
 }
 
@@ -280,18 +437,60 @@ void MoL_FillAllLevels(CCTK_ARGUMENTS)
   }
 
   CCTK_VInfo(CCTK_THORNSTRING,
-             "The maximum number of evolved variables is %d. %d are registered",
+             "The maximum number of evolved variables is %d. %d are registered.",
              MoL_Num_Evolved_Vars,MoLNumEvolvedVariables);
   
   CCTK_VInfo(CCTK_THORNSTRING,
-             "The maximum number of constrained variables is %d. %d are registered",
+             "The maximum number of constrained variables is %d. %d are registered.",
              MoL_Num_Constrained_Vars,MoLNumConstrainedVariables);
   
   CCTK_VInfo(CCTK_THORNSTRING,
-             "The maximum number of SandR variables is %d. %d are registered",
+             "The maximum number of SandR variables is %d. %d are registered.",
              MoL_Num_SaveAndRestore_Vars,MoLNumSandRVariables);
   
+
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "The maximum number of evolved complex variables is %d. %d are registered.",
+             MoL_Num_ComplexEvolved_Vars,MoLNumEvolvedComplexVariables);
+  
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "The maximum number of constrained complex variables is %d. %d are registered.",
+             MoL_Num_ComplexConstrained_Vars,MoLNumConstrainedComplexVariables);
   
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "The maximum number of SandR complex variables is %d. %d are registered.",
+             MoL_Num_ComplexSaveAndRestore_Vars,MoLNumSandRComplexVariables);
+  
+
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "The maximum number of evolved array variables is %d. %d are registered.",
+             MoL_Num_ArrayEvolved_Vars,MoLNumEvolvedArrayVariables);
+  
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "The maximum number of constrained array variables is %d. %d are registered.",
+             MoL_Num_ArrayConstrained_Vars,MoLNumConstrainedArrayVariables);
+  
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "The maximum number of SandR array variables is %d. %d are registered.",
+             MoL_Num_ArraySaveAndRestore_Vars,MoLNumSandRArrayVariables);
+  
+
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "The maximum number of evolved complex array variables is %d. %d are registered.",
+             MoL_Num_ComplexArrayEvolved_Vars,MoLNumEvolvedComplexArrayVariables);
+  
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "The maximum number of constrained complex array variables is %d. %d are registered.",
+             MoL_Num_ComplexArrayConstrained_Vars,MoLNumConstrainedComplexArrayVariables);
+  
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "The maximum number of SandR complex array variables is %d. %d are registered.",
+             MoL_Num_ComplexArraySaveAndRestore_Vars,MoLNumSandRComplexArrayVariables);  
+  
+  CCTK_VInfo(CCTK_THORNSTRING,
+             "The maximum size of any array variables is %d.",
+             MoL_Max_Evolved_Array_Size);
+
   return;
 }