r1d/solvers/Block.h

#ifndef R1D_BLOCK_H
#define R1D_BLOCK_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 "Propagator.h"                   // base class argument
#include <r1d/domain/GeometryMode.h>     // argument (enum)
#include <pscf/solvers/BlockTmpl.h>       // base class template
#include <pscf/math/TridiagonalSolver.h>  // member
 
namespace Pscf { 
namespace R1d 
{ 
 
   class Domain;
   using namespace Util;
 
   class Block : public BlockTmpl<Propagator>
   {
 
   public:
 
      Block();
 
      ~Block();
 
      void setDiscretization(Domain const & domain, double ds);
 
      virtual void setLength(double newLength);
 
      void setupSolver(DArray<double> const & w);
 
      void computeConcentration(double prefactor);
 
      void step(DArray<double> const & q, DArray<double>& qNew);
 
      Domain const & domain() const;
 
      int ns() const;
 
   private:
 
      TridiagonalSolver solver_;
 
      // Arrays dA_, uA_, lB_ dB_, uB_, luB_ contain elements of the 
      // the tridiagonal matrices A and B used in propagation from
      // step i to i + 1, which requires solution of a linear system 
      // of the form: A q(i+1) = B q(i).
 
      DArray<double> dA_;
 
      DArray<double> uA_;
 
      DArray<double> lA_;
 
      DArray<double> dB_;
 
      DArray<double> uB_;
 
      DArray<double> lB_;
 
      DArray<double> v_;
 
      Domain const * domainPtr_;
 
      double ds_;
 
      // Contour length step size (value input in param file).
      double dsTarget_;
 
      int ns_;
 
   };
 
   // Inline member functions
 
   inline Domain const & Block::domain() const
   {   
      UTIL_ASSERT(domainPtr_);
      return *domainPtr_;
   }
 
   inline int Block::ns() const
   {  return ns_; }
 
}
}
#endif