libMesh::NloptOptimizationSolver< T > Class Template Reference

This class provides an interface to the NLopt optimization solvers. More...

#include <nlopt_optimization_solver.h>

Inheritance diagram for libMesh::NloptOptimizationSolver< T >:

Public Types
typedef OptimizationSystem	sys_type
	The type of system that we use in conjunction with this solver.

Public Member Functions
	NloptOptimizationSolver (sys_type &system)
	Constructor.
	~NloptOptimizationSolver ()
	Destructor.
virtual void	clear () override
	Release all memory and clear data structures.
virtual void	init () override
	Initialize data structures if not done so already.
nlopt_opt	get_nlopt_object ()
virtual void	solve () override
	Call the NLopt solver.
virtual void	print_converged_reason () override
	Prints a useful message about why the latest optimization solve con(di)verged.
virtual int	get_converged_reason () override
unsigned &	get_iteration_count ()
bool	initialized () const
virtual void	get_dual_variables ()
	Get the current values of dual variables associated with inequality and equality constraints.
const sys_type &	system () const
sys_type &	system ()
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static std::unique_ptr< OptimizationSolver< T > >	build (sys_type &s, const SolverPackage solver_package=libMesh::default_solver_package())
	Builds an OptimizationSolver using the package specified by solver_package.
static std::string	get_info ()
	Gets a string containing the reference information.
static void	print_info (std::ostream &out_stream=libMesh::out)
	Prints the reference information, by default to libMesh::out.
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects.
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info().
static void	disable_print_counter_info ()

Public Attributes
OptimizationSystem::ComputeObjective *	objective_object
	Object that computes the objective function f(X) at the input iterate X.
OptimizationSystem::ComputeGradient *	gradient_object
	Object that computes the gradient grad_f(X) of the objective function at the input iterate X.
OptimizationSystem::ComputeHessian *	hessian_object
	Object that computes the Hessian H_f(X) of the objective function at the input iterate X.
OptimizationSystem::ComputeEqualityConstraints *	equality_constraints_object
	Object that computes the equality constraints vector C_eq(X).
OptimizationSystem::ComputeEqualityConstraintsJacobian *	equality_constraints_jacobian_object
	Object that computes the Jacobian of C_eq(X).
OptimizationSystem::ComputeInequalityConstraints *	inequality_constraints_object
	Object that computes the inequality constraints vector C_ineq(X).
OptimizationSystem::ComputeInequalityConstraintsJacobian *	inequality_constraints_jacobian_object
	Object that computes the Jacobian of C_ineq(X).
OptimizationSystem::ComputeLowerAndUpperBounds *	lower_and_upper_bounds_object
	Object that computes the lower and upper bounds vectors.
unsigned int	max_objective_function_evaluations
	Maximum number of objective function evaluations allowed.
double	objective_function_relative_tolerance
	Required change in objective function which signals convergence.
bool	verbose
	Control how much is output from the OptimizationSolver as it's running.

Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
	Data structure to log the information.

Protected Member Functions
void	increment_constructor_count (const std::string &name) noexcept
	Increments the construction counter.
void	increment_destructor_count (const std::string &name) noexcept
	Increments the destruction counter.

Protected Attributes
nlopt_opt	_opt
	Optimization solver context.
