VecOpMisc.h

#ifndef PSCF_CUDA_VEC_OP_MISC_H
#define PSCF_CUDA_VEC_OP_MISC_H
 
/*
* PSCF - Polymer Self-Consistent Field
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <pscf/cuda/cudaTypes.h>
#include <pscf/cuda/DeviceArray.h>
#include <util/containers/DArray.h>
 
namespace Pscf {
namespace VecOp {
 
   /*
   * Miscellaneous element-wise vector operations performed on the GPU.
   *
   * This collection of functions is not intended to be comprehensive.  
   * Rather, they are written and included as needed during the development 
   * of other code.
   *
   * Note: this file is included at the end of VecOp.h, so any file that
   * includes VecOp.h will also include this file.
   *
   * Combined operations:
   *
   * The first set of functions defined in this file combine 2 or more 
   * element-wise vector operations. Several of these functions perform
   * linear combinations of vectors multiplied (or scaled) by coefficients, 
   * thus combining vector-scalar multiplication with vector addition. On 
   * a GPU, these operations are performed by launching a single kernel,
   * which will generally be faster than consecutively calling multiple 
   * simpler operations.
   *
   * The names of these functions follow conventions similar to those used
   * in VecOp.h, using eq, add, sub, mul, div, exp and combinations
   * thereof to indicate the operation(s) being performed. V denotes a
   * a vector input, S denotes a scalar, and Vc denotes a vector that 
   * is multiplied by a scalar coefficient and then used in another
   * operation. For example, addEqVc(a, b, c) performs a[i] += b[i] * c
   * for all i.
   *
   * Pair operations:
   * 
   * A second of functions defined in this file contain the word Pair,
   * indicating that these functions perform the same operation for a
   * pair of real output arrays, using a shared input array. For example, 
   * eqVPair performs a1[i] = s[i] and a2[i] = s[i] for all i. On a GPU,
   * performing these operations in pairs is faster because the shared 
   * input array only needs to be loaded from global memory once.
   *
   * "Many" operations:
   * 
   * A third set of functions defined in this file contain the word
   * "Many", indicating that an undefined number of input vectors (>2) 
   * are involved in an operation. For example, addVMany adds >2 vectors
   * together by passing an array of vectors, rather than a discrete set 
   * of vectors.
   *
   * The functions declared in this file are wrappers for CUDA kernels
   * that perform the actual vector operations. The underlying kernels 
   * are only intended to be called through their wrappers, and so are
   * defined in an anonymous namespace in the file VecOpMisc.cu that
   * is inaccessible outside that file. 
   */
 
   // Combined operations

   void addVcVc(DeviceArray<cudaReal>& a,
                DeviceArray<cudaReal> const & b1, cudaReal const c1,
                DeviceArray<cudaReal> const & b2, cudaReal const c2);

   void addVcS(DeviceArray<cudaReal>& a,
               DeviceArray<cudaReal> const & b, cudaReal const c,
               cudaReal const s);

   void addEqVc(DeviceArray<cudaReal>& a,
                DeviceArray<cudaReal> const & b,
                cudaReal const c);

   void addVcVcVc(DeviceArray<cudaReal>& a,
                  DeviceArray<cudaReal> const & b1, cudaReal const c1,
                  DeviceArray<cudaReal> const & b2, cudaReal const c2,
                  DeviceArray<cudaReal> const & b3, cudaReal const c3);

   void addVcVcS(DeviceArray<cudaReal>& a,
                 DeviceArray<cudaReal> const & b1, cudaReal const c1,
                 DeviceArray<cudaReal> const & b2, cudaReal const c2,
                 cudaReal const s);

   void divEqVc(DeviceArray<cudaComplex>& a,
                DeviceArray<cudaReal> const & b,
                cudaReal const c);

   void expVc(DeviceArray<cudaReal>& a, 
              DeviceArray<cudaReal> const & b,
              cudaReal const c);
 
 
   // Pair operations (two output arrays and a shared input)

   void eqVPair(DeviceArray<cudaReal>& a1, 
                DeviceArray<cudaReal>& a2,
                DeviceArray<cudaReal> const & s);

   void mulVVPair(DeviceArray<cudaReal>& a1, DeviceArray<cudaReal>& a2,
                  DeviceArray<cudaReal> const & b1,
                  DeviceArray<cudaReal> const & b2,
                  DeviceArray<cudaReal> const & s);

   void mulEqVPair(DeviceArray<cudaReal>& a1, 
                   DeviceArray<cudaReal>& a2,
                   DeviceArray<cudaReal> const & s);
 
   // Functions of "many" vectors

   void addVMany(DeviceArray<cudaReal>& a,
                 DArray<DeviceArray<cudaReal> > const & vecs);

   void addVMany(DeviceArray<cudaReal>& a,
                 DArray<DeviceArray<cudaReal> const *> const & vecs);

   void mulVMany(DeviceArray<cudaReal>& a,
                 DArray<DeviceArray<cudaReal> > const & vecs);

   void mulVMany(DeviceArray<cudaReal>& a,
                 DArray<DeviceArray<cudaReal> const *> const & vecs);
 
   // Other useful functions

   void sqSqAbsV(DeviceArray<cudaReal>& a,
                 DeviceArray<cudaComplex> const & b);
 
} // namespace VecOp
} // namespace Pscf
#endif