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. More...

Public Member Functions
	NloptOptimizationSolver (sys_type &system)
	Constructor. More...
	~NloptOptimizationSolver ()
	Destructor. More...
virtual void	clear () override
	Release all memory and clear data structures. More...
virtual void	init () override
	Initialize data structures if not done so already. More...
nlopt_opt	get_nlopt_object ()
virtual void	solve () override
	Call the NLopt solver. More...
virtual void	print_converged_reason () override
	Prints a useful message about why the latest optimization solve con(di)verged. More...
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. More...
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. More...
static std::string	get_info ()
	Gets a string containing the reference information. More...
static void	print_info (std::ostream &out=libMesh::out)
	Prints the reference information, by default to libMesh::out. More...
static unsigned int	n_objects ()
	Prints the number of outstanding (created, but not yet destroyed) objects. More...
static void	enable_print_counter_info ()
	Methods to enable/disable the reference counter output from print_info() More...
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. More...
OptimizationSystem::ComputeGradient *	gradient_object
	Object that computes the gradient grad_f(X) of the objective function at the input iterate X. More...
OptimizationSystem::ComputeHessian *	hessian_object
	Object that computes the Hessian H_f(X) of the objective function at the input iterate X. More...
OptimizationSystem::ComputeEqualityConstraints *	equality_constraints_object
	Object that computes the equality constraints vector C_eq(X). More...
OptimizationSystem::ComputeEqualityConstraintsJacobian *	equality_constraints_jacobian_object
	Object that computes the Jacobian of C_eq(X). More...
OptimizationSystem::ComputeInequalityConstraints *	inequality_constraints_object
	Object that computes the inequality constraints vector C_ineq(X). More...
OptimizationSystem::ComputeInequalityConstraintsJacobian *	inequality_constraints_jacobian_object
	Object that computes the Jacobian of C_ineq(X). More...
OptimizationSystem::ComputeLowerAndUpperBounds *	lower_and_upper_bounds_object
	Object that computes the lower and upper bounds vectors. More...
unsigned int	max_objective_function_evaluations
	Maximum number of objective function evaluations allowed. More...
double	objective_function_relative_tolerance
	Required change in objective function which signals convergence. More...
bool	verbose
	Control how much is output from the OptimizationSolver as it's running. More...

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

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

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

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

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 117 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 273 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.
  if (sizeof(dof_id_type) != sizeof(unsigned int))
    libmesh_error_msg("The NloptOptimizationSolver should not be used with dof_id_type != unsigned int.");
}

~NloptOptimizationSolver()

template<typename T >

libMesh::NloptOptimizationSolver< T >::~NloptOptimizationSolver

(

)

Destructor.

Definition at line 293 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 libmesh_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 libmesh_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.

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 301 of file nlopt_optimization_solver.C.

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