nlopt_result	_result
	Store the result (i.e.
unsigned	_iteration_count
	Stores the current iteration index (incremented at each call of __libmesh_nlopt_objective).
double	_constraints_tolerance
	NLopt requires us to specify a tolerance for the constraints.
sys_type &	_system
	A reference to the system we are solving.
bool	_is_initialized
	Flag indicating if the data structures have been initialized.
const Parallel::Communicator &	_communicator

Static Protected Attributes
static Counts	_counts
	Actually holds the data.
static Threads::atomic< unsigned int >	_n_objects
	The number of objects.
static Threads::spin_mutex	_mutex
	Mutual exclusion object to enable thread-safe reference counting.
static bool	_enable_print_counter = true
	Flag to control whether reference count information is printed when print_info is called.

Static Private Member Functions
static std::map< std::string, nlopt_algorithm >	build_map ()

Static Private Attributes
static std::map< std::string, nlopt_algorithm >	_nlopt_algorithms = NloptOptimizationSolver<T>::build_map()

Friends
double	__libmesh_nlopt_objective (unsigned n, const double *x, double *gradient, void *data)
void	__libmesh_nlopt_equality_constraints (unsigned m, double *result, unsigned n, const double *x, double *gradient, void *data)
void	__libmesh_nlopt_inequality_constraints (unsigned m, double *result, unsigned n, const double *x, double *gradient, void *data)

Detailed Description

template<typename T>
class libMesh::NloptOptimizationSolver< T >

This class provides an interface to the NLopt optimization solvers.

http://ab-initio.mit.edu/wiki/index.php/NLopt

Author

David Knezevic

John Peterson

Date

2015

Definition at line 70 of file nlopt_optimization_solver.h.

Member Typedef Documentation

Counts

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts

protectedinherited

Data structure to log the information.

The log is identified by the class name.

Definition at line 119 of file reference_counter.h.

sys_type

template<typename T >

typedef OptimizationSystem libMesh::NloptOptimizationSolver< T >::sys_type

The type of system that we use in conjunction with this solver.

Definition at line 77 of file nlopt_optimization_solver.h.

Constructor & Destructor Documentation

NloptOptimizationSolver()

template<typename T >

libMesh::NloptOptimizationSolver< T >::NloptOptimizationSolver ( sys_type &  system )

explicit

Constructor.

Definition at line 272 of file nlopt_optimization_solver.C.

  :
  OptimizationSolver<T>(system_in),
  _opt(nullptr),
  _result(NLOPT_SUCCESS),
  _iteration_count(0),
  _constraints_tolerance(1.e-8)
{
  // The nlopt interfaces all use unsigned int as their index type, so
  // don't risk using the NloptOptimizationSolver with a libmesh that
  // is configured to use 64-bit indices. We can detect this at
  // configure time, so it should not be possible to actually reach
  // this error message... it's here just in case.
  libmesh_error_msg_if(sizeof(dof_id_type) != sizeof(unsigned int),
                       "The NloptOptimizationSolver should not be used with dof_id_type != unsigned int.");
}

~NloptOptimizationSolver()

template<typename T >

libMesh::NloptOptimizationSolver< T >::~NloptOptimizationSolver

(

)

Destructor.

Definition at line 292 of file nlopt_optimization_solver.C.

{
  this->clear ();
}

Member Function Documentation

build()

template<typename T >

std::unique_ptr< OptimizationSolver< T > > libMesh::OptimizationSolver< T >::build ( sys_type &  s, const SolverPackage  solver_package = libMesh::default_solver_package()  )

staticinherited

Builds an OptimizationSolver using the package specified by solver_package.

Definition at line 62 of file optimization_solver.C.

{
  // Prevent unused variables warnings when Tao is not available
  libmesh_ignore(s);
 
  // Build the appropriate solver
  switch (solver_package)
    {
 
#if defined(LIBMESH_HAVE_PETSC_TAO) && !defined(LIBMESH_USE_COMPLEX_NUMBERS)
    case PETSC_SOLVERS:
      return std::make_unique<TaoOptimizationSolver<T>>(s);
#endif // #if defined(LIBMESH_HAVE_PETSC_TAO) && !defined(LIBMESH_USE_COMPLEX_NUMBERS)
 
#if defined(LIBMESH_HAVE_NLOPT) && !defined(LIBMESH_USE_COMPLEX_NUMBERS)
    case NLOPT_SOLVERS:
      return std::make_unique<NloptOptimizationSolver<T>>(s);
#endif // #if defined(LIBMESH_HAVE_NLOPT) && !defined(LIBMESH_USE_COMPLEX_NUMBERS)
 
    default:
      libmesh_error_msg("ERROR:  Unrecognized solver package: " << solver_package);
    }
}

References libMesh::libmesh_ignore(), libMesh::NLOPT_SOLVERS, and libMesh::PETSC_SOLVERS.

Referenced by main().

build_map()

template<typename T >

static std::map< std::string, nlopt_algorithm > libMesh::NloptOptimizationSolver< T >::build_map ( )

inlinestaticprivate

Definition at line 182 of file nlopt_optimization_solver.h.

  {
    std::map<std::string, nlopt_algorithm> ret;
    ret["LD_SLSQP"]                   = NLOPT_LD_SLSQP;
    ret["LD_MMA"]                     = NLOPT_LD_MMA;
    ret["LD_CCSAQ"]                   = NLOPT_LD_CCSAQ;
    ret["LD_LBFGS"]                   = NLOPT_LD_LBFGS;
    ret["LD_LBFGS_NOCEDAL"]           = NLOPT_LD_LBFGS_NOCEDAL;
    ret["LD_TNEWTON"]                 = NLOPT_LD_TNEWTON;
    ret["LD_TNEWTON_RESTART"]         = NLOPT_LD_TNEWTON_RESTART;
    ret["LD_TNEWTON_PRECOND"]         = NLOPT_LD_TNEWTON_PRECOND;
    ret["LD_TNEWTON_PRECOND_RESTART"] = NLOPT_LD_TNEWTON_PRECOND_RESTART;
    ret["LD_AUGLAG"]                  = NLOPT_LD_AUGLAG;
    ret["LD_VAR1"]                    = NLOPT_LD_VAR1;
    ret["LD_VAR2"]                    = NLOPT_LD_VAR2;
    ret["LN_COBYLA"]                  = NLOPT_LN_COBYLA;
    ret["LN_BOBYQA"]                  = NLOPT_LN_BOBYQA;
    ret["LN_PRAXIS"]                  = NLOPT_LN_PRAXIS;
    ret["LN_NELDERMEAD"]              = NLOPT_LN_NELDERMEAD;
    ret["LN_SBPLX"]                   = NLOPT_LN_SBPLX;
    ret["GN_ISRES"]                   = NLOPT_GN_ISRES;
    return ret;
  }

clear()

template<typename T >

void libMesh::NloptOptimizationSolver< T >::clear ( )

overridevirtual

Release all memory and clear data structures.

Reimplemented from libMesh::OptimizationSolver< T >.

Definition at line 300 of file nlopt_optimization_solver.C.

{
  if (this->initialized())
    {
      this->_is_initialized = false;
 
      nlopt_destroy(_opt);
    }
}

References libMesh::initialized().

comm()

const Parallel::Communicator & libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns

A reference to the Parallel::Communicator object used by this mesh.

Definition at line 97 of file parallel_object.h.

  { return _communicator; }

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::DofMap::add_constraints_to_send_list(), add_cube_convex_hull_to_mesh(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::TransientRBConstruction::add_IC_to_RB_space(), libMesh::RBEIMEvaluation::add_interpolation_data(), libMesh::CondensedEigenSystem::add_matrices(), libMesh::EigenSystem::add_matrices(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::System::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::System::add_vector(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::AdvectionSystem::assemble_claw_rhs(), libMesh::FEMSystem::assemble_qoi(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::MeshCommunication::assign_global_indices(), libMesh::Partitioner::assign_partitioning(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::MeshBase::cache_elem_data(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::MeshTetInterface::check_hull_integrity(), libMesh::MeshBase::complete_preparation(), libMesh::RBConstruction::compute_Fq_representor_innerprods(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::RBConstruction::compute_output_dual_innerprods(), libMesh::RBConstruction::compute_residual_dual_norm_slow(), libMesh::RBSCMConstruction::compute_SCM_bounds_on_training_set(), libMesh::DofMap::computed_sparsity_already(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), PetscSolverConfiguration::configure_solver(), libMesh::ContinuationSystem::ContinuationSystem(), libMesh::MeshBase::copy_constraint_rows(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::CondensedEigenSystem::copy_super_to_sub(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshTools::create_bounding_box(), libMesh::DofMap::create_dof_constraints(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::PetscMatrix< T >::create_submatrix_nosort(), create_wrapped_function(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::MeshBase::detect_interior_parents(), libMesh::RBEIMEvaluation::distribute_bfs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_interiors(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_nodes(), libMesh::RBEIMConstruction::enrich_eim_approximation_on_sides(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::SmoothnessEstimator::estimate_smoothness(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_error_tolerance(), libMesh::MeshRefinement::flag_elements_by_mean_stddev(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::RBEIMEvaluation::get_eim_basis_function_node_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_side_value(), libMesh::RBEIMEvaluation::get_eim_basis_function_value(), libMesh::MeshBase::get_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::RBEIMConstruction::get_max_abs_value(), libMesh::RBEIMConstruction::get_node_max_abs_value(), libMesh::RBEIMEvaluation::get_parametrized_function_node_value(), libMesh::RBEIMEvaluation::get_parametrized_function_side_value(), libMesh::RBEIMEvaluation::get_parametrized_function_value(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::RBEIMConstruction::get_random_point(), libMesh::MeshTetInterface::improve_hull_integrity(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::StaticCondensation::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::LocationMap< T >::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), ElasticitySystem::init_data(), libMesh::AdvectionSystem::init_data(), libMesh::ClawSystem::init_data(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_parametrized_functions_in_training_set(), libMesh::RBEIMConstruction::inner_product(), integrate_function(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_equal_connectivity(), libMesh::MeshTools::libmesh_assert_equal_points(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_constraint_rows(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_flags(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_p_levels(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshTools::libmesh_assert_valid_unique_ids(), libMesh::libmesh_petsc_linesearch_shellfunc(), libMesh::libmesh_petsc_preconditioner_apply(), libMesh::libmesh_petsc_snes_mffd_interface(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), libMesh::LinearImplicitSystem::LinearImplicitSystem(), main(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_parallel_consistent(), libMesh::MeshCommunication::make_node_bcids_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshCommunication::make_p_levels_parallel_consistent(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::DofMap::n_constrained_dofs(), libMesh::MeshBase::n_constraint_rows(), libMesh::DofMap::n_dofs(), libMesh::DofMap::n_dofs_per_processor(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), MixedOrderTest::n_neighbor_links(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SparsityPattern::Build::n_nonzeros(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_distribute_bfs(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::RBEIMConstruction::node_inner_product(), libMesh::PetscVector< T >::operator=(), libMesh::MeshBase::operator==(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshTools::paranoid_n_levels(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::petsc_auto_fieldsplit(), LaplaceSystem::postprocess(), PoissonSystem::postprocess(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Partitioner::processor_pairs_to_interface_nodes(), libMesh::InterMeshProjection::project_system_vectors(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), FEMParameters::read(), libMesh::EquationSystems::read(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), MeshFunctionTest::read_variable_info_from_output_data(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::BoundaryInfo::remove_edge_id(), libMesh::BoundaryInfo::remove_node_id(), libMesh::BoundaryInfo::remove_shellface_id(), libMesh::BoundaryInfo::remove_side_id(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), scale_mesh_and_plot(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::send_and_insert_dof_values(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::Partitioner::set_interface_node_processor_ids_BFS(), libMesh::Partitioner::set_interface_node_processor_ids_linear(), libMesh::Partitioner::set_interface_node_processor_ids_petscpartitioner(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::Partitioner::set_parent_processor_ids(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::RBEIMEvaluation::side_distribute_bfs(), libMesh::RBEIMEvaluation::side_gather_bfs(), libMesh::RBEIMConstruction::side_inner_product(), libMesh::Partitioner::single_partition(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::VariationalMeshSmoother::smooth(), libMesh::NoxNonlinearSolver< Number >::solve(), libMesh::ClawSystem::solve_conservation_law(), libMesh::split_mesh(), libMesh::RBEIMConstruction::store_eim_solutions_for_training_set(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::MeshBase::sync_subdomain_name_map(), ConstraintOperatorTest::test1DCoarseningNewNodes(), ConstraintOperatorTest::test1DCoarseningOperator(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), DofMapTest::testBadElemFECombo(), SystemsTest::testBlockRestrictedVarNDofs(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), CheckpointIOTest::testC0PolygonCheckpoint(), VolumeTest::testC0PolygonMethods(), CheckpointIOTest::testC0PolyhedronCheckpoint(), VolumeTest::testC0PolyhedronMethods(), ConstraintOperatorTest::testCoreform(), ConnectedComponentsTest::testEdge(), MeshInputTest::testExodusIGASidesets(), MeshTriangulationTest::testFoundCenters(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), PointLocatorTest::testPlanar(), MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup(), MeshTriangulationTest::testPoly2TriRefinementBase(), SystemsTest::testProjectCubeWithMeshFunction(), SystemsTest::testProjectScalarCoarsening(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testSelectiveRenumber(), BoundaryMeshSubdomainTest::testSingleSubdomain(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshTriangulationTest::testTriangulatorInterp(), MeshTriangulationTest::testTriangulatorMeshedHoles(), MeshTriangulationTest::testTriangulatorRoundHole(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::RBConstruction::train_reduced_basis_with_POD(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::Poly2TriTriangulator::triangulate(), libMesh::RBConstruction::truth_assembly(), libMesh::TransientRBConstruction::truth_assembly(), update_current_local_solution(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::RBEvaluation::write_out_vectors(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::RBDataSerialization::RBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::TransientRBEvaluationSerialization::write_to_file(), libMesh::RBDataSerialization::RBEIMEvaluationSerialization::write_to_file(), and libMesh::RBDataSerialization::RBSCMEvaluationSerialization::write_to_file().

disable_print_counter_info()

void libMesh::ReferenceCounter::disable_print_counter_info ( )

staticinherited

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

Methods to enable/disable the reference counter output from print_info().

Enabled by default.

Definition at line 94 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

get_converged_reason()

template<typename T >

int libMesh::NloptOptimizationSolver< T >::get_converged_reason ( )

overridevirtual

Returns

The currently-available (or most recently obtained, if the NLopt object has been destroyed) convergence reason. Refer to NLopt docs for the meaning of different the value.

Reimplemented from libMesh::OptimizationSolver< T >.

Definition at line 445 of file nlopt_optimization_solver.C.

{
  return static_cast<int>(_result);
}

get_dual_variables()

template<typename T >

virtual void libMesh::OptimizationSolver< T >::get_dual_variables ( )

inlinevirtualinherited

Get the current values of dual variables associated with inequality and equality constraints.

The variables will be stored in _system.lambda_eq and _system.lambda_ineq.

Reimplemented in libMesh::TaoOptimizationSolver< T >.

Definition at line 105 of file optimization_solver.h.

  { libmesh_not_implemented(); }

get_info()

std::string libMesh::ReferenceCounter::get_info ( )

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
  std::ostringstream oss;
 
  oss << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
 
  for (const auto & [name, cd] : _counts)
    oss << "| " << name << " reference count information:\n"
        << "|  Creations:    " << cd.first    << '\n'
        << "|  Destructions: " << cd.second << '\n';
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts.

Referenced by libMesh::ReferenceCounter::print_info().

get_iteration_count()

template<typename T >

unsigned & libMesh::NloptOptimizationSolver< T >::get_iteration_count ( )

inline

Returns

A writable reference to the current iteration count which can be incremented in the objective function.

Definition at line 127 of file nlopt_optimization_solver.h.

{ return _iteration_count; }

References libMesh::NloptOptimizationSolver< T >::_iteration_count.

get_nlopt_object()

template<typename T >

nlopt_opt libMesh::NloptOptimizationSolver< T >::get_nlopt_object ( )

inline

Returns

The raw NLopt object.

Definition at line 103 of file nlopt_optimization_solver.h.

{ this->init(); return _opt; }

References libMesh::NloptOptimizationSolver< T >::_opt, and libMesh::NloptOptimizationSolver< T >::init().

increment_constructor_count()

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name )

inlineprotectednoexceptinherited

Increments the construction counter.

Should be called in the constructor of any derived class that will be reference counted.

Definition at line 183 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.first++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_constructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), libMesh::ReferenceCountedObject< T >::ReferenceCountedObject(), and libMesh::ReferenceCountedObject< T >::ReferenceCountedObject().

increment_destructor_count()

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name )

inlineprotectednoexceptinherited

Increments the destruction counter.

Should be called in the destructor of any derived class that will be reference counted.

Definition at line 207 of file reference_counter.h.

{
  libmesh_try
  {
    Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
    std::pair<unsigned int, unsigned int> & p = _counts[name];
    p.second++;
  }
  libmesh_catch (...)
  {
    auto stream = libMesh::err.get();
    stream->exceptions(stream->goodbit); // stream must not throw
    libMesh::err << "Encountered unrecoverable error while calling "
                 << "ReferenceCounter::increment_destructor_count() "
                 << "for a(n) " << name << " object." << std::endl;
    std::terminate();
  }
}

References libMesh::err, libMesh::BasicOStreamProxy< charT, traits >::get(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< T >::~ReferenceCountedObject().

init()

template<typename T >

void libMesh::NloptOptimizationSolver< T >::init ( )

overridevirtual

Initialize data structures if not done so already.

Implements libMesh::OptimizationSolver< T >.

Definition at line 313 of file nlopt_optimization_solver.C.

{
  // Initialize the data structures if not done so already.
  if (!this->initialized())
    {
      this->_is_initialized = true;
 
      // By default, use the LD_SLSQP solver
      std::string nlopt_algorithm_name = "LD_SLSQP";
 
      if (libMesh::on_command_line("--nlopt-algorithm"))
        nlopt_algorithm_name = libMesh::command_line_next ("--nlopt-algorithm",
                                                           nlopt_algorithm_name);
 
      // Convert string to an nlopt algorithm type
      _opt = nlopt_create(libmesh_map_find(_nlopt_algorithms, nlopt_algorithm_name),
                          this->system().solution->size());
    }
}

References libMesh::command_line_next(), libMesh::initialized(), and libMesh::on_command_line().

Referenced by libMesh::NloptOptimizationSolver< T >::get_nlopt_object().

initialized()

template<typename T >

bool libMesh::OptimizationSolver< T >::initialized ( ) const

inlineinherited

Returns

true if the data structures are initialized, false otherwise.

Definition at line 83 of file optimization_solver.h.

{ return _is_initialized; }

References libMesh::OptimizationSolver< T >::_is_initialized.

n_objects()

static unsigned int libMesh::ReferenceCounter::n_objects ( )

inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 85 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

Referenced by libMesh::LibMeshInit::~LibMeshInit().

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 103 of file parallel_object.h.

  {
    processor_id_type returnval =
      cast_int<processor_id_type>(_communicator.size());
    libmesh_assert(returnval); // We never have an empty comm
    return returnval;
  }

References libMesh::ParallelObject::_communicator, libMesh::libmesh_assert(), and libMesh::Parallel::Communicator::size().

Referenced by libMesh::Partitioner::_find_global_index_by_pid_map(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DistributedMesh::add_node(), libMesh::System::add_vector(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::Partitioner::build_graph(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::copy_nodes_and_elements(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DistributedMesh::DistributedMesh(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::MeshBase::get_info(), libMesh::StaticCondensation::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_petscdm(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), libMesh::NumericVector< T >::is_effectively_ghosted(), libMesh::NumericVector< T >::is_effectively_serial(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_topology_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::DofMap::n_dofs_per_processor(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::XdrIO::read_header(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::Partitioner::repartition(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), WriteVecAndScalar::setupTests(), libMesh::RBEIMEvaluation::side_gather_bfs(), DistributedMeshTest::testRemoteElemError(), CheckpointIOTest::testSplitter(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

print_converged_reason()

template<typename T >

void libMesh::NloptOptimizationSolver< T >::print_converged_reason ( )

overridevirtual

Prints a useful message about why the latest optimization solve con(di)verged.

Reimplemented from libMesh::OptimizationSolver< T >.

Definition at line 436 of file nlopt_optimization_solver.C.

{
  libMesh::out << "NLopt optimization solver convergence/divergence reason: "
               << this->get_converged_reason() << std::endl;
}

References libMesh::out.

print_info()

void libMesh::ReferenceCounter::print_info ( std::ostream &  out_stream = libMesh::out )

staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 81 of file reference_counter.C.

{
  if (_enable_print_counter)
    out_stream << ReferenceCounter::get_info();
}

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::~LibMeshInit().

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 114 of file parallel_object.h.

  { return cast_int<processor_id_type>(_communicator.rank()); }

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DistributedMesh::add_node(), libMesh::MeshTools::Modification::all_tri(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO::assert_symmetric_cmaps(), libMesh::Partitioner::assign_partitioning(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Partitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::MeshFunction::check_found_elem(), libMesh::DistributedMesh::clear(), libMesh::DistributedMesh::clear_elems(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::RBConstruction::compute_max_error_bound(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_nodal_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::Nemesis_IO::copy_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMapBase::first_dof(), libMesh::DofMapBase::first_old_dof(), libMesh::RBEIMEvaluation::gather_bfs(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::RBEIMEvaluation::get_interior_basis_functions_as_vecs(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::get_local_constraints(), libMesh::MeshBase::get_local_constraints(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::SparsityPattern::Build::handle_vi_vj(), libMesh::LaplaceMeshSmoother::init(), libMesh::SystemSubsetBySubdomain::init(), HeatSystem::init_data(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::DistributedMesh::insert_elem(), libMesh::MeshTools::Modification::interpolate_surface(), libMesh::SparsityPattern::Build::join(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_contiguous_dof_ids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), main(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::MeshTools::n_connected_components(), libMesh::MeshBase::n_constraint_rows(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMapBase::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::RBEIMEvaluation::node_gather_bfs(), libMesh::DistributedMesh::own_node(), libMesh::BoundaryInfo::parallel_sync_node_ids(), libMesh::BoundaryInfo::parallel_sync_side_ids(), libMesh::MeshBase::print_constraint_rows(), libMesh::DofMap::print_dof_constraints(), libMesh::DofMap::process_mesh_constraint_rows(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::XdrIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::NameBasedIO::read(), libMesh::EquationSystems::read(), libMesh::EquationSystems::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::ExodusII_IO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::DynaIO::read_mesh(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::RBConstruction::read_riesz_representors_from_files(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::Nemesis_IO_Helper::read_var_names_impl(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::StaticCondensationDofMap::reinit(), libMesh::DistributedMesh::renumber_dof_objects(), libMesh::DistributedMesh::renumber_nodes_and_elements(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DistributedMesh::set_next_unique_id(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::RBEIMEvaluation::side_gather_bfs(), MeshFunctionTest::test_bad_gradient_var_with_out_of_mesh_value(), MeshFunctionTest::test_bad_hessian_var_with_out_of_mesh_value(), ExodusTest< elem_type >::test_read_gold(), ExodusTest< elem_type >::test_write(), ExodusC0PolyhedronTest::test_write_and_read_hexagonal_prism(), ExodusC0PolygonTest::test_write_and_read_pentagon(), MeshInputTest::testAbaqusRead(), MeshInputTest::testBadGmsh(), BoundaryInfoTest::testBoundaryIDs(), MeshInputTest::testCopyElementSolutionImpl(), MeshInputTest::testCopyElementVectorImpl(), MeshInputTest::testCopyNodalSolutionImpl(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaFileMappings(), MeshInputTest::testDynaNoSplines(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusFileMappings(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), MeshInputTest::testGmshBCIDOverlap(), MeshInputTest::testGoodGmsh(), MeshInputTest::testGoodSTL(), MeshInputTest::testGoodSTLBinary(), BoundaryInfoTest::testInternalBoundary(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryMeshSubdomainTest::testPerBoundarySubdomain(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), MeshInputTest::testSingleElementImpl(), BoundaryMeshSubdomainTest::testSingleSubdomain(), WriteVecAndScalar::testSolution(), CheckpointIOTest::testSplitter(), MeshInputTest::testTetgenIO(), MeshSmootherTest::testVariationalSmoother(), libMesh::MeshTools::total_weight(), libMesh::NetGenMeshInterface::triangulate(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::MeshTools::volume(), libMesh::STLIO::write(), libMesh::XdrIO::write(), libMesh::NameBasedIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO::write_element_data_from_discontinuous_nodal_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_element_values_element_major(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elemset_data(), libMesh::ExodusII_IO_Helper::write_elemsets(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_common(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodeset_data(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::RBEIMEvaluation::write_out_interior_basis_functions(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), write_output_solvedata(), libMesh::System::write_parallel_data(), libMesh::RBConstruction::write_riesz_representors_to_files(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sideset_data(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), libMesh::ExodusII_IO_Helper::write_timestep(), and libMesh::ExodusII_IO::write_timestep_discontinuous().

solve()

template<typename T >

void libMesh::NloptOptimizationSolver< T >::solve ( )

overridevirtual

Call the NLopt solver.

Implements libMesh::OptimizationSolver< T >.

Definition at line 336 of file nlopt_optimization_solver.C.

{
  LOG_SCOPE("solve()", "NloptOptimizationSolver");
 
  this->init ();
 
  unsigned int nlopt_size = this->system().solution->size();
 
  // We have to have an objective function
  libmesh_assert( this->objective_object );
 
  // Set routine for objective and (optionally) gradient evaluation
  {
    nlopt_result ierr =
      nlopt_set_min_objective(_opt,
                              __libmesh_nlopt_objective,
                              this);
    libmesh_error_msg_if(ierr < 0, "NLopt failed to set min objective: " << ierr);
  }
 
  if (this->lower_and_upper_bounds_object)
    {
      // Need to actually compute the bounds vectors first
      this->lower_and_upper_bounds_object->lower_and_upper_bounds(this->system());
 
      std::vector<Real> nlopt_lb(nlopt_size);
      std::vector<Real> nlopt_ub(nlopt_size);
      for (unsigned int i = 0; i < nlopt_size; ++i)
        {
          nlopt_lb[i] = this->system().get_vector("lower_bounds")(i);
          nlopt_ub[i] = this->system().get_vector("upper_bounds")(i);
        }
 
      nlopt_set_lower_bounds(_opt, nlopt_lb.data());
      nlopt_set_upper_bounds(_opt, nlopt_ub.data());
    }
 
  // If we have an equality constraints object, tell NLopt about it.
  if (this->equality_constraints_object)
    {
      // NLopt requires a vector to specify the tolerance for each constraint.
      // NLopt makes a copy of this vector internally, so it's safe for us to
      // let it go out of scope.
      std::vector<double> equality_constraints_tolerances(this->system().C_eq->size(),
                                                          _constraints_tolerance);
 
      // It would be nice to call the C interface directly, at least it should return an error
      // code we could parse... unfortunately, there does not seem to be a way to extract
      // the underlying nlopt_opt object from the nlopt::opt class!
      nlopt_result ierr =
        nlopt_add_equality_mconstraint(_opt,
                                       equality_constraints_tolerances.size(),
                                       __libmesh_nlopt_equality_constraints,
                                       this,
                                       equality_constraints_tolerances.data());
 
      libmesh_error_msg_if(ierr < 0, "NLopt failed to add equality constraint: " << ierr);
    }
 
  // If we have an inequality constraints object, tell NLopt about it.
  if (this->inequality_constraints_object)
    {
      // NLopt requires a vector to specify the tolerance for each constraint
      std::vector<double> inequality_constraints_tolerances(this->system().C_ineq->size(),
                                                            _constraints_tolerance);
 
      nlopt_add_inequality_mconstraint(_opt,
                                       inequality_constraints_tolerances.size(),
                                       __libmesh_nlopt_inequality_constraints,
                                       this,
                                       inequality_constraints_tolerances.data());
    }
 
  // Set a relative tolerance on the optimization parameters
  nlopt_set_ftol_rel(_opt, this->objective_function_relative_tolerance);
 
  // Set the maximum number of allowed objective function evaluations
  nlopt_set_maxeval(_opt, this->max_objective_function_evaluations);
 
  // Reset internal iteration counter
  this->_iteration_count = 0;
 
  // Perform the optimization
  std::vector<Real> x(nlopt_size);
  Real min_val = 0.;
  _result = nlopt_optimize(_opt, x.data(), &min_val);
 
  if (_result < 0)
    libMesh::out << "NLopt failed!" << std::endl;
  else
    libMesh::out << "NLopt obtained optimal value: "
                 << min_val
                 << " in "
                 << this->get_iteration_count()
                 << " iterations."
                 << std::endl;
}

References libMesh::__libmesh_nlopt_equality_constraints(), libMesh::__libmesh_nlopt_inequality_constraints(), libMesh::__libmesh_nlopt_objective(), libMesh::libmesh_assert(), libMesh::out, and libMesh::Real.

system() [1/2]

template<typename T >

sys_type & libMesh::OptimizationSolver< T >::system ( )

inlineinherited

Returns

A writable reference to the system we are using to define the optimization problem.

Definition at line 180 of file optimization_solver.h.

{ return _system; }

References libMesh::OptimizationSolver< T >::_system.

system() [2/2]

template<typename T >

const sys_type & libMesh::OptimizationSolver< T >::system ( ) const

inlineinherited

Returns

A constant reference to the system we are using to define the optimization problem.

Definition at line 174 of file optimization_solver.h.

{ return _system; }

References libMesh::OptimizationSolver< T >::_system.

Friends And Related Symbol Documentation

__libmesh_nlopt_equality_constraints

template<typename T >

void __libmesh_nlopt_equality_constraints ( unsigned  m, double *  result, unsigned  n, const double *  x, double *  gradient, void *  data  )

friend

Definition at line 107 of file nlopt_optimization_solver.C.

{
  LOG_SCOPE("equality_constraints()", "NloptOptimizationSolver");
 
  libmesh_assert(data);
 
  // data should be a pointer to the solver (it was passed in as void *)
  NloptOptimizationSolver<Number> * solver =
    static_cast<NloptOptimizationSolver<Number> *> (data);
 
  OptimizationSystem & sys = solver->system();
 
  // We'll use current_local_solution below, so let's ensure that it's consistent
  // with the vector x that was passed in.
  libmesh_error_msg_if(sys.solution->size() != n,
                       "Error: Input vector x has different length than sys.solution!");
 
  for (auto i : index_range(*sys.solution))
    sys.solution->set(i, x[i]);
  sys.solution->close();
 
  // Impose constraints on the solution vector
  sys.get_dof_map().enforce_constraints_exactly(sys);
 
  // Update sys.current_local_solution based on the solution vector
  sys.update();
 
  // Call the user's equality constraints function if there is one.
  OptimizationSystem::ComputeEqualityConstraints * eco = solver->equality_constraints_object;
  if (eco)
    {
      eco->equality_constraints(*sys.current_local_solution,
                                *sys.C_eq,
                                sys);
 
      sys.C_eq->close();
 
      // Copy the values out of eq_constraints into 'result'.
      // TODO: Even better would be if we could use 'result' directly
      // as the storage of eq_constraints.  Perhaps a serial-only
      // NumericVector variant which supports this option?
      for (unsigned int i = 0; i < m; ++i)
        result[i] = (*sys.C_eq)(i);
 
      // If gradient != nullptr, then the Jacobian matrix of the equality
      // constraints has been requested.  The incoming 'gradient'
      // array is of length m*n and d(c_i)/d(x_j) = gradient[n*i+j].
      if (gradient)
        {
          OptimizationSystem::ComputeEqualityConstraintsJacobian * eco_jac =
            solver->equality_constraints_jacobian_object;
 
          if (eco_jac)
            {
              eco_jac->equality_constraints_jacobian(*sys.current_local_solution,
                                                     *sys.C_eq_jac,
                                                     sys);
 
              sys.C_eq_jac->close();
 
              // copy the Jacobian data to the gradient array
              for (numeric_index_type i=0; i<m; i++)
                for (const auto & dof_index : sys.eq_constraint_jac_sparsity[i])
                  gradient[n*i+dof_index] = (*sys.C_eq_jac)(i,dof_index);
            }
          else
            libmesh_error_msg("Jacobian function not defined in __libmesh_nlopt_equality_constraints");
        }
 
    }
  else
    libmesh_error_msg("Constraints function not defined in __libmesh_nlopt_equality_constraints");
}

__libmesh_nlopt_inequality_constraints

template<typename T >

void __libmesh_nlopt_inequality_constraints ( unsigned  m, double *  result, unsigned  n, const double *  x, double *  gradient, void *  data  )

friend

Definition at line 187 of file nlopt_optimization_solver.C.

{
  LOG_SCOPE("inequality_constraints()", "NloptOptimizationSolver");
 
  libmesh_assert(data);
 
  // data should be a pointer to the solver (it was passed in as void *)
  NloptOptimizationSolver<Number> * solver =
    static_cast<NloptOptimizationSolver<Number> *> (data);
 
  OptimizationSystem & sys = solver->system();
 
  // We'll use current_local_solution below, so let's ensure that it's consistent
  // with the vector x that was passed in.
  libmesh_error_msg_if(sys.solution->size() != n, "Error: Input vector x has different length than sys.solution!");
 
  for (auto i : index_range(*sys.solution))
    sys.solution->set(i, x[i]);
  sys.solution->close();
 
  // Impose constraints on the solution vector
  sys.get_dof_map().enforce_constraints_exactly(sys);
 
  // Update sys.current_local_solution based on the solution vector
  sys.update();
 
  // Call the user's inequality constraints function if there is one.
  OptimizationSystem::ComputeInequalityConstraints * ineco = solver->inequality_constraints_object;
  if (ineco)
    {
      ineco->inequality_constraints(*sys.current_local_solution,
                                    *sys.C_ineq,
                                    sys);
 
      sys.C_ineq->close();
 
      // Copy the values out of ineq_constraints into 'result'.
      // TODO: Even better would be if we could use 'result' directly
      // as the storage of ineq_constraints.  Perhaps a serial-only
      // NumericVector variant which supports this option?
      for (unsigned int i = 0; i < m; ++i)
        result[i] = (*sys.C_ineq)(i);
 
      // If gradient != nullptr, then the Jacobian matrix of the equality
      // constraints has been requested.  The incoming 'gradient'
      // array is of length m*n and d(c_i)/d(x_j) = gradient[n*i+j].
      if (gradient)
        {
          OptimizationSystem::ComputeInequalityConstraintsJacobian * ineco_jac =
            solver->inequality_constraints_jacobian_object;
 
          if (ineco_jac)
            {
              ineco_jac->inequality_constraints_jacobian(*sys.current_local_solution,
                                                         *sys.C_ineq_jac,
                                                         sys);
 
              sys.C_ineq_jac->close();
 
              // copy the Jacobian data to the gradient array
              for (numeric_index_type i=0; i<m; i++)
                for (const auto & dof_index : sys.ineq_constraint_jac_sparsity[i])
                  gradient[n*i+dof_index] = (*sys.C_ineq_jac)(i,dof_index);
            }
          else
            libmesh_error_msg("Jacobian function not defined in __libmesh_nlopt_inequality_constraints");
        }
 
    }
  else
    libmesh_error_msg("Constraints function not defined in __libmesh_nlopt_inequality_constraints");
}

__libmesh_nlopt_objective

template<typename T >

double __libmesh_nlopt_objective ( unsigned  n, const double *  x, double *  gradient, void *  data  )

friend

Definition at line 37 of file nlopt_optimization_solver.C.

{
  LOG_SCOPE("objective()", "NloptOptimizationSolver");
 
  // ctx should be a pointer to the solver (it was passed in as void *)
  NloptOptimizationSolver<Number> * solver =
    static_cast<NloptOptimizationSolver<Number> *> (data);
 
  OptimizationSystem & sys = solver->system();
 
  // We'll use current_local_solution below, so let's ensure that it's consistent
  // with the vector x that was passed in.
  for (auto i : index_range(*sys.solution))
    sys.solution->set(i, x[i]);
 
  // Make sure the solution vector is parallel-consistent
  sys.solution->close();
 
  // Impose constraints on X
  sys.get_dof_map().enforce_constraints_exactly(sys);
 
  // Update sys.current_local_solution based on X
  sys.update();
 
  Real objective;
  if (solver->objective_object != nullptr)
    {
      objective =
        solver->objective_object->objective(*(sys.current_local_solution), sys);
    }
  else
    {
      libmesh_error_msg("Objective function not defined in __libmesh_nlopt_objective");
    }
 
  // If the gradient has been requested, fill it in
  if (gradient)
    {
      if (solver->gradient_object != nullptr)
        {
          solver->gradient_object->gradient(*(sys.current_local_solution), *(sys.rhs), sys);
 
          // we've filled up sys.rhs with the gradient data, now copy it
          // to the nlopt data structure
          libmesh_assert(sys.rhs->size() == n);
 
          std::vector<double> grad;
          sys.rhs->localize_to_one(grad);
          for (unsigned int i = 0; i < n; ++i)
            gradient[i] = grad[i];
        }
      else
        libmesh_error_msg("Gradient function not defined in __libmesh_nlopt_objective");
    }
 
  // Increment the iteration count.
  solver->get_iteration_count()++;
 
  // Possibly print the current value of the objective function
  if (solver->verbose)
    libMesh::out << objective << std::endl;
 
  return objective;
}

Member Data Documentation

_communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), libMesh::BoundaryInfo::regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and libMesh::BoundaryInfo::synchronize_global_id_set().

_constraints_tolerance

template<typename T >

double libMesh::NloptOptimizationSolver< T >::_constraints_tolerance

protected

NLopt requires us to specify a tolerance for the constraints.

Definition at line 149 of file nlopt_optimization_solver.h.

_counts

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts

staticprotectedinherited

Actually holds the data.

Definition at line 124 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info().

_enable_print_counter

bool libMesh::ReferenceCounter::_enable_print_counter = true

staticprotectedinherited

Flag to control whether reference count information is printed when print_info is called.

Definition at line 143 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

_is_initialized

template<typename T >

bool libMesh::OptimizationSolver< T >::_is_initialized

protectedinherited

Flag indicating if the data structures have been initialized.

Definition at line 207 of file optimization_solver.h.

Referenced by libMesh::OptimizationSolver< T >::initialized().

_iteration_count

template<typename T >

unsigned libMesh::NloptOptimizationSolver< T >::_iteration_count

protected

Stores the current iteration index (incremented at each call of __libmesh_nlopt_objective).

Definition at line 144 of file nlopt_optimization_solver.h.

Referenced by libMesh::NloptOptimizationSolver< T >::get_iteration_count().

_mutex

Threads::spin_mutex libMesh::ReferenceCounter::_mutex

staticprotectedinherited

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 137 of file reference_counter.h.

_n_objects

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects

staticprotectedinherited

The number of objects.

Print the reference count information when the number returns to 0.

Definition at line 132 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

_nlopt_algorithms

template<typename T >

std::map< std::string, nlopt_algorithm > libMesh::NloptOptimizationSolver< T >::_nlopt_algorithms = NloptOptimizationSolver<T>::build_map()

staticprivate

Definition at line 174 of file nlopt_optimization_solver.h.

_opt

template<typename T >

nlopt_opt libMesh::NloptOptimizationSolver< T >::_opt

protected

Optimization solver context.

Definition at line 134 of file nlopt_optimization_solver.h.

Referenced by libMesh::NloptOptimizationSolver< T >::get_nlopt_object().

_result

template<typename T >

nlopt_result libMesh::NloptOptimizationSolver< T >::_result

protected

Store the result (i.e.

convergence/divergence) for the most recent NLopt solve.

Definition at line 139 of file nlopt_optimization_solver.h.

_system

template<typename T >

sys_type& libMesh::OptimizationSolver< T >::_system

protectedinherited

A reference to the system we are solving.

Definition at line 202 of file optimization_solver.h.

Referenced by libMesh::OptimizationSolver< T >::system(), and libMesh::OptimizationSolver< T >::system().

equality_constraints_jacobian_object

template<typename T >

OptimizationSystem::ComputeEqualityConstraintsJacobian* libMesh::OptimizationSolver< T >::equality_constraints_jacobian_object

inherited

Object that computes the Jacobian of C_eq(X).

Definition at line 152 of file optimization_solver.h.

equality_constraints_object

template<typename T >

OptimizationSystem::ComputeEqualityConstraints* libMesh::OptimizationSolver< T >::equality_constraints_object

inherited

Object that computes the equality constraints vector C_eq(X).

This will lead to the constraints C_eq(X) = 0 being imposed.

Definition at line 147 of file optimization_solver.h.

gradient_object

template<typename T >

OptimizationSystem::ComputeGradient* libMesh::OptimizationSolver< T >::gradient_object

inherited

Object that computes the gradient grad_f(X) of the objective function at the input iterate X.

Definition at line 135 of file optimization_solver.h.

hessian_object

template<typename T >

OptimizationSystem::ComputeHessian* libMesh::OptimizationSolver< T >::hessian_object

inherited

Object that computes the Hessian H_f(X) of the objective function at the input iterate X.

Definition at line 141 of file optimization_solver.h.

inequality_constraints_jacobian_object

template<typename T >

OptimizationSystem::ComputeInequalityConstraintsJacobian* libMesh::OptimizationSolver< T >::inequality_constraints_jacobian_object

inherited

Object that computes the Jacobian of C_ineq(X).

Definition at line 163 of file optimization_solver.h.

inequality_constraints_object

template<typename T >

OptimizationSystem::ComputeInequalityConstraints* libMesh::OptimizationSolver< T >::inequality_constraints_object

inherited

Object that computes the inequality constraints vector C_ineq(X).

This will lead to the constraints C_ineq(X) >= 0 being imposed.

Definition at line 158 of file optimization_solver.h.

lower_and_upper_bounds_object

template<typename T >

OptimizationSystem::ComputeLowerAndUpperBounds* libMesh::OptimizationSolver< T >::lower_and_upper_bounds_object

inherited

Object that computes the lower and upper bounds vectors.

Definition at line 168 of file optimization_solver.h.

max_objective_function_evaluations

template<typename T >

unsigned int libMesh::OptimizationSolver< T >::max_objective_function_evaluations

inherited

Maximum number of objective function evaluations allowed.

Definition at line 185 of file optimization_solver.h.

objective_function_relative_tolerance

template<typename T >

double libMesh::OptimizationSolver< T >::objective_function_relative_tolerance

inherited

Required change in objective function which signals convergence.

Definition at line 190 of file optimization_solver.h.

objective_object

template<typename T >

OptimizationSystem::ComputeObjective* libMesh::OptimizationSolver< T >::objective_object

inherited

Object that computes the objective function f(X) at the input iterate X.

Definition at line 129 of file optimization_solver.h.

verbose

template<typename T >

bool libMesh::OptimizationSolver< T >::verbose

inherited

Control how much is output from the OptimizationSolver as it's running.

Definition at line 195 of file optimization_solver.h.

---

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

• include/solvers/nlopt_optimization_solver.h
• src/solvers/nlopt_optimization_solver.C