pyfemtet 0.9.5__py3-none-any.whl → 1.0.0b0__py3-none-any.whl

pyfemtet/opt/interface/_solidworks_interface/solidworks_interface.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+from time import sleep
+from typing import TYPE_CHECKING
+
+import os
+import re
+
+from win32com.client import DispatchEx, CDispatch
+# noinspection PyUnresolvedReferences
+from pythoncom import CoInitialize, CoUninitialize, com_error
+
+from pyfemtet._util.dask_util import *
+from pyfemtet.opt.exceptions import *
+from pyfemtet.opt.interface._base_interface import COMInterface
+from pyfemtet._i18n import _
+from pyfemtet.opt.problem.variable_manager import SupportedVariableTypes
+from pyfemtet.logger import get_module_logger
+
+if TYPE_CHECKING:
+    from pyfemtet.opt.optimizer import AbstractOptimizer
+
+
+logger = get_module_logger('opt.interface', False)
+
+
+# 定数の宣言
+swThisConfiguration = 1  # https://help.solidworks.com/2023/english/api/swconst/SOLIDWORKS.Interop.swconst~SOLIDWORKS.Interop.swconst.swInConfigurationOpts_e.html
+swAllConfiguration = 2
+swSpecifyConfiguration = 3  # use with ConfigName argument
+swSaveAsCurrentVersion = 0
+swSaveAsOptions_Copy = 2  #
+swSaveAsOptions_Silent = 1  # https://help.solidworks.com/2021/english/api/swconst/solidworks.interop.swconst~solidworks.interop.swconst.swsaveasoptions_e.html
+swSaveWithReferencesOptions_None = 0  # https://help-solidworks-com.translate.goog/2023/english/api/swconst/SolidWorks.Interop.swconst~SolidWorks.Interop.swconst.swSaveWithReferencesOptions_e.html?_x_tr_sl=auto&_x_tr_tl=ja&_x_tr_hl=ja&_x_tr_pto=wapp
+swDocPART = 1  # https://help.solidworks.com/2023/english/api/swconst/SOLIDWORKS.Interop.swconst~SOLIDWORKS.Interop.swconst.swDocumentTypes_e.html
+
+
+class FileNotOpenedError(Exception):
+    pass
+
+
+# noinspection PyPep8Naming
+class SolidworksInterface(COMInterface):
+
+    swApp: CDispatch
+    com_members = {'swApp': 'SLDWORKS.Application'}
+    _access_sw_lock_name = 'access_sw'
+
+    def __init__(
+            self,
+            sldprt_path,
+            close_solidworks_on_terminate=False,
+            visible=True,
+    ):
+        self.sldprt_path = os.path.abspath(sldprt_path)
+        self.quit_solidworks_on_terminate = close_solidworks_on_terminate
+        self.solidworks_visible = visible
+
+        assert os.path.isfile(self.sldprt_path)
+        self._original_sldprt_path = self.sldprt_path
+
+    def connect_sw(self):
+        logger.info(_(
+            en_message='Connecting to Solidworks...',
+            jp_message='Solidworks に接続しています...'
+        ))
+        try:
+            self.swApp = DispatchEx('SLDWORKS.Application')
+        except com_error:
+            raise Exception(_(
+                en_message='Failed to instantiate Solidworks. '
+                           'Please check installation and enabling macro.',
+                jp_message='Solidworks のインスタンス化に失敗しました。'
+                           'Solidworks がインストールされており、'
+                           'Solidworks マクロが有効であることを確認してください。'))
+        self.swApp.Visible = self.solidworks_visible
+
+    def _setup_before_parallel(self):
+        self._distribute_files([self.sldprt_path])
+
+    def _setup_after_parallel(self, opt: AbstractOptimizer = None):
+
+        # get suffix
+        suffix = self._get_worker_index_from_optimizer(opt)
+
+        # rename and get worker path
+        self.sldprt_path = self._rename_and_get_path_on_worker_space(
+            self._original_sldprt_path,
+            suffix,
+        )
+
+        # connect solidworks
+        CoInitialize()
+        with Lock(self._access_sw_lock_name):
+            self.connect_sw()
+
+            # open it
+            self.swApp.OpenDoc(self.sldprt_path, swDocPART)
+
+    @property
+    def swModel(self) -> CDispatch:
+        return _get_model_by_basename(self.swApp, os.path.basename(self.sldprt_path))
+
+    def update(self) -> None:
+        raise NotImplementedError
+
+    def update_parameter(self, x: dict[str, SupportedVariableTypes]) -> None:
+
+        COMInterface.update_parameter(self, x)
+
+        # sw はプロセスが一つなので Lock
+        with Lock(self._access_sw_lock_name):
+
+            sleep(0.2)
+
+            # ===== model を取得 =====
+            swModel = self.swModel
+
+            # ===== equation manager を取得 =====
+            swEqnMgr = swModel.GetEquationMgr
+            nEquation = swEqnMgr.GetCount
+
+            # プロパティを退避
+            buffer_aso = swEqnMgr.AutomaticSolveOrder
+            buffer_ar = swEqnMgr.AutomaticRebuild
+            swEqnMgr.AutomaticSolveOrder = False
+            swEqnMgr.AutomaticRebuild = False
+
+            # 値を更新
+            for i in range(nEquation):
+                # name, equation の取得
+                eq = swEqnMgr.Equation(i)
+                prm_name = _get_name_from_equation(eq)
+                # 対象なら処理
+                if prm_name in self.current_prm_values:
+                    new_equation = f'"{prm_name}" = {self.current_prm_values[prm_name]}'
+                    swEqnMgr.Equation(i, new_equation)
+
+            # 式の計算
+            # noinspection PyStatementEffect
+            swEqnMgr.EvaluateAll  # always returns -1
+
+            # プロパティをもとに戻す
+            swEqnMgr.AutomaticSolveOrder = buffer_aso
+            swEqnMgr.AutomaticRebuild = buffer_ar
+
+    def update_model(self):
+        """Update .sldprt"""
+
+        # sw はプロセスが一つなので Lock
+        with Lock(self._access_sw_lock_name):
+
+            sleep(0.2)
+
+            # ===== model を取得 =====
+            swModel = self.swModel
+
+            # モデル再構築
+            result = swModel.EditRebuild3  # モデル再構築
+            if not result:
+                raise ModelError(_(
+                    en_message='Failed to update the model on Solidworks.',
+                    jp_message='Solidworks モデルの更新に失敗しました。'
+                ))
+
+    def close(self):
+        if not hasattr(self, 'swApp'):
+            return
+
+        if self.swApp is None:
+            return
+
+        with Lock(self._access_sw_lock_name):
+            model_name = os.path.basename(self.sldprt_path)
+            logger.info(_(
+                en_message='Closing {model_name} ...',
+                jp_message='モデル {model_name} を閉じています...',
+                model_name=model_name,
+            ))
+
+            # 最後の Doc ならばプロセスを落とす仕様？
+            self.swApp.QuitDoc(os.path.basename(self.sldprt_path))
+            # logger.info(Msg.F_SW_MODEL_CLOSED(model_name))
+            logger.info(_(
+                en_message='Successfully closed {model_name}.',
+                jp_message='モデル {model_name} を閉じました。',
+                model_name=model_name,
+            ))
+            sleep(3)
+
+
+# noinspection PyPep8Naming
+def _get_model_by_basename(swApp, basename):
+    swModel = swApp.ActivateDoc(basename)
+    if swModel is None:
+        raise FileNotOpenedError(f'Model {basename} is not opened.')
+    return swModel
+
+
+def _get_name_from_equation(equation: str):
+    pattern = r'^\s*"(.+?)"\s*$'
+    matched = re.match(pattern, equation.split('=')[0])
+    if matched:
+        return matched.group(1)
+    else:
+        return None

