Class containing the operations needed for the FETI solver. More...

#include <FETI_operations.h>

Public Member Functions
	FETI_Operations (libMesh::Parallel::Communicator &comm, const std::string &scratch_folder_path, const std::string &coupling_folder_path)
	Constructor with scratch folder path, coupling matrices base filename, and libMesh communicator. More...

	FETI_Operations (libMesh::Parallel::Communicator &comm, const std::string &scratch_folder_path)
	Constructor with scratch folder path and libMesh communicator. More...

	~FETI_Operations ()
	Destructor, deallocates the PETSc. More...

void	set_coupling_matrix_R_micro ()
	Read the mediator - micro system coupling matrix. More...

void	set_coupling_matrix_R_BIG ()
	Read the mediator - macro system coupling matrix. More...

void	set_coupling_matrix_RR ()
	Read the mediator - mediator system coupling matrix. More...

void	read_coupling_matrices ()
	Read all the coupling matrices. More...

void	set_preconditioner (BaseCGPrecondType CG_precond_type, bool bInitialSet=true)

void	using_rb_modes (bool bUseRigidBodyModes)
	Set up the. More...

void	set_null_space (const std::string &input_filename_base, int nb_of_vecs)
	Set and print the null space vectors and matrices. More...

void	read_null_space_vecs (const std::string &RB_vectors_base, int nb_of_rb_vectors)
	Read the null space vectors. More...

void	read_null_space_inv_RITRI_mat ()
	Read the $inv({R^I}^t \cdot R^I)$ matrix. More...

void	calculate_null_space_phi_0 (const std::string &force_path)
	Calculate the inital solution, $\phi_0$ . More...

void	read_decoupled_solutions ()
	Read the decoupled solutions, . More...

void	read_ext_solver_output ()
	Read the latest external solver output. More...

void	read_rb_corr ()
	Read the rigid body modes correction vector. More...

void	read_previous_phi ()
	Read the previous Lagrage multiplier / solution. More...

void	read_previous_r ()
	Read the previous residual. More...

void	read_all_previous_p ()
	Read all the previous `p` vectors. More...

void	read_all_previous_q ()
	Read all the previous `q` vectors. More...

void	read_scalar_data ()
	Read the scalar data, `rho(0 ... kkk)`, `\| RB_corr(0 ... kkk) \|` and `p(0 ... kkk - 1).q(0 ... kkk - 1)` More...

void	read_vector_data ()
	Read the vector data - essentially calls the "read_previous" and "read_all_previous" methods. More...

void	calculate_initial_p ()
	Calculate the initial `p(0)` vector. More...

void	calculate_initial_r ()
	Calculate the inital residual vector, `r(0)` More...

void	calculate_p ()
	Calculate the current `p(kkk+1)` vector. More...

void	calculate_q ()
	Calculate the current `q(kkk)` vector. More...

void	calculate_r ()
	Calculate the current `r(kkk+1)` residual vector. More...

void	calculate_z ()
	Calculate the current `z(kkk+1)` vector. More...

void	calculate_phi ()
	Calculate the current `phi(kkk+1)` solution vector. More...

void	calculate_rb_correction ()
	Calculate the rigid body modes corrections. More...

void	calculate_scalar_data ()
	Calculate the scalar quantities. More...

void	calculate_coupled_solution ()
	Calculate the final coupled solution. More...

IterationStatus	check_convergence (double rel_residual_conv, double abs_residual_conv, int max_iter_div, double rel_residual_div, double rb_modes_conv=-1)
	Check the convergence. More...

void	increase_iter_counter ()
	Increase the iteration counter. More...

void	export_ext_solver_rhs_Ct_p ()
	Calculate and export the external solver RHS's for the next iteration. More...

void	export_ext_solver_rhs_initial ()
	Calculate and export the external solver RHS's for the first iteration. More...

void	export_ext_solver_rhs_Ct_phi ()
	Calculate and export the external solver RHS's for the decoupled problem. More...

void	export_rb_correction_vector ()
	Export the rigid body modes correction. More...

void	export_p ()
	Export the current `p(kkk+1)` vector. More...

void	export_q ()
	Export the current `q(kkk)` vector. More...

void	export_r ()
	Export the current `r(kkk+1)` residual vector. More...

void	export_phi ()
	Export the current Lagrange multiplier / solution. More...

void	export_inital_vecs ()
	Export the initial iteration vectors, `r(0)` and `p(0)` More...

void	export_initial_scalar_data ()
	Export the initial iteration scalar data, `rho(0)` and `\| RB_corr(0) \|` More...

void	export_scalar_data ()
	Export the iteration scalar data, `rho(kkk+1)`, `\| RB_corr(kkk+1) \|` and `p(kkk).q(kkk)` More...

void	export_iter_vecs ()

void	export_coupled_solution (std::string output_base)

void	print_previous_iters_conv (int nb_of_iters=5)

Protected Types
enum	{ maxVecLimit = 6 }

Protected Member Functions
void	set_inverse_precond_solver ()
	Set up the full inversed coupling matrix preconditioner. More...

void	set_jacobi_precond_vector ()
	Set up the Jacobi coupling matrix preconditioner vector. More...

void	read_jacobi_precond_vector ()
	Read the Jacobi coupling matrix preconditioner vector. More...

void	apply_inverse_coupling_precond (Vec vec_in, Vec vec_out)
	Apply the full inversed coupling matrix preconditioner. More...

void	apply_jacobi_coupling_precond (Vec vec_in, Vec vec_out)
	Apply the Jacobi coupling matrix preconditioner vector. More...

void	apply_precond (Vec vec_in, Vec vec_out)
	Common interface to the preconditionners. More...

void	apply_RB_projection (Vec vec_in, Vec vec_out)
	Apply the rigid body modes projection operation. More...

void	export_ext_solver_rhs (Vec vec_in)
	Calculate and export the external solver RHS's. More...

void	clear_PETSc ()
	PETSc Vec and Mat deallocation, called by the destructor. More...

	FETI_Operations ()
	Default constructor. More...

Protected Attributes
libMesh::Parallel::Communicator &	m_comm
	Communicator. More...

bool	m_bScratchFolderSet
	Have the scratch folder been set? More...

bool	m_bCouplingFolderSet
	Have the Coupling matrices folder been set? More...

std::string	m_scratch_folder_path
	Scratch folder path. More...

std::string	m_coupling_folder_path
	Coupling matrices path. More...

IterationStatus	m_FETI_solver_status
	Current FETI / CG solver status. More...

int	m_kkk
	Current iteration index. More...

Mat	m_C_R_micro
	Mediator - micro system coupling matrix. More...

Mat	m_C_R_BIG
	Mediator - macro system coupling matrix. More...

Mat	m_C_RR
	Mediator - mediator system coupling matrix. More...

PetscInt	m_C_R_micro_M

PetscInt	m_C_R_micro_N

PetscInt	m_C_R_micro_M_local

PetscInt	m_C_R_micro_N_local

PetscInt	m_C_R_BIG_M

PetscInt	m_C_R_BIG_N

PetscInt	m_C_R_BIG_M_local

PetscInt	m_C_R_BIG_N_local

PetscInt	m_C_RR_M

PetscInt	m_C_RR_M_local

KSP	m_coupling_precond_solver
	Preconditioner system solver. More...

Vec	m_coupling_jacobi_precond_vec
	Preconditioner Jacobi vector. More...

bool	m_bC_R_micro_MatrixSet
	Mediator - micro coupling matrix has been set? More...

bool	m_bC_R_BIG_MatrixSet
	Mediator - macro coupling matrix has been set? More...

bool	m_bC_RR_MatrixSet
	Mediator - mediator coupling matrix has been set? More...

bool	m_bCouplingMatricesSet
	All coupling matrices has been set? More...

bool	m_bmicro_sizes_set
	Have the micro dimensions been set yet? More...

bool	m_bBIG_sizes_set
	Have the macro dimensions been set yet? More...

bool	m_bR_sizes_set
	Have the mediator dimensions been set yet? More...

BaseCGPrecondType	m_precond_type
	Preconditioner type. Default: `BaseCGPrecondType::NO_PRECONDITIONER`. More...

RBModesSystem	m_RB_modes_system
	Which model is associated to the RB modes? Default: `RBModesSystem::MICRO`. More...

bool	m_bCreatedPrecondSolver
	Have the preconditioner system solver been set? More...

bool	m_bCreatedPrecondJacobiVec
	Have the preconditioner system solver been set? More...

PetscInt	m_null_nb_vecs
	Number of null space vectors. More...

Vec	m_null_vecs [maxVecLimit]
	Null space vectors. More...

Vec	m_null_coupled_vecs [maxVecLimit]
	Null space vectors times the coupling matrix. More...

PetscInt	m_null_vecs_N

PetscInt	m_null_vecs_N_local

Mat	m_RITRI_mat
	Matrix ${R^I}^t \cdot R^I = R^t C^t \cdot C R$ . More...

Mat	m_inv_RITRI_mat
	Matrix $inv({R^I}^t \cdot R^I)$ , used in some projectors. More...

bool	m_bUsingNullVecs
	Do we need to use the null space vectors? More...

bool	m_bNullVecsSet
	Have the null space vectors been set? More...

bool	m_bNullVecsDimensionsSet
	Have the null space vectors' dimensions been set? More...

bool	m_binvRITRIMatSet
	Have the inv(RI^T * RI) matrix been set? More...

Vec	m_u_0_micro
	Solution of the decoupled micro model. More...

Vec	m_u_0_BIG
	Solution of the decoupled macro model. More...

Vec	m_ext_solver_sol_micro
	Micro model external solver solution. More...

Vec	m_ext_solver_sol_BIG
	Macro model external solver solution. More...

Vec	m_current_residual
	Current residual vector, `r(kkk+1)` (`r(0)` for the initialization) More...

Vec	m_current_z
	Current `z(kkk+1)` (`z(0)` for the initialization) More...

Vec	m_current_p
	Current `p(kkk+1)` (`p(0)` for the initialization) More...

Vec	m_current_phi
	Current Lagrange multipliers / solution, `phi(kkk+1)` (`phi(0)` for the initialization) More...

Vec	m_current_rb_correction
	Current rigid body modes correction, `RB_corr(kkk+1)` (`RB_corr(0)` for the initialization) More...

Vec	m_previous_residual
	Previous residual vector, `r(kkk)` More...

Vec	m_previous_phi
	Previous Lagrange multipliers / solution, `phi(kkk)` More...

Vec *	m_previous_p_ptr
	Pointer to the previous `p` vectors, `p(0 ... kkk)` More...

Vec *	m_previous_q_ptr
	Pointer to the previous `q` vectors, `q(0 ... kkk)` More...

double	m_gamma
	Double containing the value of `rho(kkk) / p(kkk) . q(kkk)` More...

double	m_rho_0
	Double containing the initial `rho(0)` More...

double	m_current_rho
	Double containing the current `rho(kkk+1)` More...

double	m_current_RB_mode_corr
	Double containing the current `RB_mode_corr(kkk+1)` More...

double	m_previous_rho
	Double containing the previous `rho(kkk)` More...

double	m_previous_RB_mode_corr
	Double containing the previous `RB_mode_corr(kkk)` More...

bool	m_bSet_u_0
	Have the u_0 vectors been set? More...

bool	m_bSet_ext_solver_sol
	Have the external solvers solutions been set vectors been set? More...

bool	m_bSet_current_residual
	Have the current `r(kkk+1)` vector been set? More...

bool	m_bSet_current_z
	Have the current `z(kkk+1)` vector been set? More...

bool	m_bSet_current_p
	Have the current `p(kkk+1)` vector been set? More...

bool	m_bSet_current_phi
	Have the current Lagrange multipliers / solution `phi(kkk+1)` been set? More...

bool	m_bSet_current_RB_correction
	Have the RB modes correction `RB_corr(kkk+1)` vector been set? More...

bool	m_bSet_previous_residual
	Have the previous `r(kkk)` vector been set? More...

bool	m_bSet_previous_phi
	Have the previous Lagrange multipliers / solution `phi(kkk)` been set? More...

bool	m_bSet_previous_p_ptr
	Have the previous `p` vectors, `p(0 ... kkk)`, been set? More...

bool	m_bSet_previous_q_ptr
	Have the previous `q` vectors, `q(0 ... kkk)`, been set? More...

std::vector< double >	m_p_dot_q
	Vector containing the `p.q` scalar products. More...

bool	m_bReadPreviousScalar
	Read the previous iterations scalar data? More...

bool	m_bCalculatedScalar
	Calculated the current iterations scalar data? More...

double	m_abs_residual_conv
	Absolute residual convergence. More...

double	m_rel_residual_conv
	Relative residual convergence (relative to initial value) More...

double	m_rb_modes_conv
	Relative RB correction convergence (relative to previous value) More...

double	m_rel_residual_div
	Relative residual divergence (relative to initial value) More...

int	m_max_iter_div
	Number of iterations divergence. More...

bool	m_bConvResidualAbs
	The residual converged? (absolute) More...

bool	m_bConvResidualRel
	The residual converged? (relative to initial value) More...

bool	m_bConvRBCorrRel
	The RB correction converged? (relative to previous value) More...

bool	m_bDivResidualRel
	The residual diverged? (relative to initial value) More...

bool	m_bDivResidualNeg
	The residual is negative? (more usefull for debugging, really) More...

bool	m_bDivIter
	The number of iterations diverged? More...

bool	m_bConv
	Did the solver converge? More...

bool	m_bDiv
	Did the solver diverge? More...

Vec	m_coupled_sol_micro
	Coupled system solution for the micro model. More...

Vec	m_coupled_sol_BIG
	Coupled system solution for the macro model. More...

