igasolver.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <net/igabase.hpp>
#include <splines/boundary.hpp>
#include <splines/functionspace.hpp>
#include <utils/solver.hpp>
 
namespace iganet {
 
template <typename Inputs, typename Outputs, typename CollPts = void>
class IgASolver : public IgABase<Inputs, Outputs, CollPts>,
                  private utils::FullQualifiedName {
 
protected:
  torch::Tensor lhs_;
 
  torch::Tensor rhs_;
  
public:
  using Base = IgABase<Inputs, Outputs, CollPts>;
 
  using Base::IgABase;
 
  inline constexpr const auto &lhs() const { return lhs_; }
 
  inline constexpr auto &lhs() { return lhs_; }
 
  inline constexpr const auto &rhs() const { return rhs_; }
 
  inline constexpr auto &rhs() { return rhs_; }
 
  virtual void init() = 0;
  
  virtual void assemble() {
    assembleLhs();
    assembleRhs();
  }
  
  virtual void assembleLhs() = 0;
 
  virtual void assembleRhs() = 0;
 
  torch::Tensor solve() const {
    auto [x, iter, res] = utils::solve_bicgstab(lhs(), rhs());    
    return x;
  }
  
  inline void pretty_print(std::ostream &os) const noexcept override {
    os << name() << "(\n";
    
    os << "inputs[" << Base::ninputs() << "] = (";
    std::apply([&os](const auto &...elems) { ((os << elems << "\n"), ...); },
               Base::inputs());
    os << ")";
 
    os << "outputs [" << Base::noutputs() << "]= (";
    std::apply([&os](const auto &...elems) { ((os << elems << "\n"), ...); },
               Base::inputs());
    os << ")";
 
    os << "collPts [" << Base::ncollPts() << "]= (";
    std::apply([&os](const auto &...elems) { ((os << elems << "\n"), ...); },
               Base::collPts());
    os << ")";
  }  
};
  
template <typename Inputs, typename Outputs, typename CollPts>
inline std::ostream &
operator<<(std::ostream &os,
           const IgASolver<Inputs, Outputs, CollPts> &obj) {
  obj.pretty_print(os);
  return os;
}  
  
} // namespace iganet