VariableCondensationPreconditioner.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

// MOOSE includes
#include "MoosePreconditioner.h"

// libMesh includes
#include "libmesh/preconditioner.h"
#include "libmesh/linear_implicit_system.h"
#include "libmesh/enum_preconditioner_type.h"
#include "libmesh/mesh_base.h"
#include "libmesh/petsc_matrix.h"
#include "libmesh/parallel_object.h"

// C++ includes
#include <vector>

// Forward declarations
class NonlinearSystemBase;
class VariableCondensationPreconditioner;

class VariableCondensationPreconditioner : public MoosePreconditioner,
                                           public libMesh::Preconditioner<Number>
{
public:
  static InputParameters validParams();

  VariableCondensationPreconditioner(const InputParameters & params);
  virtual ~VariableCondensationPreconditioner();

  virtual void init();

  virtual void setup();

  virtual void apply(const NumericVector<Number> & y, NumericVector<Number> & x);

  virtual void clear();

private:
  void getDofToCondense();

  void getDofColRow();

  void findZeroDiagonals(SparseMatrix<Number> & mat, std::vector<dof_id_type> & indices);

  void condenseSystem();

  void preallocateCondensedJacobian(PetscMatrix<Number> & condensed_mat,
                                    PetscMatrix<Number> & original_mat,
                                    const std::vector<dof_id_type> & rows,
                                    const std::vector<dof_id_type> & cols,
                                    const std::vector<dof_id_type> & grows,
                                    const std::vector<dof_id_type> & gcols,
                                    PetscMatrix<Number> & block_mat);

  void computeCondensedJacobian(PetscMatrix<Number> & condensed_mat,
                                PetscMatrix<Number> & original_mat,
                                const std::vector<dof_id_type> & grows,
                                PetscMatrix<Number> & block_mat);
  void computeDInverse(Mat & mat);

  void computeDInverseDiag(Mat & mat);

  void getCondensedXY(const NumericVector<Number> & y, NumericVector<Number> & x);

  void computeCondensedVariables();

  void getFullSolution(const NumericVector<Number> & y, NumericVector<Number> & x);

  void mergeArrays(const PetscInt * a,
                   const PetscInt * b,
                   const PetscInt & na,
                   const PetscInt & nb,
                   std::vector<PetscInt> & c);

  NonlinearSystemBase & _nl;

  MooseMesh & _mesh;

  const libMesh::DofMap & _dofmap;

  const bool _is_lm_coupling_diagonal;

  const bool _adaptive_condensation;

  const unsigned int _n_vars;

  const std::vector<std::string> _lm_var_names;
  std::vector<unsigned int> _lm_var_ids;

  const std::vector<std::string> _primary_var_names;
  std::vector<unsigned int> _primary_var_ids;

  std::unique_ptr<PetscMatrix<Number>> _D, _M, _K;
  Mat _dinv;

  std::unique_ptr<PetscMatrix<Number>> _J_condensed;

  std::unique_ptr<NumericVector<Number>> _x_hat, _y_hat, _primary_rhs_vec, _lm_sol_vec;

  std::vector<dof_id_type> _zero_rows;

  mutable bool _need_condense;

  libMesh::PreconditionerType _pre_type;

  std::unique_ptr<Preconditioner<Number>> _preconditioner;

  std::vector<dof_id_type> _global_lm_dofs, _lm_dofs, _global_primary_dofs, _primary_dofs;

  std::vector<dof_id_type> _global_rows, _rows, _global_cols, _cols;

  std::unordered_map<dof_id_type, dof_id_type> _global_rows_to_idx, _rows_to_idx,
      _global_cols_to_idx, _cols_to_idx;

  std::unordered_map<dof_id_type, dof_id_type> _map_global_lm_primary, _map_global_primary_order;

  PerfID _init_timer;
  PerfID _apply_timer;
};