bool	m_bCoupled_sols_set
	Have the coupled solutions been set yet? More...

Detailed Description

Class containing the operations needed for the FETI solver.

This class is used by the several CArl_FETI programs to do operations of the FETI solver, including matrix and vector I/O and iteration operations. Due to the need to read vectors and matrices and the usage of several PETSc operations for which the libMesh interface was not implemented, direct PETSc Vec's and Mat's are used instead of their libMesh interfaces. libMesh's parallel communicators are still used, though.

To avoid any confusion involving the iteration index m_kkk, it is only changed when reading the previous iterations's scalar data, and is kept constant during an iteration - following the of Alg. 1 in the article.

This class methods' implementations are separated into three different files:

FETI_operations_setup.cpp, for setup and internal calculations (including all protected methods).
FETI_operations_operations.cpp, for FETI operations called by the CArl_FETI programs.
FETI_operations_IO.cpp, for read/write methods.

Definition at line 36 of file FETI_operations.h.

Member Enumeration Documentation

anonymous enum

protected

Enumerator
maxVecLimit

Definition at line 98 of file FETI_operations.h.

98 { maxVecLimit = 6 };

carl::FETI_Operations::maxVecLimit

Definition: FETI_operations.h:98

Constructor & Destructor Documentation

carl::FETI_Operations::FETI_Operations ( )

protected

Default constructor.

carl::FETI_Operations::FETI_Operations	(	libMesh::Parallel::Communicator &	comm,
		const std::string &	scratch_folder_path,
		const std::string &	coupling_folder_path
	)

inline

Constructor with scratch folder path, coupling matrices base filename, and libMesh communicator.

Definition at line 216 of file FETI_operations.h.

                                                                                                                                      :
         m_comm { comm },
         m_bScratchFolderSet { true },
         m_bCouplingFolderSet { true },
         m_scratch_folder_path { scratch_folder_path },
         m_coupling_folder_path { coupling_folder_path },
         m_FETI_solver_status { IterationStatus::ITERATING },
         m_kkk { 0 },
         m_C_R_micro_M { -1},
         m_C_R_micro_N { -1},
         m_C_R_micro_M_local { -1},
         m_C_R_micro_N_local { -1},
         m_C_R_BIG_M { -1},
         m_C_R_BIG_N { -1},
         m_C_R_BIG_M_local { -1},
         m_C_R_BIG_N_local { -1},
         m_C_RR_M { -1},
         m_C_RR_M_local { -1},
         m_bC_R_micro_MatrixSet  { false },
         m_bC_R_BIG_MatrixSet  { false },
         m_bC_RR_MatrixSet  { false },
         m_bCouplingMatricesSet  { false },
         m_bmicro_sizes_set { false },
         m_bBIG_sizes_set { false },
         m_bR_sizes_set { false },
         m_precond_type { BaseCGPrecondType::NO_PRECONDITIONER },
         m_RB_modes_system { RBModesSystem::MICRO },
         m_bCreatedPrecondSolver { false },
         m_bCreatedPrecondJacobiVec { false },
         m_null_nb_vecs { -1 },
         m_null_vecs_N { -1 },
         m_null_vecs_N_local { -1 },
         m_bUsingNullVecs { false },
         m_bNullVecsSet { false },
         m_bNullVecsDimensionsSet { false },
         m_binvRITRIMatSet { false }, 
         m_gamma { -1 },
         m_rho_0 { -1 },
         m_current_rho { -1 },
         m_current_RB_mode_corr { -1 },
         m_previous_rho { -1 },
         m_previous_RB_mode_corr { -1 },
         m_bSet_u_0 { false },
         m_bSet_ext_solver_sol { false },
         m_bSet_current_residual { false },
         m_bSet_current_z { false },
         m_bSet_current_p { false },
         m_bSet_current_phi { false },
         m_bSet_current_RB_correction { false },
         m_bSet_previous_residual { false },
         m_bSet_previous_phi { false },
         m_bSet_previous_p_ptr { false },
         m_bSet_previous_q_ptr { false },
         m_bReadPreviousScalar { false },
         m_bCalculatedScalar { false },
         m_abs_residual_conv { -1 },
         m_rel_residual_conv { -1 },
         m_rb_modes_conv { -1 },
         m_rel_residual_div { -1 },
         m_max_iter_div { -1 },
         m_bConvResidualAbs { false },
         m_bConvResidualRel { false },
         m_bConvRBCorrRel { false },
         m_bDivResidualRel { false },
         m_bDivResidualNeg { false },
         m_bDivIter { false },
         m_bConv { false },
         m_bDiv { false },
         m_bCoupled_sols_set {false}
     {
     };

carl::FETI_Operations::FETI_Operations	(	libMesh::Parallel::Communicator &	comm,
		const std::string &	scratch_folder_path
	)

inline

Constructor with scratch folder path and libMesh communicator.

Definition at line 289 of file FETI_operations.h.

                                                                                              :
         m_comm { comm },
         m_bScratchFolderSet { true },
         m_bCouplingFolderSet { false },
         m_scratch_folder_path { scratch_folder_path },
         m_coupling_folder_path { "" },
         m_FETI_solver_status { IterationStatus::ITERATING },
         m_kkk { 0 },
         m_C_R_micro_M { -1},
         m_C_R_micro_N { -1},
         m_C_R_micro_M_local { -1},
         m_C_R_micro_N_local { -1},
         m_C_R_BIG_M { -1},
         m_C_R_BIG_N { -1},
         m_C_R_BIG_M_local { -1},
         m_C_R_BIG_N_local { -1},
         m_C_RR_M { -1},
         m_C_RR_M_local { -1},
         m_bC_R_micro_MatrixSet  { false },
         m_bC_R_BIG_MatrixSet  { false },
         m_bC_RR_MatrixSet  { false },
         m_bCouplingMatricesSet  { false },
         m_bmicro_sizes_set { false },
         m_bBIG_sizes_set { false },
         m_bR_sizes_set { false },
         m_precond_type { BaseCGPrecondType::NO_PRECONDITIONER },
         m_RB_modes_system { RBModesSystem::MICRO },
         m_bCreatedPrecondSolver { false },
         m_bCreatedPrecondJacobiVec { false },
         m_null_nb_vecs { -1 },
         m_null_vecs_N { -1 },
         m_null_vecs_N_local { -1 },
         m_bUsingNullVecs { false },
         m_bNullVecsSet { false },
         m_bNullVecsDimensionsSet { false },
         m_binvRITRIMatSet { false }, 
         m_gamma { -1 },
         m_rho_0 { -1 },
         m_current_rho { -1 },
         m_current_RB_mode_corr { -1 },
         m_previous_rho { -1 },
         m_previous_RB_mode_corr { -1 },
         m_bSet_u_0 { false },
         m_bSet_ext_solver_sol { false },
         m_bSet_current_residual { false },
         m_bSet_current_z { false },
         m_bSet_current_p { false },
         m_bSet_current_phi { false },
         m_bSet_current_RB_correction { false },
         m_bSet_previous_residual { false },
         m_bSet_previous_phi { false },
         m_bSet_previous_p_ptr { false },
         m_bSet_previous_q_ptr { false },
         m_bReadPreviousScalar { false },
         m_bCalculatedScalar { false },
         m_abs_residual_conv { -1 },
         m_rel_residual_conv { -1 },
         m_rb_modes_conv { -1 },
         m_rel_residual_div { -1 },
         m_max_iter_div { -1 },
         m_bConvResidualAbs { false },
         m_bConvResidualRel { false },
         m_bConvRBCorrRel { false },
         m_bDivResidualRel { false },
         m_bDivResidualNeg { false },
         m_bDivIter { false },
         m_bConv { false },
         m_bDiv { false },
         m_bCoupled_sols_set {false}
     {
     };

carl::FETI_Operations::~FETI_Operations ( )

inline

Destructor, deallocates the PETSc.

Definition at line 362 of file FETI_operations.h.

     {
         this->clear_PETSc();
     };

Member Function Documentation

void carl::FETI_Operations::apply_inverse_coupling_precond	(	Vec	vec_in,
		Vec	vec_out
	)

protected

Apply the full inversed coupling matrix preconditioner.

Definition at line 57 of file FETI_operations_setup.cpp.

 {
     homemade_assert_msg(m_bCreatedPrecondSolver,"Preconditioner system not set yet!");
     KSPSolve(m_coupling_precond_solver, vec_in, vec_out);
 }

void carl::FETI_Operations::apply_jacobi_coupling_precond	(	Vec	vec_in,
		Vec	vec_out
	)

protected

Apply the Jacobi coupling matrix preconditioner vector.

Definition at line 63 of file FETI_operations_setup.cpp.

 {   
     homemade_assert_msg(m_bCreatedPrecondJacobiVec,"Preconditioner vector not set yet!");
     VecPointwiseMult(vec_out, m_coupling_jacobi_precond_vec, vec_in);
 }

void carl::FETI_Operations::apply_precond	(	Vec	vec_in,
		Vec	vec_out
	)

protected

Common interface to the preconditionners.

Definition at line 69 of file FETI_operations_setup.cpp.

 {   
     switch (m_precond_type)
     {
         case BaseCGPrecondType::NO_PRECONDITIONER : 
                 // Shouldn't call this function in this case
                 homemade_error_msg("No preconditioner to be applied!");
                 break;
 
         case BaseCGPrecondType::COUPLING_OPERATOR : 
                 this->apply_inverse_coupling_precond(vec_in, vec_out);
                 break;
 
         case BaseCGPrecondType::COUPLING_JACOBI :
                 this->apply_jacobi_coupling_precond(vec_in, vec_out);
                 break;
         default :
                 // Undefined preconditioner
                 homemade_error_msg("Undefined preconditioner");
     }
 }

void carl::FETI_Operations::apply_RB_projection	(	Vec	vec_in,
		Vec	vec_out
	)

protected

Apply the rigid body modes projection operation.

Definition at line 91 of file FETI_operations_setup.cpp.

 {
     homemade_assert_msg(m_bNullVecsSet,"Null space vectors not set yet!");
     homemade_assert_msg(m_binvRITRIMatSet,"Null space matrices not set yet!");
 
     // vec_out = [ I - RC * (inv_RITRI_mat) * RC^t ] * vec_in
 
     // Declaration of Vecs with size 'm_null_nb_vecs'
     Vec dummy_seq_vec;
     Vec dummy_seq_vec_bis;
     VecCreateSeq(PETSC_COMM_SELF,m_null_nb_vecs,&dummy_seq_vec);
     VecZeroEntries(dummy_seq_vec);
     VecDuplicate(dummy_seq_vec,&dummy_seq_vec_bis);
 
     // dummy_seq_vec = RC^t * vec_in
     // -> All the communications are done here!
     PetscScalar *dummy_seq_array;
     VecGetArray(dummy_seq_vec,&dummy_seq_array);
     VecMDot(vec_in,m_null_nb_vecs,m_null_coupled_vecs,dummy_seq_array);
     VecRestoreArray(dummy_seq_vec,&dummy_seq_array);
 
     // dummy_seq_vec_bis = - inv_RITRI_mat * dummy_seq_vec
     // -> Calculate dummy_seq_vec_bis on the first proc, and then broadcast the value
     
     /*    
      *    Originally, this operation was done locally, but due to a syncing issue,
      *    we have to do it this way to avoid a "Value must the same in all processors" error
      *    when calling VecMAXPY below.
      */ 
     PETSC_MatMultScale_Bcast(m_inv_RITRI_mat,dummy_seq_vec,dummy_seq_vec_bis,-1);
 
     m_comm.barrier();
 
     // vec_out = vec_in + sum ( dummy_seq_vec_bis[i] * vec_RC[i])
     // -> This should have no communications at all!
     VecCopy(vec_in,vec_out);
     
     VecGetArray(dummy_seq_vec_bis,&dummy_seq_array);
     VecMAXPY(vec_out,m_null_nb_vecs,dummy_seq_array,m_null_coupled_vecs);
     VecRestoreArray(dummy_seq_vec_bis,&dummy_seq_array);
 
     // Cleanup
     VecDestroy(&dummy_seq_vec);
     VecDestroy(&dummy_seq_vec_bis);
 }

void carl::FETI_Operations::calculate_coupled_solution ( )

Calculate the final coupled solution.

Definition at line 363 of file FETI_operations_operations.cpp.

 {
     homemade_assert_msg(m_bSet_ext_solver_sol,"Ext. solver solutions not set yet!");
     homemade_assert_msg(m_bSet_u_0,"Decoupled solution not set yet!");
     homemade_assert_msg(m_bSet_current_RB_correction && m_bUsingNullVecs,"RB modes correction not set yet!");
 
     // Set the solution vectors
     VecDuplicate(m_u_0_micro,&m_coupled_sol_micro);
     VecDuplicate(m_u_0_BIG,&m_coupled_sol_BIG);
 
     // u_1 = - x_1(FINAL) + u_0,1 
     VecWAXPY(m_coupled_sol_BIG,-1,m_ext_solver_sol_BIG,m_u_0_BIG);
 
     // u_2 =   x_2(FINAL) + u_0,2 
     VecWAXPY(m_coupled_sol_micro,1,m_ext_solver_sol_micro,m_u_0_micro);
 
     // Add rigid body modes correction, if needed
     if(m_bUsingNullVecs)
     {
         switch (m_RB_modes_system)
         {
             case RBModesSystem::MACRO :
                             VecAXPY(m_coupled_sol_BIG,1,m_current_rb_correction);
                             break;
 
             case RBModesSystem::MICRO :
                             VecAXPY(m_coupled_sol_micro,1,m_current_rb_correction);
                             break;
         }
     }
     
     // Set flags
     m_bCoupled_sols_set = true;
 }