pyfemtet/opt/interface/_surrogate_model_interface/__init__.py

@@ -0,0 +1,8 @@
+from .base_surrogate_interface import AbstractSurrogateModelInterfaceBase
+from .botorch_interface import BoTorchInterface, PoFBoTorchInterface
+
+__all__ = [
+    'AbstractSurrogateModelInterfaceBase',
+    'BoTorchInterface',
+    'PoFBoTorchInterface',
+]

pyfemtet/opt/interface/_surrogate_model_interface/base_surrogate_interface.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
+
+from pyfemtet.opt.history import *
+
+from pyfemtet.opt.interface import AbstractFEMInterface
+from pyfemtet._i18n import _
+
+if TYPE_CHECKING:
+    from pyfemtet.opt.optimizer import AbstractOptimizer
+
+
+__all__ = [
+    'AbstractSurrogateModelInterfaceBase',
+]
+
+
+class AbstractSurrogateModelInterfaceBase(AbstractFEMInterface):
+    _load_problem_from_fem = True
+    current_obj_values: dict[str, float]
+    train_history: History
+
+    def __init__(
+            self,
+            history_path: str = None,
+            train_history: History = None,
+            _output_directions: (
+                Sequence[str | float]
+                | dict[str, str | float]
+                | dict[int, str | float]
+            ) = None
+    ):
+
+        self._output_directions = _output_directions
+
+        # history_path が与えられた場合、train_history をコンストラクトする
+        if history_path is not None:
+            train_history = History()
+            train_history.load_csv(history_path, with_finalize=True)
+
+        assert train_history is not None
+
+        self.train_history = train_history
+
+        self.current_obj_values = {}
+
+    def load_objectives(self, opt: AbstractOptimizer):
+
+        # output directions が与えられない場合、
+        # opt.add_objective との整合をチェックする
+        if self._output_directions is None:
+
+            # add_objective された目的のうち、
+            # training data に含まれる名前ならば
+            # fun を「その時点の current_obj_values を返す関数」で
+            # 上書き
+            obj_name: str
+            for obj_name, obj in opt.objectives.items():
+                # あれば上書き、なければ surrogate 最適化の際に
+                # 新しく追加した model を使わない目的関数と見做して何もしない
+                if obj_name in self.train_history.obj_names:
+                    obj.fun = lambda _, obj_name_=obj_name: self.current_obj_values[obj_name_]
+
+        # dict で与えられた場合
+        elif isinstance(self._output_directions, dict):
+
+            # index 入力か str 入力かで統一されているか確認
+            keys = tuple(self._output_directions.keys())
+            assert all([isinstance(key, type(keys[0])) for key in keys]), _(
+                en_message='The keys of _output_directions must be '
+                           'all-int or all-str.',
+                jp_message='_output_directions のキーは int または str で'
+                           '統一されていなければなりません。',
+            )
+
+            # index がキーである場合
+            if isinstance(keys[0], int):
+
+                for index, direction in self._output_directions.items():
+                    obj_name = self.train_history.obj_names[index]
+
+                    opt.add_objective(
+                        name=obj_name,
+                        fun=lambda _, obj_name_=obj_name: self.current_obj_values[obj_name_],
+                        direction=direction,
+                        args=(),
+                        kwargs={},
+                    )
+
+            # obj_name がキーである場合
+            if isinstance(keys[0], str):
+
+                for obj_name, direction in self._output_directions.items():
+                    assert obj_name in self.train_history.obj_names, _(
+                        en_message='The objective name passed as a key of '
+                                   '_output_direction must be one of the history\'s '
+                                   'objective names. Passed name: {obj_name} / '
+                                   'History\'s names: {obj_names}',
+                        jp_message='_output_directions に目的関数名を与える場合は'
+                                   'history に含まれる名前を指定しなければなりません。'
+                                   '与えられた目的名: {obj_name} / history に含まれる'
+                                   '目的名: {obj_names}',
+                        obj_name=obj_name,
+                        obj_names=', '.join(self.train_history.obj_names)
+                    )
+
+                    opt.add_objective(
+                        name=obj_name,
+                        fun=lambda obj_name_=obj_name: self.current_obj_values[obj_name_],
+                        direction=direction,
+                        args=(),
+                        kwargs={},
+                    )
+
+        # tuple で与えられた場合
+        elif isinstance(self._output_directions, list) \
+                or isinstance(self._output_directions, tuple):
+
+            obj_names = self.train_history.obj_names
+            assert len(self._output_directions) == len(obj_names), _(
+                en_message='The length of _output_directions passed as a list '
+                           'must be same with that of the history\'s objective '
+                           'names.',
+                jp_message='_output_directions をリストで渡す場合は'
+                           'その長さが history の目的関数数と一致して'
+                           'いなければなりません。'
+            )
+
+            for obj_name, direction in zip(obj_names, self._output_directions):
+                opt.add_objective(
+                    name=obj_name,
+                    fun=lambda _, obj_name_=obj_name: self.current_obj_values[obj_name_],
+                    direction=direction,
+                    args=(),
+                    kwargs={},
+                )
+
+    def load_variables(self, opt: AbstractOptimizer):
+        # opt の変数が充分であるかのチェックのみ
+        parameters = opt.variable_manager.get_variables()
+        assert len(set(self.train_history.prm_names) - set(parameters.keys())) == 0
+
+    def _check_using_fem(self, fun: callable) -> bool:
+        return False
+
+    def _check_param_and_raise(self, prm_name) -> None:
+        if prm_name not in self.train_history.prm_names:
+            raise KeyError(f'Parameter name {prm_name} is not in '
+                           f'training input {self.train_history.prm_names}.')