References libMesh::libMeshPrivateData::_is_initialized, and 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 94 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::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), libMesh::__libmesh_tao_objective(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::BoundaryInfo::_find_id_maps(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult(), libMesh::SlepcEigenSolver< libMesh::Number >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< Number >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::MeshRefinement::_smooth_flags(), 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::ImplicitSystem::add_matrix(), libMesh::RBConstruction::add_scaled_matrix_and_vector(), libMesh::DynaIO::add_spline_constraints(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::TransientRBConstruction::allocate_data_structures(), libMesh::RBConstruction::allocate_data_structures(), libMesh::TransientRBConstruction::assemble_affine_expansion(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::Generation::build_extrusion(), 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::System::calculate_norm(), libMesh::DofMap::check_dirichlet_bcid_consistency(), 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::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::ExodusII_IO::copy_elemental_solution(), libMesh::ExodusII_IO::copy_scalar_solution(), 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::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMlibMeshSetSystem_libMesh(), DMVariableBounds_libMesh(), libMesh::DTKSolutionTransfer::DTKSolutionTransfer(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::RBEIMConstruction::enrich_RB_space(), libMesh::TransientRBConstruction::enrich_RB_space(), libMesh::RBConstruction::enrich_RB_space(), libMesh::EpetraVector< T >::EpetraVector(), AssembleOptimization::equality_constraints(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::RBEIMConstruction::evaluate_mesh_function(), 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::DofMap::gather_constraints(), libMesh::MeshfreeInterpolation::gather_remote_data(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::ImplicitSystem::get_linear_solver(), AssembleOptimization::inequality_constraints(), AssembleOptimization::inequality_constraints_jacobian(), libMesh::LocationMap< T >::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::EigenSystem::init_matrices(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), libMesh::RBEIMConstruction::initialize_rb_construction(), integrate_function(), 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_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::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_preconditioner_apply(), libMesh::libmesh_petsc_snes_fd_residual(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_mffd_residual(), libMesh::libmesh_petsc_snes_postcheck(), libMesh::libmesh_petsc_snes_residual(), libMesh::libmesh_petsc_snes_residual_helper(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::limit_overrefined_boundary(), libMesh::MeshRefinement::limit_underrefined_boundary(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_new_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_new_nodes_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::MeshRefinement::make_refinement_compatible(), libMesh::TransientRBConstruction::mass_matrix_scaled_matvec(), libMesh::FEMSystem::mesh_position_set(), LinearElasticityWithContact::move_mesh(), libMesh::DistributedMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::DofMap::n_constrained_dofs(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::DistributedMesh::parallel_max_elem_id(), libMesh::DistributedMesh::parallel_max_node_id(), libMesh::ReplicatedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_max_unique_id(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::MeshTools::paranoid_n_levels(), libMesh::petsc_auto_fieldsplit(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), FEMParameters::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::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::MeshRefinement::refine_and_coarsen_elements(), libMesh::DistributedMesh::renumber_dof_objects(), LinearElasticityWithContact::residual_and_jacobian(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::TransientRBConstruction::set_error_temporal_data(), libMesh::RBEIMConstruction::set_explicit_sys_subvector(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::PetscDiffSolver::setup_petsc_data(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::split_mesh(), libMesh::BoundaryInfo::sync(), libMesh::MeshRefinement::test_level_one(), MeshfunctionDFEM::test_mesh_function_dfem(), MeshfunctionDFEM::test_mesh_function_dfem_grad(), MeshFunctionTest::test_p_level(), libMesh::MeshRefinement::test_unflagged(), SystemsTest::testBlockRestrictedVarNDofs(), PointLocatorTest::testLocator(), BoundaryInfoTest::testMesh(), SystemsTest::testProjectCubeWithMeshFunction(), CheckpointIOTest::testSplitter(), libMesh::MeshTools::total_weight(), libMesh::MeshFunctionSolutionTransfer::transfer(), libMesh::MeshfreeSolutionTransfer::transfer(), libMesh::TransientRBConstruction::truth_assembly(), libMesh::RBConstruction::truth_assembly(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::TransientRBConstruction::update_RB_initial_condition_all_N(), libMesh::RBEIMConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_RB_system_matrices(), libMesh::RBConstruction::update_RB_system_matrices(), libMesh::TransientRBConstruction::update_residual_terms(), libMesh::RBConstruction::update_residual_terms(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::VTKIO::write_nodal_data(), libMesh::RBEvaluation::write_out_vectors(), libMesh::TransientRBConstruction::write_riesz_representors_to_files(), libMesh::RBConstruction::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 106 of file reference_counter.C.

{
  _enable_print_counter = false;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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

enable_print_counter_info()

void libMesh::ReferenceCounter::enable_print_counter_info ( )

staticinherited

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

Definition at line 100 of file reference_counter.C.

{
  _enable_print_counter = true;
  return;
}

References libMesh::ReferenceCounter::_enable_print_counter.

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 448 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 113 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 & pr : _counts)
    {
      const std::string name(pr.first);
      const unsigned int creations    = pr.second.first;
      const unsigned int destructions = pr.second.second;
 
      oss << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }
 
  oss << " ---------------------------------------------------------------------------- \n";
 
  return oss.str();
 
#else
 
  return "";
 
#endif
}

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

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.

Referenced by libMesh::__libmesh_nlopt_objective().

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 )

inlineprotectedinherited

Increments the construction counter.

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

Definition at line 181 of file reference_counter.h.

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int> & p = _counts[name];
 
  p.first++;
}

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

increment_destructor_count()

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

inlineprotectedinherited

Increments the destruction counter.

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

Definition at line 194 of file reference_counter.h.

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int> & p = _counts[name];
 
  p.second++;
}

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~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 314 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::libMeshPrivateData::_is_initialized, 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 91 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 83 of file reference_counter.h.

  { return _n_objects; }

References libMesh::ReferenceCounter::_n_objects.

n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns

The number of processors in the group.

Definition at line 100 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::DofMap::add_constraints_to_send_list(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO::copy_scalar_solution(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::DistributedMesh::insert_elem(), 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::DofMap::local_variable_indices(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::partition(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::prepare_send_list(), libMesh::DofMap::print_dof_constraints(), libMesh::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::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(), OverlappingFunctorTest::run_partitioner_test(), libMesh::DofMap::scatter_constraints(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), 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 439 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 = libMesh::out )

staticinherited

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

Definition at line 87 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().

processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns

The rank of this processor in the group.

Definition at line 106 of file parallel_object.h.

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

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::EquationSystems::_read_impl(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::DistributedMesh::add_elem(), libMesh::BoundaryInfo::add_elements(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::DistributedMesh::add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::MeshTools::Modification::all_tri(), libMesh::DofMap::allgather_recursive_constraints(), libMesh::FEMSystem::assembly(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::DistributedMesh::clear(), 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_scalar_solution(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::ExodusII_IO_Helper::create(), libMesh::DistributedMesh::delete_elem(), libMesh::DistributedMesh::delete_node(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DistributedMesh::DistributedMesh(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::RBEIMConstruction::evaluate_mesh_function(), libMesh::MeshFunction::find_element(), libMesh::MeshFunction::find_elements(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), 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::DofMap::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::DofMap::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::SystemSubsetBySubdomain::init(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), 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::DofMap::is_evaluable(), libMesh::SparsityPattern::Build::join(), libMesh::DofMap::last_dof(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::RBEIMEvaluation::legacy_write_out_interpolation_points_elem(), 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(), libMesh::DofMap::local_variable_indices(), main(), libMesh::MeshRefinement::make_coarsening_compatible(), AugmentSparsityOnInterface::mesh_reinit(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::SparsityPattern::Build::operator()(), libMesh::DistributedMesh::own_node(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::DofMap::print_dof_constraints(), 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::NameBasedIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::CheckpointIO::read(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::ExodusII_IO_Helper::read_global_values(), libMesh::CheckpointIO::read_header(), libMesh::XdrIO::read_header(), libMesh::System::read_header(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::System::read_legacy_data(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::TransientRBConstruction::read_riesz_representors_from_files(), libMesh::RBConstruction::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::DistributedMesh::renumber_dof_objects(), libMesh::DofMap::scatter_constraints(), libMesh::CheckpointIO::select_split_config(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::PetscDMWrapper::set_point_range_in_section(), libMesh::LaplaceMeshSmoother::smooth(), DefaultCouplingTest::testCoupling(), PointNeighborCouplingTest::testCoupling(), MeshInputTest::testDynaReadElem(), MeshInputTest::testDynaReadPatch(), MeshInputTest::testExodusCopyElementSolution(), MeshInputTest::testExodusWriteElementDataFromDiscontinuousNodalData(), SystemsTest::testProjectMatrix1D(), SystemsTest::testProjectMatrix2D(), SystemsTest::testProjectMatrix3D(), BoundaryInfoTest::testShellFaceConstraints(), CheckpointIOTest::testSplitter(), WriteVecAndScalar::testWrite(), libMesh::MeshTools::total_weight(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::Parallel::Packing< Node * >::unpack(), libMesh::Parallel::Packing< Elem * >::unpack(), libMesh::DistributedMesh::update_parallel_id_counts(), libMesh::DTKAdapter::update_variable_values(), libMesh::NameBasedIO::write(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_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::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::VTKIO::write_nodal_data(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::RBEvaluation::write_out_vectors(), 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::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_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 337 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);
    if (ierr < 0)
      libmesh_error_msg("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());
 
      if (ierr < 0)
        libmesh_error_msg("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::ierr, libMesh::TriangleWrapper::init(), 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 188 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 182 of file optimization_solver.h.

{ return _system; }

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

Referenced by libMesh::__libmesh_nlopt_equality_constraints(), libMesh::__libmesh_nlopt_inequality_constraints(), libMesh::__libmesh_nlopt_objective(), libMesh::__libmesh_tao_equality_constraints(), libMesh::__libmesh_tao_equality_constraints_jacobian(), libMesh::__libmesh_tao_gradient(), libMesh::__libmesh_tao_hessian(), libMesh::__libmesh_tao_inequality_constraints(), libMesh::__libmesh_tao_inequality_constraints_jacobian(), and libMesh::__libmesh_tao_objective().

Friends And Related Function 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.
  if (sys.solution->size() != n)
    libmesh_error_msg("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.
  if (sys.solution->size() != n)
    libmesh_error_msg("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 112 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

_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 122 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

_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 141 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 215 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 135 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 130 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), 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 210 of file optimization_solver.h.

Referenced by 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 160 of file optimization_solver.h.

Referenced by libMesh::__libmesh_nlopt_equality_constraints(), and libMesh::__libmesh_tao_equality_constraints_jacobian().

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 155 of file optimization_solver.h.

Referenced by libMesh::__libmesh_nlopt_equality_constraints(), and libMesh::__libmesh_tao_equality_constraints().

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 143 of file optimization_solver.h.

Referenced by libMesh::__libmesh_nlopt_objective(), and libMesh::__libmesh_tao_gradient().

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 149 of file optimization_solver.h.

Referenced by libMesh::__libmesh_tao_hessian().

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 171 of file optimization_solver.h.

Referenced by libMesh::__libmesh_nlopt_inequality_constraints(), and libMesh::__libmesh_tao_inequality_constraints_jacobian().

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 166 of file optimization_solver.h.

Referenced by libMesh::__libmesh_nlopt_inequality_constraints(), and libMesh::__libmesh_tao_inequality_constraints().

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 176 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 193 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 198 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 137 of file optimization_solver.h.

Referenced by libMesh::__libmesh_nlopt_objective(), and libMesh::__libmesh_tao_objective().

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 203 of file optimization_solver.h.

Referenced by libMesh::__libmesh_nlopt_objective().

---

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

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