void carl::FETI_Operations::calculate_initial_p ( )

Calculate the initial p(0) vector.

Definition at line 78 of file FETI_operations_operations.cpp.

 {
     // `p(0)` is identical to `z(0)`, so just calculate the latter
     this->calculate_z();
 }

void carl::FETI_Operations::calculate_initial_r ( )

Calculate the inital residual vector, r(0)

Definition at line 84 of file FETI_operations_operations.cpp.

 {
     /*
      *      If m_bUsingNullVecs == true :
      *          r(0) = ( C_1 * u_1,0 - C_2 * u_2,0 ) - C_1 * x_1(0) - C_2 * x_2(0)
      *
      *      eles
      *          r(0) = ( C_1 * u_1,0 - C_2 * u_2,0 )
      */
 
     // Common asserts
     homemade_assert_msg(m_bC_R_micro_MatrixSet,"Micro coupling matrix not set yet!");
     homemade_assert_msg(m_bC_R_BIG_MatrixSet,"Macro coupling matrix not set yet!");
     homemade_assert_msg(m_bC_R_micro_MatrixSet,"Micro system dimensions not set yet!");
     homemade_assert_msg(m_bC_R_BIG_MatrixSet,"Macro system dimensions not set yet!");
     homemade_assert_msg(m_bSet_u_0,"Decoupled solution not set yet!");
 
     // Assert for only m_bUsingNullVecs == true
     homemade_assert_msg(m_bSet_ext_solver_sol && m_bUsingNullVecs,"Ext. solver solutions not set yet!");
 
     // Create the vector
     VecCreate(m_comm.get(),&m_current_residual);
     VecSetSizes(m_current_residual,m_C_RR_M_local,m_C_RR_M);
     VecSetFromOptions(m_current_residual);
 
     // - C_2 * u_0,2
     MatMult(m_C_R_micro,m_u_0_micro,m_current_residual);
     VecScale(m_current_residual,-1);
 
     // C_1 * u_0,1
     // --> r(0) = ( C_1 * u_0,1 - C_2 * u_0,2 )
     MatMultAdd(m_C_R_BIG,m_u_0_BIG,m_current_residual,m_current_residual);
     
     if(m_bUsingNullVecs)
     {
         Vec dummy_vec;
         VecDuplicate(m_current_residual,&dummy_vec);
 
         // C_1 * x_1(0)
         MatMult(m_C_R_BIG,m_ext_solver_sol_BIG,dummy_vec);
 
         // C_2 * x_2(0)
         MatMultAdd(m_C_R_micro,m_ext_solver_sol_micro,dummy_vec,dummy_vec);
 
         // --> r(0) = ( C_1 * u_1,0 - C_2 * u_2,0 ) - C_1 * x_1(0) - C_2 * x_2(0)
         VecAXPY(m_current_residual,-1,dummy_vec);
         VecDestroy(&dummy_vec);
     }
 
     // Set flag
     m_bSet_current_residual = true;
 }

void carl::FETI_Operations::calculate_null_space_phi_0 ( const std::string & force_path )

Calculate the inital solution, $\phi_0$ .

Definition at line 6 of file FETI_operations_operations.cpp.

 {
     //  phi0 = - RC * (inv_RITRI_mat) * R^t* Force
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bNullVecsSet,"Null space vectors not set yet!");
     homemade_assert_msg(m_binvRITRIMatSet,"Null space matrices not set yet!");
     homemade_assert_msg(m_bC_R_micro_MatrixSet,"Micro coupling matrix not set yet!");
     homemade_assert_msg(m_bC_R_BIG_MatrixSet,"Macro coupling matrix not set yet!");
 
     // --- Declare / create the vectors
     // phi(0)
     VecCreate(m_comm.get(),&m_current_phi);
     VecSetSizes(m_current_phi,m_C_RR_M_local,m_C_RR_M);
     VecSetFromOptions(m_current_phi);
 
     // Force vector
     Vec vec_force_PETSc;
     VecCreate(m_comm.get(),&vec_force_PETSc);
     read_PETSC_vector(vec_force_PETSc,force_path,m_comm.get());
 
     // Create the local auxiliary vectors
     Vec aux_null_vec_input;
     Vec aux_null_vec_output;
 
     VecCreateSeq(PETSC_COMM_SELF,m_null_nb_vecs,&aux_null_vec_input);
     VecCreateSeq(PETSC_COMM_SELF,m_null_nb_vecs,&aux_null_vec_output);
 
     VecZeroEntries(aux_null_vec_input);
     VecZeroEntries(aux_null_vec_output);
 
     // aux_vec_input = R^t * vec_force
     // -> All the communications are done here!
     // Cannot use VecMDot because "m_null_vecs" is a constant pointer ...
     PetscScalar *dummy_array_input;
     VecGetArray(aux_null_vec_input,&dummy_array_input);
     for(int iii = 0; iii < m_null_nb_vecs; ++iii)
     {
         VecDot(vec_force_PETSc,m_null_vecs[iii],&dummy_array_input[iii]);
     }
     VecRestoreArray(aux_null_vec_input,&dummy_array_input);
 
     // aux_vec_output = inv_RITRI_mat * aux_vec_input
         // -> Calculate aux_vec_output on the first proc, and then broadcast the value
         /*    
          *    Originally, this operation was done locally, but due to a syncing issue,
          *    we have to do it this way to avoid a "Value must the same in all processors" error
          *    when calling VecMAXPY below.
          */
         PETSC_MatMultScale_Bcast(m_inv_RITRI_mat,aux_null_vec_input,aux_null_vec_output,1);
 
     m_comm.barrier();
     
     // -> This should have no communications at all!
     VecZeroEntries(m_current_phi);
 
     PetscScalar *dummy_array_output;
     VecGetArray(aux_null_vec_output,&dummy_array_output);
     VecMAXPY(m_current_phi,m_null_nb_vecs,dummy_array_output,m_null_coupled_vecs);
     VecRestoreArray(aux_null_vec_output,&dummy_array_output);
 
     VecScale(m_current_phi,-1);
 
     // Cleanup
     VecDestroy(&vec_force_PETSc);
     VecDestroy(&aux_null_vec_input);
     VecDestroy(&aux_null_vec_output);
 
     // Set flags
     m_bSet_current_phi = true;
 }

void carl::FETI_Operations::calculate_p ( )

Calculate the current p(kkk+1) vector.

Definition at line 137 of file FETI_operations_operations.cpp.

 {
     homemade_assert_msg(m_bSet_current_z,"Current 'z' not calculated yet!");
     homemade_assert_msg(m_bSet_previous_p_ptr,"'p' vectors not set yet!");
     homemade_assert_msg(m_bSet_previous_q_ptr,"'q' vectors not set yet!");
 
     // p(kkk+1) = z(kkk+1) + \sum ( beta(iii) * p(iii) ), iii = 0 ... kkk
     // beta(iii) = - z(kkk+1).q(iii) / p(iii).q(iii)
     // For simplicity, the signal was included in 'beta' - WATCH OUT FOR THE SIGNAL!
     std::vector<PetscScalar> beta(m_kkk+1,0);
     VecMDot(m_current_z,m_kkk+1,m_previous_q_ptr,beta.data());
     for(int iii = 0; iii < m_kkk+1; ++iii)
     {
         beta[iii] = - beta[iii] / m_p_dot_q[iii];
     }
 
     // p(kkk+1) = z(kkk+1)
     VecDuplicate(m_current_z,&m_current_p);
     VecCopy(m_current_z,m_current_p);
 
     // p(kkk+1) = z(kkk+1) + \sum ( beta(iii) * p(iii) )
     VecMAXPY(m_current_p,m_kkk+1,beta.data(),m_previous_p_ptr);
 
     m_bSet_current_p = true;
 }

void carl::FETI_Operations::calculate_phi ( )

Calculate the current phi(kkk+1) solution vector.

Definition at line 266 of file FETI_operations_operations.cpp.

 {
     homemade_assert_msg(m_bSet_previous_p_ptr,"'p' vectors not set yet!");
     homemade_assert_msg(m_bSet_previous_q_ptr,"'q' vectors not set yet!");
     homemade_assert_msg(m_bSet_previous_phi,"Previous 'phi' not set yet!");
 
     // Calculate 'phi(kkk + 1) = phi(kkk) + gamma * p(kkk)'
 
     // gamma = rho(kkk) / ( p(kkk).q(kkk) )
     VecDot(m_previous_p_ptr[m_kkk],m_previous_q_ptr[m_kkk],&m_p_dot_q[m_kkk]);
     m_gamma = m_previous_rho / m_p_dot_q[m_kkk];
 
     // phi(kkk + 1) = phi(kkk) + gamma * p(kkk)
     VecDuplicate(m_previous_phi,&m_current_phi);
     VecWAXPY(m_current_phi,m_gamma,m_previous_p_ptr[m_kkk],m_previous_phi);
 
     m_bSet_current_phi = true;
 }

void carl::FETI_Operations::calculate_q ( )

Calculate the current q(kkk) vector.

Definition at line 163 of file FETI_operations_operations.cpp.

 {
     homemade_assert_msg(m_bC_R_micro_MatrixSet,"Micro coupling matrix not set yet!");
     homemade_assert_msg(m_bC_R_BIG_MatrixSet,"Macro coupling matrix not set yet!");
     homemade_assert_msg(m_bSet_ext_solver_sol,"Ext. solver solutions not set yet!");
     homemade_assert_msg(m_bSet_previous_q_ptr,"'q' vectors not set yet!");
 
     // q(kkk) = C_1 * x_1(kkk) + C_2 * x_2(kkk)
     MatMult(m_C_R_BIG,m_ext_solver_sol_BIG,m_previous_q_ptr[m_kkk]);
     MatMultAdd(m_C_R_micro,m_ext_solver_sol_micro,m_previous_q_ptr[m_kkk],m_previous_q_ptr[m_kkk]);
 }

void carl::FETI_Operations::calculate_r ( )

Calculate the current r(kkk+1) residual vector.

Definition at line 175 of file FETI_operations_operations.cpp.

 {
     homemade_assert_msg(m_bSet_previous_q_ptr,"'q' vectors not set yet!");
     homemade_assert_msg(m_bSet_previous_residual,"Previous 'r' not set yet!");
     homemade_assert_msg(m_bSet_current_phi,"Current 'phi' not set yet!");
     // Last assert is needed to guarantee that 'm_p_dot_q(kkk)' has been calculated
 
     // Calculate 'r(kkk + 1) = r(kkk) - gamma * q(kkk)'
 
     double dummy_double = - m_gamma;
     VecDuplicate(m_previous_residual,&m_current_residual);
     VecWAXPY(m_current_residual,dummy_double,m_previous_q_ptr[m_kkk],m_previous_residual);
 
     m_bSet_current_residual = true;
 }

void carl::FETI_Operations::calculate_rb_correction ( )

Calculate the rigid body modes corrections.

Definition at line 285 of file FETI_operations_operations.cpp.

 {
     homemade_assert_msg(m_bNullVecsSet,"Null space vectors not set yet!");
     homemade_assert_msg(m_bSet_current_residual,"Current residual not calculated yet!");
 
     // Declare and create vectors
     Vec dummy_seq_vec;
     Vec dummy_seq_vec_bis;
     VecCreateSeq(PETSC_COMM_SELF,m_null_nb_vecs,&dummy_seq_vec);
     VecZeroEntries(dummy_seq_vec);
     VecDuplicate(dummy_seq_vec,&dummy_seq_vec_bis);
 
     VecDuplicate(m_null_vecs[0],&m_current_rb_correction);
     VecZeroEntries(m_current_rb_correction);
 
     // m_current_rb_correction = R * (inv_RITRI_mat) * RC^t * m_current_residual
 
     // dummy_seq_vec = RC^t * m_current_residual
     // -> All the communications are done here!
     PetscScalar *dummy_seq_array;
     VecGetArray(dummy_seq_vec,&dummy_seq_array);
     VecMDot(m_current_residual,m_null_nb_vecs,m_null_coupled_vecs,dummy_seq_array);
 
     VecRestoreArray(dummy_seq_vec,&dummy_seq_array);
 
     // dummy_seq_vec_bis = inv_RITRI_mat * dummy_seq_vec
         /*    
          *    Originally, this operation was done locally, but due to a syncing issue,
          *    we have to do it this way to avoid a "Value must the same in all processors" error
          *    when calling VecMAXPY below.
          */
         PETSC_MatMultScale_Bcast(m_inv_RITRI_mat,dummy_seq_vec,dummy_seq_vec_bis,1);
 
     m_comm.barrier();
 
     // m_current_rb_correction = sum ( dummy_seq_vec_bis[i] * m_null_vecs[i])
     // -> This should have no communications at all!
     VecGetArray(dummy_seq_vec_bis,&dummy_seq_array);
     VecMAXPY(m_current_rb_correction,m_null_nb_vecs,dummy_seq_array,m_null_vecs);
     VecRestoreArray(dummy_seq_vec_bis,&dummy_seq_array);
 
     // Cleanup
     VecDestroy(&dummy_seq_vec);
     VecDestroy(&dummy_seq_vec_bis);
 
     // Set flag
     m_bSet_current_RB_correction = true;
 }

void carl::FETI_Operations::calculate_scalar_data ( )

Calculate the scalar quantities.

