BinaryRelaxIterator.h

#ifndef FD1D_BINARY_RELAX_ITERATOR_H
#define FD1D_BINARY_RELAX_ITERATOR_H
 
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "Iterator.h"
#include <fd1d/solvers/Mixture.h>
#include <pscf/math/LuSolver.h>
#include <util/containers/Array.h>
#include <util/containers/DArray.h>
#include <util/containers/DMatrix.h>
 
 
namespace Pscf {
namespace Fd1d
{
 
   using namespace Util;
 
   class BinaryRelaxIterator : public Iterator
   {
    
   public:
    
      typedef Mixture::WField WField;
    
      typedef Mixture::CField CField;
   
      BinaryRelaxIterator(System& system);
    
      virtual ~BinaryRelaxIterator();
    
      void readParameters(std::istream& in);
    
      int solve(bool isContinuation = false);
   
   private:
    
    
      DArray<WField> wFieldsNew_;
    
      DArray<WField> cFieldsNew_;
      
      
      DArray<double> cArray_;
    
      DArray<double> wArray_;
    
      DArray<double> residual_;
    
      DArray<double> residualNew_;
      
      DArray<WField> dW_;
      
      DArray<WField> dWNew_;
      
      double dWNorm_;
      
      double dWNormNew_;
      
      double epsilon_;
      
      double lambdaPlus_;
      
      double lambdaMinus_;
      
      int maxItr_;
    
      bool isAllocated_;
    
      bool isCanonical_;
    
      void allocate();
    
      void computeDW(Array<WField> const & wOld, 
                     Array<CField> const & cFields,
                     Array<WField> & dW,
                     double & dWNorm);
     
      void updateWFields(Array<WField> const & wOld,
                         Array<WField> const & dW_,
                         Array<WField> & wNew);
                         
   };
 
} // namespace Fd1d
} // namespace Pscf
#endif