Method SuperLUDistSolver

cpp/dolfinx/la/superlu_dist.cpp:310–380

//----------------------------------------------------------------------------
template <typename T>
SuperLUDistSolver<T>::SuperLUDistSolver(
    std::shared_ptr<const SuperLUDistMatrix<T>> A)
    : _superlu_matA(std::move(A)),
      _options(
          []
          {
            auto o = std::make_unique<
                SuperLUDistStructs::superlu_dist_options_t>();
            set_default_options_dist(o.get());
            o->PrintStat = NO;
            return o;
          }()),
      _gridinfo(
          [comm = _superlu_matA->comm()]
          {
            int nprow = dolfinx::MPI::size(comm);
            int npcol = 1;
            std::unique_ptr<SuperLUDistStructs::gridinfo_t, GridInfoDeleter> p(
                new SuperLUDistStructs::gridinfo_t, GridInfoDeleter{});
            superlu_gridinit(comm, nprow, npcol, p.get());
            return p;
          }()),
      _scalepermstruct(
          [m = _superlu_matA->supermatrix()->nrow]
          {
            std::unique_ptr<typename map_t<T>::ScalePermstruct_t,
                            ScalePermStructDeleter>
                s(new map_t<T>::ScalePermstruct_t, ScalePermStructDeleter{});

            if constexpr (std::is_same_v<T, double>)
            {
              dScalePermstructInit(m, m, s.get());
            }
            else if constexpr (std::is_same_v<T, float>)
            {
              sScalePermstructInit(m, m, s.get());
            }
            else if constexpr (std::is_same_v<T, std::complex<double>>)
            {
              zScalePermstructInit(m, m, s.get());
            }
            else
              static_assert(always_false_v<T>, "Invalid scalar type");
            return s;
          }()),
      _lustruct(
          [m = _superlu_matA->supermatrix()->nrow]
          {
            std::unique_ptr<typename map_t<T>::LUstruct_t, LUStructDeleter> l(
                new map_t<T>::LUstruct_t, LUStructDeleter{});

            if constexpr (std::is_same_v<T, double>)
            {
              dLUstructInit(m, l.get());
            }
            else if constexpr (std::is_same_v<T, float>)
            {
              sLUstructInit(m, l.get());