ThreeBarTrussFunction

class ThreeBarTrussFunction(P: float = 2.0, sigma_max: float = 2.0, objective: str = 'minimize', modifiers: List[BaseModifier] | None = None, memory: bool = False, collect_data: bool = True, callbacks=None, catch_errors=None, penalty_coefficient: float = 1000000.0)

Three-bar planar truss design optimization problem.

This classic structural engineering problem involves designing a three-bar planar truss to support a load P at minimum weight while satisfying stress constraints in each member.

Problem Description

The truss consists of three members arranged symmetrically: - Two diagonal members (area A1) at 45 degrees - One vertical member (area A2)

The structure must support a vertical load P applied at the junction point. The objective is to minimize the total weight (proportional to total material volume) while ensuring that stresses in all members remain below the allowable stress.

|------ L ------|
*               *
 \             /
  \ A1     A1 /
   \         /
    \       /
     \     /
      \   /
       \ /
        * ---- A2
        |
        | P (load)
        v

Design Variables

A1float

Cross-sectional area of diagonal members (dimensionless, normalized). Bounds: [0, 1]

A2float

Cross-sectional area of vertical member (dimensionless, normalized). Bounds: [0, 1]

Objective Function

Minimize weight:

\[f(A_1, A_2) = (2\sqrt{2} A_1 + A_2) \cdot L\]

where L is the member length (normalized to 1).

Constraints

Three stress constraints ensure members don’t exceed allowable stress:

\[ \begin{align}\begin{aligned}g_1: \frac{\sqrt{2} A_1 + A_2}{\sqrt{2} A_1^2 + 2 A_1 A_2} P - \sigma_{max} \leq 0\\g_2: \frac{A_2}{\sqrt{2} A_1^2 + 2 A_1 A_2} P - \sigma_{max} \leq 0\\g_3: \frac{1}{A_1 + \sqrt{2} A_2} P - \sigma_{max} \leq 0\end{aligned}\end{align} \]

Parameters:

• P (float, default=2.0) – Applied load magnitude.

• sigma_max (float, default=2.0) – Maximum allowable stress.

• objective (str, default="minimize") – Either “minimize” or “maximize”.

• sleep (float, default=0) – Artificial delay in seconds.

• penalty_coefficient (float, default=1e6) – Penalty coefficient for constraint violations.

f_global

Best known objective value: approximately 263.895843.

Type:

float

x_global

Best known solution: approximately [0.7886751346, 0.4082482905].

Type:

ndarray

References

[1]

Coello, C.A.C. (2000). “Use of a self-adaptive penalty approach for engineering optimization problems.” Computers in Industry, 41(2), 113-127.

Examples

>>> from surfaces.test_functions.engineering import ThreeBarTrussFunction
>>> func = ThreeBarTrussFunction()
>>> # Evaluate at a point
>>> result = func({"A1": 0.5, "A2": 0.5})
>>> # Check if solution is feasible
>>> func.is_feasible({"A1": 0.789, "A2": 0.408})
True

x_global: ndarray | None = array([0.78867513, 0.40824829])

__call__(params: Dict[str, Any] | ndarray | list | tuple | None = None, *, fidelity: float | None = None, **kwargs)

Evaluate the objective function.

Args:

params: Parameter values as dict, array, list, or tuple fidelity: Optional fidelity level in (0, 1]. Controls evaluation

cost vs accuracy trade-off for multi-fidelity optimization (e.g. Hyperband, BOHB). None means full-fidelity evaluation. Only supported by ML test functions; ignored by algebraic functions.

**kwargs: Parameters as keyword arguments (only with dict input)

Returns:

The objective function value

batch(X: ArrayLike) → ArrayLike

Evaluate multiple parameter sets in a single call.

Parameters:

X (ArrayLike) – 2D array of shape (n_points, n_dim) where each row is a parameter set.

Returns:

1D array of shape (n_points,) with evaluation results.

Return type:

ArrayLike

Raises:

• NotImplementedError – If the function does not implement _batch_objective.

• ValueError – If X has wrong number of dimensions or wrong n_dim.

property callbacks

Callback management (CallbackAccessor).

constraint_violations(params: Dict[str, Any]) → List[float]

Calculate constraint violations (positive values only).

Parameters:

params (dict) – Design variable values.

Returns:

Violation amounts. Zero means constraint is satisfied.

Return type:

list of float

constraints(params: Dict[str, Any]) → List[float]

Public API: evaluate constraint functions.

property data

Evaluation data (DataAccessor).

property errors

Error handler management (ErrorAccessor).

is_feasible(params: Dict[str, Any]) → bool

Check if a solution satisfies all constraints.

Parameters:

params (dict) – Design variable values.

Returns:

True if all constraints are satisfied.

Return type:

bool

property memory

Memory cache management (MemoryAccessor).

property meta: MetaSpec

Instance display/identity metadata (a frozen MetaSpec).

Metadata is fully static today, so this returns the class-level MetaSpec resolved at class-definition time.

property modifiers

Modifier management (ModifierAccessor).

property n_dim: int

Number of design variables.

penalty(params: Dict[str, Any]) → float

Calculate total penalty for constraint violations.

Parameters:

params (dict) – Design variable values.

Returns:

Penalty value (sum of squared violations times coefficient).

Return type:

float

property plot

Access plotting methods for this function.

pure(params: Dict[str, Any] | ndarray | list | tuple | None = None, *, fidelity: float | None = None, **kwargs)

Evaluate the function without modifiers.

Returns the true (deterministic) function value, bypassing any configured modifiers. Does not update search_data, n_evaluations, or callbacks. Ignores memory caching.

Parameters:

• params (dict, array, list, or tuple) – Parameter values to evaluate.

• fidelity (float or None) – Fidelity level in (0, 1] for multi-fidelity evaluation.

• **kwargs (dict) – Parameters as keyword arguments.

Returns:

The true function value without modifiers, with direction applied.

Return type:

float or np.ndarray

raw_objective(params: Dict[str, Any]) → float

Public API: evaluate raw objective without penalties.

reset() → None

Reset all state including collected data and memory cache.

property search_space: Dict[str, Any]

Search space for this function (read-only public API).

property spec: FunctionSpec

Instance-resolved function specification (a frozen FunctionSpec).

type(self)._spec is the static class-level template. This property overlays the fields that genuinely vary per instance (n_dim, n_objectives, f_global, x_global) by lifting them off the instance, so that func.spec.n_dim reflects this instance’s value. It is resolved on every access rather than cached, because some functions (e.g. BBOB) read spec during __init__ before the optimum has been computed, and a cached early value would go stale.