pyfemtet/opt/interface/_surrogate_model_interface/botorch_interface.py

@@ -0,0 +1,298 @@
+from typing import Sequence
+
+import numpy as np
+from scipy.stats.distributions import norm
+
+# from gpytorch.priors.torch_priors import GammaPrior
+
+from pyfemtet._i18n import _
+from pyfemtet.opt.history import *
+from pyfemtet.opt.exceptions import *
+
+from pyfemtet.opt.prediction._model import PyFemtetModel, SingleTaskGPModel
+
+from pyfemtet.opt.interface._surrogate_model_interface.base_surrogate_interface import AbstractSurrogateModelInterfaceBase
+
+from pyfemtet.logger import get_module_logger
+
+logger = get_module_logger('opt.interface', False)
+
+
+__all__ = [
+    'BoTorchInterface',
+    'PoFBoTorchInterface',
+]
+
+
+class BoTorchInterface(AbstractSurrogateModelInterfaceBase):
+
+    def __init__(
+            self,
+            history_path: str = None,
+            train_history: History = None,
+            _output_directions: (
+                    Sequence[str | float]
+                    | dict[str, str | float]
+                    | dict[int, str | float]
+            ) = None
+    ):
+        AbstractSurrogateModelInterfaceBase.__init__(
+            self,
+            history_path,
+            train_history,
+            _output_directions
+        )
+
+        self.model = SingleTaskGPModel()
+        self.pyfemtet_model = PyFemtetModel()
+
+        # get main only
+        df = self.train_history.get_df(MAIN_FILTER)
+
+        # filter succeeded only
+        df = df[df['state'] == TrialState.succeeded]
+
+        # training
+        self.pyfemtet_model.update_model(self.model)
+        self.pyfemtet_model.fit(
+            history=self.train_history,
+            df=df,
+            observation_noise='no',
+        )
+
+    def update(self) -> None:
+        # update current objective values
+        x = np.array([self.current_prm_values.values()])
+
+        y, _ = self.pyfemtet_model.predict(x)
+        y = y[0]
+
+        for obj_name, obj_value in zip(self.train_history.obj_names, y):
+            self.current_obj_values.update({obj_name: obj_value})
+
+
+class PoFBoTorchInterface(BoTorchInterface, AbstractSurrogateModelInterfaceBase):
+
+    _debug: bool = False
+
+    def __init__(
+            self,
+            history_path: str,
+            train_history: History = None,
+            observation_noise: float | str | None = None,
+            feasibility_noise: float | str | None = None,
+            feasibility_cdf_threshold: float | str = 0.5,  # or 'sample_mean'
+            _output_directions: (
+                    Sequence[str | float]
+                    | dict[str, str | float]
+                    | dict[int, str | float]
+            ) = None
+    ):
+        AbstractSurrogateModelInterfaceBase.__init__(
+            self,
+            history_path,
+            train_history,
+            _output_directions
+        )
+
+        self.model = SingleTaskGPModel()
+        self.pyfemtet_model = PyFemtetModel()
+        self.model_c = SingleTaskGPModel()
+        self.pyfemtet_model_c = PyFemtetModel()
+        self.train_history_c = History()
+        self.train_history_c.load_csv(history_path, with_finalize=True)
+        self.pof_threshold = 0.5
+        self.feasibility_cdf_threshold = feasibility_cdf_threshold
+
+        # use feasibility as a single objective
+        self.train_history_c.obj_names = ['feasibility']
+
+        # get main only
+        df = self.train_history.get_df(MAIN_FILTER)
+        df_c = self.train_history_c.get_df(MAIN_FILTER)
+
+        # filter succeeded only for main
+        df = df[df['state'] == TrialState.succeeded]
+
+        # convert type bool to float
+        df_c = df_c.astype({'feasibility': float})
+
+        # training main
+        self.pyfemtet_model.update_model(self.model)
+        self.pyfemtet_model.fit(
+            history=self.train_history,
+            df=df,
+            observation_noise=observation_noise,
+        )
+
+        # training model_c
+        self.pyfemtet_model_c.update_model(self.model_c)
+        self.pyfemtet_model_c.fit(
+            history=self.train_history_c,
+            df=df_c,
+            # observation_noise=None,
+            # observation_noise='no',
+            # observation_noise=0.001,
+            observation_noise=feasibility_noise,
+            # covar_module_settings=dict(
+            #     name='matern_kernel_with_gamma_prior',
+            #     nu=2.5,
+            #     lengthscale_prior=GammaPrior(1.0, 9.0),  # default: 3, 6
+            #     outputscale_prior=GammaPrior(1.0, 0.15),  # default: 2, 0.15
+            # )
+            covar_module_settings=dict(
+                name='get_covar_module_with_dim_scaled_prior_extension',
+                loc_coef=0.01,
+                scale_coef=0.01,
+            )
+        )
+
+        # set auto feasibility_cdf_threshold
+        if self.feasibility_cdf_threshold == 'sample_mean':
+            self.feasibility_cdf_threshold = df_c['feasibility'].mean()
+
+        if self._debug:
+            self._debug_df_c = df_c
+
+    def calc_pof(self):
+
+        if self._debug:
+            import plotly.graph_objects as go
+
+            df = self._debug_df_c
+
+            x_list = []
+            prm_names = self.train_history_c.prm_names
+            for prm_name in prm_names:
+                x_list.append(np.linspace(
+                    df[prm_name + '_lower_bound'].values[0],
+                    df[prm_name + '_upper_bound'].values[0],
+                    20
+                ))
+
+            for i in range(len(x_list)):
+                for j in range(i, len(x_list)):
+                    if i == j:
+                        continue
+
+                    # i=0
+                    # j=1
+
+                    xx = np.meshgrid(x_list[i], x_list[j])
+
+                    x_plot = np.array([[x[0]] * 400 for x in x_list]).T
+                    x_plot[:, i] = xx[0].ravel()
+                    x_plot[:, j] = xx[1].ravel()
+
+                    y_mean, y_std = self.pyfemtet_model_c.predict(x_plot)
+                    # feasibility_cdf_threshold = self.feasibility_cdf_threshold
+                    # feasibility_cdf_threshold = 0.5
+                    cdf_threshold = 0.25  # 不明なところは pof が 1 近くにすればあとは ACQF がうまいことやってくれる
+                    # feasibility_cdf_threshold = self.feasibility_cdf_threshold * 0.5
+                    pof = 1 - norm.cdf(cdf_threshold, y_mean, y_std)
+
+                    x1 = x_list[i]
+                    x2 = x_list[j]
+                    xx1 = xx[0]
+                    xx2 = xx[1]
+
+                    fig = go.Figure()
+                    fig.add_trace(
+                        go.Contour(
+                            x0=x1[0],
+                            y0=x2[0],
+                            dx=np.diff(x1)[0],
+                            dy=np.diff(x2)[0],
+                            z=pof.reshape(xx1.shape),
+                        )
+                    )
+                    fig.add_trace(
+                        go.Scatter(
+                            x=self._debug_df_c[prm_names[i]],
+                            y=self._debug_df_c[prm_names[j]],
+                            mode='markers',
+                            marker=dict(
+                                color=self._debug_df_c['feasibility'],
+                                colorscale='greens',
+                            ),
+                        )
+                    )
+                    fig.show()
+
+                    fig = go.Figure()
+                    fig.add_trace(
+                        go.Surface(
+                            x=xx1,
+                            y=xx2,
+                            z=y_mean.reshape(xx1.shape),
+                        )
+                    )
+                    fig.add_trace(
+                        go.Surface(
+                            x=xx1,
+                            y=xx2,
+                            z=(y_mean + y_std).reshape(xx1.shape),
+                            opacity=0.3,
+                        )
+                    )
+                    fig.add_trace(
+                        go.Surface(
+                            x=xx1,
+                            y=xx2,
+                            z=(y_mean - y_std).reshape(xx1.shape),
+                            opacity=0.3,
+                        )
+                    )
+                    fig.add_trace(
+                        go.Scatter3d(
+                            x=self._debug_df_c[prm_names[i]],
+                            y=self._debug_df_c[prm_names[j]],
+                            z=self._debug_df_c['feasibility'],
+                            mode='markers',
+                        )
+                    )
+                    fig.show()
+
+            return
+
+        x = np.array([self.current_prm_values.values()])
+
+        f_mean, f_std = self.pyfemtet_model_c.predict(x)
+        f_mean, f_std = f_mean[0][0], f_std[0][0]
+
+        if isinstance(self.feasibility_cdf_threshold, float):
+            cdf_threshold = self.feasibility_cdf_threshold
+        else:
+            raise NotImplementedError(
+                f'self.cdf_threshold must be float, '
+                f'passed {self.feasibility_cdf_threshold}'
+            )
+
+        pof = 1 - norm.cdf(cdf_threshold, f_mean, f_std)
+
+        return pof
+
+    def update(self) -> None:
+
+        # BoTorchInterface.update() の前に PoF を計算する
+        pof = self.calc_pof()
+        if pof < self.pof_threshold:
+            logger.info(
+                _(
+                    en_message='The surrogate model estimated '
+                               'that the probability of '
+                               'feasibility (PoF) is {pof}. '
+                               'This is under {thresh}. '
+                               'So this trial is processed as '
+                               'a constraint violation.',
+                    jp_message='サロゲートモデルは解の実行可能確率（PoF）が'
+                               '{pof} であると予測しました。'
+                               'これは閾値 {thresh} を下回っているので、'
+                               '最適化試行においては拘束違反であると扱います。',
+                    pof=pof,
+                    thresh=self.pof_threshold,
+                )
+            )
+            raise _HiddenConstraintViolation(f'PoF < {self.pof_threshold}')
+
+        BoTorchInterface.update(self)

