Line data    Source code

       1              : //
       2              : // Class UniformCartesian
       3              : //   UniformCartesian class - represents uniform-spacing cartesian meshes.
       4              : //
       5              : #include "Utility/IpplInfo.h"
       6              : #include "Utility/PAssert.h"
       7              : 
       8              : #include "Field/BareField.h"
       9              : #include "Field/Field.h"
      10              : 
      11              : namespace ippl {
      12              : 
      13              :     template <typename T, unsigned Dim>
      14          392 :     KOKKOS_INLINE_FUNCTION UniformCartesian<T, Dim>::UniformCartesian()
      15              :         : Mesh<T, Dim>()
      16          392 :         , volume_m(0.0) {}
      17              : 
      18              :     template <typename T, unsigned Dim>
      19         1132 :     KOKKOS_INLINE_FUNCTION UniformCartesian<T, Dim>::UniformCartesian(const NDIndex<Dim>& ndi,
      20              :                                                                       const vector_type& hx,
      21         1132 :                                                                       const vector_type& origin) {
      22         1132 :         this->initialize(ndi, hx, origin);
      23         1132 :     }
      24              : 
      25              :     template <typename T, unsigned Dim>
      26         1156 :     KOKKOS_INLINE_FUNCTION void UniformCartesian<T, Dim>::initialize(const NDIndex<Dim>& ndi,
      27              :                                                                      const vector_type& hx,
      28              :                                                                      const vector_type& origin) {
      29         1156 :         meshSpacing_m = hx;
      30              : 
      31         1156 :         volume_m = 1.0;
      32         4604 :         for (unsigned d = 0; d < Dim; ++d) {
      33         3448 :             this->gridSizes_m[d] = ndi[d].length();
      34         3448 :             volume_m *= meshSpacing_m[d];
      35              :         }
      36              : 
      37         1156 :         this->setOrigin(origin);
      38         1156 :     }
      39              : 
      40              :     template <typename T, unsigned Dim>
      41            0 :     KOKKOS_INLINE_FUNCTION void UniformCartesian<T, Dim>::setMeshSpacing(
      42              :         const vector_type& meshSpacing) {
      43            0 :         meshSpacing_m = meshSpacing;
      44            0 :         this->updateCellVolume_m();
      45            0 :     }
      46              : 
      47              :     template <typename T, unsigned Dim>
      48          924 :     KOKKOS_INLINE_FUNCTION T UniformCartesian<T, Dim>::getMeshSpacing(unsigned dim) const {
      49          924 :         PAssert_LT(dim, Dim);
      50          924 :         return meshSpacing_m[dim];
      51              :     }
      52              : 
      53              :     template <typename T, unsigned Dim>
      54              :     KOKKOS_INLINE_FUNCTION const typename UniformCartesian<T, Dim>::vector_type&
      55          652 :     UniformCartesian<T, Dim>::getMeshSpacing() const {
      56          652 :         return meshSpacing_m;
      57              :     }
      58              : 
      59              :     template <typename T, unsigned Dim>
      60           96 :     KOKKOS_INLINE_FUNCTION T UniformCartesian<T, Dim>::getCellVolume() const {
      61           96 :         return volume_m;
      62              :     }
      63              : 
      64              :     template <typename T, unsigned Dim>
      65           72 :     KOKKOS_INLINE_FUNCTION T UniformCartesian<T, Dim>::getMeshVolume() const {
      66           72 :         T ret = 1;
      67          324 :         for (unsigned int d = 0; d < Dim; ++d) {
      68          252 :             ret *= this->getGridsize(d) * this->getMeshSpacing(d);
      69              :         }
      70           72 :         return ret;
      71              :     }
      72              : 
      73              :     template <typename T, unsigned Dim>
      74            0 :     KOKKOS_INLINE_FUNCTION void UniformCartesian<T, Dim>::updateCellVolume_m() {
      75              :         // update cell volume
      76            0 :         volume_m = 1.0;
      77            0 :         for (unsigned i = 0; i < Dim; ++i) {
      78            0 :             volume_m *= meshSpacing_m[i];
      79              :         }
      80            0 :     }
      81              : 
      82              : }  // namespace ippl