fts/compressor/LrAmCompressor.h

#ifndef RP_LR_AM_COMPRESSOR_H
#define RP_LR_AM_COMPRESSOR_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/iterator/AmIteratorTmpl.h>        // base class template
#include <pscf/math/IntVec.h>                    // member
#include <util/containers/DArray.h>              // member
 
namespace Pscf {
namespace Rp {
 
   using namespace Util;

   template <int D, class T, class V>
   class LrAmCompressor
    : public AmIteratorTmpl<typename T::Compressor, V>
   {
 
   public:

      using VectorT = V;

      void readParameters(std::istream& in) override;

      void setup(bool isContinuation) override;

      int compress() override;

      void outputTimers(std::ostream& out) const override;

      void clearTimers() override;
 
   protected:

      LrAmCompressor(typename T::System& system);

      ~LrAmCompressor() = default;
 
      // Alias for base class.
      using CompressorT = typename T::Compressor;
 
      // Inherited member function.
      using CompressorT::system;
 
   private:

      DArray< typename T::RField > w0_;

      DArray< typename T::RField > wFieldTmp_;

      typename T::RField resid_;

      typename T::RFieldDft residK_;

      typename T::RField intraCorrelationK_;

      typename T::IntraCorrelation intra_;

      IntVec<D> kMeshDimensions_;

      int kSize_;

      bool isIntraCalculated_;

      bool isAllocated_;
 
      // Private AM algorithm operations

      int nElements() override;

      bool hasInitialGuess() override;

      void getCurrent(VectorT& curr) override;

      void evaluate() override;

      void getResidual(VectorT& resid) override;

      void addCorrection(VectorT& fieldTrial,
                         VectorT const & resTrial) override;

      void update(VectorT& newGuess) override;

      void outputToLog() override;

      using FFTT = typename T::FFT;

      using AmTmpl = AmIteratorTmpl< CompressorT, VectorT >;
 
   };
 
} // namespace Rp
} // namespace Pscf
#endif