Line data    Source code

       1             : /**********************************************************************/
       2             : /*                     DO NOT MODIFY THIS HEADER                      */
       3             : /* MAGPIE - Mesoscale Atomistic Glue Program for Integrated Execution */
       4             : /*                                                                    */
       5             : /*            Copyright 2017 Battelle Energy Alliance, LLC            */
       6             : /*                        ALL RIGHTS RESERVED                         */
       7             : /**********************************************************************/
       8             : 
       9             : #include "FFTData.h"
      10             : 
      11             : template <typename T>
      12             : FFTData<T> &
      13           0 : FFTData<T>::operator+=(FFTData<T> const & rhs)
      14             : {
      15           0 :   for (std::size_t i = 0; i < _buffer.size(); ++i)
      16           0 :     _buffer[i] += rhs[i];
      17           0 :   return *this;
      18             : }
      19             : 
      20             : template <typename T>
      21             : FFTData<T> &
      22           0 : FFTData<T>::operator-=(FFTData<T> const & rhs)
      23             : {
      24           0 :   for (std::size_t i = 0; i < _buffer.size(); ++i)
      25           0 :     _buffer[i] -= rhs[i];
      26           0 :   return *this;
      27             : }
      28             : 
      29             : template <typename T>
      30             : FFTData<T> &
      31          60 : FFTData<T>::operator*=(FFTData<typename FFTScalarType<T>::type> const & rhs)
      32             : {
      33       13260 :   for (std::size_t i = 0; i < _buffer.size(); ++i)
      34           0 :     _buffer[i] *= rhs[i];
      35          60 :   return *this;
      36             : }
      37             : 
      38             : template <typename T>
      39             : FFTData<T> &
      40           0 : FFTData<T>::operator/=(FFTData<typename FFTScalarType<T>::type> const & rhs)
      41             : {
      42           0 :   for (std::size_t i = 0; i < _buffer.size(); ++i)
      43           0 :     _buffer[i] /= rhs[i];
      44           0 :   return *this;
      45             : }
      46             : 
      47             : template <typename T>
      48             : FFTData<T> &
      49          93 : FFTData<T>::operator*=(Real rhs)
      50             : {
      51      375213 :   for (std::size_t i = 0; i < _buffer.size(); ++i)
      52      330120 :     _buffer[i] *= rhs;
      53          93 :   return *this;
      54             : }
      55             : 
      56             : template <typename T>
      57             : FFTData<T> &
      58           0 : FFTData<T>::operator/=(Real rhs)
      59             : {
      60           0 :   const Real reciprocal = 1 / rhs;
      61           0 :   for (std::size_t i = 0; i < _buffer.size(); ++i)
      62           0 :     _buffer[i] *= reciprocal;
      63           0 :   return *this;
      64             : }
      65             : 
      66             : template <typename T>
      67             : FFTData<T> &
      68          60 : FFTData<T>::operator=(FFTData<T> const & rhs)
      69             : {
      70             :   mooseAssert(size() == rhs.size(), "Buffers need to have identical size!");
      71          60 :   _buffer = rhs._buffer;
      72          60 :   return *this;
      73             : }
      74             : 
      75             : template <typename T>
      76             : FFTData<T> &
      77           3 : FFTData<T>::operator=(const T & rhs)
      78             : {
      79             :   std::fill(_buffer.begin(), _buffer.end(), rhs);
      80           3 :   return *this;
      81             : }
      82             : 
      83             : template <typename T>
      84             : template <typename T1, typename T2>
      85             : void
      86          18 : FFTData<T>::setToProductRealSpace(const FFTData<T1> & m1, const FFTData<T2> & m2)
      87             : {
      88             :   mooseAssert(size() == m1.size(), "Buffer size mismatch");
      89             :   mooseAssert(size() == m2.size(), "Buffer size mismatch");
      90             : 
      91      589842 :   for (unsigned int index = 0; index < _buffer.size(); index++)
      92      589824 :     (*this)[index] = m1[index] * m2[index];
      93          18 : }
      94             : 
      95             : template <>
      96             : void *
      97          42 : FFTData<Real>::start(std::size_t i)
      98             : {
      99          42 :   return reinterpret_cast<void *>(&_buffer[i]);
     100             : }
     101             : template <>
     102             : void *
     103          42 : FFTData<Complex>::start(std::size_t i)
     104             : {
     105          42 :   return reinterpret_cast<void *>(&_buffer[i]);
     106             : }
     107             : 
     108             : template <>
     109             : void *
     110          18 : FFTData<RealVectorValue>::start(std::size_t i)
     111             : {
     112          18 :   return reinterpret_cast<void *>(&_buffer[i](0));
     113             : }
     114             : template <>
     115             : void *
     116          18 : FFTData<ComplexVectorValue>::start(std::size_t i)
     117             : {
     118          18 :   return reinterpret_cast<void *>(&_buffer[i](0));
     119             : }
     120             : 
     121             : template <>
     122             : void *
     123          12 : FFTData<RankTwoTensor>::start(std::size_t i)
     124             : {
     125          12 :   return reinterpret_cast<void *>(&_buffer[i](0, 0));
     126             : }
     127             : template <>
     128             : void *
     129          12 : FFTData<ComplexRankTwoTensor>::start(std::size_t i)
     130             : {
     131          12 :   return reinterpret_cast<void *>(&_buffer[i](0, 0));
     132             : }
     133             : 
     134             : template <>
     135             : void *
     136           0 : FFTData<RankThreeTensor>::start(std::size_t i)
     137             : {
     138           0 :   return reinterpret_cast<void *>(&_buffer[i](0, 0, 0));
     139             : }
     140             : template <>
     141             : void *
     142           0 : FFTData<ComplexRankThreeTensor>::start(std::size_t i)
     143             : {
     144           0 :   return reinterpret_cast<void *>(&_buffer[i](0, 0, 0));
     145             : }
     146             : 
     147             : template <>
     148             : void *
     149          12 : FFTData<RankFourTensor>::start(std::size_t i)
     150             : {
     151          12 :   return reinterpret_cast<void *>(&_buffer[i](0, 0, 0, 0));
     152             : }
     153             : template <>
     154             : void *
     155          12 : FFTData<ComplexRankFourTensor>::start(std::size_t i)
     156             : {
     157          12 :   return reinterpret_cast<void *>(&_buffer[i](0, 0, 0, 0));
     158             : }
     159             : 
     160             : template <typename T>
     161             : std::size_t
     162           0 : FFTData<T>::howMany() const
     163             : {
     164           0 :   mooseError("Only call howMany() on the real space buffer!");
     165             : }
     166             : 
     167             : template <>
     168             : std::size_t
     169          21 : FFTData<Real>::howMany() const
     170             : {
     171          21 :   return 1;
     172             : }
     173             : 
     174             : template <>
     175             : std::size_t
     176           9 : FFTData<RealVectorValue>::howMany() const
     177             : {
     178           9 :   return LIBMESH_DIM;
     179             : }
     180             : 
     181             : template <>
     182             : std::size_t
     183           6 : FFTData<RankTwoTensor>::howMany() const
     184             : {
     185           6 :   return LIBMESH_DIM * LIBMESH_DIM;
     186             : }
     187             : 
     188             : template <>
     189             : std::size_t
     190           0 : FFTData<RankThreeTensor>::howMany() const
     191             : {
     192           0 :   return LIBMESH_DIM * LIBMESH_DIM * LIBMESH_DIM;
     193             : }
     194             : 
     195             : template <>
     196             : std::size_t
     197           6 : FFTData<RankFourTensor>::howMany() const
     198             : {
     199           6 :   return LIBMESH_DIM * LIBMESH_DIM * LIBMESH_DIM * LIBMESH_DIM;
     200             : }
     201             : 
     202             : // explicit instantiations
     203             : template class FFTData<Real>;
     204             : template class FFTData<RealVectorValue>;
     205             : template class FFTData<RankTwoTensor>;
     206             : template class FFTData<RankThreeTensor>;
     207             : template class FFTData<RankFourTensor>;
     208             : 
     209             : template class FFTData<Complex>;
     210             : template class FFTData<ComplexVectorValue>;
     211             : template class FFTData<ComplexRankTwoTensor>;
     212             : template class FFTData<ComplexRankThreeTensor>;
     213             : template class FFTData<ComplexRankFourTensor>;
     214             : 
     215             : template void FFTData<RankTwoTensor>::setToProductRealSpace(const FFTData<RankFourTensor> & m1,
     216             :                                                             const FFTData<RankTwoTensor> & m2);