Definition at line 334 of file FETI_operations_operations.cpp.

 {
     homemade_assert_msg(m_bSet_current_residual,"Current residual not calculated yet!");
     homemade_assert_msg(m_bSet_current_z,"Current 'z' not calculated yet!");
     if(m_bUsingNullVecs)
     homemade_assert_msg(m_bSet_current_RB_correction && m_bUsingNullVecs,"Current RB modes correction not calculated yet!");
 
     // --- Calculate the values
     // rho(kkk+1)
     if(m_precond_type != BaseCGPrecondType::NO_PRECONDITIONER || m_bUsingNullVecs)
     {
         VecDot(m_current_residual,m_current_z,&m_current_rho);
     } else {
         VecDot(m_current_residual,m_current_residual,&m_current_rho);
     }
 
     // RB_corr(kkk+1)
     if(m_bUsingNullVecs)
     {
         VecNorm(m_current_rb_correction,NORM_2,&m_current_RB_mode_corr);
     }
 
     // gamma(kkk)
     VecDot(m_previous_p_ptr[m_kkk],m_previous_q_ptr[m_kkk],&m_p_dot_q[m_kkk]);
 
     // Set flags
     m_bCalculatedScalar = true;
 }

void carl::FETI_Operations::calculate_z ( )

Calculate the current z(kkk+1) vector.

Definition at line 191 of file FETI_operations_operations.cpp.

 {
     /*  
      *  Four possibilities:
      *   - m_bUsingNullVecs == false
      *     m_precond_type == BaseCGPrecondType::NO_PRECONDITIONER
      *     -> m_current_z = m_current_residual
      *
      *   - m_bUsingNullVecs == false
      *     m_precond_type != BaseCGPrecondType::NO_PRECONDITIONER
      *     -> m_current_z = M_PC^-1 * m_current_residual
      *
      *   - m_bUsingNullVecs == true
      *     m_precond_type == BaseCGPrecondType::NO_PRECONDITIONER
      *     -> m_current_z = M_proj * m_current_residual
      *
      *   - m_bUsingNullVecs == true
      *     m_precond_type != BaseCGPrecondType::NO_PRECONDITIONER
      *     -> m_current_z = M_proj * M_PC^-1 * M_proj * m_current_residual
      */
 
     homemade_assert_msg((m_precond_type != BaseCGPrecondType::NO_PRECONDITIONER) && m_bC_RR_MatrixSet,"Preconditioner matrix not set yet!");
     homemade_assert_msg(m_bSet_current_residual,"Current residual not calculated yet!");
 
     if(m_bUsingNullVecs)
     {
         // Use projections!
         if(m_precond_type != BaseCGPrecondType::NO_PRECONDITIONER)
         {
             // -> m_current_z = M_proj * M_PC^-1 * M_proj * m_current_residual
             VecDuplicate(m_current_residual,&m_current_z);
 
             Vec dummy_vec, dummy_vec_bis;
             VecDuplicate(m_current_residual,&dummy_vec);
             VecDuplicate(m_current_residual,&dummy_vec_bis);
 
             // dummy_vec = M_proj * m_current_residual
             this->apply_RB_projection(m_current_residual,dummy_vec);
 
             // dummy_vec_bis =  M_PC^-1 * dummy_vec
             this->apply_precond(dummy_vec,dummy_vec_bis);
 
             // m_current_z = M_proj * dummy_vec_bis
             this->apply_RB_projection(dummy_vec_bis,m_current_z);
 
             VecDestroy(&dummy_vec);
             VecDestroy(&dummy_vec_bis);
 
             // Set flag
             m_bSet_current_z = true;
         }
         else
         {
             // -> m_current_z = M_proj * m_current_residual
             VecDuplicate(m_current_residual,&m_current_z);
 
             this->apply_RB_projection(m_current_residual,m_current_z);
             m_bSet_current_z = true;
         }
     }
     else
     {
         // Do not use projections!
         if(m_precond_type != BaseCGPrecondType::NO_PRECONDITIONER)
         {
             // -> m_current_z = M_PC^-1 * m_current_residual
             VecDuplicate(m_current_residual,&m_current_z);
 
             this->apply_precond(m_current_residual,m_current_z);
             m_bSet_current_z = true;
         }
         // else, m_current_z = m_current_residual -> DO NOTHING!
     }
 }

IterationStatus carl::FETI_Operations::check_convergence	(	double	rel_residual_conv,
		double	abs_residual_conv,
		int	max_iter_div,
		double	rel_residual_div,
		double	rb_modes_conv = `-1`
	)

Check the convergence.

Definition at line 398 of file FETI_operations_operations.cpp.

 {
     homemade_assert_msg(m_bCalculatedScalar,"Scalar quantities not calculated yet!");
 
     m_abs_residual_conv = abs_residual_conv;
     m_rel_residual_conv = rel_residual_conv;
     m_rb_modes_conv = rb_modes_conv;
     m_rel_residual_div = rel_residual_div;
     m_max_iter_div = max_iter_div;
 
     // Check the iteration divergence
     if(m_kkk == m_max_iter_div) // Iteration divergence
     {
         m_bDivIter = true;
     }
 
     // Check the residual convergence / divergence
     if(m_current_rho > 0)
     {
         // Check the residual convergence
         if(m_current_rho < m_abs_residual_conv) // Absolute convergence
         {
             m_bConvResidualAbs = true;
         }
 
         if(m_current_rho < m_rel_residual_conv * m_rho_0) // Relative convergence
         {
             m_bConvResidualRel = true;
         }
 
         // Check the residual divergence
         if(m_current_rho > m_rel_residual_div * m_rho_0) // Relative divergence
         {
             m_bDivResidualRel = true;
         }
     } else {
         // There's something wrong ...
         m_bDivResidualNeg = true;
     } 
 
     // Check the rigid body modes correction convergence
     if(m_bUsingNullVecs)
     {
         if(std::abs(m_current_RB_mode_corr - m_previous_RB_mode_corr)/m_current_RB_mode_corr < m_rb_modes_conv) // Correction convergence
         {
             m_bConvRBCorrRel = true;
         }
     } else {
         // Short-circuit this boolean
         m_bConvRBCorrRel = true;
     }
 
     // Possible cases:
     // - Any diverged flag is true: diverged!
     // - Both the RB modes correction AND one of the residual convergence flags are true: converged!
     // - All flags false: continue iterating!
 
     m_bConv = ( m_bConvResidualAbs || m_bConvResidualRel ) && m_bConvRBCorrRel;
     m_bDiv = m_bDivResidualNeg || m_bDivResidualRel || m_bDivIter;
 
     IterationStatus output_status = IterationStatus::ITERATING;
     if(m_bDiv) {
         output_status = IterationStatus::DIVERGED;
     } else if(m_bConv) {
         output_status = IterationStatus::CONVERGED;
     } else {
         output_status = IterationStatus::ITERATING;
     }
 
     return output_status;
 }

void carl::FETI_Operations::clear_PETSc ( )

protected

PETSc Vec and Mat deallocation, called by the destructor.

Definition at line 167 of file FETI_operations_setup.cpp.

 {
     if(m_bC_R_BIG_MatrixSet)
         MatDestroy(&m_C_R_BIG);
     if(m_bC_R_micro_MatrixSet)
         MatDestroy(&m_C_R_micro);
     if(m_bC_RR_MatrixSet)
         MatDestroy(&m_C_RR);
     if(m_bNullVecsSet)
     {
         for(int iii = 0; iii < m_null_nb_vecs; ++iii)
             VecDestroy(&m_null_vecs[iii]);
     }
     if(m_binvRITRIMatSet)
     {
         MatDestroy(&m_inv_RITRI_mat);
     }
     if(m_bSet_u_0)
     {
         VecDestroy(&m_u_0_BIG);
         VecDestroy(&m_u_0_micro);   
     }
     if(m_bSet_ext_solver_sol)
     {
         VecDestroy(&m_ext_solver_sol_BIG);
         VecDestroy(&m_ext_solver_sol_micro);    
     }
     if(m_bSet_current_phi)
     {
         VecDestroy(&m_current_phi);
     }
     if(m_bSet_current_residual)
     {
         VecDestroy(&m_current_residual);
     }
     if(m_bCreatedPrecondSolver)
     {
         KSPDestroy(&m_coupling_precond_solver);
     }
     if(m_bCreatedPrecondJacobiVec)
     {
         VecDestroy(&m_coupling_jacobi_precond_vec);
     }
     if(m_bSet_current_RB_correction)
     {
         VecDestroy(&m_current_rb_correction);
     }
     if(m_bSet_previous_residual)
     {
         VecDestroy(&m_previous_residual);
     }
     if(m_bSet_previous_phi)
     {
         VecDestroy(&m_previous_phi);
     }
     if(m_bSet_previous_p_ptr)
     {
         VecDestroyVecs(m_kkk+1,&m_previous_p_ptr);
         delete[] m_previous_p_ptr;
     }
     if(m_bSet_previous_q_ptr)
     {
         VecDestroyVecs(m_kkk+1,&m_previous_q_ptr);
         delete[] m_previous_q_ptr;
     }
     if(m_bCoupled_sols_set)
     {
         VecDestroy(&m_coupled_sol_micro);
         VecDestroy(&m_coupled_sol_BIG);
     }
 }

void carl::FETI_Operations::export_coupled_solution ( std::string output_base )

Definition at line 764 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bCoupled_sols_set,"Coupled solutions not calculated yet!");
 
     write_PETSC_vector(m_coupled_sol_BIG,output_base + "/coupled_sol_A.petscvec",m_comm.rank(),m_comm.get());
     write_PETSC_vector(m_coupled_sol_micro,output_base + "/coupled_sol_B.petscvec",m_comm.rank(),m_comm.get());
 
 // Print MatLab debugging output? Variable defined at "carl_headers.h"
 #ifdef PRINT_MATLAB_DEBUG
     write_PETSC_vector_MATLAB(m_coupled_sol_BIG,output_base + "/coupled_sol_A.m",m_comm.get());
     write_PETSC_vector_MATLAB(m_coupled_sol_micro,output_base + "/coupled_sol_B.m",m_comm.get());
 #endif
 }

void carl::FETI_Operations::export_ext_solver_rhs ( Vec vec_in )

protected

Calculate and export the external solver RHS's.

Definition at line 137 of file FETI_operations_setup.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
 
     Vec vec_C_micro_t_p_kkk_PETSc;
     VecCreate(m_comm.get(),&vec_C_micro_t_p_kkk_PETSc);
     VecSetSizes(vec_C_micro_t_p_kkk_PETSc,m_C_R_micro_N_local,m_C_R_micro_N);
     VecSetFromOptions(vec_C_micro_t_p_kkk_PETSc);
 
     Vec vec_C_BIG_t_p_kkk_PETSc;
     VecCreate(m_comm.get(),&vec_C_BIG_t_p_kkk_PETSc);
     VecSetSizes(vec_C_BIG_t_p_kkk_PETSc,m_C_R_BIG_N_local,m_C_R_BIG_N);
     VecSetFromOptions(vec_C_BIG_t_p_kkk_PETSc);
 
     MatMultTranspose(m_C_R_micro,vec_in,vec_C_micro_t_p_kkk_PETSc);
     MatMultTranspose(m_C_R_BIG,vec_in,vec_C_BIG_t_p_kkk_PETSc);
 
     write_PETSC_vector(vec_C_BIG_t_p_kkk_PETSc,m_scratch_folder_path + "/ext_solver_A_rhs.petscvec",m_comm.rank(),m_comm.get());
     write_PETSC_vector(vec_C_micro_t_p_kkk_PETSc,m_scratch_folder_path + "/ext_solver_B_rhs.petscvec",m_comm.rank(),m_comm.get());
 
 // Print MatLab debugging output? Variable defined at "carl_headers.h"
 #ifdef PRINT_MATLAB_DEBUG
     write_PETSC_vector_MATLAB(vec_C_micro_t_p_kkk_PETSc,m_scratch_folder_path + "/ext_solver_B_rhs.m",m_comm.get());
     write_PETSC_vector_MATLAB(vec_C_BIG_t_p_kkk_PETSc,m_scratch_folder_path + "/ext_solver_A_rhs.m",m_comm.get());
 #endif
 
     VecDestroy(&vec_C_micro_t_p_kkk_PETSc);
     VecDestroy(&vec_C_BIG_t_p_kkk_PETSc);
 }

void carl::FETI_Operations::export_ext_solver_rhs_Ct_p ( )

Calculate and export the external solver RHS's for the next iteration.

Definition at line 510 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
 
     homemade_assert_msg(m_bSet_current_p,"Current 'p' not calculated yet!");
     this->export_ext_solver_rhs(m_current_p);
 }

void carl::FETI_Operations::export_ext_solver_rhs_Ct_phi ( )

Calculate and export the external solver RHS's for the decoupled problem.

Definition at line 526 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bSet_current_phi,"Current 'phi' not calculated yet!");
 
     this->export_ext_solver_rhs(m_current_phi);
 }

void carl::FETI_Operations::export_ext_solver_rhs_initial ( )

Calculate and export the external solver RHS's for the first iteration.

Definition at line 518 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
 
     homemade_assert_msg(m_bSet_current_z,"Current 'p' not calculated yet!");
     this->export_ext_solver_rhs(m_current_z);
 }

void carl::FETI_Operations::export_inital_vecs ( )

Export the initial iteration vectors, r(0) and p(0)

Definition at line 600 of file FETI_operations_IO.cpp.

 {
     // Export r(0) and p(0) ( p(0) is identical to z(0))
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bSet_current_residual,"Current residual not calculated yet!");
 
     // In all cases, print r(0)
     write_PETSC_vector(m_current_residual,m_scratch_folder_path + "/FETI_iter__r__current.petscvec",m_comm.rank(),m_comm.get());
 
 // Print MatLab debugging output? Variable defined at "carl_headers.h"
 #ifdef PRINT_MATLAB_DEBUG
     write_PETSC_vector_MATLAB(m_current_residual,m_scratch_folder_path + "/FETI_iter__r__current.m",m_comm.get());
 #endif
 
     // p(0) is only identical to r(0) if neither a preconditioner or the RB modes are used
     if(m_precond_type != BaseCGPrecondType::NO_PRECONDITIONER || m_bUsingNullVecs)
     {
         write_PETSC_vector(m_current_z,m_scratch_folder_path + "/FETI_iter__p__0.petscvec",m_comm.rank(),m_comm.get());
 
 // Print MatLab debugging output? Variable defined at "carl_headers.h"
 #ifdef PRINT_MATLAB_DEBUG
         write_PETSC_vector_MATLAB(m_current_z,m_scratch_folder_path + "/FETI_iter__p__0.m",m_comm.get());
 #endif
     }
 }

