diff --git a/bofire/data_models/strategies/api.py b/bofire/data_models/strategies/api.py
index c93ec0fe9..80f846b19 100644
--- a/bofire/data_models/strategies/api.py
+++ b/bofire/data_models/strategies/api.py
@@ -1,7 +1,17 @@
 from typing import Union
 
 from bofire.data_models.strategies.actual_strategy_type import ActualStrategy
-from bofire.data_models.strategies.doe import DoEStrategy
+from bofire.data_models.strategies.doe import (
+    AnyDoEOptimalityCriterion,
+    AnyOptimalityCriterion,
+    AOptimalityCriterion,
+    DoEStrategy,
+    DOptimalityCriterion,
+    EOptimalityCriterion,
+    GOptimalityCriterion,
+    KOptimalityCriterion,
+    SpaceFillingCriterion,
+)
 from bofire.data_models.strategies.factorial import FactorialStrategy
 from bofire.data_models.strategies.fractional_factorial import (
     FractionalFactorialStrategy,
diff --git a/bofire/data_models/strategies/doe.py b/bofire/data_models/strategies/doe.py
index 75d260499..aacc4b1b6 100644
--- a/bofire/data_models/strategies/doe.py
+++ b/bofire/data_models/strategies/doe.py
@@ -1,24 +1,98 @@
-from typing import Literal, Optional, Type, Union
+from typing import Dict, Literal, Optional, Type, Union
 
+from formulaic import Formula
+from formulaic.errors import FormulaSyntaxError
+from pydantic import Field, field_validator
+
+from bofire.data_models.base import BaseModel
 from bofire.data_models.constraints.api import Constraint
 from bofire.data_models.features.api import Feature, MolecularInput
 from bofire.data_models.objectives.api import Objective
 from bofire.data_models.strategies.strategy import Strategy
 from bofire.data_models.types import Bounds
-from bofire.strategies.enum import OptimalityCriterionEnum
 
 
-class DoEStrategy(Strategy):
-    type: Literal["DoEStrategy"] = "DoEStrategy"
+PREDEFINED_MODEL_TYPES = Literal[
+    "linear",
+    "linear-and-quadratic",
+    "linear-and-interactions",
+    "fully-quadratic",
+]
+
+
+class OptimalityCriterion(BaseModel):
+    type: str
+    delta: float = 1e-6
+    transform_range: Optional[Bounds] = None
+
+
+class SpaceFillingCriterion(OptimalityCriterion):
+    type: Literal["SpaceFillingCriterion"] = "SpaceFillingCriterion"  # type: ignore
+
+
+class DoEOptimalityCriterion(OptimalityCriterion):
+    type: str
     formula: Union[
-        Literal[
-            "linear",
-            "linear-and-quadratic",
-            "linear-and-interactions",
-            "fully-quadratic",
-        ],
+        PREDEFINED_MODEL_TYPES,
         str,
     ]
+    """
+    model_type (str, Formula): keyword or formulaic Formula describing the model. Known keywords
+    are "linear", "linear-and-interactions", "linear-and-quadratic", "fully-quadratic".
+    """
+
+    @field_validator("formula")
+    @classmethod
+    def validate_formula(cls, formula: str) -> str:
+        if formula not in PREDEFINED_MODEL_TYPES.__args__:  # type: ignore
+            # check that it is a valid formula
+            try:
+                Formula(formula)
+            except FormulaSyntaxError:
+                raise ValueError(f"Invalid formula: {formula}")
+        return formula
+
+
+class DOptimalityCriterion(DoEOptimalityCriterion):
+    type: Literal["DOptimalityCriterion"] = "DOptimalityCriterion"  # type: ignore
+
+
+class EOptimalityCriterion(DoEOptimalityCriterion):
+    type: Literal["EOptimalityCriterion"] = "EOptimalityCriterion"  # type: ignore
+
+
+class AOptimalityCriterion(DoEOptimalityCriterion):
+    type: Literal["AOptimalityCriterion"] = "AOptimalityCriterion"  # type: ignore
+
+
+class GOptimalityCriterion(DoEOptimalityCriterion):
+    type: Literal["GOptimalityCriterion"] = "GOptimalityCriterion"  # type: ignore
+
+
+class KOptimalityCriterion(DoEOptimalityCriterion):
+    type: Literal["KOptimalityCriterion"] = "KOptimalityCriterion"  # type: ignore
+
+
+AnyDoEOptimalityCriterion = Union[
+    KOptimalityCriterion,
+    GOptimalityCriterion,
+    AOptimalityCriterion,
+    EOptimalityCriterion,
+    DOptimalityCriterion,
+]
+
+AnyOptimalityCriterion = Union[
+    AnyDoEOptimalityCriterion,
+    SpaceFillingCriterion,
+]
+
+
+class DoEStrategy(Strategy):
+    type: Literal["DoEStrategy"] = "DoEStrategy"  # type: ignore
+
+    criterion: AnyOptimalityCriterion = Field(
+        default_factory=lambda: DOptimalityCriterion(formula="fully-quadratic")
+    )
     optimization_strategy: Literal[
         "default",
         "exhaustive",
@@ -28,11 +102,8 @@ class DoEStrategy(Strategy):
         "iterative",
     ] = "default"
 
-    verbose: bool = False
-
-    objective: OptimalityCriterionEnum = OptimalityCriterionEnum.D_OPTIMALITY
-
-    transform_range: Optional[Bounds] = None
+    verbose: bool = False  # get rid of this at a later stage
+    ipopt_options: Optional[Dict] = None
 
     @classmethod
     def is_constraint_implemented(cls, my_type: Type[Constraint]) -> bool:
diff --git a/bofire/data_models/strategies/space_filling.py b/bofire/data_models/strategies/space_filling.py
index dd03f1a8d..b91494479 100644
--- a/bofire/data_models/strategies/space_filling.py
+++ b/bofire/data_models/strategies/space_filling.py
@@ -31,7 +31,7 @@ class SpaceFillingStrategy(Strategy):
 
     """
 
-    type: Literal["SpaceFillingStrategy"] = "SpaceFillingStrategy"
+    type: Literal["SpaceFillingStrategy"] = "SpaceFillingStrategy"  # type: ignore
     sampling_fraction: Annotated[float, Field(gt=0, lt=1)] = 0.3
     ipopt_options: dict = {"maxiter": 200, "disp": 0}
 
diff --git a/bofire/strategies/doe/branch_and_bound.py b/bofire/strategies/doe/branch_and_bound.py
index 048fc108c..7e3556114 100644
--- a/bofire/strategies/doe/branch_and_bound.py
+++ b/bofire/strategies/doe/branch_and_bound.py
@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+import time
 from functools import total_ordering
+from itertools import combinations_with_replacement, product
 from queue import PriorityQueue
 from typing import Dict, List, Optional, Tuple
 
@@ -8,10 +10,11 @@
 import pandas as pd
 
 from bofire.data_models.constraints.api import ConstraintNotFulfilledError
-from bofire.data_models.features.api import ContinuousInput
+from bofire.data_models.domain.api import Domain
+from bofire.data_models.features.api import ContinuousInput, Input
+from bofire.data_models.strategies.doe import AnyOptimalityCriterion
 from bofire.strategies.doe.design import find_local_max_ipopt
-from bofire.strategies.doe.objective import get_objective_class
-from bofire.strategies.doe.utils import get_formula_from_string
+from bofire.strategies.doe.objective import get_objective_function
 from bofire.strategies.doe.utils_categorical_discrete import equal_count_split
 
 
@@ -167,21 +170,12 @@ def bnb(
     if priority_queue.empty():
         raise RuntimeError("Queue empty before feasible solution was found")
 
-    domain = kwargs["domain"]
-    n_experiments = kwargs["n_experiments"]
-
-    # get objective function
-    model_formula = get_formula_from_string(
-        model_type=kwargs["model_type"],
-        rhs_only=True,
-        domain=domain,
-    )
-    objective_class = get_objective_class(kwargs["objective"])
-    objective_class = objective_class(
-        domain=domain,
-        model=model_formula,
-        n_experiments=n_experiments,
+    objective_function = get_objective_function(
+        criterion=kwargs["criterion"],
+        domain=kwargs["domain"],
+        n_experiments=kwargs["n_experiments"],
     )
+    assert objective_function is not None, "Criterion type is not supported!"
 
     pre_size = priority_queue.qsize()
     current_branch = priority_queue.get()
@@ -202,7 +196,7 @@ def bnb(
         kwargs["sampling"] = current_branch.design_matrix
         try:
             design = find_local_max_ipopt(partially_fixed_experiments=branch, **kwargs)
-            value = objective_class.evaluate(design.to_numpy().flatten())
+            value = objective_function.evaluate(design.to_numpy().flatten())
             new_node = NodeExperiment(
                 branch,
                 design,
@@ -210,7 +204,7 @@ def bnb(
                 current_branch.categorical_groups,
                 current_branch.discrete_vars,
             )
-            domain.validate_candidates(
+            kwargs["domain"].validate_candidates(
                 candidates=design.apply(lambda x: np.round(x, 8)),
                 only_inputs=True,
                 tol=1e-4,
@@ -228,3 +222,308 @@ def bnb(
         num_explored=num_explored + len(next_branches),
         **kwargs,
     )
+
+
+def find_local_max_ipopt_BaB(
+    domain: Domain,
+    n_experiments: int,
+    criterion: Optional[AnyOptimalityCriterion] = None,
+    ipopt_options: Optional[Dict] = None,
+    sampling: Optional[pd.DataFrame] = None,
+    fixed_experiments: Optional[pd.DataFrame] = None,
+    partially_fixed_experiments: Optional[pd.DataFrame] = None,
+    categorical_groups: Optional[List[List[ContinuousInput]]] = None,
+    discrete_variables: Optional[Dict[str, Tuple[ContinuousInput, List[float]]]] = None,
+    verbose: bool = False,
+) -> pd.DataFrame:
+    """Function computing a d-optimal design" for a given domain and model.
+    It allows for the problem to have categorical values which is solved by Branch-and-Bound
+        Args:
+            domain (Domain): domain containing the inputs and constraints.
+            model_type (str, Formula): keyword or formulaic Formula describing the model. Known keywords
+                are "linear", "linear-and-interactions", "linear-and-quadratic", "fully-quadratic".
+            n_experiments (int): Number of experiments. By default the value corresponds to
+                the number of model terms - dimension of ker() + 3.
+            delta (float): Regularization parameter. Default value is 1e-3.
+            ipopt_options (Dict, optional): options for IPOPT. For more information see [this link](https://coin-or.github.io/Ipopt/OPTIONS.html)
+            sampling (pd.DataFrame): dataframe containing the initial guess.
+            fixed_experiments (pd.DataFrame): dataframe containing experiments that will be definitely part of the design.
+                Values are set before the optimization.
+            partially_fixed_experiments (pd.DataFrame): dataframe containing (some) fixed variables for experiments.
+                Values are set before the optimization. Within one experiment not all variables need to be fixed.
+                Variables can be fixed to one value or can be set to a range by setting a tuple with lower and upper bound
+                Non-fixed variables have to be set to None or nan.
+            objective (OptimalityCriterionEnum): OptimalityCriterionEnum object indicating which objective function to use.
+            categorical_groups (Optional[List[List[ContinuousInput]]]). Represents the different groups of the
+               relaxed categorical variables. Defaults to None.
+            discrete_variables (Optional[Dict[str, Tuple[ContinuousInput, List[float]]]]): dict of relaxed discrete inputs
+                with key:(relaxed variable, valid values). Defaults to None
+            verbose (bool): if true, print information during the optimization process
+            transform_range (Optional[Bounds]): range to which the input variables are transformed.
+                If None is provided, the features will not be scaled. Defaults to None.
+        Returns:
+            A pd.DataFrame object containing the best found input for the experiments. In general, this is only a
+            local optimum.
+    """
+    from bofire.strategies.doe.branch_and_bound import NodeExperiment, bnb
+
+    if categorical_groups is None:
+        categorical_groups = []
+
+    objective_function = get_objective_function(
+        criterion, domain=domain, n_experiments=n_experiments
+    )
+    assert objective_function is not None, "Criterion type is not supported!"
+
+    # setting up initial node in the branch-and-bound tree
+    column_keys = domain.inputs.get_keys()
+
+    if fixed_experiments is not None:
+        subtract = len(fixed_experiments)
+        initial_branch = pd.DataFrame(
+            np.full((n_experiments - subtract, len(column_keys)), None),
+            columns=column_keys,
+        )
+        initial_branch = pd.concat([fixed_experiments, initial_branch]).reset_index(
+            drop=True
+        )
+    else:
+        initial_branch = pd.DataFrame(
+            np.full((n_experiments, len(column_keys)), None),
+            columns=column_keys,
+        )
+
+    if partially_fixed_experiments is not None:
+        partially_fixed_experiments = pd.concat(
+            [
+                partially_fixed_experiments,
+                pd.DataFrame(
+                    np.full(
+                        (
+                            n_experiments - len(partially_fixed_experiments),
+                            len(domain.inputs),
+                        ),
+                        None,
+                    ),
+                    columns=domain.inputs.get_keys(includes=Input),
+                ),
+            ]
+        ).reset_index(drop=True)
+
+        initial_branch.mask(
+            partially_fixed_experiments.notnull(),  # type: ignore
+            other=partially_fixed_experiments,
+            inplace=True,
+        )
+
+    initial_design = find_local_max_ipopt(
+        domain,
+        n_experiments,
+        criterion,
+        ipopt_options,
+        sampling,
+        None,
+        partially_fixed_experiments=initial_branch,
+    )
+    initial_value = objective_function.evaluate(
+        initial_design.to_numpy().flatten(),
+    )
+
+    initial_node = NodeExperiment(
+        initial_branch,
+        initial_design,
+        initial_value,
+        categorical_groups,
+        discrete_variables,
+    )
+
+    # initializing branch-and-bound queue
+    initial_queue = PriorityQueue()
+    initial_queue.put(initial_node)
+
+    # starting branch-and-bound
+    result_node = bnb(
+        initial_queue,
+        domain=domain,
+        n_experiments=n_experiments,
+        ipopt_options=ipopt_options,
+        sampling=sampling,
+        fixed_experiments=None,
+        criterion=criterion,
+        verbose=verbose,
+    )
+
+    return result_node.design_matrix
+
+
+def find_local_max_ipopt_exhaustive(
+    domain: Domain,
+    n_experiments: int,
+    criterion: Optional[AnyOptimalityCriterion] = None,
+    ipopt_options: Optional[Dict] = None,
+    sampling: Optional[pd.DataFrame] = None,
+    fixed_experiments: Optional[pd.DataFrame] = None,
+    partially_fixed_experiments: Optional[pd.DataFrame] = None,
+    categorical_groups: Optional[List[List[ContinuousInput]]] = None,
+    discrete_variables: Optional[Dict[str, Tuple[ContinuousInput, List[float]]]] = None,
+    verbose: bool = False,
+) -> pd.DataFrame:
+    """Function computing a d-optimal design" for a given domain and model.
+    It allows for the problem to have categorical values which is solved by exhaustive search
+        Args:
+            domain (Domain): domain containing the inputs and constraints.
+            model_type (str, Formula): keyword or formulaic Formula describing the model. Known keywords
+                are "linear", "linear-and-interactions", "linear-and-quadratic", "fully-quadratic".
+            n_experiments (int): Number of experiments. By default the value corresponds to
+                the number of model terms - dimension of ker() + 3.
+            delta (float): Regularization parameter. Default value is 1e-3.
+            ipopt_options (Dict, optional): options for IPOPT. For more information see [this link](https://coin-or.github.io/Ipopt/OPTIONS.html)
+            sampling (pd.DataFrame): dataframe containing the initial guess.
+            fixed_experiments (pd.DataFrame): dataframe containing experiments that will be definitely part of the design.
+                Values are set before the optimization.
+            objective (OptimalityCriterionEnum): OptimalityCriterionEnum object indicating which objective function to use.
+            partially_fixed_experiments (pd.DataFrame): dataframe containing (some) fixed variables for experiments.
+                Values are set before the optimization. Within one experiment not all variables need to be fixed.
+                Variables can be fixed to one value or can be set to a range by setting a tuple with lower and upper bound
+                Non-fixed variables have to be set to None or nan.
+            categorical_groups (Optional[List[List[ContinuousInput]]]). Represents the different groups of the
+               relaxed categorical variables. Defaults to None.
+            discrete_variables (Optional[Dict[str, Tuple[ContinuousInput, List[float]]]]): dict of relaxed discrete inputs
+                with key:(relaxed variable, valid values). Defaults to None
+            verbose (bool): if true, print information during the optimization process
+            transform_range (Optional[Bounds]): range to which the input variables are transformed.
+        Returns:
+            A pd.DataFrame object containing the best found input for the experiments. In general, this is only a
+            local optimum.
+    """
+
+    if categorical_groups is None:
+        categorical_groups = []
+
+    if discrete_variables is not None or len(discrete_variables) > 0:  # type: ignore
+        raise NotImplementedError(
+            "Exhaustive search for discrete variables is not implemented yet."
+        )
+
+    objective_function = get_objective_function(
+        criterion, domain=domain, n_experiments=n_experiments
+    )
+    assert objective_function is not None, "Criterion type is not supported!"
+
+    # get binary variables
+    binary_vars = [var for group in categorical_groups for var in group]
+    list_keys = [var.key for var in binary_vars]
+
+    # determine possible fixations of the different categories
+    allowed_fixations = []
+    for group in categorical_groups:
+        allowed_fixations.append(np.eye(len(group)))
+
+    n_non_fixed_experiments = n_experiments
+    if fixed_experiments is not None:
+        n_non_fixed_experiments -= len(fixed_experiments)
+
+    allowed_fixations = product(*allowed_fixations)
+    all_n_fixed_experiments = combinations_with_replacement(
+        allowed_fixations, n_non_fixed_experiments
+    )
+
+    if partially_fixed_experiments is not None:
+        partially_fixed_experiments = pd.concat(
+            [
+                partially_fixed_experiments,
+                pd.DataFrame(
+                    np.full(
+                        (
+                            n_non_fixed_experiments - len(partially_fixed_experiments),
+                            len(domain.inputs),
+                        ),
+                        None,
+                    ),
+                    columns=domain.inputs.get_keys(includes=Input),
+                ),
+            ]
+        ).reset_index(drop=True)
+
+    # testing all different fixations
+    column_keys = domain.inputs.get_keys()
+    group_keys = [var.key for group in categorical_groups for var in group]
+    minimum = float("inf")
+    optimal_design = pd.DataFrame()
+    all_n_fixed_experiments = list(all_n_fixed_experiments)
+    for i, binary_fixed_experiments in enumerate(all_n_fixed_experiments):
+        if verbose:
+            start_time = time.time()
+        # setting up the pd.Dataframe for the partially fixed experiment
+        binary_fixed_experiments = np.array(
+            [
+                var
+                for experiment in binary_fixed_experiments
+                for group in experiment
+                for var in group
+            ]
+        ).reshape(n_non_fixed_experiments, len(binary_vars))
+
+        binary_fixed_experiments = pd.DataFrame(
+            binary_fixed_experiments, columns=group_keys
+        )
+        one_set_of_experiments = pd.DataFrame(
+            np.full((n_non_fixed_experiments, len(domain.inputs)), None),
+            columns=column_keys,
+        )
+
+        one_set_of_experiments.mask(
+            binary_fixed_experiments.notnull(),
+            other=binary_fixed_experiments,
+            inplace=True,
+        )
+
+        if partially_fixed_experiments is not None:
+            one_set_of_experiments.mask(
+                partially_fixed_experiments.notnull(),
+                other=partially_fixed_experiments,
+                inplace=True,
+            )
+
+        if fixed_experiments is not None:
+            one_set_of_experiments = pd.concat(
+                [fixed_experiments, one_set_of_experiments]
+            ).reset_index(drop=True)
+
+        if sampling is not None:
+            sampling.loc[:, list_keys] = one_set_of_experiments[list_keys].to_numpy()
+
+        # minimizing with the current fixation
+        try:
+            current_design = find_local_max_ipopt(
+                domain,
+                n_experiments,
+                criterion,
+                ipopt_options,
+                sampling,
+                None,
+                one_set_of_experiments,
+            )
+            domain.validate_candidates(
+                candidates=current_design.apply(lambda x: np.round(x, 8)),
+                only_inputs=True,
+                tol=1e-4,
+                raise_validation_error=True,
+            )
+            temp_value = objective_function.evaluate(
+                current_design.to_numpy().flatten(),
+            )
+            if minimum is None or minimum > temp_value:
+                minimum = temp_value
+                optimal_design = current_design
+            if verbose:
+                print(
+                    f"branch: {i} / {len(all_n_fixed_experiments)}, "
+                    f"time: {time.time() - start_time},"  # type: ignore
+                    f"solution: {temp_value}, minimum after run {minimum},"
+                    f"difference: {temp_value - minimum}"
+                )
+        except ConstraintNotFulfilledError:
+            if verbose:
+                print("skipping branch because of not fulfilling constraints")
+    return optimal_design
diff --git a/bofire/strategies/doe/design.py b/bofire/strategies/doe/design.py
index bed6b5cf5..b9453d7dc 100644
--- a/bofire/strategies/doe/design.py
+++ b/bofire/strategies/doe/design.py
@@ -1,7 +1,4 @@
-import time
 import warnings
-from itertools import combinations_with_replacement, product
-from queue import PriorityQueue
 from typing import Dict, List, Optional, Tuple, Union
 
 import numpy as np
@@ -16,385 +13,29 @@
 )
 from bofire.data_models.domain.api import Domain
 from bofire.data_models.enum import SamplingMethodEnum
-from bofire.data_models.features.api import ContinuousInput, Input
 from bofire.data_models.strategies.api import RandomStrategy as RandomStrategyDataModel
-from bofire.data_models.types import Bounds
-from bofire.strategies.doe.objective import get_objective_class
+from bofire.data_models.strategies.doe import AnyOptimalityCriterion
+from bofire.strategies.doe.objective import get_objective_function
 from bofire.strategies.doe.utils import (
     constraints_as_scipy_constraints,
-    get_formula_from_string,
-    metrics,
     nchoosek_constraints_as_bounds,
 )
-from bofire.strategies.enum import OptimalityCriterionEnum
 from bofire.strategies.random import RandomStrategy
 
 
-def find_local_max_ipopt_BaB(
-    domain: Domain,
-    model_type: Union[str, Formula],
-    n_experiments: Optional[int] = None,
-    delta: float = 1e-7,
-    ipopt_options: Optional[Dict] = None,
-    sampling: Optional[pd.DataFrame] = None,
-    fixed_experiments: Optional[pd.DataFrame] = None,
-    partially_fixed_experiments: Optional[pd.DataFrame] = None,
-    objective: OptimalityCriterionEnum = OptimalityCriterionEnum.D_OPTIMALITY,
-    categorical_groups: Optional[List[List[ContinuousInput]]] = None,
-    discrete_variables: Optional[Dict[str, Tuple[ContinuousInput, List[float]]]] = None,
-    verbose: bool = False,
-    transform_range: Optional[Bounds] = None,
-) -> pd.DataFrame:
-    """Function computing a d-optimal design" for a given domain and model.
-    It allows for the problem to have categorical values which is solved by Branch-and-Bound
-
-    Args:
-        domain (Domain): domain containing the inputs and constraints.
-        model_type (str, Formula): keyword or formulaic Formula describing the model. Known keywords
-            are "linear", "linear-and-interactions", "linear-and-quadratic", "fully-quadratic".
-        n_experiments (int): Number of experiments. By default the value corresponds to
-            the number of model terms - dimension of ker() + 3.
-        delta (float): Regularization parameter. Default value is 1e-3.
-        ipopt_options (Dict, optional): options for IPOPT. For more information see [this link](https://coin-or.github.io/Ipopt/OPTIONS.html)
-        sampling (pd.DataFrame): dataframe containing the initial guess.
-        fixed_experiments (pd.DataFrame): dataframe containing experiments that will be definitely part of the design.
-            Values are set before the optimization.
-        partially_fixed_experiments (pd.DataFrame): dataframe containing (some) fixed variables for experiments.
-            Values are set before the optimization. Within one experiment not all variables need to be fixed.
-            Variables can be fixed to one value or can be set to a range by setting a tuple with lower and upper bound
-            Non-fixed variables have to be set to None or nan.
-        objective (OptimalityCriterionEnum): OptimalityCriterionEnum object indicating which objective function to use.
-        categorical_groups (Optional[List[List[ContinuousInput]]]). Represents the different groups of the
-            relaxed categorical variables. Defaults to None.
-        discrete_variables (Optional[Dict[str, Tuple[ContinuousInput, List[float]]]]): dict of relaxed discrete inputs
-            with key:(relaxed variable, valid values). Defaults to None
-        verbose (bool): if true, print information during the optimization process
-        transform_range (Optional[Bounds]): range to which the input variables are transformed.
-            If None is provided, the features will not be scaled. Defaults to None.
-
-    Returns:
-        A pd.DataFrame object containing the best found input for the experiments. In general, this is only a
-        local optimum.
-
-    """
-    from bofire.strategies.doe.branch_and_bound import NodeExperiment, bnb
-
-    if categorical_groups is None:
-        categorical_groups = []
-
-    model_formula = get_formula_from_string(
-        model_type=model_type,
-        rhs_only=True,
-        domain=domain,
-    )
-
-    n_experiments = get_n_experiments(model_formula, n_experiments)
-
-    # get objective function
-    objective_class = get_objective_class(objective)
-    objective_class = objective_class(
-        domain=domain,
-        model=model_formula,
-        n_experiments=n_experiments,
-        delta=delta,
-        transform_range=transform_range,
-    )
-
-    # setting up initial node in the branch-and-bound tree
-    column_keys = domain.inputs.get_keys()
-
-    if fixed_experiments is not None:
-        subtract = len(fixed_experiments)
-        initial_branch = pd.DataFrame(
-            np.full((n_experiments - subtract, len(column_keys)), None),
-            columns=column_keys,
-        )
-        initial_branch = pd.concat([fixed_experiments, initial_branch]).reset_index(
-            drop=True,
-        )
-    else:
-        initial_branch = pd.DataFrame(
-            np.full((n_experiments, len(column_keys)), None),
-            columns=column_keys,
-        )
-
-    if partially_fixed_experiments is not None:
-        partially_fixed_experiments = pd.concat(
-            [
-                partially_fixed_experiments,
-                pd.DataFrame(
-                    np.full(
-                        (
-                            n_experiments - len(partially_fixed_experiments),
-                            len(domain.inputs),
-                        ),
-                        None,
-                    ),
-                    columns=domain.inputs.get_keys(includes=Input),
-                ),
-            ],
-        ).reset_index(drop=True)
-
-        initial_branch.mask(
-            partially_fixed_experiments.notnull(),  # type: ignore
-            other=partially_fixed_experiments,
-            inplace=True,
-        )
-
-    initial_design = find_local_max_ipopt(
-        domain,
-        model_formula,
-        n_experiments,
-        delta,
-        ipopt_options,
-        sampling,
-        None,
-        partially_fixed_experiments=initial_branch,
-        objective=objective,
-    )
-    initial_value = objective_class.evaluate(
-        initial_design.to_numpy().flatten(),
-    )
-
-    initial_node = NodeExperiment(
-        initial_branch,
-        initial_design,
-        initial_value,
-        categorical_groups,
-        discrete_variables,
-    )
-
-    # initializing branch-and-bound queue
-    initial_queue = PriorityQueue()
-    initial_queue.put(initial_node)
-
-    # starting branch-and-bound
-    result_node = bnb(
-        initial_queue,
-        domain=domain,
-        model_type=model_formula,
-        n_experiments=n_experiments,
-        delta=delta,
-        ipopt_options=ipopt_options,
-        sampling=sampling,
-        fixed_experiments=None,
-        objective=objective,
-        verbose=verbose,
-    )
-
-    return result_node.design_matrix
-
-
-def find_local_max_ipopt_exhaustive(
-    domain: Domain,
-    model_type: Union[str, Formula],
-    n_experiments: Optional[int] = None,
-    delta: float = 1e-7,
-    ipopt_options: Optional[Dict] = None,
-    sampling: Optional[pd.DataFrame] = None,
-    fixed_experiments: Optional[pd.DataFrame] = None,
-    objective: OptimalityCriterionEnum = OptimalityCriterionEnum.D_OPTIMALITY,
-    partially_fixed_experiments: Optional[pd.DataFrame] = None,
-    categorical_groups: Optional[List[List[ContinuousInput]]] = None,
-    discrete_variables: Optional[Dict[str, Tuple[ContinuousInput, List[float]]]] = None,
-    verbose: bool = False,
-    transform_range: Optional[Bounds] = None,
-) -> pd.DataFrame:
-    """Function computing a d-optimal design" for a given domain and model.
-    It allows for the problem to have categorical values which is solved by exhaustive search
-        Args:
-            domain (Domain): domain containing the inputs and constraints.
-            model_type (str, Formula): keyword or formulaic Formula describing the model. Known keywords
-                are "linear", "linear-and-interactions", "linear-and-quadratic", "fully-quadratic".
-            n_experiments (int): Number of experiments. By default the value corresponds to
-                the number of model terms - dimension of ker() + 3.
-            delta (float): Regularization parameter. Default value is 1e-3.
-            ipopt_options (Dict, optional): options for IPOPT. For more information see [this link](https://coin-or.github.io/Ipopt/OPTIONS.html)
-            sampling (pd.DataFrame): dataframe containing the initial guess.
-            fixed_experiments (pd.DataFrame): dataframe containing experiments that will be definitely part of the design.
-                Values are set before the optimization.
-            objective (OptimalityCriterionEnum): OptimalityCriterionEnum object indicating which objective function to use.
-            partially_fixed_experiments (pd.DataFrame): dataframe containing (some) fixed variables for experiments.
-                Values are set before the optimization. Within one experiment not all variables need to be fixed.
-                Variables can be fixed to one value or can be set to a range by setting a tuple with lower and upper bound
-                Non-fixed variables have to be set to None or nan.
-            categorical_groups (Optional[List[List[ContinuousInput]]]). Represents the different groups of the
-               relaxed categorical variables. Defaults to None.
-            discrete_variables (Optional[Dict[str, Tuple[ContinuousInput, List[float]]]]): dict of relaxed discrete inputs
-                with key:(relaxed variable, valid values). Defaults to None
-            verbose (bool): if true, print information during the optimization process
-            transform_range (Optional[Bounds]): range to which the input variables are transformed.
-
-    Returns:
-            A pd.DataFrame object containing the best found input for the experiments. In general, this is only a
-            local optimum.
-
-    """
-    if categorical_groups is None:
-        categorical_groups = []
-
-    if discrete_variables is not None or len(discrete_variables) > 0:  # type: ignore
-        raise NotImplementedError(
-            "Exhaustive search for discrete variables is not implemented yet.",
-        )
-
-    # get objective function
-    model_formula = get_formula_from_string(
-        model_type=model_type,
-        rhs_only=True,
-        domain=domain,
-    )
-    objective_class = get_objective_class(objective)
-    objective_class = objective_class(
-        domain=domain,
-        model=model_formula,
-        n_experiments=n_experiments,
-        delta=delta,
-        transform_range=transform_range,
-    )
-
-    # get binary variables
-    binary_vars = [var for group in categorical_groups for var in group]
-    list_keys = [var.key for var in binary_vars]
-
-    # determine possible fixations of the different categories
-    allowed_fixations = []
-    for group in categorical_groups:
-        allowed_fixations.append(np.eye(len(group)))
-
-    n_experiments = get_n_experiments(model_formula, n_experiments)
-    n_non_fixed_experiments = n_experiments
-    if fixed_experiments is not None:
-        n_non_fixed_experiments -= len(fixed_experiments)
-
-    allowed_fixations = product(*allowed_fixations)
-    all_n_fixed_experiments = combinations_with_replacement(
-        allowed_fixations,
-        n_non_fixed_experiments,
-    )
-
-    if partially_fixed_experiments is not None:
-        partially_fixed_experiments = pd.concat(
-            [
-                partially_fixed_experiments,
-                pd.DataFrame(
-                    np.full(
-                        (
-                            n_non_fixed_experiments - len(partially_fixed_experiments),
-                            len(domain.inputs),
-                        ),
-                        None,
-                    ),
-                    columns=domain.inputs.get_keys(includes=Input),
-                ),
-            ],
-        ).reset_index(drop=True)
-
-    # testing all different fixations
-    column_keys = domain.inputs.get_keys()
-    group_keys = [var.key for group in categorical_groups for var in group]
-    minimum = float("inf")
-    optimal_design = pd.DataFrame()
-    all_n_fixed_experiments = list(all_n_fixed_experiments)
-    for i, binary_fixed_experiments in enumerate(all_n_fixed_experiments):
-        if verbose:
-            start_time = time.time()
-        # setting up the pd.Dataframe for the partially fixed experiment
-        binary_fixed_experiments = np.array(
-            [
-                var
-                for experiment in binary_fixed_experiments
-                for group in experiment
-                for var in group
-            ],
-        ).reshape(n_non_fixed_experiments, len(binary_vars))
-
-        binary_fixed_experiments = pd.DataFrame(
-            binary_fixed_experiments,
-            columns=group_keys,
-        )
-        one_set_of_experiments = pd.DataFrame(
-            np.full((n_non_fixed_experiments, len(domain.inputs)), None),
-            columns=column_keys,
-        )
-
-        one_set_of_experiments.mask(
-            binary_fixed_experiments.notnull(),
-            other=binary_fixed_experiments,
-            inplace=True,
-        )
-
-        if partially_fixed_experiments is not None:
-            one_set_of_experiments.mask(
-                partially_fixed_experiments.notnull(),
-                other=partially_fixed_experiments,
-                inplace=True,
-            )
-
-        if fixed_experiments is not None:
-            one_set_of_experiments = pd.concat(
-                [fixed_experiments, one_set_of_experiments],
-            ).reset_index(drop=True)
-
-        if sampling is not None:
-            sampling.loc[:, list_keys] = one_set_of_experiments[list_keys].to_numpy()
-
-        # minimizing with the current fixation
-        try:
-            current_design = find_local_max_ipopt(
-                domain,
-                model_formula,
-                n_experiments,
-                delta,
-                ipopt_options,
-                sampling,
-                None,
-                one_set_of_experiments,
-                objective,
-            )
-            domain.validate_candidates(
-                candidates=current_design.apply(lambda x: np.round(x, 8)),
-                only_inputs=True,
-                tol=1e-4,
-                raise_validation_error=True,
-            )
-            temp_value = objective_class.evaluate(
-                current_design.to_numpy().flatten(),
-            )
-            if minimum is None or minimum > temp_value:
-                minimum = temp_value
-                optimal_design = current_design
-            if verbose:
-                print(
-                    f"branch: {i} / {len(all_n_fixed_experiments)}, "
-                    f"time: {time.time() - start_time},"  # type: ignore
-                    f"solution: {temp_value}, minimum after run {minimum},"
-                    f"difference: {temp_value - minimum}",
-                )
-        except ConstraintNotFulfilledError:
-            if verbose:
-                print("skipping branch because of not fulfilling constraints")
-    return optimal_design
-
-
 def find_local_max_ipopt(
     domain: Domain,
-    model_type: Union[str, Formula],
-    n_experiments: Optional[int] = None,
-    delta: float = 1e-7,
+    n_experiments: int,
+    criterion: Optional[AnyOptimalityCriterion] = None,
     ipopt_options: Optional[Dict] = None,
     sampling: Optional[pd.DataFrame] = None,
     fixed_experiments: Optional[pd.DataFrame] = None,
     partially_fixed_experiments: Optional[pd.DataFrame] = None,
-    objective: OptimalityCriterionEnum = OptimalityCriterionEnum.D_OPTIMALITY,
-    transform_range: Optional[Bounds] = None,
 ) -> pd.DataFrame:
     """Function computing an optimal design for a given domain and model.
 
     Args:
         domain (Domain): domain containing the inputs and constraints.
-        model_type (str, Formula): keyword or formulaic Formula describing the model. Known keywords
-            are "linear", "linear-and-interactions", "linear-and-quadratic", "fully-quadratic".
         n_experiments (int): Number of experiments. By default the value corresponds to
             the number of model terms - dimension of ker() + 3.
         delta (float): Regularization parameter. Default value is 1e-3.
@@ -406,8 +47,7 @@ def find_local_max_ipopt(
             Values are set before the optimization. Within one experiment not all variables need to be fixed.
             Variables can be fixed to one value or can be set to a range by setting a tuple with lower and upper bound
             Non-fixed variables have to be set to None or nan.
-        objective (OptimalityCriterionEnum): OptimalityCriterionEnum object indicating which objective function to use.
-        transform_range (Optional[Bounds]): range to which the input variables are transformed.
+        criterion (OptimalityCriterion): OptimalityCriterion object indicating which criterion function to use.
 
     Returns:
         A pd.DataFrame object containing the best found input for the experiments. In general, this is only a
@@ -428,14 +68,10 @@ def find_local_max_ipopt(
         )
         raise e
 
-    model_formula = get_formula_from_string(
-        model_type=model_type,
-        rhs_only=True,
-        domain=domain,
+    objective_function = get_objective_function(
+        criterion, domain=domain, n_experiments=n_experiments
     )
-
-    # determine number of experiments (only relevant if n_experiments is not provided by the user)
-    n_experiments = get_n_experiments(model_formula, n_experiments)
+    assert objective_function is not None, "Criterion type is not supported!"
 
     if partially_fixed_experiments is not None:
         # check if partially fixed experiments are valid
@@ -502,16 +138,6 @@ def find_local_max_ipopt(
             .flatten()
         )
 
-    # get objective function and its jacobian
-    objective_class = get_objective_class(objective)
-    objective_function = objective_class(
-        domain=domain,
-        model=model_formula,
-        n_experiments=n_experiments,
-        delta=delta,
-        transform_range=transform_range,
-    )
-
     # write constraints as scipy constraints
     constraints = constraints_as_scipy_constraints(
         domain,
@@ -567,14 +193,6 @@ def find_local_max_ipopt(
         columns=domain.inputs.get_keys(),
         index=[f"exp{i}" for i in range(n_experiments)],
     )
-
-    # exit message
-    if _ipopt_options[b"print_level"] > 12:  # type: ignore
-        for key in ["fun", "message", "nfev", "nit", "njev", "status", "success"]:
-            print(key + ":", result[key])
-        X = model_formula.get_model_matrix(design).to_numpy()
-        print("metrics:", metrics(X))
-
     # check if all points respect the domain and the constraint
     try:
         domain.validate_candidates(
diff --git a/bofire/strategies/doe/objective.py b/bofire/strategies/doe/objective.py
index 973a5e7de..d02a248cd 100644
--- a/bofire/strategies/doe/objective.py
+++ b/bofire/strategies/doe/objective.py
@@ -1,6 +1,6 @@
 from abc import abstractmethod
 from copy import deepcopy
-from typing import Optional, Type
+from typing import Optional
 
 import numpy as np
 import pandas as pd
@@ -9,9 +9,19 @@
 from torch import Tensor
 
 from bofire.data_models.domain.api import Domain
+from bofire.data_models.strategies.doe import (
+    AOptimalityCriterion,
+    DoEOptimalityCriterion,
+    DOptimalityCriterion,
+    EOptimalityCriterion,
+    GOptimalityCriterion,
+    KOptimalityCriterion,
+    OptimalityCriterion,
+    SpaceFillingCriterion,
+)
 from bofire.data_models.types import Bounds
 from bofire.strategies.doe.transform import IndentityTransform, MinMaxTransform
-from bofire.strategies.enum import OptimalityCriterionEnum
+from bofire.strategies.doe.utils import get_formula_from_string
 from bofire.utils.torch_tools import tkwargs
 
 
@@ -19,7 +29,6 @@ class Objective:
     def __init__(
         self,
         domain: Domain,
-        model: Formula,
         n_experiments: int,
         delta: float = 1e-6,
         transform_range: Optional[Bounds] = None,
@@ -32,7 +41,6 @@ def __init__(
         transform_range (Bounds, optional): range to which the input variables are transformed before applying the objective function. Default is None.
 
         """
-        self.model = deepcopy(model)
         self.domain = deepcopy(domain)
 
         if transform_range is None:
@@ -49,23 +57,6 @@ def __init__(
         self.vars = self.domain.inputs.get_keys()
         self.n_vars = len(self.domain.inputs)
 
-        self.model_terms = list(np.array(model, dtype=str))
-        self.n_model_terms = len(self.model_terms)
-
-        # terms for model jacobian
-        self.terms_jacobian_t = []
-        for var in self.vars:
-            _terms = [
-                str(term).replace(":", "*") + f" + 0 * {self.vars[0]}"
-                for term in model.differentiate(var, use_sympy=True)
-            ]  # 0*vars[0] added to make sure terms are evaluated as series, not as number
-            terms = "["
-            for t in _terms:
-                terms += t + ", "
-            terms = terms[:-1] + "]"
-
-            self.terms_jacobian_t.append(terms)
-
     def __call__(self, x: np.ndarray) -> float:
         return self.evaluate(x)
 
@@ -83,6 +74,62 @@ def evaluate_jacobian(self, x: np.ndarray) -> np.ndarray:
     def _evaluate_jacobian(self, x: np.ndarray) -> np.ndarray:
         pass
 
+    @abstractmethod
+    def _convert_input_to_model_tensor(
+        self,
+        x: np.ndarray,
+        requires_grad: bool = True,
+    ) -> Tensor:
+        """Args:
+        x: x (np.ndarray): values of design variables a 1d array.
+        """
+        assert x.ndim == 1, "values of design should be 1d array"
+        pass
+
+
+class ModelBasedObjective(Objective):
+    def __init__(
+        self,
+        domain: Domain,
+        model: Formula,
+        n_experiments: int,
+        delta: float = 1e-6,
+        transform_range: Optional[Bounds] = None,
+    ) -> None:
+        """Args:
+        domain (Domain): A domain defining the DoE domain together with model_type.
+        model_type (str or Formula): A formula containing all model terms.
+        n_experiments (int): Number of experiments
+        delta (float): A regularization parameter for the information matrix. Default value is 1e-3.
+        transform_range (Bounds, optional): range to which the input variables are transformed before applying the objective function. Default is None.
+
+        """
+        super().__init__(
+            domain=domain,
+            n_experiments=n_experiments,
+            delta=delta,
+            transform_range=transform_range,
+        )
+
+        self.model = deepcopy(model)
+
+        self.model_terms = list(np.array(model, dtype=str))
+        self.n_model_terms = len(self.model_terms)
+
+        # terms for model jacobian
+        self.terms_jacobian_t = []
+        for var in self.vars:
+            _terms = [
+                str(term).replace(":", "*") + f" + 0 * {self.vars[0]}"
+                for term in model.differentiate(var, use_sympy=True)
+            ]  # 0*vars[0] added to make sure terms are evaluated as series, not as number
+            terms = "["
+            for t in _terms:
+                terms += t + ", "
+            terms = terms[:-1] + "]"
+
+            self.terms_jacobian_t.append(terms)
+
     def _convert_input_to_model_tensor(
         self,
         x: np.ndarray,
@@ -112,8 +159,11 @@ def _model_jacobian_t(self, x: np.ndarray) -> np.ndarray:
         jacobians = np.swapaxes(X.eval(self.terms_jacobian_t), 0, 2)  # type: ignore
         return np.swapaxes(jacobians, 1, 2)
 
+    def get_model_matrix(self, design: pd.DataFrame) -> pd.DataFrame:
+        return self.model.get_model_matrix(design)
 
-class DOptimality(Objective):
+
+class DOptimality(ModelBasedObjective):
     """A class implementing the evaluation of logdet(X.T@X + delta) and its jacobian w.r.t. the inputs.
     The Jacobian can be divided into two parts, one for logdet(X.T@ + delta) w.r.t. X (there is a simple
     closed expression for this one) and one model dependent part for the jacobian of X.T@X
@@ -217,7 +267,7 @@ def _evaluate_jacobian(self, x: np.ndarray) -> np.ndarray:
         return J.flatten()
 
 
-class AOptimality(Objective):
+class AOptimality(ModelBasedObjective):
     """A class implementing the evaluation of tr((X.T@X + delta)^-1) and its jacobian w.r.t. the inputs.
     The jacobian evaluation is done analogously to DOptimality with the first part of the jacobian being
     the jacobian of tr((X.T@X + delta)^-1) instead of logdet(X.T@X + delta).
@@ -279,7 +329,7 @@ def _evaluate_jacobian(self, x: np.ndarray) -> np.ndarray:
         return J.flatten()
 
 
-class GOptimality(Objective):
+class GOptimality(ModelBasedObjective):
     """A class implementing the evaluation of max(diag(H)) and its jacobian w.r.t. the inputs where
     H = X @ (X.T@X + delta)^-1 @ X.T is the (regularized) hat matrix. The jacobian evaluation is done analogously
     to DOptimality with the first part of the jacobian being the jacobian of max(diag(H)) instead of
@@ -346,7 +396,7 @@ def _evaluate_jacobian(self, x: np.ndarray) -> np.ndarray:
         return J.flatten()
 
 
-class EOptimality(Objective):
+class EOptimality(ModelBasedObjective):
     """A class implementing the evaluation of minus one times the minimum eigenvalue of (X.T @ X + delta)
     and its jacobian w.r.t. the inputs. The jacobian evaluation is done analogously to DOptimality with the
     first part of the jacobian being the jacobian of the smallest eigenvalue of (X.T @ X + delta) instead of
@@ -409,7 +459,7 @@ def _evaluate_jacobian(self, x: np.ndarray) -> np.ndarray:
         return J.flatten()
 
 
-class KOptimality(Objective):
+class KOptimality(ModelBasedObjective):
     """A class implementing the evaluation of the condition number of (X.T @ X + delta)
     and its jacobian w.r.t. the inputs. The jacobian evaluation is done analogously to
     DOptimality with the first part of the jacobian being the jacobian of condition number
@@ -494,18 +544,62 @@ def _convert_input_to_tensor(
         return torch.tensor(X.values, requires_grad=requires_grad, **tkwargs)
 
 
-def get_objective_class(objective: OptimalityCriterionEnum) -> Type:
-    objective = OptimalityCriterionEnum(objective)
-
-    if objective == OptimalityCriterionEnum.D_OPTIMALITY:
-        return DOptimality
-    if objective == OptimalityCriterionEnum.A_OPTIMALITY:
-        return AOptimality
-    if objective == OptimalityCriterionEnum.G_OPTIMALITY:
-        return GOptimality
-    if objective == OptimalityCriterionEnum.E_OPTIMALITY:
-        return EOptimality
-    if objective == OptimalityCriterionEnum.K_OPTIMALITY:
-        return KOptimality
-    if objective == OptimalityCriterionEnum.SPACE_FILLING:
-        return SpaceFilling
+def get_objective_function(
+    criterion: Optional[OptimalityCriterion], domain: Domain, n_experiments: int
+) -> Optional[Objective]:
+    if criterion is None:
+        return DOptimality(
+            domain,
+            model=get_formula_from_string(domain=domain),
+            n_experiments=n_experiments,
+        )
+    if isinstance(criterion, DoEOptimalityCriterion):
+        if isinstance(criterion, DOptimalityCriterion):
+            return DOptimality(
+                domain,
+                model=get_formula_from_string(criterion.formula, domain),
+                n_experiments=n_experiments,
+                delta=criterion.delta,
+                transform_range=criterion.transform_range,
+            )
+        if isinstance(criterion, AOptimalityCriterion):
+            return AOptimality(
+                domain,
+                model=get_formula_from_string(criterion.formula, domain),
+                n_experiments=n_experiments,
+                delta=criterion.delta,
+                transform_range=criterion.transform_range,
+            )
+        if isinstance(criterion, GOptimalityCriterion):
+            return GOptimality(
+                domain,
+                model=get_formula_from_string(criterion.formula, domain),
+                n_experiments=n_experiments,
+                delta=criterion.delta,
+                transform_range=criterion.transform_range,
+            )
+        if isinstance(criterion, EOptimalityCriterion):
+            return EOptimality(
+                domain,
+                model=get_formula_from_string(criterion.formula, domain),
+                n_experiments=n_experiments,
+                delta=criterion.delta,
+                transform_range=criterion.transform_range,
+            )
+        if isinstance(criterion, KOptimalityCriterion):
+            return KOptimality(
+                domain,
+                model=get_formula_from_string(criterion.formula, domain),
+                n_experiments=n_experiments,
+                delta=criterion.delta,
+                transform_range=criterion.transform_range,
+            )
+    if isinstance(criterion, SpaceFillingCriterion):
+        return SpaceFilling(
+            domain,
+            n_experiments=n_experiments,
+            delta=criterion.delta,
+            transform_range=criterion.transform_range,
+        )
+    else:
+        NotImplementedError("Criterion type not implemented!")
diff --git a/bofire/strategies/doe/utils.py b/bofire/strategies/doe/utils.py
index 850942afb..aa4a6a651 100644
--- a/bofire/strategies/doe/utils.py
+++ b/bofire/strategies/doe/utils.py
@@ -421,61 +421,6 @@ def jacobian(self, x: np.ndarray) -> np.ndarray:
         return jacobian
 
 
-def d_optimality(X: np.ndarray, delta=1e-9) -> float:
-    """Compute ln(1/|X^T X|) for a model matrix X (smaller is better).
-    The covariance of the estimated model parameters for $y = X beta + epsilon $is
-    given by $Var(beta) ~ (X^T X)^{-1}$.
-    The determinant |Var| quantifies the volume of the confidence ellipsoid which is to
-    be minimized.
-    """
-    eigenvalues = np.linalg.eigvalsh(X.T @ X)
-    eigenvalues = eigenvalues[np.abs(eigenvalues) > delta]
-    return np.sum(np.log(eigenvalues))
-
-
-def a_optimality(X: np.ndarray, delta=1e-9) -> float:
-    """Compute the A-optimality for a model matrix X (smaller is better).
-    A-optimality is the sum of variances of the estimated model parameters, which is
-    the trace of the covariance matrix $X.T @ X^-1$.
-
-    F is symmetric positive definite, hence the trace of (X.T @ X)^-1 is equal to the
-    the sum of inverse eigenvalues.
-    """
-    eigenvalues = np.linalg.eigvalsh(X.T @ X)
-    eigenvalues = eigenvalues[np.abs(eigenvalues) > delta]
-    return np.sum(1.0 / eigenvalues)  # type: ignore
-
-
-def g_optimality(X: np.ndarray, delta: float = 1e-9) -> float:
-    """Compute the G-optimality for a model matrix X (smaller is better).
-    G-optimality is the maximum entry in the diagonal of the hat matrix
-    H = X (X.T X)^-1 X.T which relates to the maximum variance of the predicted values.
-    """
-    H = X @ np.linalg.inv(X.T @ X + delta * np.eye(len(X))) @ X.T
-    return np.max(np.diag(H))  # type: ignore
-
-
-def metrics(X: np.ndarray, delta: float = 1e-9) -> pd.Series:
-    """Returns a series containing D-optimality, A-optimality and G-efficiency
-    for a model matrix X
-
-    Args:
-        X (np.ndarray): model matrix for which the metrics are determined
-        delta (float): cutoff value for eigenvalues of the information matrix. Default value is 1e-9.
-
-    Returns:
-        A pd.Series containing the values for the three metrics.
-
-    """
-    return pd.Series(
-        {
-            "D-optimality": d_optimality(X, delta),
-            "A-optimality": a_optimality(X, delta),
-            "G-optimality": g_optimality(X, delta),
-        },
-    )
-
-
 def check_nchoosek_constraints_as_bounds(domain: Domain) -> None:
     """Checks if NChooseK constraints of domain can be formulated as bounds.
 
diff --git a/bofire/strategies/doe_strategy.py b/bofire/strategies/doe_strategy.py
index e58567f59..20e51d0bc 100644
--- a/bofire/strategies/doe_strategy.py
+++ b/bofire/strategies/doe_strategy.py
@@ -1,13 +1,20 @@
+from typing import Optional
+
 import pandas as pd
 from pydantic.types import PositiveInt
 
 import bofire.data_models.strategies.api as data_models
 from bofire.data_models.features.api import CategoricalInput, Input
-from bofire.strategies.doe.design import (
-    find_local_max_ipopt,
+from bofire.data_models.strategies.doe import (
+    AnyDoEOptimalityCriterion,
+    DoEOptimalityCriterion,
+)
+from bofire.strategies.doe.branch_and_bound import (
     find_local_max_ipopt_BaB,
     find_local_max_ipopt_exhaustive,
 )
+from bofire.strategies.doe.design import find_local_max_ipopt, get_n_experiments
+from bofire.strategies.doe.utils import get_formula_from_string, n_zero_eigvals
 from bofire.strategies.doe.utils_categorical_discrete import (
     design_from_new_to_original_domain,
     discrete_to_relaxable_domain_mapper,
@@ -29,11 +36,18 @@ def __init__(
         **kwargs,
     ):
         super().__init__(data_model=data_model, **kwargs)
-        self.formula = data_model.formula
         self.data_model = data_model
         self._partially_fixed_candidates = None
         self._fixed_candidates = None
 
+    @property
+    def formula(self):
+        if isinstance(self.data_model.criterion, DoEOptimalityCriterion):
+            return get_formula_from_string(
+                self.data_model.criterion.formula, self.data_model.domain
+            )
+        return None
+
     def set_candidates(self, candidates: pd.DataFrame):
         original_columns = self.domain.inputs.get_keys(includes=Input)
         to_many_columns = []
@@ -87,7 +101,6 @@ def _ask(self, candidate_count: PositiveInt) -> pd.DataFrame:  # type: ignore
 
         num_binary_vars = len([var for group in new_categories for var in group])
         num_discrete_vars = len(new_discretes)
-
         if (
             self.data_model.optimization_strategy == "relaxed"
             or (num_binary_vars == 0 and num_discrete_vars == 0)
@@ -99,12 +112,11 @@ def _ask(self, candidate_count: PositiveInt) -> pd.DataFrame:  # type: ignore
         ):
             design = find_local_max_ipopt(
                 new_domain,
-                self.formula,
                 n_experiments=_candidate_count,
                 fixed_experiments=None,
                 partially_fixed_experiments=adapted_partially_fixed_candidates,
-                objective=self.data_model.objective,
-                transform_range=self.data_model.transform_range,
+                ipopt_options=self.data_model.ipopt_options,
+                criterion=self.data_model.criterion,
             )
         # TODO adapt to when exhaustive search accepts discrete variables
         elif (
@@ -113,15 +125,14 @@ def _ask(self, candidate_count: PositiveInt) -> pd.DataFrame:  # type: ignore
         ):
             design = find_local_max_ipopt_exhaustive(
                 domain=new_domain,
-                model_type=self.formula,
                 n_experiments=_candidate_count,
                 fixed_experiments=None,
                 verbose=self.data_model.verbose,
                 partially_fixed_experiments=adapted_partially_fixed_candidates,
                 categorical_groups=all_new_categories,
                 discrete_variables=new_discretes,
-                objective=self.data_model.objective,
-                transform_range=self.data_model.transform_range,
+                ipopt_options=self.data_model.ipopt_options,
+                criterion=self.data_model.criterion,
             )
         elif self.data_model.optimization_strategy in [
             "branch-and-bound",
@@ -130,15 +141,14 @@ def _ask(self, candidate_count: PositiveInt) -> pd.DataFrame:  # type: ignore
         ]:
             design = find_local_max_ipopt_BaB(
                 domain=new_domain,
-                model_type=self.formula,
                 n_experiments=_candidate_count,
                 fixed_experiments=None,
                 verbose=self.data_model.verbose,
                 partially_fixed_experiments=adapted_partially_fixed_candidates,
                 categorical_groups=all_new_categories,
                 discrete_variables=new_discretes,
-                objective=self.data_model.objective,
-                transform_range=self.data_model.transform_range,
+                ipopt_options=self.data_model.ipopt_options,
+                criterion=self.data_model.criterion,
             )
         elif self.data_model.optimization_strategy == "iterative":
             # a dynamic programming approach to shrink the optimization space by optimizing one experiment at a time
@@ -155,15 +165,14 @@ def _ask(self, candidate_count: PositiveInt) -> pd.DataFrame:  # type: ignore
             for i in range(_candidate_count):
                 design = find_local_max_ipopt_BaB(
                     domain=new_domain,
-                    model_type=self.formula,
                     n_experiments=num_adapted_partially_fixed_candidates + i + 1,
                     fixed_experiments=None,
                     verbose=self.data_model.verbose,
                     partially_fixed_experiments=adapted_partially_fixed_candidates,
                     categorical_groups=all_new_categories,
                     discrete_variables=new_discretes,
-                    objective=self.data_model.objective,
-                    transform_range=self.data_model.transform_range,
+                    ipopt_options=self.data_model.ipopt_options,
+                    criterion=self.data_model.criterion,
                 )
                 adapted_partially_fixed_candidates = pd.concat(
                     [
@@ -188,6 +197,16 @@ def _ask(self, candidate_count: PositiveInt) -> pd.DataFrame:  # type: ignore
             drop=True,
         )
 
+    def get_required_number_of_experiments(self) -> Optional[int]:
+        if self.formula:
+            return get_n_experiments(self.formula) - n_zero_eigvals(
+                domain=self.data_model.domain, model_type=self.formula
+            )
+        else:
+            ValueError(
+                f"Only {AnyDoEOptimalityCriterion} type have required number of experiments."
+            )
+
     def has_sufficient_experiments(
         self,
     ) -> bool:
diff --git a/bofire/strategies/enum.py b/bofire/strategies/enum.py
deleted file mode 100644
index 9f16eb371..000000000
--- a/bofire/strategies/enum.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from enum import Enum
-
-
-class OptimalityCriterionEnum(str, Enum):
-    D_OPTIMALITY = "D_OPTIMALITY"
-    E_OPTIMALITY = "E_OPTIMALITY"
-    A_OPTIMALITY = "A_OPTIMALITY"
-    G_OPTIMALITY = "G_OPTIMALITY"
-    K_OPTIMALITY = "K_OPTIMALITY"
-    SPACE_FILLING = "SPACE_FILLING"
diff --git a/bofire/strategies/space_filling.py b/bofire/strategies/space_filling.py
index 5aa575eb1..df9ac6c45 100644
--- a/bofire/strategies/space_filling.py
+++ b/bofire/strategies/space_filling.py
@@ -1,8 +1,8 @@
 import pandas as pd
 
 from bofire.data_models.strategies.api import SpaceFillingStrategy as DataModel
+from bofire.data_models.strategies.doe import SpaceFillingCriterion
 from bofire.strategies.doe.design import find_local_max_ipopt
-from bofire.strategies.enum import OptimalityCriterionEnum
 from bofire.strategies.strategy import Strategy
 
 
@@ -31,13 +31,11 @@ def __init__(
     def _ask(self, candidate_count: int) -> pd.DataFrame:
         samples = find_local_max_ipopt(
             domain=self.domain,
-            model_type="linear",  # dummy model
             n_experiments=self.num_candidates
             + int(candidate_count / self.sampling_fraction),
             ipopt_options=self.ipopt_options,
-            objective=OptimalityCriterionEnum.SPACE_FILLING,
+            criterion=SpaceFillingCriterion(transform_range=self.transform_range),
             fixed_experiments=self.candidates,
-            transform_range=self.transform_range,
         )
 
         samples = samples.iloc[self.num_candidates :,]
diff --git a/pyproject.toml b/pyproject.toml
index 8f1fe26f8..1744c889c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -26,6 +26,7 @@ dependencies = [
     "pydantic>=2.5",
     "scipy>=1.7",
     "typing-extensions",
+    "formulaic==1.0.1",
 ]
 
 [project.optional-dependencies]
@@ -34,7 +35,6 @@ optimization = [
     "numpy",
     "multiprocess",
     "plotly",
-    "formulaic>=1.0.1",
     "cloudpickle>=2.0.0",
     "sympy>=1.12",
     "cvxpy[CLARABEL]",
@@ -63,7 +63,7 @@ all = [
     "numpy",
     "multiprocess",
     "plotly",
-    "formulaic>=1.0.1",
+    "formulaic==1.0.1",
     "cloudpickle>=2.0.0",
     "sympy>=1.12",
     "cvxpy[CLARABEL]",
diff --git a/setup.py b/setup.py
new file mode 100644
index 000000000..bfc7373af
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,79 @@
+import itertools
+import os.path
+
+from setuptools import find_packages, setup
+
+
+sklearn_dependency = "scikit-learn>=1.0.0"
+
+root_dir = os.path.dirname(__file__)
+with open(os.path.join(root_dir, "README.md")) as f:
+    long_description = f.read()
+
+
+extras_require = {
+    "optimization": [
+        "botorch>=0.10.0",
+        "numpy",
+        "multiprocess",
+        "plotly",
+        "cloudpickle>=2.0.0",
+        "sympy>=1.12",
+        "cvxpy[CLARABEL]",
+        sklearn_dependency,
+    ],
+    "entmoot": ["entmoot>=2.0", "lightgbm==4.0.0", "pyomo==6.7.1", "gurobipy"],
+    "xgb": ["xgboost>=1.7.5"],
+    "cheminfo": ["rdkit>=2023.3.2", sklearn_dependency, "mordred"],
+    "tests": [
+        "mopti",
+        "pytest",
+        "pytest-cov",
+        "papermill",
+    ],
+    "docs": [
+        "mkdocs",
+        "mkdocs-material",
+        "mkdocs-jupyter",
+        "mkdocstrings>=0.18",
+        "mkdocstrings-python-legacy",
+        "mike",
+    ],
+    "tutorials": ["jupyter", "matplotlib", "seaborn"],
+}
+extras_require["all"] = list(itertools.chain.from_iterable(extras_require.values()))
+
+setup(
+    name="bofire",
+    description="",
+    author="",
+    license="BSD-3",
+    url="https://github.com/experimental-design/bofire",
+    keywords=[
+        "Bayesian optimization",
+        "Multi-objective optimization",
+        "Experimental design",
+    ],
+    classifiers=[
+        "Development Status :: 1 - Planning",
+        "Programming Language :: Python :: 3 :: Only",
+        "License :: OSI Approved :: BSD License",
+        "Topic :: Scientific/Engineering",
+        "Intended Audience :: Science/Research",
+        "Intended Audience :: Developers",
+    ],
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    python_requires=">=3.9.0",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "numpy",
+        "pandas",
+        "pydantic>=2.5",
+        "scipy>=1.7",
+        "typing-extensions",
+        "formulaic>=1.0.1",
+    ],
+    extras_require=extras_require,
+)
diff --git a/tests/bofire/data_models/specs/strategies.py b/tests/bofire/data_models/specs/strategies.py
index c9879602c..cf6436a00 100644
--- a/tests/bofire/data_models/specs/strategies.py
+++ b/tests/bofire/data_models/specs/strategies.py
@@ -21,7 +21,6 @@
     TaskInput,
 )
 from bofire.data_models.surrogates.api import BotorchSurrogates, MultiTaskGPSurrogate
-from bofire.strategies.enum import OptimalityCriterionEnum
 from tests.bofire.data_models.specs.api import domain
 from tests.bofire.data_models.specs.specs import Specs
 
@@ -212,12 +211,12 @@
     strategies.DoEStrategy,
     lambda: {
         "domain": domain.valid().obj().model_dump(),
-        "formula": "linear",
         "optimization_strategy": "default",
         "verbose": False,
         "seed": 42,
-        "objective": OptimalityCriterionEnum.D_OPTIMALITY,
-        "transform_range": None,
+        "criterion": strategies.DOptimalityCriterion(
+            formula="fully-quadratic", transform_range=None
+        ).model_dump(),
     },
 )
 specs.add_valid(
diff --git a/tests/bofire/strategies/doe/test_design.py b/tests/bofire/strategies/doe/test_design.py
index ab956e809..d0489dec0 100644
--- a/tests/bofire/strategies/doe/test_design.py
+++ b/tests/bofire/strategies/doe/test_design.py
@@ -13,6 +13,7 @@
 )
 from bofire.data_models.domain.api import Domain
 from bofire.data_models.features.api import ContinuousInput, ContinuousOutput
+from bofire.data_models.strategies.doe import DOptimalityCriterion
 from bofire.strategies.doe.design import (
     check_fixed_experiments,
     check_partially_and_fully_fixed_experiments,
@@ -52,7 +53,7 @@ def test_find_local_max_ipopt_no_constraint():
         + 3
     )
 
-    design = find_local_max_ipopt(domain, "linear")
+    design = find_local_max_ipopt(domain, n_experiments=num_exp)
     assert design.shape == (num_exp, dim_input)
 
 
@@ -88,7 +89,9 @@ def test_find_local_max_ipopt_nchoosek():
     )
     print(N)
 
-    A = find_local_max_ipopt(domain, "linear")
+    A = find_local_max_ipopt(
+        domain, n_experiments=N, criterion=DOptimalityCriterion(formula="linear")
+    )
     assert A.shape == (N, D)
 
 
@@ -117,7 +120,9 @@ def test_find_local_max_ipopt_mixture():
     D = len(domain.inputs)
 
     N = len(get_formula_from_string(domain=domain, model_type="linear")) + 3
-    A = find_local_max_ipopt(domain, "linear")
+    A = find_local_max_ipopt(
+        domain, n_experiments=N, criterion=DOptimalityCriterion(formula="linear")
+    )
     assert A.shape == (N, D)
 
 
@@ -155,8 +160,18 @@ def test_find_local_max_ipopt_mixed_results():
         ],
     )
 
+    N = (
+        len(get_formula_from_string(model_type="fully-quadratic", domain=domain))
+        - n_zero_eigvals(domain=domain, model_type="fully-quadratic")
+        + 3
+    )
     # with pytest.warns(ValueError):
-    A = find_local_max_ipopt(domain, "fully-quadratic", ipopt_options={"maxiter": 100})
+    A = find_local_max_ipopt(
+        domain,
+        n_experiments=N,
+        criterion=DOptimalityCriterion(formula="fully-quadratic"),
+        ipopt_options={"maxiter": 100},
+    )
     opt = np.eye(3)
     for row in A.to_numpy():
         assert any(np.allclose(row, o, atol=1e-2) for o in opt)
@@ -197,7 +212,9 @@ def test_find_local_max_ipopt_results():
         ],
     )
     np.random.seed(1)
-    A = find_local_max_ipopt(domain, "linear", n_experiments=12)
+    A = find_local_max_ipopt(
+        domain, criterion=DOptimalityCriterion(formula="linear"), n_experiments=12
+    )
     opt = np.array([[0.2, 0.2, 0.6], [0.3, 0.6, 0.1], [0.7, 0.1, 0.2], [0.3, 0.1, 0.6]])
     for row in A.to_numpy():
         assert any(np.allclose(row, o, atol=1e-2) for o in opt)
@@ -224,7 +241,7 @@ def test_find_local_max_ipopt_results():
 @pytest.mark.skipif(not CYIPOPT_AVAILABLE, reason="requires cyipopt")
 def test_find_local_max_ipopt_batch_constraint():
     # define problem with batch constraints
-    domain = Domain(
+    domain = Domain.from_lists(
         inputs=[
             ContinuousInput(key="x1", bounds=(0, 1)),
             ContinuousInput(key="x2", bounds=(0, 1)),
@@ -236,7 +253,7 @@ def test_find_local_max_ipopt_batch_constraint():
 
     result = find_local_max_ipopt(
         domain,
-        "linear",
+        criterion=DOptimalityCriterion(formula="linear"),
         ipopt_options={"maxiter": 100},
         n_experiments=30,
     )
@@ -309,7 +326,7 @@ def test_find_local_max_ipopt_fixed_experiments():
     with pytest.raises(ValueError):
         find_local_max_ipopt(
             domain,
-            "linear",
+            criterion=DOptimalityCriterion(formula="linear"),
             n_experiments=12,
             fixed_experiments=pd.DataFrame(
                 np.ones(shape=(12, 3)),
@@ -352,9 +369,17 @@ def test_find_local_max_ipopt_fixed_experiments():
 
     # with pytest.warns(ValueError):
     np.random.seed(1)
+
+    num_exp = (
+        len(get_formula_from_string(model_type="fully-quadratic", domain=domain))
+        - n_zero_eigvals(domain=domain, model_type="fully-quadratic")
+        + 3
+    )
+
     A = find_local_max_ipopt(
         domain,
-        "fully-quadratic",
+        n_experiments=num_exp,
+        criterion=DOptimalityCriterion(formula="fully-quadratic"),
         ipopt_options={"maxiter": 100},
         fixed_experiments=pd.DataFrame(
             [[1, 0, 0], [0, 1, 0]],
@@ -506,7 +531,18 @@ def test_find_local_max_ipopt_nonlinear_constraint():
         ],
     )
 
-    result = find_local_max_ipopt(domain, "linear", ipopt_options={"maxiter": 100})
+    num_exp = (
+        len(get_formula_from_string(model_type="fully-quadratic", domain=domain))
+        - n_zero_eigvals(domain=domain, model_type="fully-quadratic")
+        + 3
+    )
+
+    result = find_local_max_ipopt(
+        domain,
+        num_exp,
+        DOptimalityCriterion(formula="linear"),
+        ipopt_options={"maxiter": 100},
+    )
 
     assert np.allclose(domain.constraints(result), 0, atol=1e-6)
 
@@ -539,7 +575,7 @@ def test_get_n_experiments():
 
 @pytest.mark.skipif(not CYIPOPT_AVAILABLE, reason="requires cyipopt")
 def test_fixed_experiments_checker():
-    domain = Domain(
+    domain = Domain.from_lists(
         inputs=[
             ContinuousInput(key="x1", bounds=(0, 5)),
             ContinuousInput(key="x2", bounds=(0, 15)),
@@ -664,7 +700,7 @@ def test_fixed_experiments_checker():
 
 
 def test_partially_fixed_experiments():
-    domain = Domain(
+    domain = Domain.from_lists(
         inputs=[
             ContinuousInput(key="x1", bounds=(0, 5)),
             ContinuousInput(key="x2", bounds=(0, 15)),
@@ -734,7 +770,7 @@ def get_domain_error(feature):
 
     doe = find_local_max_ipopt(
         domain,
-        "linear",
+        criterion=DOptimalityCriterion(formula="linear"),
         n_experiments=3,
         fixed_experiments=fixed_experiments,
     ).reset_index(drop=True)
@@ -753,7 +789,7 @@ def get_domain_error(feature):
     with pytest.raises(ValueError) as e:
         doe = find_local_max_ipopt(
             domain,
-            "linear",
+            criterion=DOptimalityCriterion(formula="linear"),
             n_experiments=2,
             fixed_experiments=fixed_experiments,
         )
@@ -767,7 +803,7 @@ def get_domain_error(feature):
     with pytest.raises(ValueError) as e:
         doe = find_local_max_ipopt(
             domain,
-            "linear",
+            criterion=DOptimalityCriterion(formula="linear"),
             n_experiments=2,
             partially_fixed_experiments=partially_fixed_experiments,
         )
@@ -780,7 +816,7 @@ def get_domain_error(feature):
 
     doe = find_local_max_ipopt(
         domain,
-        "linear",
+        criterion=DOptimalityCriterion(formula="linear"),
         n_experiments=3,
         fixed_experiments=fixed_experiments,
     ).reset_index(drop=True)
@@ -797,7 +833,7 @@ def get_domain_error(feature):
     )
     doe = find_local_max_ipopt(
         domain,
-        "linear",
+        criterion=DOptimalityCriterion(formula="linear"),
         n_experiments=3,
         partially_fixed_experiments=partially_fixed_experiments,
     ).reset_index(drop=True)
@@ -810,7 +846,7 @@ def get_domain_error(feature):
 
     doe = find_local_max_ipopt(
         domain,
-        "linear",
+        criterion=DOptimalityCriterion(formula="linear"),
         n_experiments=4,
         fixed_experiments=fixed_experiments,
         partially_fixed_experiments=partially_fixed_experiments,
@@ -832,7 +868,7 @@ def get_domain_error(feature):
     with pytest.raises(ValueError) as e:
         doe = find_local_max_ipopt(
             domain,
-            "linear",
+            criterion=DOptimalityCriterion(formula="linear"),
             n_experiments=1,
             fixed_experiments=fixed_experiments,
             partially_fixed_experiments=partially_fixed_experiments,
@@ -841,7 +877,7 @@ def get_domain_error(feature):
     with pytest.raises(ValueError) as e:
         doe = find_local_max_ipopt(
             domain,
-            "linear",
+            criterion=DOptimalityCriterion(formula="linear"),
             n_experiments=2,
             fixed_experiments=fixed_experiments,
             partially_fixed_experiments=partially_fixed_experiments,
@@ -852,7 +888,7 @@ def get_domain_error(feature):
     with pytest.raises(ValueError) as e:
         doe = find_local_max_ipopt(
             domain,
-            "linear",
+            criterion=DOptimalityCriterion(formula="linear"),
             n_experiments=3,
             fixed_experiments=_fixed_experiments,
             partially_fixed_experiments=partially_fixed_experiments,
@@ -863,7 +899,7 @@ def get_domain_error(feature):
     with pytest.raises(ValueError) as e:
         doe = find_local_max_ipopt(
             domain,
-            "linear",
+            criterion=DOptimalityCriterion(formula="linear"),
             n_experiments=3,
             fixed_experiments=fixed_experiments,
             partially_fixed_experiments=_partially_fixed_experiments,
@@ -875,7 +911,7 @@ def get_domain_error(feature):
     with pytest.raises(ValueError) as e:
         doe = find_local_max_ipopt(
             domain,
-            "linear",
+            criterion=DOptimalityCriterion(formula="linear"),
             n_experiments=3,
             fixed_experiments=_fixed_experiments,
             partially_fixed_experiments=_partially_fixed_experiments,
diff --git a/tests/bofire/strategies/doe/test_objective.py b/tests/bofire/strategies/doe/test_objective.py
index 96bd66723..8c6e7d3b0 100644
--- a/tests/bofire/strategies/doe/test_objective.py
+++ b/tests/bofire/strategies/doe/test_objective.py
@@ -4,13 +4,21 @@
 
 from bofire.data_models.domain.api import Domain
 from bofire.data_models.features.api import ContinuousInput, ContinuousOutput
+from bofire.data_models.strategies.doe import (
+    AOptimalityCriterion,
+    DOptimalityCriterion,
+    EOptimalityCriterion,
+    GOptimalityCriterion,
+    SpaceFillingCriterion,
+)
 from bofire.strategies.doe.objective import (
     AOptimality,
     DOptimality,
     EOptimality,
     GOptimality,
-    Objective,
+    ModelBasedObjective,
     SpaceFilling,
+    get_objective_function,
 )
 from bofire.strategies.doe.utils import get_formula_from_string
 
@@ -32,7 +40,7 @@ def test_Objective_model_jacobian_t():
     f = Formula("x1 + x2 + x3 + x1:x2 + {x3**2}")
     x = np.array([[1, 2, 3]])
 
-    objective = Objective(
+    objective = ModelBasedObjective(
         domain=domain,
         model=f,
         n_experiments=1,
@@ -51,7 +59,7 @@ def test_Objective_model_jacobian_t():
     model_terms = np.array(f, dtype=str)
     x = np.array([[1, 2, 3]])
 
-    objective = Objective(
+    objective = ModelBasedObjective(
         domain=domain,
         model=f,
         n_experiments=1,
@@ -116,7 +124,7 @@ def test_Objective_model_jacobian_t():
                 formula += term
     f = Formula(formula[:-3])
     x = np.array([[1, 2, 3, 4, 5]])
-    objective = Objective(
+    objective = ModelBasedObjective(
         domain=domain,
         model=f,
         n_experiments=1,
@@ -467,7 +475,7 @@ def test_DOptimality_instantiation():
 
 def test_DOptimality_evaluate_jacobian():
     # n_experiment = 1, n_inputs = 2, model: x1 + x2
-    def jacobian(x: np.ndarray, delta=1e-3) -> np.ndarray:
+    def get_jacobian(x: np.ndarray, delta=1e-3) -> np.ndarray:
         return -2 * x / (x[0] ** 2 + x[1] ** 2 + delta)
 
     domain = Domain.from_lists(
@@ -493,10 +501,12 @@ def jacobian(x: np.ndarray, delta=1e-3) -> np.ndarray:
     np.random.seed(1)
     for _ in range(10):
         x = np.random.rand(2)
-        assert np.allclose(d_optimality.evaluate_jacobian(x), jacobian(x), rtol=1e-3)
+        assert np.allclose(
+            d_optimality.evaluate_jacobian(x), get_jacobian(x), rtol=1e-3
+        )
 
     # n_experiment = 1, n_inputs = 2, model: x1**2 + x2**2
-    def jacobian(x: np.ndarray, delta=1e-3) -> np.ndarray:
+    def get_jacobian(x: np.ndarray, delta=1e-3) -> np.ndarray:
         return -4 * x**3 / (x[0] ** 4 + x[1] ** 4 + delta)
 
     model = Formula("{x1**2} + {x2**2} - 1")
@@ -509,10 +519,12 @@ def jacobian(x: np.ndarray, delta=1e-3) -> np.ndarray:
     np.random.seed(1)
     for _ in range(10):
         x = np.random.rand(2)
-        assert np.allclose(d_optimality.evaluate_jacobian(x), jacobian(x), rtol=1e-3)
+        assert np.allclose(
+            d_optimality.evaluate_jacobian(x), get_jacobian(x), rtol=1e-3
+        )
 
     # n_experiment = 2, n_inputs = 2, model = x1 + x2
-    def jacobian(x: np.ndarray, delta=1e-3) -> np.ndarray:
+    def get_jacobian(x: np.ndarray, delta=1e-3) -> np.ndarray:
         X = x.reshape(2, 2)
 
         y = np.empty(4)
@@ -562,7 +574,9 @@ def jacobian(x: np.ndarray, delta=1e-3) -> np.ndarray:
     np.random.seed(1)
     for _ in range(10):
         x = np.random.rand(4)
-        assert np.allclose(d_optimality.evaluate_jacobian(x), jacobian(x), rtol=1e-3)
+        assert np.allclose(
+            d_optimality.evaluate_jacobian(x), get_jacobian(x), rtol=1e-3
+        )
 
     # n_experiment = 2, n_inputs = 2, model = x1**2 + x2**2
     def jacobian(x: np.ndarray, delta=1e-3) -> np.ndarray:
@@ -762,9 +776,8 @@ def test_SpaceFilling_evaluate():
         inputs=[ContinuousInput(key="x1", bounds=(0, 1))],
         outputs=[ContinuousOutput(key="y")],
     )
-    model = get_formula_from_string("linear", domain=domain)
 
-    space_filling = SpaceFilling(domain=domain, model=model, n_experiments=4, delta=0)
+    space_filling = SpaceFilling(domain=domain, n_experiments=4, delta=0)
 
     x = np.array([1, 0.6, 0.1, 0.3])
 
@@ -776,9 +789,8 @@ def test_SpaceFilling_evaluate_jacobian():
         inputs=[ContinuousInput(key="x1", bounds=(0, 1))],
         outputs=[ContinuousOutput(key="y")],
     )
-    model = get_formula_from_string("linear", domain=domain)
 
-    space_filling = SpaceFilling(domain=domain, model=model, n_experiments=4, delta=0)
+    space_filling = SpaceFilling(domain=domain, n_experiments=4, delta=0)
 
     x = np.array([1, 0.4, 0, 0.1])
 
@@ -790,26 +802,52 @@ def test_MinMaxTransform():
         inputs=[ContinuousInput(key="x1", bounds=(0, 1))],
         outputs=[ContinuousOutput(key="y")],
     )
-    model = get_formula_from_string("linear", domain=domain)
-
     x = np.array([1, 0.8, 0.55, 0.65])
     x_scaled = x * 2 - 1
 
-    for cls in [DOptimality, AOptimality, EOptimality, GOptimality, SpaceFilling]:
-        objective_unscaled = cls(
-            domain=domain,
-            model=model,
-            n_experiments=4,
-            delta=0,
-            transform_range=None,
-        )
-        objective_scaled = cls(
-            domain=domain,
-            model=model,
-            n_experiments=4,
-            delta=0,
-            transform_range=(-1.0, 1.0),
-        )
+    for cls in [
+        DOptimalityCriterion,
+        AOptimalityCriterion,
+        EOptimalityCriterion,
+        GOptimalityCriterion,
+        SpaceFillingCriterion,
+    ]:
+        if cls == SpaceFillingCriterion:
+            objective_unscaled = get_objective_function(
+                cls(
+                    transform_range=None,
+                ),
+                domain=domain,
+                n_experiments=4,
+            )
+
+            objective_scaled = get_objective_function(
+                cls(
+                    transform_range=(-1.0, 1.0),
+                ),
+                domain=domain,
+                n_experiments=4,
+            )
+        else:
+            objective_unscaled = get_objective_function(
+                cls(
+                    formula="linear",
+                    delta=0,
+                    transform_range=None,
+                ),
+                domain=domain,
+                n_experiments=4,
+            )
+
+            objective_scaled = get_objective_function(
+                cls(
+                    formula="linear",
+                    delta=0,
+                    transform_range=(-1.0, 1.0),
+                ),
+                domain=domain,
+                n_experiments=4,
+            )
         assert np.allclose(
             objective_unscaled.evaluate(x_scaled),
             objective_scaled.evaluate(x),
diff --git a/tests/bofire/strategies/doe/test_utils.py b/tests/bofire/strategies/doe/test_utils.py
index ffabccc41..dc45b8430 100644
--- a/tests/bofire/strategies/doe/test_utils.py
+++ b/tests/bofire/strategies/doe/test_utils.py
@@ -20,13 +20,9 @@
 )
 from bofire.strategies.doe.utils import (
     ConstraintWrapper,
-    a_optimality,
     check_nchoosek_constraints_as_bounds,
     constraints_as_scipy_constraints,
-    d_optimality,
-    g_optimality,
     get_formula_from_string,
-    metrics,
     n_zero_eigvals,
     nchoosek_constraints_as_bounds,
 )
@@ -481,84 +477,6 @@ def test_ConstraintWrapper():
     )
 
 
-def test_d_optimality():
-    # define model matrix: full rank
-    X = np.array(
-        [
-            [1, 1, 0, 0],
-            [1, 0, 1, 0],
-            [1, 0, 0, 1],
-            [1, 0, 0, 0],
-        ],
-    )
-    assert np.allclose(d_optimality(X), np.linalg.slogdet(X.T @ X)[1])
-
-    # define model matrix: not full rank
-    X = np.array(
-        [
-            [1, 1, 0, 0],
-            [1, 0, 1, 0],
-            [1, 0, 0, 1],
-            [1, 1 / 3, 1 / 3, 1 / 3],
-        ],
-    )
-    assert np.allclose(d_optimality(X), np.sum(np.log(np.linalg.eigvalsh(X.T @ X)[1:])))
-
-
-def test_a_optimality():
-    # define model matrix: full rank
-    X = np.array(
-        [
-            [1, 1, 0, 0],
-            [1, 0, 1, 0],
-            [1, 0, 0, 1],
-            [1, 0, 0, 0],
-        ],
-    )
-    assert np.allclose(a_optimality(X), np.sum(1 / (np.linalg.eigvalsh(X.T @ X))))
-
-    # define model matrix: not full rank
-    X = np.array(
-        [
-            [1, 1, 0, 0],
-            [1, 0, 1, 0],
-            [1, 0, 0, 1],
-            [1, 1 / 3, 1 / 3, 1 / 3],
-        ],
-    )
-    assert np.allclose(a_optimality(X), np.sum(1 / (np.linalg.eigvalsh(X.T @ X)[1:])))
-
-
-def test_g_optimality():
-    # define model matrix and domain: no constraints
-    X = np.array(
-        [
-            [1, 0, 0, 0],
-            [0, 0.1, 0, 0],
-            [0, 0, 0.1, 0],
-            [0, 0, 0, 0.1],
-        ],
-    )
-    assert np.allclose(g_optimality(X), 1)
-
-
-def test_metrics():
-    # define model matrix
-    X = np.array(
-        [
-            [1, 1, 0, 0],
-            [1, 0, 1, 0],
-            [1, 0, 0, 1],
-            [1, 0, 0, 0],
-        ],
-    )
-
-    m = metrics(X)
-    assert np.allclose(m["A-optimality"], a_optimality(X))
-    assert np.allclose(m["D-optimality"], d_optimality(X))
-    assert np.allclose(m["G-optimality"], g_optimality(X))
-
-
 def test_check_nchoosek_constraints_as_bounds():
     # define domain: possible to formulate as bounds, no NChooseK constraints
     domain = Domain.from_lists(
diff --git a/tests/bofire/strategies/test_doe.py b/tests/bofire/strategies/test_doe.py
index a99c5853b..fe049c857 100644
--- a/tests/bofire/strategies/test_doe.py
+++ b/tests/bofire/strategies/test_doe.py
@@ -16,6 +16,7 @@
     ContinuousOutput,
     DiscreteInput,
 )
+from bofire.data_models.strategies.doe import DOptimalityCriterion
 from bofire.strategies.api import DoEStrategy
 
 
@@ -61,13 +62,17 @@
 
 
 def test_doe_strategy_init():
-    data_model = data_models.DoEStrategy(domain=domain, formula="linear")
+    data_model = data_models.DoEStrategy(
+        domain=domain, criterion=DOptimalityCriterion(formula="linear")
+    )
     strategy = DoEStrategy(data_model=data_model)
     assert strategy is not None
 
 
 def test_doe_strategy_ask():
-    data_model = data_models.DoEStrategy(domain=domain, formula="linear")
+    data_model = data_models.DoEStrategy(
+        domain=domain, criterion=DOptimalityCriterion(formula="linear")
+    )
     strategy = DoEStrategy(data_model=data_model)
     candidates = strategy.ask(candidate_count=12)
     assert candidates.shape == (12, 3)
@@ -78,7 +83,9 @@ def test_doe_strategy_ask_with_candidates():
         np.array([[0.2, 0.2, 0.6], [0.3, 0.6, 0.1], [0.7, 0.1, 0.2], [0.3, 0.1, 0.6]]),
         columns=["x1", "x2", "x3"],
     )
-    data_model = data_models.DoEStrategy(domain=domain, formula="linear")
+    data_model = data_models.DoEStrategy(
+        domain=domain, criterion=DOptimalityCriterion(formula="linear")
+    )
     strategy = DoEStrategy(data_model=data_model)
     strategy.set_candidates(candidates_fixed)
     candidates = strategy.ask(candidate_count=12)
@@ -99,7 +106,7 @@ def test_nchoosek_implemented():
     )
     data_model = data_models.DoEStrategy(
         domain=domain,
-        formula="linear",
+        criterion=DOptimalityCriterion(formula="linear"),
         optimization_strategy="partially-random",
     )
     strategy = DoEStrategy(data_model=data_model)
@@ -108,6 +115,10 @@ def test_nchoosek_implemented():
 
 
 def test_formulas_implemented():
+    domain = Domain.from_lists(
+        inputs=inputs,
+        outputs=[ContinuousOutput(key="y")],
+    )
     expected_num_candidates = {
         "linear": 7,  # 1+a+b+c+3
         "linear-and-quadratic": 10,  # 1+a+b+c+a**2+b**2+c**2+3
@@ -116,9 +127,11 @@ def test_formulas_implemented():
     }
 
     for formula, num_candidates in expected_num_candidates.items():
-        data_model = data_models.DoEStrategy(domain=domain, formula=formula)
+        data_model = data_models.DoEStrategy(
+            domain=domain, criterion=DOptimalityCriterion(formula=formula)
+        )
         strategy = DoEStrategy(data_model=data_model)
-        candidates = strategy.ask()
+        candidates = strategy.ask(strategy.get_required_number_of_experiments())
         assert candidates.shape == (num_candidates, 3)
 
 
@@ -127,7 +140,9 @@ def test_doe_strategy_correctness():
         np.array([[0.2, 0.2, 0.6], [0.3, 0.6, 0.1], [0.7, 0.1, 0.2], [0.3, 0.1, 0.6]]),
         columns=["x1", "x2", "x3"],
     )
-    data_model = data_models.DoEStrategy(domain=domain, formula="linear")
+    data_model = data_models.DoEStrategy(
+        domain=domain, criterion=DOptimalityCriterion(formula="linear")
+    )
     strategy = DoEStrategy(data_model=data_model)
     strategy.set_candidates(candidates_fixed)
     candidates = strategy.ask(candidate_count=12)
@@ -147,7 +162,9 @@ def test_doe_strategy_amount_of_candidates():
         np.array([[0.2, 0.2, 0.6], [0.3, 0.6, 0.1], [0.7, 0.1, 0.2], [0.3, 0.1, 0.6]]),
         columns=["x1", "x2", "x3"],
     )
-    data_model = data_models.DoEStrategy(domain=domain, formula="linear")
+    data_model = data_models.DoEStrategy(
+        domain=domain, criterion=DOptimalityCriterion(formula="linear")
+    )
     strategy = DoEStrategy(data_model=data_model)
     strategy.set_candidates(candidates_fixed)
     candidates = strategy.ask(candidate_count=12)
@@ -193,7 +210,7 @@ def test_categorical_discrete_doe():
     ]
 
     n_experiments = 10
-    domain = Domain(
+    domain = Domain.from_lists(
         inputs=all_inputs,
         outputs=[ContinuousOutput(key="y")],
         constraints=all_constraints,
@@ -201,7 +218,7 @@ def test_categorical_discrete_doe():
 
     data_model = data_models.DoEStrategy(
         domain=domain,
-        formula="linear",
+        criterion=DOptimalityCriterion(formula="linear"),
         optimization_strategy="partially-random",
     )
     strategy = DoEStrategy(data_model=data_model)
@@ -232,7 +249,7 @@ def test_partially_fixed_experiments():
     n_experiments = 10
 
     all_inputs = all_inputs + continuous_var
-    domain = Domain(
+    domain = Domain.from_lists(
         inputs=all_inputs,
         outputs=[ContinuousOutput(key="y")],
         constraints=all_constraints,
@@ -240,7 +257,7 @@ def test_partially_fixed_experiments():
 
     data_model = data_models.DoEStrategy(
         domain=domain,
-        formula="linear",
+        criterion=DOptimalityCriterion(formula="linear"),
         optimization_strategy="relaxed",
         verbose=True,
     )
@@ -283,7 +300,6 @@ def test_partially_fixed_experiments():
     )
 
     candidates = strategy.ask(candidate_count=n_experiments)
-    print(candidates)
     only_partially_fixed = only_partially_fixed.mask(
         only_partially_fixed.isnull(),
         candidates[:4],
@@ -310,8 +326,7 @@ def test_scaled_doe():
     )
     data_model = data_models.DoEStrategy(
         domain=domain,
-        formula="linear",
-        transform_range=(-1, 1),
+        criterion=DOptimalityCriterion(formula="linear", transform_range=(-1, 1)),
     )
     strategy = DoEStrategy(data_model=data_model)
     candidates = strategy.ask(candidate_count=6).to_numpy()
@@ -339,7 +354,7 @@ def test_categorical_doe_iterative():
     ]
 
     n_experiments = 5
-    domain = Domain(
+    domain = Domain.from_lists(
         inputs=all_inputs,
         outputs=[ContinuousOutput(key="y")],
         constraints=all_constraints,
@@ -347,7 +362,7 @@ def test_categorical_doe_iterative():
 
     data_model = data_models.DoEStrategy(
         domain=domain,
-        formula="linear",
+        criterion=DOptimalityCriterion(formula="linear"),
         optimization_strategy="iterative",
     )
     strategy = DoEStrategy(data_model=data_model)
@@ -357,3 +372,7 @@ def test_categorical_doe_iterative():
     )
 
     assert candidates.shape == (5, 3)
+
+
+if __name__ == "__main__":
+    test_formulas_implemented()
diff --git a/tutorials/doe/basic_examples.ipynb b/tutorials/doe/basic_examples.ipynb
index c2ea31dc2..0b4874203 100644
--- a/tutorials/doe/basic_examples.ipynb
+++ b/tutorials/doe/basic_examples.ipynb
@@ -17,7 +17,7 @@
    "source": [
     "# Basic Examples for the DoE Subpackage\n",
     "\n",
-    "The following example has been taken from the paper \"The construction of D- and I-optimal designs for mixture experiments with linear constraints on the components\" by R. Coetzer and L. M. Haines. "
+    "The following example has been taken from the paper \"The construction of D- and I-optimal designs for mixture experiments with linear constraints on the components\" by R. Coetzer and L. M. Haines (https://www.sciencedirect.com/science/article/pii/S0169743917303106). "
    ]
   },
   {
@@ -40,6 +40,7 @@
     "import numpy as np\n",
     "from matplotlib.ticker import FormatStrFormatter\n",
     "\n",
+    "import bofire.strategies.api as strategies\n",
     "from bofire.data_models.constraints.api import (\n",
     "    InterpointEqualityConstraint,\n",
     "    LinearEqualityConstraint,\n",
@@ -49,7 +50,8 @@
     ")\n",
     "from bofire.data_models.domain.api import Domain\n",
     "from bofire.data_models.features.api import ContinuousInput, ContinuousOutput\n",
-    "from bofire.strategies.doe.design import find_local_max_ipopt"
+    "from bofire.data_models.strategies.api import DoEStrategy\n",
+    "from bofire.data_models.strategies.doe import DOptimalityCriterion"
    ]
   },
   {
@@ -67,7 +69,15 @@
     "tags": []
    },
    "source": [
-    "## linear model"
+    "## Linear model\n",
+    "\n",
+    "Creating an experimental design that is D-optimal with respect to a linear model is done the same way as making proposals using other methods in BoFire; you \n",
+    "1. create a domain\n",
+    "2. construct a stategy data model (here we want DoEStrategy)\n",
+    "3. map the strategy to its functional version, and finally \n",
+    "4. ask the strategy for proposals. \n",
+    "   \n",
+    "We will start with the simplest case: make a design based on a linear model containing main-effects (i.e., simply the inputs themselves and an intercept, without any second-order terms)."
    ]
   },
   {
@@ -108,17 +118,27 @@
     "    ],\n",
     ")\n",
     "\n",
-    "d_optimal_design = (\n",
-    "    find_local_max_ipopt(domain, \"linear\", n_experiments=12, ipopt_options={\"disp\": 0})\n",
-    "    .to_numpy()\n",
-    "    .T\n",
-    ")"
+    "data_model = DoEStrategy(\n",
+    "    domain=domain,\n",
+    "    criterion=DOptimalityCriterion(formula=\"linear\"),\n",
+    "    ipopt_options={\"disp\": 0},\n",
+    ")\n",
+    "strategy = strategies.map(data_model=data_model)\n",
+    "candidates = strategy.ask(candidate_count=12)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4",
+   "metadata": {},
+   "source": [
+    "Let's visualize the experiments that were chosen. We will see that such a design puts the experiments at the extremes of the experimental space - these are the points that best allow us to estimate the parameters of the linear model we chose."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "4",
+   "id": "5",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -150,9 +170,9 @@
     "\n",
     "# plot D-optimal solutions\n",
     "ax.scatter(\n",
-    "    xs=d_optimal_design[0],\n",
-    "    ys=d_optimal_design[1],\n",
-    "    zs=d_optimal_design[2],\n",
+    "    xs=candidates[\"x1\"],\n",
+    "    ys=candidates[\"x2\"],\n",
+    "    zs=candidates[\"x3\"],\n",
     "    marker=\"o\",\n",
     "    s=40,\n",
     "    color=\"orange\",\n",
@@ -165,7 +185,7 @@
   {
    "attachments": {},
    "cell_type": "markdown",
-   "id": "5",
+   "id": "6",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -177,13 +197,17 @@
     "tags": []
    },
    "source": [
-    "## cubic model"
+    "## cubic model\n",
+    "\n",
+    "While the previous design is optimal for the main-effects model, we might prefer to see something that does not allocate all the experimental effort to values at the boundary of the space. This implies that we think there might be some higher-order effects present in the system - if we were sure that the target variable would follow straight-line behavior across the domain, we would not need to investigate any points away from the extremes.\n",
+    "\n",
+    "We can address this by specifying our own linear model that includes higher-order terms. "
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "6",
+   "id": "7",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -196,16 +220,32 @@
    },
    "outputs": [],
    "source": [
-    "d_optimal_design = (\n",
-    "    find_local_max_ipopt(\n",
-    "        domain,\n",
-    "        \"x1 + x2 + x3 + {x1**2} + {x2**2} + {x3**2} + {x1**3} + {x2**3} + {x3**3} + x1:x2 + x1:x3 + x2:x3 + x1:x2:x3\",\n",
-    "        n_experiments=12,\n",
-    "    )\n",
-    "    .to_numpy()\n",
-    "    .T\n",
+    "data_model = DoEStrategy(\n",
+    "    domain=domain,\n",
+    "    criterion=DOptimalityCriterion(\n",
+    "        formula=\"x1 + x2 + x3 + {x1**2} + {x2**2} + {x3**2} + {x1**3} + {x2**3} + {x3**3} + x1:x2 + x1:x3 + x2:x3 + x1:x2:x3\"\n",
+    "    ),\n",
+    "    ipopt_options={\"disp\": 0},\n",
     ")\n",
-    "\n",
+    "strategy = strategies.map(data_model=data_model)\n",
+    "candidates = strategy.ask(12)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8",
+   "metadata": {},
+   "source": [
+    "In this case we can compare with the result reported in the paper of Coetzer and Haines."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "d_opt = np.array(\n",
     "    [\n",
     "        [\n",
@@ -270,9 +310,9 @@
     ")\n",
     "\n",
     "ax.scatter(\n",
-    "    xs=d_optimal_design[0],\n",
-    "    ys=d_optimal_design[1],\n",
-    "    zs=d_optimal_design[2],\n",
+    "    xs=candidates[\"x1\"],\n",
+    "    ys=candidates[\"x2\"],\n",
+    "    zs=candidates[\"x3\"],\n",
     "    marker=\"o\",\n",
     "    s=40,\n",
     "    color=\"orange\",\n",
@@ -285,7 +325,7 @@
   {
    "attachments": {},
    "cell_type": "markdown",
-   "id": "7",
+   "id": "10",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -299,13 +339,15 @@
    "source": [
     "## Nonlinear Constraints\n",
     "\n",
-    "IPOPT also supports nonlinear constraints. This notebook shows examples of design optimizations with nonlinear constraints."
+    "Design generation also supports nonlinear constraints. The following 3 examples show what is possible.\n",
+    "\n",
+    "First, a convenience function for plotting."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "8",
+   "id": "11",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -343,7 +385,7 @@
   {
    "attachments": {},
    "cell_type": "markdown",
-   "id": "9",
+   "id": "12",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -358,15 +400,15 @@
     "### Example 1: Design inside a cone / nonlinear inequality\n",
     "\n",
     "In the following example we have three design variables. \n",
-    "We impose the constraint of all experiments to be contained in the interior of a cone, which corresponds the nonlinear inequality constraint\n",
+    "We impose the constraint that all experiments have to be contained in the interior of a cone, which corresponds to the nonlinear inequality constraint\n",
     "$\\sqrt{x_1^2 + x_2^2} - x_3 \\leq 0$.\n",
-    "The optimization is done for a linear model and places the points on the surface of the cone so as to maximize the between them"
+    "The optimization is done for a linear model and we will see that it places the points on the surface of the cone so as to maximize the distance between them (although this is not explicitly the objective of the optimization)."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "10",
+   "id": "13",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -394,11 +436,13 @@
     "    ],\n",
     ")\n",
     "\n",
-    "result = find_local_max_ipopt(\n",
-    "    domain,\n",
-    "    \"linear\",\n",
+    "data_model = DoEStrategy(\n",
+    "    domain=domain,\n",
+    "    criterion=DOptimalityCriterion(formula=\"linear\"),\n",
     "    ipopt_options={\"maxiter\": 100, \"disp\": 0},\n",
     ")\n",
+    "strategy = strategies.map(data_model=data_model)\n",
+    "result = strategy.ask(strategy.get_required_number_of_experiments())\n",
     "result.round(3)\n",
     "plot_results_3d(result, surface_func=lambda x1, x2: np.sqrt(x1**2 + x2**2))"
    ]
@@ -406,7 +450,7 @@
   {
    "attachments": {},
    "cell_type": "markdown",
-   "id": "11",
+   "id": "14",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -418,13 +462,13 @@
     "tags": []
    },
    "source": [
-    "And the same for a design space limited by an elliptical cone $x_1^2 + x_2^2 - x_3 \\leq 0$.\n"
+    "We can do the same for a design space limited by an elliptical cone $x_1^2 + x_2^2 - x_3 \\leq 0$.\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "12",
+   "id": "15",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -451,8 +495,13 @@
     "        ),\n",
     "    ],\n",
     ")\n",
-    "\n",
-    "result = find_local_max_ipopt(domain, \"linear\", ipopt_options={\"maxiter\": 100})\n",
+    "data_model = DoEStrategy(\n",
+    "    domain=domain,\n",
+    "    criterion=DOptimalityCriterion(formula=\"linear\"),\n",
+    "    ipopt_options={\"maxiter\": 100, \"disp\": 0},\n",
+    ")\n",
+    "strategy = strategies.map(data_model=data_model)\n",
+    "result = strategy.ask(strategy.get_required_number_of_experiments())\n",
     "result.round(3)\n",
     "plot_results_3d(result, surface_func=lambda x1, x2: x1**2 + x2**2)"
    ]
@@ -460,7 +509,7 @@
   {
    "attachments": {},
    "cell_type": "markdown",
-   "id": "13",
+   "id": "16",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -474,15 +523,15 @@
    "source": [
     "### Example 2: Design on the surface of a cone / nonlinear equality\n",
     "\n",
-    "We can also limit the design space to the surface of a cone, defined by the equality constraint $\\sqrt{x_1^2 + x_2^2} - x_3 = 0$\n",
+    "We can also limit the design space to the surface of a cone, defined by the equality constraint $\\sqrt{x_1^2 + x_2^2} - x_3 = 0$. Before, we observed that the experimental proposals happened to be on the surface of the cone, but now they are constrained so that this must be the case.\n",
     "\n",
-    "Note that due to missing sampling methods in opti, the initial points provided to IPOPT don't satisfy the constraints.\n"
+    "Remark: Due to missing sampling methods, the initial points provided to IPOPT don't satisfy the constraints. But this does not matter for the solution.\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "14",
+   "id": "17",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -509,15 +558,20 @@
     "        ),\n",
     "    ],\n",
     ")\n",
-    "\n",
-    "result = find_local_max_ipopt(domain, \"linear\", ipopt_options={\"maxiter\": 100})\n",
+    "data_model = DoEStrategy(\n",
+    "    domain=domain,\n",
+    "    criterion=DOptimalityCriterion(formula=\"linear\"),\n",
+    "    ipopt_options={\"maxiter\": 100, \"disp\": 0},\n",
+    ")\n",
+    "strategy = strategies.map(data_model=data_model)\n",
+    "result = strategy.ask(12)\n",
     "result.round(3)\n",
     "plot_results_3d(result, surface_func=lambda x1, x2: np.sqrt(x1**2 + x2**2))"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "15",
+   "id": "18",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -530,13 +584,15 @@
    },
    "source": [
     "### Example 3: Batch constraints\n",
-    "Batch constraints can be used to create designs where each set of `multiplicity` subsequent experiments have the same value for a certain feature. In the following example we fix the value of the decision variable `x1` inside each batch of size 3.   "
+    "Batch constraints can be used to create designs where each set of `multiplicity` subsequent experiments have the same value for a certain feature. This can be useful for setups where experiments are done in parallel and some parameters must be shared by experiments in the same parallel batch.\n",
+    "\n",
+    "In the following example we fix the value of the decision variable `x1` for each batch of 3 experiments.   "
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "16",
+   "id": "19",
    "metadata": {
     "papermill": {
      "duration": null,
@@ -558,20 +614,20 @@
     "    outputs=[ContinuousOutput(key=\"y\")],\n",
     "    constraints=[InterpointEqualityConstraint(feature=\"x1\", multiplicity=3)],\n",
     ")\n",
-    "\n",
-    "result = find_local_max_ipopt(\n",
-    "    domain,\n",
-    "    \"linear\",\n",
-    "    ipopt_options={\"maxiter\": 100},\n",
-    "    n_experiments=12,\n",
+    "data_model = DoEStrategy(\n",
+    "    domain=domain,\n",
+    "    criterion=DOptimalityCriterion(formula=\"linear\"),\n",
+    "    ipopt_options={\"maxiter\": 100, \"disp\": 0},\n",
     ")\n",
+    "strategy = strategies.map(data_model=data_model)\n",
+    "result = strategy.ask(12)\n",
     "result.round(3)"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "base",
+   "display_name": "bofire",
    "language": "python",
    "name": "python3"
   },
@@ -585,7 +641,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.7"
+   "version": "3.11.11"
   },
   "papermill": {
    "default_parameters": {},
diff --git a/tutorials/doe/design_with_explicit_formula.ipynb b/tutorials/doe/design_with_explicit_formula.ipynb
index 2d121f271..d42ca8b15 100644
--- a/tutorials/doe/design_with_explicit_formula.ipynb
+++ b/tutorials/doe/design_with_explicit_formula.ipynb
@@ -56,11 +56,11 @@
    },
    "outputs": [],
    "source": [
-    "from formulaic import Formula\n",
-    "\n",
+    "import bofire.strategies.api as strategies\n",
     "from bofire.data_models.api import Domain, Inputs\n",
     "from bofire.data_models.features.api import ContinuousInput\n",
-    "from bofire.strategies.doe.design import find_local_max_ipopt\n",
+    "from bofire.data_models.strategies.api import DoEStrategy\n",
+    "from bofire.data_models.strategies.doe import DOptimalityCriterion\n",
     "from bofire.utils.doe import get_confounding_matrix"
    ]
   },
@@ -124,7 +124,7 @@
     "tags": []
    },
    "source": [
-    "## Definitionn of the formula for which the optimal points should be found"
+    "## Definition of the formula for which the optimal points should be found"
    ]
   },
   {
@@ -141,9 +141,20 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'a + {a**2} + b + c + d + a:b + a:c + a:d + b:c + b:d + c:d'"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "model_type = Formula(\"a + {a**2} + b + c + d + a:b + a:c + a:d + b:c + b:d + c:d\")\n",
+    "model_type = \"a + {a**2} + b + c + d + a:b + a:c + a:d + b:c + b:d + c:d\"\n",
     "model_type"
    ]
   },
@@ -179,9 +190,192 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>a</th>\n",
+       "      <th>b</th>\n",
+       "      <th>c</th>\n",
+       "      <th>d</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>5.000000e+00</td>\n",
+       "      <td>40.000000</td>\n",
+       "      <td>180.000002</td>\n",
+       "      <td>199.999998</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2.047832e+00</td>\n",
+       "      <td>40.000000</td>\n",
+       "      <td>180.000002</td>\n",
+       "      <td>800.000008</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>5.000000e+00</td>\n",
+       "      <td>40.000000</td>\n",
+       "      <td>180.000002</td>\n",
+       "      <td>800.000008</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>5.000000e+00</td>\n",
+       "      <td>800.000008</td>\n",
+       "      <td>79.999999</td>\n",
+       "      <td>199.999998</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5.000000e+00</td>\n",
+       "      <td>800.000008</td>\n",
+       "      <td>79.999999</td>\n",
+       "      <td>800.000008</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>-9.973772e-09</td>\n",
+       "      <td>40.000000</td>\n",
+       "      <td>180.000002</td>\n",
+       "      <td>199.999998</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>5.000000e+00</td>\n",
+       "      <td>800.000008</td>\n",
+       "      <td>180.000002</td>\n",
+       "      <td>199.999998</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>-9.973772e-09</td>\n",
+       "      <td>800.000008</td>\n",
+       "      <td>180.000002</td>\n",
+       "      <td>800.000008</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>-8.091201e-09</td>\n",
+       "      <td>40.000000</td>\n",
+       "      <td>79.999999</td>\n",
+       "      <td>199.999998</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>5.000000e+00</td>\n",
+       "      <td>40.000000</td>\n",
+       "      <td>79.999999</td>\n",
+       "      <td>199.999998</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>-9.981833e-09</td>\n",
+       "      <td>40.000000</td>\n",
+       "      <td>79.999999</td>\n",
+       "      <td>800.000008</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>2.907832e+00</td>\n",
+       "      <td>40.000000</td>\n",
+       "      <td>79.999999</td>\n",
+       "      <td>800.000008</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>-9.976118e-09</td>\n",
+       "      <td>800.000008</td>\n",
+       "      <td>180.000002</td>\n",
+       "      <td>199.999998</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>-9.906825e-09</td>\n",
+       "      <td>800.000008</td>\n",
+       "      <td>79.999999</td>\n",
+       "      <td>199.999998</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>-9.981833e-09</td>\n",
+       "      <td>40.000000</td>\n",
+       "      <td>79.999999</td>\n",
+       "      <td>800.000008</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>-8.091050e-09</td>\n",
+       "      <td>800.000008</td>\n",
+       "      <td>79.999999</td>\n",
+       "      <td>800.000008</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>5.000000e+00</td>\n",
+       "      <td>800.000008</td>\n",
+       "      <td>180.000002</td>\n",
+       "      <td>800.000008</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "               a           b           c           d\n",
+       "0   5.000000e+00   40.000000  180.000002  199.999998\n",
+       "1   2.047832e+00   40.000000  180.000002  800.000008\n",
+       "2   5.000000e+00   40.000000  180.000002  800.000008\n",
+       "3   5.000000e+00  800.000008   79.999999  199.999998\n",
+       "4   5.000000e+00  800.000008   79.999999  800.000008\n",
+       "5  -9.973772e-09   40.000000  180.000002  199.999998\n",
+       "6   5.000000e+00  800.000008  180.000002  199.999998\n",
+       "7  -9.973772e-09  800.000008  180.000002  800.000008\n",
+       "8  -8.091201e-09   40.000000   79.999999  199.999998\n",
+       "9   5.000000e+00   40.000000   79.999999  199.999998\n",
+       "10 -9.981833e-09   40.000000   79.999999  800.000008\n",
+       "11  2.907832e+00   40.000000   79.999999  800.000008\n",
+       "12 -9.976118e-09  800.000008  180.000002  199.999998\n",
+       "13 -9.906825e-09  800.000008   79.999999  199.999998\n",
+       "14 -9.981833e-09   40.000000   79.999999  800.000008\n",
+       "15 -8.091050e-09  800.000008   79.999999  800.000008\n",
+       "16  5.000000e+00  800.000008  180.000002  800.000008"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "design = find_local_max_ipopt(domain=domain, model_type=model_type, n_experiments=17)\n",
+    "data_model = DoEStrategy(\n",
+    "    domain=domain,\n",
+    "    criterion=DOptimalityCriterion(formula=model_type),\n",
+    "    ipopt_options={\"maxiter\": 100, \"disp\": 0},\n",
+    ")\n",
+    "strategy = strategies.map(data_model=data_model)\n",
+    "design = strategy.ask(17)\n",
     "design"
    ]
   },
@@ -217,7 +411,18 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 768x576 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "import matplotlib\n",
     "import matplotlib.pyplot as plt\n",
@@ -240,7 +445,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "bofire",
    "language": "python",
    "name": "python3"
   },
@@ -254,7 +459,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.7"
+   "version": "3.11.11"
   },
   "papermill": {
    "default_parameters": {},
diff --git a/tutorials/doe/nchoosek_constraint.ipynb b/tutorials/doe/nchoosek_constraint.ipynb
index 4e500b063..a29ff72d3 100644
--- a/tutorials/doe/nchoosek_constraint.ipynb
+++ b/tutorials/doe/nchoosek_constraint.ipynb
@@ -57,10 +57,221 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/linznedd/miniforge3/envs/bofire/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "******************************************************************************\n",
+      "This program contains Ipopt, a library for large-scale nonlinear optimization.\n",
+      " Ipopt is released as open source code under the Eclipse Public License (EPL).\n",
+      "         For more information visit https://github.com/coin-or/Ipopt\n",
+      "******************************************************************************\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>x1</th>\n",
+       "      <th>x2</th>\n",
+       "      <th>x3</th>\n",
+       "      <th>x4</th>\n",
+       "      <th>x5</th>\n",
+       "      <th>x6</th>\n",
+       "      <th>x7</th>\n",
+       "      <th>x8</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.1</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.7</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.3</td>\n",
+       "      <td>-0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.1</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>0.1</td>\n",
+       "      <td>-0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.7</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.1</td>\n",
+       "      <td>-0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>0.7</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.3</td>\n",
+       "      <td>-0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.1</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>-0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     x1   x2   x3   x4   x5   x6   x7   x8\n",
+       "0  -0.0 -0.0 -0.0  0.9 -0.0 -0.0 -0.0  0.1\n",
+       "1  -0.0 -0.0 -0.0  0.1 -0.0 -0.0 -0.0  0.9\n",
+       "2  -0.0  0.7 -0.0 -0.0 -0.0 -0.0  0.3 -0.0\n",
+       "3  -0.0 -0.0 -0.0 -0.0 -0.0  0.1 -0.0  0.9\n",
+       "4  -0.0 -0.0 -0.0 -0.0 -0.0  0.9  0.1 -0.0\n",
+       "5  -0.0 -0.0  0.7 -0.0 -0.0 -0.0 -0.0  0.3\n",
+       "6  -0.0 -0.0 -0.0  0.9 -0.0 -0.0  0.1 -0.0\n",
+       "7  -0.0 -0.0 -0.0 -0.0 -0.0  0.9 -0.0  0.1\n",
+       "8   0.7 -0.0 -0.0 -0.0 -0.0 -0.0  0.3 -0.0\n",
+       "9  -0.0 -0.0 -0.0 -0.0  0.1 -0.0  0.9 -0.0\n",
+       "10 -0.0 -0.0 -0.0 -0.0  0.9 -0.0 -0.0  0.1\n",
+       "11 -0.0 -0.0 -0.0 -0.0 -0.0  0.9 -0.0  0.1"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "\n",
+    "import bofire.strategies.api as strategies\n",
     "from bofire.data_models.constraints.api import (\n",
     "    LinearEqualityConstraint,\n",
     "    LinearInequalityConstraint,\n",
@@ -68,7 +279,8 @@
     ")\n",
     "from bofire.data_models.domain.api import Domain\n",
     "from bofire.data_models.features.api import ContinuousInput, ContinuousOutput\n",
-    "from bofire.strategies.doe.design import find_local_max_ipopt\n",
+    "from bofire.data_models.strategies.api import DoEStrategy\n",
+    "from bofire.data_models.strategies.doe import DOptimalityCriterion\n",
     "\n",
     "\n",
     "domain = Domain(\n",
@@ -100,18 +312,20 @@
     "    ],\n",
     ")\n",
     "\n",
-    "res = find_local_max_ipopt(\n",
+    "data_model = DoEStrategy(\n",
     "    domain=domain,\n",
-    "    model_type=\"fully-quadratic\",\n",
+    "    criterion=DOptimalityCriterion(formula=\"fully-quadratic\"),\n",
     "    ipopt_options={\"maxiter\": 500},\n",
     ")\n",
-    "np.round(res, 3)"
+    "strategy = strategies.map(data_model=data_model)\n",
+    "candidates = strategy.ask(candidate_count=12)\n",
+    "np.round(candidates, 3)"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "bofire",
    "language": "python",
    "name": "python3"
   },
@@ -125,7 +339,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.7"
+   "version": "3.11.11"
   },
   "papermill": {
    "default_parameters": {},
diff --git a/tutorials/doe/optimality_criteria.ipynb b/tutorials/doe/optimality_criteria.ipynb
index f02f15eab..bdaedfbf6 100644
--- a/tutorials/doe/optimality_criteria.ipynb
+++ b/tutorials/doe/optimality_criteria.ipynb
@@ -14,15 +14,32 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/linznedd/miniforge3/envs/bofire/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
+    "import bofire.strategies.api as strategies\n",
     "from bofire.data_models.constraints.api import LinearEqualityConstraint\n",
     "from bofire.data_models.domain.api import Domain\n",
     "from bofire.data_models.features.api import ContinuousInput, ContinuousOutput\n",
-    "from bofire.strategies.doe.design import find_local_max_ipopt\n",
-    "from bofire.strategies.enum import OptimalityCriterionEnum"
+    "from bofire.data_models.strategies.api import DoEStrategy\n",
+    "from bofire.data_models.strategies.doe import (\n",
+    "    AOptimalityCriterion,\n",
+    "    DOptimalityCriterion,\n",
+    "    EOptimalityCriterion,\n",
+    "    KOptimalityCriterion,\n",
+    "    SpaceFillingCriterion,\n",
+    ")\n",
+    "from bofire.strategies.doe.objective import get_objective_function"
    ]
   },
   {
@@ -57,7 +74,31 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "******************************************************************************\n",
+      "This program contains Ipopt, a library for large-scale nonlinear optimization.\n",
+      " Ipopt is released as open source code under the Eclipse Public License (EPL).\n",
+      "         For more information visit https://github.com/coin-or/Ipopt\n",
+      "******************************************************************************\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Optimal designs for a quadratic model on the unit square\n",
     "domain = Domain(\n",
@@ -68,14 +109,24 @@
     "n_experiments = 13\n",
     "\n",
     "designs = {}\n",
-    "for obj in OptimalityCriterionEnum:\n",
-    "    designs[obj.value] = find_local_max_ipopt(\n",
-    "        domain,\n",
-    "        model_type=model_type,\n",
-    "        n_experiments=n_experiments,\n",
-    "        objective=obj,\n",
+    "for crit in [\n",
+    "    DOptimalityCriterion,\n",
+    "    AOptimalityCriterion,\n",
+    "    KOptimalityCriterion,\n",
+    "    EOptimalityCriterion,\n",
+    "]:\n",
+    "    criterion = crit(formula=model_type)\n",
+    "    data_model = DoEStrategy(\n",
+    "        domain=domain,\n",
+    "        criterion=criterion,\n",
     "        ipopt_options={\"maxiter\": 300},\n",
-    "    ).to_numpy()\n",
+    "    )\n",
+    "    strategy = strategies.map(data_model=data_model)\n",
+    "    design = strategy.ask(candidate_count=n_experiments)\n",
+    "    obj_value = get_objective_function(\n",
+    "        criterion=criterion, domain=domain, n_experiments=n_experiments\n",
+    "    ).evaluate(design.to_numpy().flatten())\n",
+    "    designs[obj_value] = design.to_numpy()\n",
     "\n",
     "fig = plt.figure(figsize=((8, 8)))\n",
     "ax = fig.add_subplot(111)\n",
@@ -120,7 +171,28 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<mpl_toolkits.mplot3d.art3d.Path3DCollection at 0x7cf598509510>"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Space filling design on the unit 2-simplex\n",
     "domain = Domain(\n",
@@ -134,15 +206,11 @@
     "        ),\n",
     "    ],\n",
     ")\n",
-    "\n",
-    "X = find_local_max_ipopt(\n",
-    "    domain,\n",
-    "    n_experiments=40,\n",
-    "    model_type=\"linear\",  # the model type does not matter for space filling designs\n",
-    "    objective=OptimalityCriterionEnum.SPACE_FILLING,\n",
-    "    ipopt_options={\"maxiter\": 500},\n",
-    ").to_numpy()\n",
-    "\n",
+    "data_model = DoEStrategy(\n",
+    "    domain=domain, criterion=SpaceFillingCriterion(), ipopt_options={\"maxiter\": 500}\n",
+    ")\n",
+    "strategy = strategies.map(data_model=data_model)\n",
+    "X = strategy.ask(candidate_count=40).to_numpy()\n",
     "\n",
     "fig = plt.figure(figsize=((10, 8)))\n",
     "ax = fig.add_subplot(111, projection=\"3d\")\n",
@@ -162,7 +230,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "base",
+   "display_name": "bofire",
    "language": "python",
    "name": "python3"
   },
@@ -176,7 +244,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.7"
+   "version": "3.11.11"
   },
   "papermill": {
    "default_parameters": {},
diff --git a/tutorials/getting_started.ipynb b/tutorials/getting_started.ipynb
index 58ef68c4c..81f1a7db3 100644
--- a/tutorials/getting_started.ipynb
+++ b/tutorials/getting_started.ipynb
@@ -690,7 +690,18 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "NonlinearEqualityConstraint(type='NonlinearEqualityConstraint', expression='x1**2 + x2**2 - 1', features=None, jacobian_expression=None)"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from bofire.data_models.constraints.api import NonlinearEqualityConstraint\n",
     "\n",
@@ -947,7 +958,19 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'constraints' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[7], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mbofire\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdata_models\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdomain\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mapi\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Domain\n\u001b[0;32m----> 4\u001b[0m domain \u001b[38;5;241m=\u001b[39m Domain(inputs\u001b[38;5;241m=\u001b[39minput_features, outputs\u001b[38;5;241m=\u001b[39moutput_features, constraints\u001b[38;5;241m=\u001b[39m\u001b[43mconstraints\u001b[49m)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'constraints' is not defined"
+     ]
+    }
+   ],
    "source": [
     "from bofire.data_models.domain.api import Domain\n",
     "\n",
@@ -1050,7 +1073,27 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/linznedd/miniforge3/envs/bofire/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "ename": "NameError",
+     "evalue": "name 'domain' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[8], line 5\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mbofire\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mstrategies\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mapi\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mstrategies\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mbofire\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdata_models\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mstrategies\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mapi\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m RandomStrategy\n\u001b[0;32m----> 5\u001b[0m strategy_data_model \u001b[38;5;241m=\u001b[39m RandomStrategy(domain\u001b[38;5;241m=\u001b[39m\u001b[43mdomain\u001b[49m)\n\u001b[1;32m      7\u001b[0m random_strategy \u001b[38;5;241m=\u001b[39m strategies\u001b[38;5;241m.\u001b[39mmap(strategy_data_model)\n\u001b[1;32m      8\u001b[0m random_candidates \u001b[38;5;241m=\u001b[39m random_strategy\u001b[38;5;241m.\u001b[39mask(\u001b[38;5;241m2\u001b[39m)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'domain' is not defined"
+     ]
+    }
+   ],
    "source": [
     "import bofire.strategies.api as strategies\n",
     "from bofire.data_models.strategies.api import RandomStrategy\n",
@@ -1237,17 +1280,146 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>x1</th>\n",
+       "      <th>x2</th>\n",
+       "      <th>x3</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>-0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.5</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>-0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>0.5</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>0.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>-0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     x1   x2   x3\n",
+       "0  -0.0  1.0 -0.0\n",
+       "1  -0.0  0.5  0.5\n",
+       "2  -0.0 -0.0  1.0\n",
+       "3   0.5  0.5 -0.0\n",
+       "4   0.5 -0.0  0.5\n",
+       "5   0.5  0.5 -0.0\n",
+       "6   1.0 -0.0 -0.0\n",
+       "7  -0.0  0.5  0.5\n",
+       "8  -0.0  1.0 -0.0\n",
+       "9  -0.0  0.5  0.5\n",
+       "10  0.5 -0.0  0.5\n",
+       "11 -0.0 -0.0  1.0"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "\n",
-    "from bofire.strategies.doe.design import find_local_max_ipopt\n",
+    "from bofire.data_models.strategies.api import DoEStrategy\n",
+    "from bofire.data_models.strategies.doe import DOptimalityCriterion\n",
     "\n",
     "\n",
     "domain = Domain(inputs=[x1, x2, x3], outputs=[y1], constraints=[constr1])\n",
-    "\n",
-    "res = find_local_max_ipopt(domain, \"fully-quadratic\")\n",
-    "np.round(res, 3)"
+    "data_model = DoEStrategy(\n",
+    "    domain=domain,\n",
+    "    criterion=DOptimalityCriterion(formula=\"fully-quadratic\"),\n",
+    ")\n",
+    "strategy = strategies.map(data_model=data_model)\n",
+    "candidates = strategy.ask(candidate_count=12)\n",
+    "np.round(candidates, 3)"
    ]
   },
   {
@@ -1282,7 +1454,29 @@
     },
     "tags": []
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'res' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[11], line 17\u001b[0m\n\u001b[1;32m     14\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot(xs\u001b[38;5;241m=\u001b[39m[\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m], ys\u001b[38;5;241m=\u001b[39m[\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m], zs\u001b[38;5;241m=\u001b[39m[\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m0\u001b[39m], linewidth\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m     16\u001b[0m \u001b[38;5;66;03m# plot D-optimal solutions\u001b[39;00m\n\u001b[0;32m---> 17\u001b[0m ax\u001b[38;5;241m.\u001b[39mscatter(xs\u001b[38;5;241m=\u001b[39m\u001b[43mres\u001b[49m[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx1\u001b[39m\u001b[38;5;124m\"\u001b[39m], ys\u001b[38;5;241m=\u001b[39mres[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx2\u001b[39m\u001b[38;5;124m\"\u001b[39m], zs\u001b[38;5;241m=\u001b[39mres[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx3\u001b[39m\u001b[38;5;124m\"\u001b[39m], marker\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mo\u001b[39m\u001b[38;5;124m\"\u001b[39m, s\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m40\u001b[39m, color\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124morange\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'res' is not defined"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
@@ -1300,13 +1494,20 @@
     "ax.plot(xs=[1, 0, 0, 1], ys=[0, 1, 0, 0], zs=[0, 0, 1, 0], linewidth=2)\n",
     "\n",
     "# plot D-optimal solutions\n",
-    "ax.scatter(xs=res[\"x1\"], ys=res[\"x2\"], zs=res[\"x3\"], marker=\"o\", s=40, color=\"orange\")"
+    "ax.scatter(\n",
+    "    xs=candidates[\"x1\"],\n",
+    "    ys=candidates[\"x2\"],\n",
+    "    zs=candidates[\"x3\"],\n",
+    "    marker=\"o\",\n",
+    "    s=40,\n",
+    "    color=\"orange\",\n",
+    ")"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "base",
+   "display_name": "bofire",
    "language": "python",
    "name": "python3"
   },
@@ -1320,7 +1521,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.7"
+   "version": "3.11.11"
   },
   "papermill": {
    "default_parameters": {},