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;
};