void carl::FETI_Operations::export_initial_scalar_data ( )

Export the initial iteration scalar data, rho(0) and | RB_corr(0) |

Definition at line 626 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
 
 
     homemade_assert_msg(m_bSet_current_residual,"Current residual not calculated yet!");
     PetscScalar residual = 0;
     PetscScalar RB_correct = 0;
 
     if(m_bUsingNullVecs)
     {
         homemade_assert_msg(m_bSet_current_RB_correction,"Current RB modes correction not calculated yet!");
     }
 
     // --- Calculate the values
     // rho(0)
     if(m_precond_type != BaseCGPrecondType::NO_PRECONDITIONER || m_bUsingNullVecs)
     {
         VecDot(m_current_residual,m_current_z,&residual);
     } else {
         VecDot(m_current_residual,m_current_residual,&residual);
     }
 
     // RB_corr(0)
     if(m_bUsingNullVecs)
     {
         VecNorm(m_current_rb_correction,NORM_2,&RB_correct);
     }
 
     // ONLY write in proc 0!
     if(m_comm.rank() == 0)
     {
         std::ofstream scalar_data;
 
         // Export the scalar data
         scalar_data.open(m_scratch_folder_path + "/FETI_iter_scalar_data.dat");
         scalar_data.precision(15);
         scalar_data << m_kkk << " " << residual << " " << residual;
 
         if(m_bUsingNullVecs)
         {
             scalar_data <<  " " << RB_correct;
         }
 
         scalar_data << std::endl;
 
         scalar_data.close();
 
         // Export the convergence data
         scalar_data.open(m_scratch_folder_path + "/FETI_convergence.dat");
         scalar_data.precision(15);
         scalar_data << m_kkk << " " << residual;
 
         if(m_bUsingNullVecs)
         {
             scalar_data <<  " " << RB_correct;
         }
 
         scalar_data << std::endl;
 
         scalar_data.close();
     }
 }

void carl::FETI_Operations::export_iter_vecs ( )

Definition at line 742 of file FETI_operations_IO.cpp.

 {
     /* Export the iteration vectors
      * Vectors to export: 'r(kkk+1)'
      *                    'phi(kkk+1)'
      *                    'p(kkk+1)'
      *                    'q(kkk)'
      */
 
     // r(kkk+1)
     this->export_r();
 
     // phi(kkk+1)
     this->export_phi();
 
     // p(kkk+1)
     this->export_p();
 
     // q(kkk)
     this->export_q();
 }

void carl::FETI_Operations::export_p ( )

Export the current p(kkk+1) vector.

Definition at line 548 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bSet_current_p,"Current 'p' not calculated yet!");
 
     write_PETSC_vector(m_current_p,m_scratch_folder_path + "/FETI_iter__p__" + std::to_string(m_kkk+1) + ".petscvec",m_comm.rank(),m_comm.get());
 
 // Print MatLab debugging output? Variable defined at "carl_headers.h"
 #ifdef PRINT_MATLAB_DEBUG
     write_PETSC_vector_MATLAB(m_current_p,m_scratch_folder_path + "/FETI_iter__p__" + std::to_string(m_kkk+1) + ".m",m_comm.get());
 #endif
 }

void carl::FETI_Operations::export_phi ( )

Export the current Lagrange multiplier / solution.

Definition at line 587 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bSet_current_phi,"Current 'phi' not calculated yet!");
 
     write_PETSC_vector(m_current_phi,m_scratch_folder_path + "/FETI_iter__phi__current.petscvec",m_comm.rank(),m_comm.get());
 
 // Print MatLab debugging output? Variable defined at "carl_headers.h"
 #ifdef PRINT_MATLAB_DEBUG
     write_PETSC_vector_MATLAB(m_current_phi,m_scratch_folder_path + "/FETI_iter__phi__current.m",m_comm.get());
 #endif
 }

void carl::FETI_Operations::export_q ( )

Export the current q(kkk) vector.

Definition at line 561 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bSet_previous_q_ptr,"'q' vectors not calculated yet!");
 
     write_PETSC_vector(m_previous_q_ptr[m_kkk],m_scratch_folder_path + "/FETI_iter__q__" + std::to_string(m_kkk) + ".petscvec",m_comm.rank(),m_comm.get());
 
 // Print MatLab debugging output? Variable defined at "carl_headers.h"
 #ifdef PRINT_MATLAB_DEBUG
     write_PETSC_vector_MATLAB(m_previous_q_ptr[m_kkk],m_scratch_folder_path + "/FETI_iter__q__" + std::to_string(m_kkk) + ".m",m_comm.get());
 #endif
 }

void carl::FETI_Operations::export_r ( )

Export the current r(kkk+1) residual vector.

Definition at line 574 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bSet_current_residual,"Current residual not calculated yet!");
 
     write_PETSC_vector(m_current_residual,m_scratch_folder_path + "/FETI_iter__r__current.petscvec",m_comm.rank(),m_comm.get());
 
 // Print MatLab debugging output? Variable defined at "carl_headers.h"
 #ifdef PRINT_MATLAB_DEBUG
     write_PETSC_vector_MATLAB(m_current_residual,m_scratch_folder_path + "/FETI_iter__r__current.m",m_comm.get());
 #endif
 }

void carl::FETI_Operations::export_rb_correction_vector ( )

Export the rigid body modes correction.

Definition at line 534 of file FETI_operations_IO.cpp.

 {   
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bSet_current_RB_correction,"Current RB correction not calculated yet!");
 
     
     write_PETSC_vector(m_current_rb_correction,m_scratch_folder_path + "/FETI_RB_correction.petscvec",m_comm.rank(),m_comm.get());
 
 // Print MatLab debugging output? Variable defined at "carl_headers.h"
 #ifdef PRINT_MATLAB_DEBUG
     write_PETSC_vector_MATLAB(m_current_rb_correction,m_scratch_folder_path + "/FETI_RB_correction.m",m_comm.get());
 #endif
 }

void carl::FETI_Operations::export_scalar_data ( )

Export the iteration scalar data, rho(kkk+1), | RB_corr(kkk+1) | and p(kkk).q(kkk)

Definition at line 690 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bCalculatedScalar,"Scalar data not calculated yet!");
 
     // ONLY write in proc 0!
     if(m_comm.rank() == 0)
     {
         std::ofstream scalar_data;
 
         // Export the scalar data
         scalar_data.open(m_scratch_folder_path + "/FETI_iter_scalar_data.dat");
         scalar_data.precision(15);
         scalar_data << m_kkk + 1 << " " << m_rho_0 << " " << m_current_rho;
 
         if(m_bUsingNullVecs)
         {
             scalar_data <<  " " << m_current_RB_mode_corr;
         }
 
         scalar_data << std::endl;
 
         scalar_data.close();
 
         // Export the convergence data
         scalar_data.open(m_scratch_folder_path + "/FETI_convergence.dat",std::ofstream::app);
         scalar_data.precision(15);
         scalar_data << m_kkk + 1 << " " << m_current_rho;
 
         if(m_bUsingNullVecs)
         {
             scalar_data <<  " " << m_current_RB_mode_corr;
         }
         scalar_data << std::endl;
 
         scalar_data.close();
 
         // Export `p(kkk).q(kkk)`
         if(m_kkk == 0)
         {
             scalar_data.open(m_scratch_folder_path + "/FETI_iter_p_dot_q.dat");
         } else {
 
             scalar_data.open(m_scratch_folder_path + "/FETI_iter_p_dot_q.dat",std::ofstream::app);
         }
         scalar_data.precision(15);
         scalar_data << m_p_dot_q[m_kkk] << std::endl;
 
         scalar_data.close();
     }
 }

void carl::FETI_Operations::increase_iter_counter ( )

Increase the iteration counter.

void carl::FETI_Operations::print_previous_iters_conv ( int nb_of_iters = 5 )

Definition at line 779 of file FETI_operations_IO.cpp.

 {
     std::cout << std::endl;
     std::cout << " --> Iteration no. " << m_kkk + 1 << " : ";
 
     if(m_bConvResidualAbs)
     {
         std::cout << "   > Abs. residual convergence : rho(kkk+1) < " << m_abs_residual_conv << std::endl;
     }
     if(m_bConvResidualRel)
     {
         std::cout << "   > Rel. residual convergence : rho(kkk+1) < " << m_rel_residual_conv << " * rho(0) " << std::endl;
     }
     if(m_bDivResidualRel)
     {
         std::cout << "   > Rel. residual DIVERGENCE : rho(kkk+1) > " << m_rel_residual_div << " * rho(0) " << std::endl;
     }
     if(m_bDivResidualNeg)
     {
         std::cout << "   > Negative residual DIVERGENCE" << std::endl;
     }
     if(m_bConvResidualAbs)
     {
         std::cout << "   > Iter. DIVERGENCE : kkk + 1 > " << m_max_iter_div << std::endl;
     }
     if(m_bUsingNullVecs)
     {   
         if(m_bConvRBCorrRel)
         {
             std::cout << "   > Rel. RB mode correction convergence : abs( RB(kkk+1) - RB_(kkk) ) / RB(kkk+1) < " << m_rb_modes_conv << std::endl;
         }
     }
     std::cout << std::endl;
 
     std::cout << " --> Previous " << std::min(m_kkk+2,nb_of_iters) << " iterations convergence parameter : " << std::endl;
     if(m_bUsingNullVecs)
     {   
         std::cout << "[ kkk ] [ rho(kkk) ] [ | RB_corr(kkk) | ]" << std::endl;
     }
     else
     {
         std::cout << "[ kkk ] [ rho(kkk) ]" << std::endl;
     }
 
     std::string command_string = "tail -n " + std::to_string(nb_of_iters) + " " + m_scratch_folder_path + "/FETI_convergence.dat";
 
     if(m_comm.rank() == 0)
     {
         std::cout << exec_command(command_string) << std::endl;
     }
     if( m_bConv ) {
         std::cout << " --> Converged!" << std::endl;
     } else if ( m_bDiv ) {
         std::cout << " --> DIVERGED!" << std::endl;
     } else {
         std::cout << " --> Iterating ..." << std::endl;
     }
     std::cout << std::endl;
 }

void carl::FETI_Operations::read_all_previous_p ( )

Read all the previous p vectors.

Definition at line 384 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bSet_previous_residual,"Previous residual vector not set yet!");
     homemade_assert_msg(m_bR_sizes_set,"Mediator space dimensions not set yet!");
 
     // Create p(0 ... kkk),
     m_previous_p_ptr = new Vec[m_kkk+1];
     VecDuplicateVecs(m_previous_residual,m_kkk+1,&m_previous_p_ptr);
 
     // Read p(0 ... kkk)
     for(int iii = 0; iii < m_kkk+1; ++iii)
     {
         read_PETSC_vector(m_previous_p_ptr[iii],m_scratch_folder_path + "/FETI_iter__p__" + std::to_string(iii) + ".petscvec", m_comm.get());
     }
 
     // Set flag
     m_bSet_previous_p_ptr = true;
 }

void carl::FETI_Operations::read_all_previous_q ( )

Read all the previous q vectors.

Definition at line 404 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bSet_previous_residual,"Previous residual vector not set yet!");
     homemade_assert_msg(m_bR_sizes_set,"Mediator space dimensions not set yet!");
 
     // Create q(0 ... kkk)
     m_previous_q_ptr = new Vec[m_kkk+1];
     VecDuplicateVecs(m_previous_residual,m_kkk+1,&m_previous_q_ptr);
 
     // Read q(0 ... kkk - 1)
     if(m_kkk > 0)
     {
         for(int iii = 0; iii < m_kkk; ++iii)
         {
             read_PETSC_vector(m_previous_q_ptr[iii],m_scratch_folder_path + "/FETI_iter__q__" + std::to_string(iii) + ".petscvec", m_comm.get());
         }
     }
 
     // Set flags
     m_bSet_previous_q_ptr = true;
 }

void carl::FETI_Operations::read_coupling_matrices ( )

Read all the coupling matrices.

Definition at line 122 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bCouplingFolderSet,"Common coupling matrix path not set yet!");
     this->set_coupling_matrix_R_micro();
     this->set_coupling_matrix_R_BIG();
     this->set_coupling_matrix_RR();
 }

void carl::FETI_Operations::read_decoupled_solutions ( )

Read the decoupled solutions, $ u_0,i$ .

