libceed-sys 0.12.0

Low-level bindings for libCEED library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

// Copyright (c) 2017-2022, Lawrence Livermore National Security, LLC and other CEED contributors.
// All Rights Reserved. See the top-level LICENSE and NOTICE files for details.
//
// SPDX-License-Identifier: BSD-2-Clause
//
// This file is part of CEED:  http://github.com/ceed

#include "../../kernel-defines.hpp"

const char *occa_tensor_basis_1d_gpu_source = STRINGIFY_SOURCE(

    typedef CeedScalar * dofArray @dim(P1D, BASIS_COMPONENT_COUNT, elementCount);
    typedef const CeedScalar *const_dofArray @dim(P1D, BASIS_COMPONENT_COUNT, elementCount);

    typedef CeedScalar * quadArray @dim(Q1D, elementCount, BASIS_COMPONENT_COUNT);
    typedef const CeedScalar *const_quadArray @dim(Q1D, elementCount, BASIS_COMPONENT_COUNT);

    typedef CeedScalar * sharedBufferArray @dim(MAX_PQ, ELEMENTS_PER_BLOCK); typedef const CeedScalar *quadToDof @dim(P1D, Q1D);
    typedef CeedScalar * elementWeightArray @dim(Q1D, elementCount);

    //---[ Utility Methods ]----------------
    inline void readDofs(const int element, const int localElement, const int component, const int p, const_dofArray U,
                         sharedBufferArray sharedBuffer) {
      // Zero out extra entries
      sharedBuffer(p, localElement) = ((p < P1D) ? U(p, component, element) : 0.0);
    }

    inline void writeDofs(const int element, const int component, const int p, const CeedScalar Vp, dofArray V) {
      if (p < P1D) {
        V(p, component, element) = Vp;
      }
    }

    inline void readQuads(const int elementCount, const int element, const int localElement, const int component, const int q, const_quadArray U,
                          sharedBufferArray sharedBuffer) { sharedBuffer(q, localElement) = U(q, element, component); }

    inline void writeQuads(const int elementCount, const int element, const int component, const int q, const CeedScalar Vq, quadArray V) {
      V(q, element, component) = Vq;
    }

    inline void contractX(const int q, const int localElement, sharedBufferArray sharedBuffer, quadToDof B, CeedScalar &V) {
      V = 0.0;
      for (int p = 0; p < P1D; ++p) {
        V += B(p, q) * sharedBuffer(p, localElement);
      }
    }

    inline void contractTransposeX(const int p, const int localElement, sharedBufferArray sharedBuffer, quadToDof B, CeedScalar &V) {
      V = 0.0;
      for (int q = 0; q < Q1D; ++q) {
        V += B(p, q) * sharedBuffer(q, localElement);
      }
    }

    //---[ Kernels ]------------------------
    @kernel void interp(const CeedInt elementCount, quadToDof B, const CeedScalar *U, CeedScalar *V) {
      for (int elementOffset = 0; elementOffset < elementCount; elementOffset += ELEMENTS_PER_BLOCK; @outer) {
        @shared CeedScalar sharedBuffer[MAX_PQ * ELEMENTS_PER_BLOCK];

        for (int localElement = 0; localElement < ELEMENTS_PER_BLOCK; ++localElement; @inner) {
          for (int q = 0; q < Q1D; ++q; @inner) {
            const int element = elementOffset + localElement;
            if (element < elementCount) {
              for (int component = 0; component < BASIS_COMPONENT_COUNT; ++component) {
                CeedScalar r;
                if (!TRANSPOSE) {
                  readDofs(element, localElement, component, q, U, sharedBuffer);
                  contractX(q, localElement, sharedBuffer, B, r);
                  writeQuads(elementCount, element, component, q, r, V);
                } else {
                  readQuads(elementCount, element, localElement, component, q, U, sharedBuffer);
                  contractTransposeX(q, localElement, sharedBuffer, B, r);
                  writeDofs(element, component, q, r, V);
                }
              }
            }
          }
        }
      }
    }

    @kernel void grad(const CeedInt elementCount, quadToDof B, quadToDof Bx, const CeedScalar *U, CeedScalar *V) {
      for (int elementOffset = 0; elementOffset < elementCount; elementOffset += ELEMENTS_PER_BLOCK; @outer) {
        @shared CeedScalar sharedBuffer[MAX_PQ * ELEMENTS_PER_BLOCK];

        for (int localElement = 0; localElement < ELEMENTS_PER_BLOCK; ++localElement; @inner) {
          for (int q = 0; q < Q1D; ++q; @inner) {
            const int element = elementOffset + localElement;
            if (element < elementCount) {
              for (int component = 0; component < BASIS_COMPONENT_COUNT; ++component) {
                CeedScalar r;
                if (!TRANSPOSE) {
                  readDofs(element, localElement, component, q, U, sharedBuffer);
                  contractX(q, localElement, sharedBuffer, Bx, r);
                  writeQuads(elementCount, element, component, q, r, V);
                } else {
                  readQuads(elementCount, element, localElement, component, q, U, sharedBuffer);
                  contractTransposeX(q, localElement, sharedBuffer, Bx, r);
                  writeDofs(element, component, q, r, V);
                }
              }
            }
          }
        }
      }
    }

    @kernel void weight(const CeedInt elementCount, const CeedScalar *qWeights1D, elementWeightArray W) {
      for (int elementOffset = 0; elementOffset < elementCount; elementOffset += ELEMENTS_PER_BLOCK; @outer) {
        for (int element = elementOffset; element < (elementOffset + ELEMENTS_PER_BLOCK); ++element; @outer) {
          for (int q = 0; q < Q1D; ++q; @inner) {
            W(q, element) = qWeights1D[q];
          }
        }
      }
    }

);