Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "DenseMatrix.h"
      11             : #include "ADReal.h"
      12             : #include "MooseError.h"
      13             : 
      14             : #include "libmesh/dense_matrix_base_impl.h"
      15             : #include "libmesh/dense_matrix_impl.h"
      16             : 
      17             : namespace libMesh
      18             : {
      19             : template <>
      20             : void
      21           0 : DenseMatrix<ADReal>::_multiply_blas(const DenseMatrixBase<ADReal> &, _BLAS_Multiply_Flag)
      22             : {
      23           0 :   mooseError("No blas/lapack support for type ", demangle(typeid(ADReal).name()));
      24             : }
      25             : 
      26             : template <>
      27             : void
      28           0 : DenseMatrix<ADReal>::_lu_decompose_lapack()
      29             : {
      30           0 :   mooseError("No blas/lapack support for type ", demangle(typeid(ADReal).name()));
      31             : }
      32             : 
      33             : template <>
      34             : void
      35           0 : DenseMatrix<ADReal>::_svd_lapack(DenseVector<Real> &)
      36             : {
      37           0 :   mooseError("No blas/lapack support for type ", demangle(typeid(ADReal).name()));
      38             : }
      39             : 
      40             : template <>
      41             : void
      42           0 : DenseMatrix<ADReal>::_svd_lapack(DenseVector<Real> &, DenseMatrix<Number> &, DenseMatrix<Number> &)
      43             : {
      44           0 :   mooseError("No blas/lapack support for type ", demangle(typeid(ADReal).name()));
      45             : }
      46             : 
      47             : template <>
      48             : void
      49           0 : DenseMatrix<ADReal>::_svd_helper(
      50             :     char, char, std::vector<Real> &, std::vector<Number> &, std::vector<Number> &)
      51             : {
      52           0 :   mooseError("No blas/lapack support for type ", demangle(typeid(ADReal).name()));
      53             : }
      54             : 
      55             : template <>
      56             : void
      57           0 : DenseMatrix<ADReal>::_svd_solve_lapack(const DenseVector<ADReal> & /*rhs*/,
      58             :                                        DenseVector<ADReal> & /*x*/,
      59             :                                        Real /*rcond*/) const
      60             : {
      61           0 :   mooseError("No blas/lapack support for type ", demangle(typeid(ADReal).name()));
      62             : }
      63             : 
      64             : template <>
      65             : void
      66           0 : DenseMatrix<ADReal>::_evd_lapack(DenseVector<ADReal> &,
      67             :                                  DenseVector<ADReal> &,
      68             :                                  DenseMatrix<ADReal> *,
      69             :                                  DenseMatrix<ADReal> *)
      70             : {
      71           0 :   mooseError("No blas/lapack support for type ", demangle(typeid(ADReal).name()));
      72             : }
      73             : 
      74             : template <>
      75             : void
      76           0 : DenseMatrix<ADReal>::_lu_back_substitute_lapack(const DenseVector<ADReal> &, DenseVector<ADReal> &)
      77             : {
      78           0 :   mooseError("No blas/lapack support for type ", demangle(typeid(ADReal).name()));
      79             : }
      80             : 
      81             : template <>
      82             : void
      83           0 : DenseMatrix<ADReal>::_matvec_blas(
      84             :     ADReal, ADReal, DenseVector<ADReal> &, const DenseVector<ADReal> &, bool) const
      85             : {
      86           0 :   mooseError("No blas/lapack support for type ", demangle(typeid(ADReal).name()));
      87             : }
      88             : 
      89             : template <>
      90     2007039 : DenseMatrix<ADReal>::DenseMatrix(const unsigned int new_m, const unsigned int new_n)
      91     2007039 :   : DenseMatrixBase<ADReal>(new_m, new_n), use_blas_lapack(false), _val(), _decomposition_type(NONE)
      92             : {
      93     2007039 :   this->resize(new_m, new_n);
      94     2007039 : }
      95             : 
      96             : template class DenseMatrixBase<ADReal>;
      97             : template class DenseMatrix<ADReal>;
      98             : 
      99             : template void DenseMatrix<ADReal>::vector_mult_add(DenseVector<ADReal> &,
     100             :                                                    const int,
     101             :                                                    const DenseVector<ADReal> &) const;
     102             : template void DenseMatrix<ADReal>::vector_mult_add(DenseVector<ADReal> &,
     103             :                                                    const double,
     104             :                                                    const DenseVector<ADReal> &) const;
     105             : 
     106             : template void DenseMatrix<Real>::vector_mult(DenseVector<ADReal> &,
     107             :                                              const DenseVector<ADReal> &) const;
     108             : template void DenseMatrix<ADReal>::vector_mult(DenseVector<ADReal> &,
     109             :                                                const DenseVector<Real> &) const;
     110             : 
     111             : template void DenseMatrix<ADReal>::cholesky_solve(const DenseVector<ADReal> & b,
     112             :                                                   DenseVector<ADReal> & x);
     113             : }