/*@@
@routine CCTKi_CommandLineFinished
@date Fri Jul 23 12:55:39 1999
@author Tom Goodale
@desc
Subroutine to do anything which has to be done based upon the
commandline, but needs to be have a default.
@enddesc
@@*/
void CCTKi_CommandLineFinished (void)
{
int myproc;
char fname[256];
/* Are we in a paramcheck run ? */
if (! paramchecking)
{
cctki_paramchecking = 0;
}
/* Redirect output from sub-processors ... */
myproc = CCTK_MyProc (NULL);
if (myproc)
{
if (redirectsubs)
{
sprintf (fname, "CCTK_Proc%d.out", myproc);
}
else
{
sprintf (fname, NULL_DEVICE);
}
freopen (fname, "w", stdout);
}
}
/*@@
@routine CCTKi_CommandLineHelp
@date Fri Jul 23 12:57:23 1999
@author Tom Goodale
@desc
Prints a help message.
@enddesc
@calls CCTK_CommandLine
CCTK_CompileDate
CCTK_CompileTime
@@*/
void CCTKi_CommandLineHelp (void)
{
char **argv;
const char *commandline_options_description =
"-h, -help : gets this help.\n"
"-O, -describe-all-parameters : describes all the parameters.\n"
"-o, -describe-parameter <paramname> : describe the given parameter.\n"
"-x, -test-parameters [nprocs] : does a quick test of the parameter file\n"
" pretending to be on nprocs processors, \n"
" or 1 if not given.\n"
"-W, -warning-level <n> : Sets the warning level to n.\n"
"-E, -error-level <n> : Sets the error level to n.\n"
"-r, -redirect-stdout : Redirects standard output to files.\n"
"-T, -list-thorns : Lists the compiled-in thorns.\n"
"-t, -test-thorn-compiled <name> : Tests for the presence of thorn <name>.\n"
" -parameter-level <level> : Sets the amount of parameter checking, \n"
" level can be script, normal, relaxed.\n"
"-v, -version : Prints the version.\n"
"-i, -ignore-next : Ignores the next argument.\n";
if (CCTK_MyProc (NULL) == 0)
{
CCTK_CommandLine (&argv);
printf ("%s, compiled on %s at %s\n",
argv[0], CCTK_CompileDate(), CCTK_CompileTime());
printf ("Usage: %s %s\n", argv[0], CACTUS_COMMANDLINE_OPTIONS);
printf ("\nValid options:\n%s", commandline_options_description);
}
CCTK_Exit (NULL, 1);
}
/*@@
@routine CCTKi_CommandLineDescribeParameter
@date Tue Apr 18 15:00:33 2000
@author Tom Goodale
@desc
Describe a particular parameter.
@enddesc
@calls Util_SplitString
CCTK_ParameterData
CCTK_ImplementationThorn
CommandLinePrintParameter
@var argument
@vdesc option argument
@vtype const char *
@vio in
@endvar
@@*/
void CCTKi_CommandLineDescribeParameter (const char *argument)
{
char *thorn, *param;
const char *cthorn;
const cParamData *properties;
if (CCTK_MyProc (NULL) == 0)
{
Util_SplitString (þ, ¶m, argument, "::");
if (! param)
{
properties = CCTK_ParameterData (argument, NULL);
}
else
{
properties = CCTK_ParameterData (param, thorn);
if (! properties)
{
cthorn = CCTK_ImplementationThorn (thorn);
properties = CCTK_ParameterData (param, cthorn);
}
free (thorn);
free (param);
}
CommandLinePrintParameter (properties);
}
CCTK_Exit (NULL, 0);
}
/*@@
@routine CactusDefaultShutdown
@date Tue Sep 29 12:45:04 1998
@author Tom Goodale
@desc
Default shutdown routine.
@enddesc
@calls
@calledby
@history introducing CCTK_SHUTDOWN scheduling [03/00 Gerd Lanfermann]
@endhistory
@@*/
int CactusDefaultShutdown(tFleshConfig *config)
{
int myproc;
unsigned int conv_level;
myproc = CCTK_MyProc(config->GH[0]);
/* Execute termination for all convergence levels */
for(conv_level = 0 ; conv_level < config->nGHs; conv_level++)
{
CCTK_Traverse(config->GH[conv_level], "CCTK_TERMINATE");
}
/* Execute shutdown for all convergence levels */
for(conv_level = 0 ; conv_level < config->nGHs; conv_level++)
{
CCTK_Traverse(config->GH[conv_level], "CCTK_SHUTDOWN");
}
#ifdef CCTK_MPI
if(MPI_Active)
{
CACTUS_MPI_ERROR(MPI_Finalize());
}
#endif
if(myproc == 0)
{
printf("--------------------------------------------------------------------------------\n");
printf("Done.\n");
}
return 0;
}
/*@@
@routine CCTKi_CommandLineListThorns
@date Tue Apr 18 15:05:00 2000
@author Tom Goodale
@desc
List the thorns which are compiled in.
@enddesc
@calls CCTKi_PrintThorns
@@*/
void CCTKi_CommandLineListThorns (void)
{
if (CCTK_MyProc (NULL) == 0)
{
printf ("\n---------------Compiled Thorns-------------\n");
CCTKi_PrintThorns (stdout, " %s\n", 0);
printf ("-------------------------------------------\n\n");
}
CCTK_Exit (NULL, 1);
}
/*@@
@routine CCTKi_CommandLineTestThorncompiled
@date Wed Feb 17 10:25:30 1999
@author Gabrielle Allen
@desc
Tests if a given thorn has been compiled.
At the moment the given thorn must be in the format
<arrangement name>/<thorn name>
@enddesc
@calls CCTK_IsThornCompiled
@var argument
@vdesc option argument
@vtype const char *
@vio in
@endvar
@@*/
void CCTKi_CommandLineTestThornCompiled (const char *argument)
{
int retval;
retval = CCTK_IsThornCompiled (argument);
if (CCTK_MyProc (NULL) == 0)
{
printf ("Thorn '%s' %savailable.\n", argument, retval ? "" : "un");
}
CCTK_Exit (NULL, retval);
}
/*@@
@routine CCTKi_CommandLineUsage
@date Fri Jul 23 12:57:04 1999
@author Tom Goodale
@desc
Prints a usage message.
@enddesc
@calls CCTK_CommandLine
@@*/
void CCTKi_CommandLineUsage (void)
{
char **argv;
if (CCTK_MyProc (NULL) == 0)
{
CCTK_CommandLine (&argv);
printf ("Usage: %s %s\n", argv[0], CACTUS_COMMANDLINE_OPTIONS);
}
CCTK_Exit (NULL, 1);
}
/*@@
@routine CCTKi_CommandLineVersion
@date Fri Jul 23 12:57:45 1999
@author Tom Goodale
@desc
Prints version info.
@enddesc
@calls CCTK_FullVersion
CCTK_CompileDate
CCTK_CompileTime
@@*/
void CCTKi_CommandLineVersion(void)
{
char **argv;
const char *version;
if (CCTK_MyProc (NULL) == 0)
{
CCTK_CommandLine (&argv);
version = CCTK_FullVersion ();
printf ("%s: Version %s. Compiled on %s at %s\n", argv[0], version,
CCTK_CompileDate (), CCTK_CompileTime ());
}
CCTK_Exit (NULL, 1);
}
/*@@
@routine CCTKi_CommandLineDescribeAllParameters
@date Tue Apr 18 15:00:12 2000
@author Tom Goodale
@desc
Describe all the parameters
@enddesc
@calls CCTK_NumCompiledThorns
CCTK_CompiledThorn
CCTK_ParameterWalk
CommandLinePrintParameter
@var argument
@vdesc option argument
@vtype const char *
@vio in
@endvar
@@*/
void CCTKi_CommandLineDescribeAllParameters (const char *argument)
{
int first, n_thorns, thorn;
char *param;
const char *thornname;
const cParamData *properties;
if (CCTK_MyProc (NULL) == 0)
{
n_thorns = CCTK_NumCompiledThorns ();
for (thorn = 0; thorn < n_thorns; thorn++)
{
thornname = CCTK_CompiledThorn (thorn);
printf ("\nParameters of thorn '%s' providing implementation '%s':\n",
thornname, CCTK_ThornImplementation (thornname));
first = 1;
while (CCTK_ParameterWalk (first, thornname, ¶m, &properties) == 0)
{
if (argument)
{
switch (*argument)
{
case 'v':
CommandLinePrintParameter (properties);
break;
default :
fprintf (stderr, "Unknown verbosity option %s\n", argument);
CCTK_Exit (NULL, 2);
}
}
else
{
printf ("%s\n", param);
}
free (param);
first = 0;
}
}
}
CCTK_Exit (NULL, 0);
}
CCTK_INT Hyperslab_DefineGlobalMappingByIndex (
const cGH *GH,
CCTK_INT vindex,
CCTK_INT dim,
const CCTK_INT *direction /* vdim*dim */,
const CCTK_INT *origin /* vdim */,
const CCTK_INT *extent /* dim */,
const CCTK_INT *downsample /* dim */,
CCTK_INT table_handle,
CCTK_INT target_proc,
t_hslabConversionFn conversion_fn,
CCTK_INT *hsize /* dim */)
{
unsigned int vdim, hdim, num_dirs;
int retval;
int stagger_index;
int myproc;
int npoints;
hslab_mapping_t *mapping;
const char *error_msg;
const pGH *pughGH; /* pointer to the current pGH */
const pGA *GA; /* the variable's GA structure from PUGH */
cGroup vinfo;
/* PUGHSlab doesn't use table information */
if (table_handle >= 0)
{
CCTK_WARN (1, "Hyperslab_DefineGlobalMappingByIndex: table information is "
"ignored");
}
/* check parameter consistency */
retval = 0;
error_msg = NULL;
if (CCTK_GroupData (CCTK_GroupIndexFromVarI (vindex), &vinfo) < 0)
{
error_msg = "invalid variable index given";
retval = -1;
}
else if (vinfo.grouptype != CCTK_GF && vinfo.grouptype != CCTK_ARRAY)
{
error_msg = "invalid variable group type given "
"(not a CCTK_GF or CCTK_ARRAY type)";
retval = -2;
}
else if (dim < 0 || dim > vinfo.dim)
{
error_msg = "invalid hyperslab dimension given";
retval = -2;
}
else if (! direction || ! origin || ! extent || ! hsize)
{
error_msg = "NULL pointer(s) passed for direction/origin/extent/hsize "
"parameters";
retval = -3;
}
else if (target_proc >= CCTK_nProcs (GH))
{
error_msg = "invalid target procesor ID given";
retval = -4;
}
else if ((pughGH = (const pGH *) PUGH_pGH (GH)) == NULL)
{
error_msg = "no PUGH GH extension registered (PUGH not activated ?)";
retval = -4;
}
else
{
for (vdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
retval |= origin[vdim] < 0;
if (vdim < (unsigned int) dim)
{
retval |= extent[vdim] <= 0;
if (downsample)
{
retval |= downsample[vdim] <= 0;
}
}
}
if (retval)
{
error_msg = "invalid hyperslab origin/extent/downsample vectors given";
retval = -5;
}
}
if (! retval)
{
mapping = (hslab_mapping_t *) malloc (sizeof (hslab_mapping_t));
if (mapping)
{
mapping->vectors = (int *) malloc ((6*vinfo.dim + 2*dim) * sizeof (int));
}
if (mapping == NULL || mapping->vectors == NULL)
{
if (mapping)
{
free (mapping);
}
error_msg = "couldn't allocate hyperslab mapping structure";
retval = -6;
}
}
/* return in case of errors */
if (retval)
{
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: %s", error_msg);
return (retval);
}
mapping->hdim = (unsigned int) dim;
mapping->vinfo = vinfo;
mapping->target_proc = target_proc;
mapping->conversion_fn = conversion_fn;
/* assign memory for the other vectors */
mapping->local_startpoint = mapping->vectors + 0*vinfo.dim;
mapping->local_endpoint = mapping->vectors + 1*vinfo.dim;
mapping->global_startpoint = mapping->vectors + 2*vinfo.dim;
mapping->global_endpoint = mapping->vectors + 3*vinfo.dim;
mapping->do_dir = mapping->vectors + 4*vinfo.dim;
mapping->downsample = mapping->vectors + 5*vinfo.dim;
mapping->local_hsize = mapping->vectors + 6*vinfo.dim + 0*dim;
mapping->global_hsize = mapping->vectors + 6*vinfo.dim + 1*dim;
/* check direction vectors */
for (hdim = 0; hdim < mapping->hdim; hdim++)
{
num_dirs = 0;
for (vdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
if (direction[hdim*vinfo.dim + vdim])
{
num_dirs++;
}
}
if (num_dirs == 0)
{
free (mapping->vectors); free (mapping);
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: %d-direction vector "
"is a null vector", hdim);
return (-7);
}
mapping->is_diagonal_in_3D = num_dirs == 3 && mapping->hdim == 1;
if (num_dirs != 1 && ! mapping->is_diagonal_in_3D)
{
free (mapping->vectors); free (mapping);
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: %d-direction vector "
"isn't axis-orthogonal", hdim);
return (-7);
}
}
/* diagonals can be extracted from non-staggered 3D variables only */
if (mapping->is_diagonal_in_3D && vinfo.stagtype != 0)
{
free (mapping->vectors); free (mapping);
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: diagonals can be "
"extracted from non-staggered 3D variables only");
return (-7);
}
for (vdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
mapping->do_dir[vdim] = 0;
for (hdim = 0; hdim < mapping->hdim; hdim++)
{
if (direction[hdim*vinfo.dim + vdim])
{
mapping->do_dir[vdim]++;
}
}
if (mapping->do_dir[vdim] > 1)
{
free (mapping->vectors); free (mapping);
CCTK_WARN (1, "Hyperslab_DefineGlobalMappingByIndex: duplicate direction "
"vectors given");
return (-8);
}
}
/* get the pGH pointer and the variable's GA structure */
GA = (const pGA *) pughGH->variables[vindex][0];
myproc = CCTK_MyProc (GH);
/* check extent */
for (vdim = hdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
if (mapping->do_dir[vdim] && hdim < mapping->hdim)
{
if (origin[vdim] + extent[hdim] > GA->extras->nsize[vdim])
{
free (mapping->vectors); free (mapping);
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: extent in "
"%d-direction exceeds grid size", hdim);
return (-8);
}
hdim++;
}
else if (mapping->is_diagonal_in_3D &&
origin[vdim] + extent[0] > GA->extras->nsize[vdim])
{
free (mapping->vectors); free (mapping);
CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
"Hyperslab_DefineGlobalMappingByIndex: extent in "
"%d-direction exceeds grid size", vdim);
return (-8);
}
}
/* now fill out the hyperslab mapping structure */
for (vdim = hdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
mapping->downsample[vdim] = 1;
if (mapping->do_dir[vdim] && hdim < mapping->hdim)
{
if (downsample)
{
mapping->downsample[vdim] = downsample[hdim];
}
mapping->global_hsize[hdim] = extent[hdim] / mapping->downsample[vdim];
if (extent[hdim] % mapping->downsample[vdim])
{
mapping->global_hsize[hdim]++;
}
/* subtract ghostzones for periodic BC */
if (GA->connectivity->perme[vdim])
{
mapping->global_hsize[hdim] -= 2 * GA->extras->nghostzones[vdim];
}
hdim++;
}
else if (mapping->is_diagonal_in_3D)
{
mapping->totals = extent[0] / mapping->downsample[0];
if (extent[0] % mapping->downsample[0])
{
mapping->totals++;
}
/* subtract ghostzones for periodic BC */
if (GA->connectivity->perme[vdim])
{
mapping->totals -= 2 * GA->extras->nghostzones[vdim];
}
if ((unsigned int) mapping->global_hsize[0] > mapping->totals)
{
mapping->global_hsize[0] = mapping->totals;
}
}
}
/* check whether the full local data patch was requested as hyperslab */
mapping->is_full_hyperslab = IsFullHyperslab (GA, origin, extent, mapping);
if (mapping->is_full_hyperslab)
{
memset (mapping->local_startpoint, 0, vinfo.dim * sizeof (int));
memcpy (mapping->local_endpoint, GA->extras->lnsize, vinfo.dim*sizeof(int));
mapping->totals = GA->extras->npoints;
}
else if (mapping->is_diagonal_in_3D)
{
/* just initialize the downsample and global_startpoint vectors */
for (vdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
mapping->downsample[vdim] = mapping->downsample[0];
mapping->global_startpoint[vdim] = origin[vdim];
}
}
else
{
/* compute the global endpoint */
for (vdim = hdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
mapping->global_endpoint[vdim] = origin[vdim] +
(mapping->do_dir[vdim] ? extent[hdim++] : 1);
}
/* compute this processor's global startpoint from the global ranges */
for (vdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
stagger_index = CCTK_StaggerDirIndex (vdim, vinfo.stagtype);
if (origin[vdim] < MY_GLOBAL_EP (GA->extras, myproc, stagger_index, vdim))
{
mapping->global_startpoint[vdim] = origin[vdim];
if (origin[vdim] < MY_GLOBAL_SP (GA->extras, myproc,stagger_index,vdim))
{
npoints = (MY_GLOBAL_SP (GA->extras, myproc, stagger_index, vdim)
- origin[vdim]) / mapping->downsample[vdim];
if ((MY_GLOBAL_SP (GA->extras, myproc, stagger_index, vdim)
- origin[vdim]) % mapping->downsample[vdim])
{
npoints++;
}
mapping->global_startpoint[vdim] += npoints*mapping->downsample[vdim];
}
}
else
{
mapping->global_startpoint[vdim] = -1;
}
}
/* compute the local start- and endpoint from the global ranges */
mapping->totals = 1;
for (vdim = hdim = 0; vdim < (unsigned int) vinfo.dim; vdim++)
{
stagger_index = CCTK_StaggerDirIndex (vdim, vinfo.stagtype);
if (mapping->global_startpoint[vdim] >= 0 &&
mapping->global_startpoint[vdim] < MY_GLOBAL_EP (GA->extras, myproc,
stagger_index,vdim))
{
mapping->local_startpoint[vdim] = mapping->global_startpoint[vdim] -
GA->extras->lb[myproc][vdim];
}
else
{
mapping->local_startpoint[vdim] = -1;
}
if (mapping->global_endpoint[vdim] > MY_GLOBAL_SP (GA->extras, myproc,
stagger_index, vdim))
{
mapping->local_endpoint[vdim] =
MIN (MY_LOCAL_EP (GA->extras, stagger_index, vdim),
mapping->global_endpoint[vdim] -
GA->extras->lb[myproc][vdim]);
}
else
{
mapping->local_endpoint[vdim] = -1;
}
#ifdef DEBUG
printf ("direction %d: global ranges [%d, %d), local ranges[%d, %d)\n",
vdim,
mapping->global_startpoint[vdim], mapping->global_endpoint[vdim],
mapping->local_startpoint[vdim], mapping->local_endpoint[vdim]);
#endif
if (mapping->local_endpoint[vdim] < 0 ||
mapping->local_startpoint[vdim] < 0)
{
mapping->totals = 0;
mapping->local_endpoint[vdim] = mapping->local_startpoint[vdim];
}
if (mapping->do_dir[vdim])
{
/* compute the local size in each hyperslab dimension */
mapping->local_hsize[hdim] = (mapping->local_endpoint[vdim] -
mapping->local_startpoint[vdim]) /
mapping->downsample[vdim];
if ((mapping->local_endpoint[vdim] - mapping->local_startpoint[vdim]) %
mapping->downsample[vdim])
{
mapping->local_hsize[hdim]++;
}
mapping->totals *= mapping->local_hsize[hdim];
hdim++;
}
}
} /* end of else branch for 'if (mapping->is_full_hyperslab)' */
#ifdef DEBUG
printf ("total number of hyperslab data points: %d\n", mapping->totals);
#endif
#if 0
if (mapping->totals > 0)
{
/* if requested, compute the offsets into the global hyperslab */
if (hoffset_global)
{
for (i = hdim = 0; i < vinfo.dim; i++)
{
if (mapping->do_dir[i])
{
if (mapping->is_full_hyperslab)
{
hoffset_global[hdim] = GA->extras->lb[myproc][i];
}
else
{
hoffset_global[hdim] = (mapping->global_startpoint[i] -
origin[i]) / mapping->downsample[i];
if (GA->connectivity->perme[i])
{
hoffset_global[hdim] -= GA->extras->nghostzones[i];
}
}
#ifdef DEBUG
printf ("hoffset_global, hsize in direction %d: %d, %d\n",
hdim, hoffset_global[hdim], mapping->local_hsize[hdim]);
#endif
hdim++;
}
}
}
}
#endif
/* add this mapping to the mapping list */
if (mapping_list)
{
mapping_list->prev = mapping;
}
mapping->prev = NULL;
mapping->next = mapping_list;
mapping_list = mapping;
mapping->handle = nmapping_list++;
/* set the global hsize in the return arguments */
if (hsize)
{
for (hdim = 0; hdim < mapping->hdim; hdim++)
{
hsize[hdim] = mapping->global_hsize[hdim];
}
}
return (mapping->handle);
}