pyfemtet/opt/interface/_surrogate_model_interface/debug-pof-botorch.reccsv

@@ -0,0 +1,18 @@
+,prm,prm_lower_bound,prm_upper_bound,prm,prm_choices,obj,obj_direction,,,,,,
+,,,,,,,,,,,,,
+trial,x1,x1_lower_bound,x1_upper_bound,x2,x2_choices,obj,obj_direction,state,datetime_start,datetime_end,message,feasibility,optimality
+0,85.63019613,50,100,A,"['A', 'B', 'C']",85.63019613,minimize,Success,48:10.2,48:10.2,,TRUE,FALSE
+1,76.66824027,50,100,B,"['A', 'B', 'C']",76.66824027,minimize,Hidden constraint violation,48:11.7,48:11.7,,FALSE,FALSE
+2,62.68444915,50,100,C,"['A', 'B', 'C']",62.68444915,minimize,Hidden constraint violation,48:16.6,48:16.6,,FALSE,FALSE
+3,63.08476439,50,100,A,"['A', 'B', 'C']",63.08476439,minimize,Success,48:20.2,48:20.2,,TRUE,FALSE
+4,78.95677052,50,100,B,"['A', 'B', 'C']",78.95677052,minimize,Hidden constraint violation,48:23.5,48:23.5,,FALSE,FALSE
+5,79.90834979,50,100,C,"['A', 'B', 'C']",79.90834979,minimize,Hidden constraint violation,48:27.2,48:27.2,,FALSE,FALSE
+6,97.4442698,50,100,A,"['A', 'B', 'C']",97.4442698,minimize,Success,48:29.8,48:29.8,,TRUE,FALSE
+7,87.12500776,50,100,B,"['A', 'B', 'C']",87.12500776,minimize,Hidden constraint violation,03:52.7,03:52.7,,FALSE,FALSE
+8,69.56378151,50,100,C,"['A', 'B', 'C']",69.56378151,minimize,Hidden constraint violation,04:00.1,04:00.1,,FALSE,FALSE
+9,80.49012367,50,100,A,"['A', 'B', 'C']",80.49012367,minimize,Success,04:06.2,04:06.2,,TRUE,FALSE
+10,87.55804836,50,100,B,"['A', 'B', 'C']",87.55804836,minimize,Hidden constraint violation,04:13.1,04:13.1,,FALSE,FALSE
+11,59.55103039,50,100,C,"['A', 'B', 'C']",59.55103039,minimize,Hidden constraint violation,04:19.3,04:19.3,,FALSE,FALSE
+12,97.91995423,50,100,A,"['A', 'B', 'C']",97.91995423,minimize,Success,04:24.6,04:24.6,,TRUE,FALSE
+13,91.01111473,50,100,B,"['A', 'B', 'C']",91.01111473,minimize,Hidden constraint violation,04:31.3,04:31.3,,FALSE,FALSE
+14,53.36556413,50,100,C,"['A', 'B', 'C']",53.36556413,minimize,Hidden constraint violation,04:36.6,04:36.6,,FALSE,FALSE