Definition at line 222 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
 
     // Create the vectors and, if needed, set sizes
     VecCreate(m_comm.get(),&m_u_0_BIG);
     VecCreate(m_comm.get(),&m_u_0_micro);
 
     // If the sizes were defined already, set them
     if(m_bBIG_sizes_set)
     {
         VecSetSizes(m_u_0_BIG,m_C_R_BIG_N_local,m_C_R_BIG_N);
     }
     
     if(m_bmicro_sizes_set)
     {
         VecSetSizes(m_u_0_micro,m_C_R_micro_N_local,m_C_R_micro_N);
     }
     
     // Read them
     read_PETSC_vector(m_u_0_BIG,m_scratch_folder_path + "/ext_solver_u0_A_sys_sol_vec.petscvec", m_comm.get());
     read_PETSC_vector(m_u_0_micro,m_scratch_folder_path + "/ext_solver_u0_B_sys_sol_vec.petscvec", m_comm.get());
 
     // If the sizes were not defined yet, define them 
     if(!m_bBIG_sizes_set)
     {
         VecGetLocalSize(m_u_0_BIG,&m_C_R_BIG_N_local);
         VecGetSize(m_u_0_BIG,&m_C_R_BIG_N);
         m_bBIG_sizes_set = true;
     }
 
     if(!m_bmicro_sizes_set)
     {
         VecGetLocalSize(m_u_0_micro,&m_C_R_micro_N_local);
         VecGetSize(m_u_0_micro,&m_C_R_micro_N);
         m_bmicro_sizes_set = true;
     }
 
     // Set null vector dimensions (if needed)
     if(m_bUsingNullVecs && !m_bNullVecsDimensionsSet)
     {
         switch (m_RB_modes_system)
         {
             case RBModesSystem::MACRO :
                             m_null_vecs_N = m_C_R_BIG_N;
                             m_null_vecs_N_local = m_C_R_BIG_N_local;
                             break;
 
             case RBModesSystem::MICRO :
                             m_null_vecs_N = m_C_R_micro_N;
                             m_null_vecs_N_local = m_C_R_micro_N_local;
                             break;
         }
         m_bNullVecsDimensionsSet = true;
     }
 
     // Set the flag
     m_bSet_u_0 = true;
 }

void carl::FETI_Operations::read_ext_solver_output ( )

Read the latest external solver output.

Definition at line 282 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
 
     // Create the vectors
     VecCreate(m_comm.get(),&m_ext_solver_sol_BIG);
     VecCreate(m_comm.get(),&m_ext_solver_sol_micro);
 
     // If the sizes were defined already, set them
     if(m_bBIG_sizes_set)
     {
         VecSetSizes(m_ext_solver_sol_BIG,m_C_R_BIG_N_local,m_C_R_BIG_N);
     }
     
     if(m_bmicro_sizes_set)
     {
         VecSetSizes(m_ext_solver_sol_micro,m_C_R_micro_N_local,m_C_R_micro_N);
     }
 
     // Read them
     read_PETSC_vector(m_ext_solver_sol_BIG,m_scratch_folder_path + "/ext_solver_A_sys_sol_vec.petscvec", m_comm.get());
     read_PETSC_vector(m_ext_solver_sol_micro,m_scratch_folder_path + "/ext_solver_B_sys_sol_vec.petscvec", m_comm.get());
 
     // If the sizes were not defined yet, define them 
     if(!m_bBIG_sizes_set)
     {
         VecGetLocalSize(m_ext_solver_sol_BIG,&m_C_R_BIG_N_local);
         VecGetSize(m_ext_solver_sol_BIG,&m_C_R_BIG_N);
         m_bBIG_sizes_set = true;
     }
 
     if(!m_bmicro_sizes_set)
     {
         VecGetLocalSize(m_ext_solver_sol_micro,&m_C_R_micro_N_local);
         VecGetSize(m_ext_solver_sol_micro,&m_C_R_micro_N);
         m_bmicro_sizes_set = true;
     }
 
     // Set null vector dimensions (if needed)
     if(m_bUsingNullVecs && !m_bNullVecsDimensionsSet)
     {
         switch (m_RB_modes_system)
         {
             case RBModesSystem::MACRO :
                             m_null_vecs_N = m_C_R_BIG_N;
                             m_null_vecs_N_local = m_C_R_BIG_N_local;
                             break;
 
             case RBModesSystem::MICRO :
                             m_null_vecs_N = m_C_R_micro_N;
                             m_null_vecs_N_local = m_C_R_micro_N_local;
                             break;
         }
         m_bNullVecsDimensionsSet = true;
     }
 
     // Set the flag
     m_bSet_ext_solver_sol = true;
 }

void carl::FETI_Operations::read_jacobi_precond_vector ( )

protected

Read the Jacobi coupling matrix preconditioner vector.

Definition at line 44 of file FETI_operations_setup.cpp.

 {
     // Create and set the vector
     VecCreate(m_comm.get(),&m_coupling_jacobi_precond_vec);
     VecSetSizes(m_coupling_jacobi_precond_vec,m_C_RR_M_local,m_C_RR_M);
 
     // Read it
     read_PETSC_vector(m_coupling_jacobi_precond_vec,m_scratch_folder_path + "/precond_Jacobi_vector.petscvec", m_comm.get());
 
     // Set flag
     m_bCreatedPrecondJacobiVec = true;
 }

void carl::FETI_Operations::read_null_space_inv_RITRI_mat ( )

Read the $inv({R^I}^t \cdot R^I)$ matrix.

Definition at line 173 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     
     // A dummy vector which will be used to sync the matrices
     std::vector<PetscScalar> dummy_matrix_contents(m_null_nb_vecs*m_null_nb_vecs, 0);
 
     MatCreateSeqDense(PETSC_COMM_SELF,m_null_nb_vecs,m_null_nb_vecs,NULL,&m_inv_RITRI_mat);
 
     // Only really read the matrix in the first processor
     if(m_comm.rank() == 0)
     {
         read_PETSC_matrix(m_inv_RITRI_mat,m_scratch_folder_path + "/rb_inv_RITRI.petscmat",PETSC_COMM_SELF);
 
         // Get the data
         PetscScalar *dummy_array;
         MatDenseGetArray(m_inv_RITRI_mat,&dummy_array);
 
         for(int iii = 0; iii < m_null_nb_vecs*m_null_nb_vecs; ++iii)
         {
             dummy_matrix_contents[iii] = dummy_array[iii];
         }
 
         MatDenseRestoreArray(m_inv_RITRI_mat,&dummy_array);
     }
 
     // Sync the matrix!
     m_comm.barrier();
     m_comm.broadcast(dummy_matrix_contents);
 
     if(m_comm.rank() != 0)
     {
         std::vector<PetscInt> dummy_indexes(m_null_nb_vecs,0);
 
         for(int iii = 0; iii < m_null_nb_vecs; ++iii)
         {
             dummy_indexes[iii] = iii;
         }
 
         MatSetValues(m_inv_RITRI_mat,m_null_nb_vecs,&dummy_indexes[0],m_null_nb_vecs,&dummy_indexes[0],&dummy_matrix_contents[0],INSERT_VALUES);
         MatAssemblyBegin(m_inv_RITRI_mat,MAT_FINAL_ASSEMBLY);
         MatAssemblyEnd(m_inv_RITRI_mat,MAT_FINAL_ASSEMBLY);
     }
 
     // Set up flag
     m_binvRITRIMatSet = true;
 }

void carl::FETI_Operations::read_null_space_vecs	(	const std::string &	RB_vectors_base,
		int	nb_of_rb_vectors
	)

Read the null space vectors.

Definition at line 131 of file FETI_operations_IO.cpp.

 {
 
     /*
      *      Note: for now, this function reads both sets of null space vectors (the "original" ones and
      *  the ones multiplied by the coupling matrix), but I'm not sure if this less efficient than re-calculating
      *  these vectors each time. [Thiago]
      */
 
     homemade_assert_msg(m_bNullVecsDimensionsSet,"Null vectors sizes not set yet!");
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
 
     // Set the null vec arrays
     m_null_nb_vecs = nb_of_rb_vectors;
 
     // Set the first nullspace vectors
     std::string rb_vec_filename = RB_vectors_base + "_0_n_" + std::to_string(m_null_nb_vecs) + ".petscvec";
     VecCreate(m_comm.get(),&m_null_vecs[0]);
     VecSetSizes(m_null_vecs[0],m_null_vecs_N_local,m_null_vecs_N);
     read_PETSC_vector(m_null_vecs[0],rb_vec_filename, m_comm.get());
     
     std::string rb_coupl_vec_filename = m_scratch_folder_path + "/rb_coupl_vector_0_n_" + std::to_string(m_null_nb_vecs) + ".petscvec";
     VecCreate(m_comm.get(),&m_null_coupled_vecs[0]);
     VecSetSizes(m_null_coupled_vecs[0],m_C_RR_M_local,m_C_RR_M);
     read_PETSC_vector(m_null_coupled_vecs[0],rb_coupl_vec_filename, m_comm.get());
 
     // Read and calculate the rest of the nullspace vectors
     for(int iii = 1; iii < m_null_nb_vecs; ++iii)
     {
         rb_vec_filename = RB_vectors_base + "_" + std::to_string(iii) + "_n_" + std::to_string(m_null_nb_vecs) + ".petscvec";
         VecDuplicate(m_null_vecs[0],&m_null_vecs[iii]);
         read_PETSC_vector(m_null_vecs[iii],rb_vec_filename, m_comm.get());
 
         rb_coupl_vec_filename = m_scratch_folder_path + "/rb_coupl_vector_" + std::to_string(iii) + "_n_" + std::to_string(m_null_nb_vecs) + ".petscvec";
         VecDuplicate(m_null_coupled_vecs[0],&m_null_coupled_vecs[iii]);
         read_PETSC_vector(m_null_coupled_vecs[iii],rb_coupl_vec_filename, m_comm.get());
     }
 
     // Set up flag
     m_bNullVecsSet = true;
 }

void carl::FETI_Operations::read_previous_phi ( )

Read the previous Lagrage multiplier / solution.

Definition at line 356 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bR_sizes_set,"Mediator space dimensions not set yet!");
 
     // Create the vectors
     VecCreate(m_comm.get(),&m_previous_phi);
     VecSetSizes(m_previous_phi,m_C_RR_M_local,m_C_RR_M);
     read_PETSC_vector(m_previous_phi,m_scratch_folder_path + "/FETI_iter__phi__current.petscvec", m_comm.get());
 
     // Set flag
     m_bSet_previous_phi = true;
 }

void carl::FETI_Operations::read_previous_r ( )

Read the previous residual.

Definition at line 370 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bR_sizes_set,"Mediator space dimensions not set yet!");
 
     // Create the vectors
     VecCreate(m_comm.get(),&m_previous_residual);
     VecSetSizes(m_previous_residual,m_C_RR_M_local,m_C_RR_M);
     read_PETSC_vector(m_previous_residual,m_scratch_folder_path + "/FETI_iter__r__current.petscvec", m_comm.get());
 
     // Set flag
     m_bSet_previous_residual = true;
 }

void carl::FETI_Operations::read_rb_corr ( )

Read the rigid body modes correction vector.

Definition at line 342 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bNullVecsDimensionsSet,"Null vectors sizes not set yet!");
 
     // Create the vectors
     VecCreate(m_comm.get(),&m_current_rb_correction);
     VecSetSizes(m_current_rb_correction,m_null_vecs_N_local,m_null_vecs_N);
     read_PETSC_vector(m_current_rb_correction,m_scratch_folder_path + "/FETI_RB_correction.petscvec", m_comm.get());
 
     // Set flag
     m_bSet_current_RB_correction = true;
 }

void carl::FETI_Operations::read_scalar_data ( )

Read the scalar data, rho(0 ... kkk), | RB_corr(0 ... kkk) | and p(0 ... kkk - 1).q(0 ... kkk - 1)

Definition at line 427 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
 
     // Import the scalar data
     // File format:  kkk   rho(0)   rho(kkk)   [ RB_corr(kkk) ]
 
     // ONLY read in proc 0!
     if(m_comm.rank() == 0)
     {
         std::ifstream scalar_data;
 
         scalar_data.open(m_scratch_folder_path + "/FETI_iter_scalar_data.dat");
         scalar_data >> m_kkk >> m_rho_0 >> m_previous_rho;
 
         if(m_bUsingNullVecs)
         {
             scalar_data >> m_previous_RB_mode_corr;
         }
         scalar_data.close();
     }
 
     // Broadcast the values
     m_comm.broadcast(m_kkk);
     m_comm.broadcast(m_rho_0);
     m_comm.broadcast(m_previous_rho);
     if(m_bUsingNullVecs)
     {
         m_comm.broadcast(m_previous_RB_mode_corr);
     }
 
     // Import `p(0 ... kkk - 1).q(0 ... kkk - 1)`
     m_p_dot_q.resize(m_kkk+1,0);
     if(m_kkk != 0)
     {
         // ONLY read in proc 0!
         if(m_comm.rank() == 0)
         {
             std::ifstream scalar_data;
             scalar_data.open(m_scratch_folder_path + "/FETI_iter_p_dot_q.dat");
 
             for(int iii = 0; iii < m_kkk; ++iii)
             {
                 scalar_data >> m_p_dot_q[iii];
             }
             scalar_data.close();
         }
 
         // Broadcast the values
         m_comm.broadcast(m_p_dot_q);
     }
 
     // Set flag
     m_bReadPreviousScalar = true;
 }

void carl::FETI_Operations::read_vector_data ( )

Read the vector data - essentially calls the "read_previous" and "read_all_previous" methods.

Definition at line 483 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
     homemade_assert_msg(m_bReadPreviousScalar,"Scalar data not set yet!");
 
     /* Vectors to read: 'r(kkk)'
      *                  'phi(kkk)'
      *                  'p(0 ... kkk)'
      *                  'q(0 ... kkk - 1)'
      */
 
     // Create and read the vectors
     // r(kkk)
     this->read_previous_r();
 
     // phi(kkk)
     this->read_previous_phi();
 
     // p(0 ... kkk)
     this->read_all_previous_p();
 
     // q(0 ... kkk)
     // Create q(0 ... kkk), read q(0 ... kkk - 1)
     this->read_all_previous_q();
 }

void carl::FETI_Operations::set_coupling_matrix_R_BIG ( )

Read the mediator - macro system coupling matrix.

