path: root/src/Reduction.c

 /*@@
   @file      Reduction.c
   @date      Thu  May 27 13:52:53 2004
   @author    Ravi Paruchuri
   @desc
              Local Reduction operators
   @enddesc
   @version   $Id$
 @@*/

#include <stdlib.h>



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

CCTK_FILEVERSION(CactusBase_LocalReduce_Reduction_c)

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

 /*@@
   @routine    LocalReductionArrays
   @author     Thomas Radke
   @date       19 Aug 1999
   @desc
               Wrapper to reduce a list of arrays.
               Just calls the appropriate reduction operator and does
               the type conversion of the results.
   @enddesc
   @calls      copy_real_to_outtype

   @var        num_dims
   @vdesc      number of dimensions of input arrays
   @vtype      int
   @vio        in
   @endvar
   @var        dims
   @vdesc      dimensions of input arrays
   @vtype      int *
   @vio        in
   @endvar
   @var        intype
   @vdesc      (common) variable type of input arrays
   @vtype      int
   @vio        in
   @endvar
   @var        num_inarrays
   @vdesc      number of input arrays
   @vtype      int
   @vio        in
   @endvar
   @var        inarrays
   @vdesc      field of input arrays
   @vtype      const void *const *
   @vio        in
   @endvar
   @var        outtype
   @vdesc      (common) variable type of output arrays
   @vtype      int
   @vio        in
   @endvar
   @var        num_outvals
   @vdesc      number of values per output array
   @vtype      int
   @vio        in
   @endvar
   @var        outvals
   @vdesc      pointer to buffer holding the output values
   @vtype      void *
   @vio        in
   @endvar
   @var        reduction_fn
   @vdesc      reduction operator callback
   @vtype      reduction_fn_t
   @vio        in
   @endvar

   @returntype int
   @returndesc
               the return code of the reduction operator, or<BR>
               -1  if array size is zero<BR>
               -2  if <num_outvals> is invalid
   @endreturndesc
@@*/
int LocalReduce_ReductionArrays ( int num_dims,
                          const int dims[/* num_dims */],
                          int intypes[],
                          int num_inarrays,
                          const void *const inarrays[/* num_inarrays */],
                          int outtypes[],
                          int num_outvals,
                          void *outvals[] /* [num_outvals] */,
                          reduction_fn_t reduction_fn)
{
  int i, num_points, retval;
  int from[1], to[1], iterator[1], points_per_dim[1];
  int intypes;
  CCTK_REAL buffer;

  points_per_dim[0] = 1;
  from[0] = 0;
  to[0] = dims[0];

  /* get the total number of array elements */
  for (i = 1; i < num_dims; i++)
  {
    to[0] *= dims[i];
  }

  /* check for zero-sized arrays */
  if (to[0] <= 0)
  {
    CCTK_WARN (2, "LocalReduce_ReductionArrays: Cannot reduce zero-sized arrays");
    return (-1);
  }

  if (num_outvals != 1)
  {
    if (num_outvals != to[0])
    {
      CCTK_VWarn (1, __LINE__, __FILE__, CCTK_THORNSTRING,
                  "LocalReduce_ReductionArrays: Don't know how to reduce "
                  "a %d-dimensional array with %d elements "
                  "to an output array of %d elements",
                  num_dims, to[0], num_outvals);
      return (-2);
    }
    to[0] = 1;
  }
  num_points = to[0];

  for(array = 0 ; array < num_inarrays; array++)
  {
  
    /* set the array types to intype */
    /* FIXME: could allow to pass in arrays of different types now !!! */
      intype = intypes[array];

    /* do the reduction on the input arrays */
    retval = reduction_fn (num_dims, from, to, iterator, points_per_dim,
                           num_points, 1, 1, intype, inarrays[array],
                           1, buffer);

    if (retval == 0 )
    {
      /* type-cast the result to the requested datatype */
      retval = copy_real_to_outtype (1,
                                     buffer, outtype[array], outvals[array]);
    }
  }
  return (retval);
}


 /*@@
   @routine    copy_real_to_outtype
   @author     Thomas Radke
   @date       19 Aug 1999
   @desc
               Does the type conversion from CCTK_REAL into the requested
               datatype.
   @enddesc
   @calls      CCTK_VarTypeSize
               CCTK_GroupTypeFromVarI
               ReductionGA
               copy_real_to_outtype

   @var        num_elems
   @vdesc      number of elements to convert
   @vtype      int
   @vio        in
   @endvar
   @var        inarray
   @vdesc      input array with results of reductions
   @vtype      CCTK_REAL *
   @vio        in
   @endvar
   @var        outtype
   @vdesc      requested output datatype
   @vtype      int
   @vio        in
   @endvar
   @var        outarray
   @vdesc      pointer to output buffer to store the converted results
   @vtype      void *
   @vio        out
   @endvar

   @returntype int
   @returndesc
               0  for success, or<BR>
               -1 if conversion into target datatype is not supported.
   @endreturndesc
@@*/
static int copy_real_to_outtype (int num_elems,
                                 CCTK_REAL inarray[/* num_elems */],
                                 int outtype,
                                 void *outarray /* [num_elems] */)
{
  int i, retval;


  retval = 0;

  if (outtype == CCTK_VARIABLE_CHAR)
  {
    CCTK_BYTE *_outarray = (CCTK_CHAR *) outarray;


    for (i = 0; i < num_elems; i++)
    {
      _outarray[i] = (CCTK_BYTE) inarray[i];
    }
  }
  else if (outtype == CCTK_VARIABLE_INT)
  {
    CCTK_INT *_outarray = (CCTK_INT *) outarray;


    for (i = 0; i < num_elems; i++)
    {
      _outarray[i] = (CCTK_INT) inarray[i];
    }
  }
#ifdef CCTK_INT1
  else if (outtype == CCTK_VARIABLE_INT1)
  {
    CCTK_INT1 *_outarray = (CCTK_INT1 *) outarray;


    for (i = 0; i < num_elems; i++)
    {
      _outarray[i] = (CCTK_INT1) inarray[i];
    }
  }
#endif
#ifdef CCTK_INT2
  else if (outtype == CCTK_VARIABLE_INT2)
  {
    CCTK_INT2 *_outarray = (CCTK_INT2 *) outarray;


    for (i = 0; i < num_elems; i++)
    {
      _outarray[i] = (CCTK_INT2) inarray[i];
    }
  }
#endif
#ifdef CCTK_INT4
  else if (outtype == CCTK_VARIABLE_INT4)
  {
    CCTK_INT4 *_outarray = (CCTK_INT4 *) outarray;


    for (i = 0; i < num_elems; i++)
    {
      _outarray[i] = (CCTK_INT4) inarray[i];
    }
  }
#endif
#ifdef CCTK_INT8
  else if (outtype == CCTK_VARIABLE_INT8)
  {
    CCTK_INT8 *_outarray = (CCTK_INT8 *) outarray;


    for (i = 0; i < num_elems; i++)
    {
      _outarray[i] = (CCTK_INT8) inarray[i];
    }
  }
#endif
  else if (outtype == CCTK_VARIABLE_REAL)
  {
    CCTK_REAL *_outarray = (CCTK_REAL *) outarray;


    for (i = 0; i < num_elems; i++)
    {
      _outarray[i] = (CCTK_REAL) inarray[i];
    }
  }
#ifdef CCTK_REAL4
  else if (outtype == CCTK_VARIABLE_REAL4)
  {
    CCTK_REAL4 *_outarray = (CCTK_REAL4 *) outarray;


    for (i = 0; i < num_elems; i++)
    {
      _outarray[i] = (CCTK_REAL4) inarray[i];
    }
  }
#endif
#ifdef CCTK_REAL8
  else if (outtype == CCTK_VARIABLE_REAL8)
  {
        CCTK_REAL8 *_outarray = (CCTK_REAL8 *) outarray;


        for (i = 0; i < num_elems; i++)
        {
          _outarray[i] = (CCTK_REAL8) inarray[i];
        }
  }
#endif
#ifdef CCTK_REAL16
  else if (outtype == CCTK_VARIABLE_REAL16)
  {
    CCTK_REAL16 *_outarray = (CCTK_REAL16 *) outarray;


    for (i = 0; i < num_elems; i++)
    {
      _outarray[i] = (CCTK_REAL16) inarray[i];
    }
  }
#endif
  else
  {
    CCTK_WARN (1, "copy_real_to_outtype: Unsupported output type");
    retval = -1;
  }

  return (retval);
}