Definition at line 50 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bCouplingFolderSet,"Common coupling matrix path not set yet!");
 
     // Create matrix and, if needed, get sizes
     MatCreate(m_comm.get(),&m_C_R_BIG);
     
     // If the sizes were defined already, set them
     if(m_bBIG_sizes_set && m_bR_sizes_set)
     {
         MatSetSizes(m_C_R_BIG,m_C_R_BIG_M_local,m_C_R_BIG_N_local,m_C_R_BIG_M,m_C_R_BIG_N);
     }
 
     // Read the matrix
     read_PETSC_matrix(m_C_R_BIG,m_coupling_folder_path + "/coupling_matrix_macro.petscmat",m_comm.get());
 
     // If the macro sizes were not defined yet, define them 
     if(!m_bBIG_sizes_set)
     {
         MatGetLocalSize(m_C_R_BIG,&m_C_R_BIG_M_local,&m_C_R_BIG_N_local);
         MatGetSize(m_C_R_BIG,&m_C_R_BIG_M,&m_C_R_BIG_N);
         m_bBIG_sizes_set = true;
     }
 
     // If the mediator sizes were not defined yet, define them
     if(!m_bR_sizes_set)
     {
         m_C_RR_M = m_C_R_BIG_M; m_C_RR_M_local = m_C_R_BIG_M_local;
         m_bR_sizes_set = true;
     }
 
     // Set null vector dimensions (if needed)
     if(m_bUsingNullVecs && m_RB_modes_system == RBModesSystem::MACRO)
     {
         m_null_vecs_N = m_C_R_BIG_N;
         m_null_vecs_N_local = m_C_R_BIG_N_local;
         m_bNullVecsDimensionsSet = true;
     }
 
     // Set flags
     m_bC_R_BIG_MatrixSet = true;
     m_bCouplingMatricesSet = m_bC_R_BIG_MatrixSet && m_bC_R_micro_MatrixSet && m_bC_RR_MatrixSet;
 }

void carl::FETI_Operations::set_coupling_matrix_R_micro ( )

Read the mediator - micro system coupling matrix.

Definition at line 6 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bCouplingFolderSet,"Common coupling matrix path not set yet!");
 
     // Create matrix and, if needed, get sizes
     MatCreate(m_comm.get(),&m_C_R_micro);
 
     // If the sizes were defined already, set them
     if(m_bmicro_sizes_set && m_bR_sizes_set)
     {
         MatSetSizes(m_C_R_micro,m_C_R_micro_M_local,m_C_R_micro_N_local,m_C_R_micro_M,m_C_R_micro_N);
     }
 
     // Read the matrix
     read_PETSC_matrix(m_C_R_micro,m_coupling_folder_path + "/coupling_matrix_micro.petscmat",m_comm.get());
 
     // If the micro sizes were not defined yet, define them 
     if(!m_bmicro_sizes_set)
     {
         MatGetLocalSize(m_C_R_micro,&m_C_R_micro_M_local,&m_C_R_micro_N_local);
         MatGetSize(m_C_R_micro,&m_C_R_micro_M,&m_C_R_micro_N);
         m_bmicro_sizes_set = true;
     }
 
     // If the mediator sizes were not defined yet, define them
     if(!m_bR_sizes_set)
     {
         m_C_RR_M = m_C_R_micro_M; m_C_RR_M_local = m_C_R_micro_M_local;
         m_bR_sizes_set = true;
     }
 
     // Set null vector dimensions (if needed)
     if(m_bUsingNullVecs && m_RB_modes_system == RBModesSystem::MICRO)
     {
         m_null_vecs_N = m_C_R_micro_N;
         m_null_vecs_N_local = m_C_R_micro_N_local;
         m_bNullVecsDimensionsSet = true;
     }
 
     // Set flags
     m_bC_R_micro_MatrixSet = true;
     m_bCouplingMatricesSet = m_bC_R_BIG_MatrixSet && m_bC_R_micro_MatrixSet && m_bC_RR_MatrixSet;
 }

void carl::FETI_Operations::set_coupling_matrix_RR ( )

Read the mediator - mediator system coupling matrix.

Definition at line 94 of file FETI_operations_IO.cpp.

 {
     homemade_assert_msg(m_bCouplingFolderSet,"Common coupling matrix path not set yet!");
 
     // Create matrix and, if needed, get sizes
     MatCreate(m_comm.get(),&m_C_RR);
 
     // If the sizes were defined already, set them
     if(m_bR_sizes_set)
     {
         MatSetSizes(m_C_RR,m_C_RR_M_local,m_C_RR_M_local,m_C_RR_M,m_C_RR_M);
     }
 
     read_PETSC_matrix(m_C_RR,m_coupling_folder_path + "/coupling_matrix_mediator.petscmat",m_comm.get());
 
     // If the mediator sizes were not defined yet, define them
     if(!m_bR_sizes_set)
     {
         MatGetLocalSize(m_C_RR,&m_C_RR_M_local,NULL);
         MatGetSize(m_C_RR,&m_C_RR_M,NULL);
         m_bR_sizes_set = true;
     }
 
     // Set flags
     m_bC_RR_MatrixSet = true;
     m_bCouplingMatricesSet = m_bC_R_BIG_MatrixSet && m_bC_R_micro_MatrixSet && m_bC_RR_MatrixSet;
 }

void carl::FETI_Operations::set_inverse_precond_solver ( )

protected

Set up the full inversed coupling matrix preconditioner.

Definition at line 6 of file FETI_operations_setup.cpp.

 {
     homemade_assert_msg(m_bC_RR_MatrixSet,"Preconditioner matrix not set yet!");
 
     KSPCreate(m_comm.get(), &m_coupling_precond_solver);
     KSPSetOperators(m_coupling_precond_solver, m_C_RR, m_C_RR);
     KSPSetFromOptions(m_coupling_precond_solver);
 
     m_bCreatedPrecondSolver = true;
 }

void carl::FETI_Operations::set_jacobi_precond_vector ( )

protected

Set up the Jacobi coupling matrix preconditioner vector.

Definition at line 17 of file FETI_operations_setup.cpp.

 {
     homemade_assert_msg(m_bC_RR_MatrixSet,"Preconditioner matrix not set yet!");
 
     // Create and set the vector
     VecCreate(m_comm.get(),&m_coupling_jacobi_precond_vec);
     VecSetSizes(m_coupling_jacobi_precond_vec,m_C_RR_M_local,m_C_RR_M);
     VecSetFromOptions(m_coupling_jacobi_precond_vec);
 
     // Get the diagonal
     MatGetDiagonal(m_C_RR,m_coupling_jacobi_precond_vec);
 
     // Calculate the reciprocal
     VecReciprocal(m_coupling_jacobi_precond_vec);
 
     // Export it
     write_PETSC_vector(m_coupling_jacobi_precond_vec,m_scratch_folder_path + "/precond_Jacobi_vector.petscvec",m_comm.rank(),m_comm.get());
 
 // Print MatLab debugging output? Variable defined at "carl_headers.h"
 #ifdef PRINT_MATLAB_DEBUG
     write_PETSC_vector_MATLAB(m_coupling_jacobi_precond_vec,m_scratch_folder_path + "/precond_Jacobi_vector.m",m_comm.get());
 #endif
 
     // Set flag
     m_bCreatedPrecondJacobiVec = true;
 }

void carl::FETI_Operations::set_null_space	(	const std::string &	input_filename_base,
		int	nb_of_vecs
	)

Set and print the null space vectors and matrices.

Definition at line 280 of file FETI_operations_setup.cpp.

 {
     homemade_assert_msg(m_bNullVecsDimensionsSet,"Null vectors sizes not set yet!");
     homemade_assert_msg(m_bScratchFolderSet,"Scratch folder not set yet!");
 
     // Set the null vec arrays
     m_null_nb_vecs = nb_of_vecs;
 
     // Set the (dummy) coupling matrix pointer
     Mat * coupling_matrix;
 
     switch (m_RB_modes_system)
     {
         case RBModesSystem::MICRO : 
                 coupling_matrix = &m_C_R_micro;
                 break;
 
         case RBModesSystem::MACRO : 
                 // TODO: Remove the error message below after the more general code was implemented
                 homemade_error_msg("Option not implemented yet!");
                 coupling_matrix = &m_C_R_BIG;
                 break;
     }
 
     // Matrix dimensions
     //                       M     x N
     // coupling_matrix     : n_med x n_sys
     // m_null_vecs         : n_sys x nb_of_vecs ( R )  -> nb_of_vecs vectors of dim n_sys
     // m_null_coupled_vecs : n_med x nb_of_vecs ( RC ) -> nb_of_vecs vectors of dim n_coupl
 
     // Set the first nullspace vectors
     std::string input_filename = input_filename_base + "_0_n_" + std::to_string(m_null_nb_vecs) + ".petscvec";
     VecCreate(m_comm.get(),&m_null_vecs[0]);
     VecSetSizes(m_null_vecs[0],m_null_vecs_N_local,m_null_vecs_N);
     read_PETSC_vector(m_null_vecs[0],input_filename, m_comm.get());
     
     std::string output_filename = m_scratch_folder_path + "/rb_coupl_vector_0_n_" + std::to_string(m_null_nb_vecs) + ".petscvec";
     VecCreate(m_comm.get(),&m_null_coupled_vecs[0]);
     VecSetSizes(m_null_coupled_vecs[0],m_C_RR_M_local,m_C_RR_M);
     VecSetFromOptions(m_null_coupled_vecs[0]);
     MatMult(*coupling_matrix,m_null_vecs[0],m_null_coupled_vecs[0]);
     write_PETSC_vector(m_null_coupled_vecs[0],output_filename,m_comm.rank(),m_comm.get());
 
     // Read and calculate the rest of the nullspace vectors
     for(int iii = 1; iii < m_null_nb_vecs; ++iii)
     {
         input_filename = input_filename_base + "_" + std::to_string(iii) + "_n_" + std::to_string(m_null_nb_vecs) + ".petscvec";
         VecDuplicate(m_null_vecs[0],&m_null_vecs[iii]);
         read_PETSC_vector(m_null_vecs[iii],input_filename, m_comm.get());
 
         std::string output_filename = m_scratch_folder_path + "/rb_coupl_vector_" + std::to_string(iii) + "_n_" + std::to_string(m_null_nb_vecs) + ".petscvec";
         VecDuplicate(m_null_coupled_vecs[0],&m_null_coupled_vecs[iii]);
         MatMult(*coupling_matrix,m_null_vecs[iii],m_null_coupled_vecs[iii]);
 
         write_PETSC_vector(m_null_coupled_vecs[iii],output_filename,m_comm.rank(),m_comm.get());
     }
 
     // Build the LOCAL dense matrix
     std::vector<PetscScalar> dummy_vec_val(m_null_nb_vecs,0);
     std::vector<PetscInt>    dummy_vec_row(m_null_nb_vecs,0);
 
     for(PetscInt iii = 0; iii < m_null_nb_vecs; ++iii)
     {
         dummy_vec_row[iii] = iii;
     }
 
     MatCreateSeqDense(PETSC_COMM_SELF,m_null_nb_vecs,m_null_nb_vecs,NULL,&m_RITRI_mat);
 
     for(PetscInt iii = 0; iii < m_null_nb_vecs; ++iii)
     {
         VecMDot(m_null_coupled_vecs[iii],m_null_nb_vecs,m_null_coupled_vecs,dummy_vec_val.data());
         MatSetValues(m_RITRI_mat,m_null_nb_vecs,dummy_vec_row.data(),1,&iii,dummy_vec_val.data(),INSERT_VALUES);
     }
     MatAssemblyBegin(m_RITRI_mat,MAT_FINAL_ASSEMBLY);
     MatAssemblyEnd(m_RITRI_mat,MAT_FINAL_ASSEMBLY);
 
     PETSC_invert_dense_matrix(m_RITRI_mat,m_inv_RITRI_mat);
 
     if(m_comm.rank() == 0)
     {
         write_PETSC_matrix(m_inv_RITRI_mat,m_scratch_folder_path + "/rb_inv_RITRI.petscmat",0,PETSC_COMM_SELF);
     }
 
     // Set up flag
     m_bNullVecsSet = true;
     m_binvRITRIMatSet = true;
 
     // Cleanup
     MatDestroy(&m_RITRI_mat);
 }

void carl::FETI_Operations::set_preconditioner	(	BaseCGPrecondType	CG_precond_type,
		bool	bInitialSet = `true`
	)

Set the preconditioner type. The boolean bInitialSet determinates if, in the case of a COUPLING_JACOBI preconditioner, if it will calculate the needed vector (true) or if it will read it (false).

Definition at line 241 of file FETI_operations_setup.cpp.

 {
     m_precond_type = CG_precond_type;
 
     switch (m_precond_type)
     {
         case BaseCGPrecondType::NO_PRECONDITIONER : 
                 // Well ... nothing to do ...
                 break;
 
         case BaseCGPrecondType::COUPLING_OPERATOR : 
                 // Read the mediator - mediator coupling matrix and set the solver
                 this->set_coupling_matrix_RR();
                 this->set_inverse_precond_solver();
                 m_bC_RR_MatrixSet = true;
                 break;
 
         case BaseCGPrecondType::COUPLING_JACOBI :
                 if(bInitialSet)
                 {
                     // Read the mediator - mediator coupling matrix and build the Jacobi coupling preconditioner vector
                     this->set_coupling_matrix_RR();
                     this->set_jacobi_precond_vector();
                     m_bC_RR_MatrixSet = true;
                 } else {
                     // Just read the Jacobi coupling preconditioner vector
                     this->read_jacobi_precond_vector();
                     m_bC_RR_MatrixSet = true;
                 }
                 break;
     }
 }

void carl::FETI_Operations::using_rb_modes ( bool bUseRigidBodyModes )

Set up the.

Definition at line 275 of file FETI_operations_setup.cpp.

 {
     m_bUsingNullVecs = bUseRigidBodyModes;
 }

Member Data Documentation

double carl::FETI_Operations::m_abs_residual_conv

protected

Absolute residual convergence.

Definition at line 166 of file FETI_operations.h.

bool carl::FETI_Operations::m_bBIG_sizes_set

protected

Have the macro dimensions been set yet?

Definition at line 79 of file FETI_operations.h.

bool carl::FETI_Operations::m_bC_R_BIG_MatrixSet

protected

Mediator - macro coupling matrix has been set?

Definition at line 74 of file FETI_operations.h.

bool carl::FETI_Operations::m_bC_R_micro_MatrixSet

protected

Mediator - micro coupling matrix has been set?

Definition at line 73 of file FETI_operations.h.

bool carl::FETI_Operations::m_bC_RR_MatrixSet

protected

Mediator - mediator coupling matrix has been set?

Definition at line 75 of file FETI_operations.h.

bool carl::FETI_Operations::m_bCalculatedScalar

protected

Calculated the current iterations scalar data?

Definition at line 163 of file FETI_operations.h.

bool carl::FETI_Operations::m_bConv

protected

Did the solver converge?

Definition at line 179 of file FETI_operations.h.

bool carl::FETI_Operations::m_bConvRBCorrRel

protected

The RB correction converged? (relative to previous value)

Definition at line 175 of file FETI_operations.h.

bool carl::FETI_Operations::m_bConvResidualAbs

protected

The residual converged? (absolute)

Definition at line 173 of file FETI_operations.h.

bool carl::FETI_Operations::m_bConvResidualRel

protected

The residual converged? (relative to initial value)

Definition at line 174 of file FETI_operations.h.

bool carl::FETI_Operations::m_bCoupled_sols_set

protected

Have the coupled solutions been set yet?

Definition at line 186 of file FETI_operations.h.

bool carl::FETI_Operations::m_bCouplingFolderSet

protected

Have the Coupling matrices folder been set?

Definition at line 43 of file FETI_operations.h.

bool carl::FETI_Operations::m_bCouplingMatricesSet

protected

All coupling matrices has been set?

Definition at line 76 of file FETI_operations.h.

bool carl::FETI_Operations::m_bCreatedPrecondJacobiVec

protected

Have the preconditioner system solver been set?

Definition at line 88 of file FETI_operations.h.

bool carl::FETI_Operations::m_bCreatedPrecondSolver

protected

Have the preconditioner system solver been set?

Definition at line 87 of file FETI_operations.h.

bool carl::FETI_Operations::m_bDiv

protected

Did the solver diverge?

Definition at line 180 of file FETI_operations.h.

bool carl::FETI_Operations::m_bDivIter

protected

The number of iterations diverged?

Definition at line 178 of file FETI_operations.h.

bool carl::FETI_Operations::m_bDivResidualNeg

protected

The residual is negative? (more usefull for debugging, really)

Definition at line 177 of file FETI_operations.h.

bool carl::FETI_Operations::m_bDivResidualRel

protected

The residual diverged? (relative to initial value)

Definition at line 176 of file FETI_operations.h.

bool carl::FETI_Operations::m_binvRITRIMatSet

protected

Have the inv(RI^T * RI) matrix been set?

Definition at line 113 of file FETI_operations.h.

bool carl::FETI_Operations::m_bmicro_sizes_set

protected

Have the micro dimensions been set yet?

Definition at line 78 of file FETI_operations.h.

bool carl::FETI_Operations::m_bNullVecsDimensionsSet

protected

Have the null space vectors' dimensions been set?

Definition at line 112 of file FETI_operations.h.

bool carl::FETI_Operations::m_bNullVecsSet

protected

Have the null space vectors been set?

Definition at line 111 of file FETI_operations.h.

bool carl::FETI_Operations::m_bR_sizes_set

protected

Have the mediator dimensions been set yet?

Definition at line 80 of file FETI_operations.h.

bool carl::FETI_Operations::m_bReadPreviousScalar

protected

Read the previous iterations scalar data?

Definition at line 162 of file FETI_operations.h.

bool carl::FETI_Operations::m_bScratchFolderSet

protected

Have the scratch folder been set?

Definition at line 42 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_current_p

protected

Have the current p(kkk+1) vector been set?

Definition at line 149 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_current_phi

protected

Have the current Lagrange multipliers / solution phi(kkk+1) been set?

Definition at line 150 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_current_RB_correction

protected

Have the RB modes correction RB_corr(kkk+1) vector been set?

Definition at line 151 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_current_residual

protected

Have the current r(kkk+1) vector been set?

Definition at line 147 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_current_z

protected

Have the current z(kkk+1) vector been set?

Definition at line 148 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_ext_solver_sol

protected

Have the external solvers solutions been set vectors been set?

Definition at line 145 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_previous_p_ptr

protected

Have the previous p vectors, p(0 ... kkk), been set?

Definition at line 155 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_previous_phi

protected

Have the previous Lagrange multipliers / solution phi(kkk) been set?

Definition at line 154 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_previous_q_ptr

protected

Have the previous q vectors, q(0 ... kkk), been set?

Definition at line 156 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_previous_residual

protected

Have the previous r(kkk) vector been set?

Definition at line 153 of file FETI_operations.h.

bool carl::FETI_Operations::m_bSet_u_0

protected

Have the u_0 vectors been set?

Definition at line 144 of file FETI_operations.h.

bool carl::FETI_Operations::m_bUsingNullVecs

protected

Do we need to use the null space vectors?

Definition at line 110 of file FETI_operations.h.

Mat carl::FETI_Operations::m_C_R_BIG

protected

Mediator - macro system coupling matrix.

Definition at line 53 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_C_R_BIG_M

protected

Definition at line 65 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_C_R_BIG_M_local

protected

Definition at line 65 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_C_R_BIG_N

protected

Definition at line 65 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_C_R_BIG_N_local

protected

Definition at line 65 of file FETI_operations.h.

Mat carl::FETI_Operations::m_C_R_micro

protected

Mediator - micro system coupling matrix.

Definition at line 52 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_C_R_micro_M

protected

Definition at line 64 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_C_R_micro_M_local

protected

Definition at line 64 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_C_R_micro_N

protected

Definition at line 64 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_C_R_micro_N_local

protected

Definition at line 64 of file FETI_operations.h.

Mat carl::FETI_Operations::m_C_RR

protected

Mediator - mediator system coupling matrix.

Definition at line 54 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_C_RR_M

protected

Definition at line 66 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_C_RR_M_local

protected

Definition at line 66 of file FETI_operations.h.

libMesh::Parallel::Communicator& carl::FETI_Operations::m_comm

protected

Communicator.

Definition at line 41 of file FETI_operations.h.

Vec carl::FETI_Operations::m_coupled_sol_BIG

protected

Coupled system solution for the macro model.

Definition at line 184 of file FETI_operations.h.

Vec carl::FETI_Operations::m_coupled_sol_micro

protected

Coupled system solution for the micro model.

Definition at line 183 of file FETI_operations.h.

std::string carl::FETI_Operations::m_coupling_folder_path

protected

Coupling matrices path.

Definition at line 45 of file FETI_operations.h.

Vec carl::FETI_Operations::m_coupling_jacobi_precond_vec

protected

Preconditioner Jacobi vector.

Definition at line 70 of file FETI_operations.h.

KSP carl::FETI_Operations::m_coupling_precond_solver

protected

Preconditioner system solver.

Definition at line 69 of file FETI_operations.h.

Vec carl::FETI_Operations::m_current_p

protected

Current p(kkk+1) (p(0) for the initialization)

Definition at line 125 of file FETI_operations.h.

Vec carl::FETI_Operations::m_current_phi

protected

Current Lagrange multipliers / solution, phi(kkk+1) (phi(0) for the initialization)

Definition at line 127 of file FETI_operations.h.

Vec carl::FETI_Operations::m_current_rb_correction

protected

Current rigid body modes correction, RB_corr(kkk+1) (RB_corr(0) for the initialization)

Definition at line 128 of file FETI_operations.h.

double carl::FETI_Operations::m_current_RB_mode_corr

protected

Double containing the current RB_mode_corr(kkk+1)

Definition at line 139 of file FETI_operations.h.

Vec carl::FETI_Operations::m_current_residual

protected

Current residual vector, r(kkk+1) (r(0) for the initialization)

Definition at line 123 of file FETI_operations.h.

double carl::FETI_Operations::m_current_rho

protected

Double containing the current rho(kkk+1)

Definition at line 138 of file FETI_operations.h.

Vec carl::FETI_Operations::m_current_z

protected

Current z(kkk+1) (z(0) for the initialization)

Definition at line 124 of file FETI_operations.h.

Vec carl::FETI_Operations::m_ext_solver_sol_BIG

protected

Macro model external solver solution.

Definition at line 121 of file FETI_operations.h.

Vec carl::FETI_Operations::m_ext_solver_sol_micro

protected

Micro model external solver solution.

Definition at line 120 of file FETI_operations.h.

IterationStatus carl::FETI_Operations::m_FETI_solver_status

protected

Current FETI / CG solver status.

Definition at line 46 of file FETI_operations.h.

double carl::FETI_Operations::m_gamma

protected

Double containing the value of rho(kkk) / p(kkk) . q(kkk)

Definition at line 136 of file FETI_operations.h.

Mat carl::FETI_Operations::m_inv_RITRI_mat

protected

Matrix $inv({R^I}^t \cdot R^I)$ , used in some projectors.

Definition at line 107 of file FETI_operations.h.

int carl::FETI_Operations::m_kkk

protected

Current iteration index.

Definition at line 47 of file FETI_operations.h.

int carl::FETI_Operations::m_max_iter_div

protected

Number of iterations divergence.

Definition at line 170 of file FETI_operations.h.

Vec carl::FETI_Operations::m_null_coupled_vecs[maxVecLimit]

protected

Null space vectors times the coupling matrix.

Definition at line 100 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_null_nb_vecs

protected

Number of null space vectors.

Definition at line 97 of file FETI_operations.h.

Vec carl::FETI_Operations::m_null_vecs[maxVecLimit]

protected

Null space vectors.

Definition at line 99 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_null_vecs_N

protected

Definition at line 103 of file FETI_operations.h.

PetscInt carl::FETI_Operations::m_null_vecs_N_local

protected

Definition at line 103 of file FETI_operations.h.

std::vector<double> carl::FETI_Operations::m_p_dot_q

protected

Vector containing the p.q scalar products.

Definition at line 159 of file FETI_operations.h.

BaseCGPrecondType carl::FETI_Operations::m_precond_type

protected

Preconditioner type. Default: BaseCGPrecondType::NO_PRECONDITIONER.

Definition at line 82 of file FETI_operations.h.

Vec* carl::FETI_Operations::m_previous_p_ptr

protected

Pointer to the previous p vectors, p(0 ... kkk)

Definition at line 132 of file FETI_operations.h.

Vec carl::FETI_Operations::m_previous_phi

protected

Previous Lagrange multipliers / solution, phi(kkk)

Definition at line 131 of file FETI_operations.h.

Vec* carl::FETI_Operations::m_previous_q_ptr

protected

Pointer to the previous q vectors, q(0 ... kkk)

Definition at line 133 of file FETI_operations.h.

double carl::FETI_Operations::m_previous_RB_mode_corr

protected

Double containing the previous RB_mode_corr(kkk)

Definition at line 141 of file FETI_operations.h.

Vec carl::FETI_Operations::m_previous_residual

protected

Previous residual vector, r(kkk)

Definition at line 130 of file FETI_operations.h.

double carl::FETI_Operations::m_previous_rho

protected

Double containing the previous rho(kkk)

Definition at line 140 of file FETI_operations.h.

double carl::FETI_Operations::m_rb_modes_conv

protected

Relative RB correction convergence (relative to previous value)

Definition at line 168 of file FETI_operations.h.

RBModesSystem carl::FETI_Operations::m_RB_modes_system

protected

Which model is associated to the RB modes? Default: RBModesSystem::MICRO.

Definition at line 85 of file FETI_operations.h.

double carl::FETI_Operations::m_rel_residual_conv

protected

Relative residual convergence (relative to initial value)

Definition at line 167 of file FETI_operations.h.

double carl::FETI_Operations::m_rel_residual_div

protected

Relative residual divergence (relative to initial value)

Definition at line 169 of file FETI_operations.h.

double carl::FETI_Operations::m_rho_0

protected

Double containing the initial rho(0)

Definition at line 137 of file FETI_operations.h.

Mat carl::FETI_Operations::m_RITRI_mat

protected

Matrix ${R^I}^t \cdot R^I = R^t C^t \cdot C R$ .

Definition at line 106 of file FETI_operations.h.

std::string carl::FETI_Operations::m_scratch_folder_path

protected

Scratch folder path.

Definition at line 44 of file FETI_operations.h.

Vec carl::FETI_Operations::m_u_0_BIG

protected

Solution of the decoupled macro model.

Definition at line 118 of file FETI_operations.h.

Vec carl::FETI_Operations::m_u_0_micro

protected

Solution of the decoupled micro model.

Definition at line 117 of file FETI_operations.h.

The documentation for this class was generated from the following files:

/Users/breubreubreu/Programming/CArl/Cpp/src/include/FETI_operations.h
/Users/breubreubreu/Programming/CArl/Cpp/src/common/FETI/FETI_operations_IO.cpp
/Users/breubreubreu/Programming/CArl/Cpp/src/common/FETI/FETI_operations_operations.cpp
/Users/breubreubreu/Programming/CArl/Cpp/src/common/FETI/FETI_operations_setup.cpp

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation