pyfemtet 0.9.4__py3-none-any.whl → 1.0.0a0__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/_base.py

@@ -1,129 +0,0 @@
-from typing import Optional, List, Any
-from abc import ABC
-
-import numpy as np
-import pandas as pd
-
-from pyfemtet.logger import get_module_logger
-from pyfemtet.opt._femopt_core import History, Objective
-from pyfemtet.opt.interface._base import FEMInterface
-from pyfemtet.opt.optimizer._base import AbstractOptimizer
-
-logger = get_module_logger('opt.interface', __name__)
-
-
-class SurrogateModelInterfaceBase(FEMInterface, ABC):
-    def __init__(
-            self,
-            history_path: str = None,
-            train_history: History = None,
-            _output_directions: dict[int, str | float] | list[str | float] = None,
-    ):
-
-        self.train_history: History
-        self.model: Any
-        self.prm: dict[str, float] = dict()
-        self.obj: dict[str, float] = dict()
-        self.df_prm: pd.DataFrame
-        self.df_obj: pd.DataFrame
-        self._output_directions = _output_directions
-
-        # history_path が与えられた場合、train_history をコンストラクトする
-        if history_path is not None:
-            train_history = History(history_path=history_path)
-
-        # train_history が与えられるかコンストラクトされている場合
-        if train_history is not None:
-            # 学習データを準備する
-            df_prm = train_history.get_df()[train_history.prm_names]
-            df_obj = train_history.get_df()[train_history.obj_names]
-
-            # obj の名前を作る
-            for obj_name in train_history.obj_names:
-                self.obj[obj_name] = np.nan
-
-            # prm の名前を作る
-            for prm_name in train_history.prm_names:
-                self.prm[prm_name] = np.nan
-
-            self.train_history = train_history
-
-        # history から作らない場合、引数チェック
-        else:
-            # assert len(train_x) == len(train_y)
-            raise NotImplementedError
-
-        self.df_prm = df_prm
-        self.df_obj = df_obj
-
-        # _output_directions が与えられている場合、
-        # history から objective の設定を読み込む
-        if self._output_directions is not None:
-            self._load_problem_from_me: bool = True
-
-        FEMInterface.__init__(
-            self,
-            train_history=train_history,  # コンストラクト済み train_history を渡せば並列計算時も何もしなくてよい
-        )
-
-
-    def load_objective(self, opt) -> None:
-        from pyfemtet.opt._femopt_core import Objective
-
-        assert self._output_directions is not None
-
-        if isinstance(self._output_directions, dict):
-
-            for index, direction in self._output_directions:
-                obj_name = self.train_history.obj_names[index]
-                opt.objectives[obj_name] = Objective(
-                    lambda obj_name_=obj_name: self.obj[obj_name_],
-                    name=obj_name,
-                    direction=direction,
-                    args=(),
-                    kwargs={},
-                )
-
-        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)
-
-            for obj_name, direction in zip(obj_names, self._output_directions):
-                opt.objectives[obj_name] = Objective(
-                    lambda obj_name_=obj_name: self.obj[obj_name_],
-                    name=obj_name,
-                    direction=direction,
-                    args=(),
-                    kwargs={},
-                )
-
-        else:
-            raise ValueError('Invalid _output_directions')
-
-    def filter_feasible(self, x: np.ndarray, y: np.ndarray, return_feasibility=False):
-        feasible_idx = np.where(~np.isnan(y.sum(axis=1)))
-        if return_feasibility:
-            # calculated or not
-            feas = np.zeros((len(y), 1), dtype=float)
-            feas[feasible_idx] = 1.
-            return x, feas
-        else:
-            return x[feasible_idx], y[feasible_idx]
-
-    def _setup_after_parallel(self, *args, **kwargs):
-        opt: AbstractOptimizer = kwargs['opt']
-        obj: Objective
-
-        # add_objective された目的のうち、
-        # training data に含まれる名前で
-        # あるものは fun を上書き
-        for obj_name, obj in opt.objectives.items():
-            if obj_name in self.train_history.obj_names:
-                obj.fun = lambda obj_name_=obj_name: self.obj[obj_name_]
-
-    def update_parameter(self, parameters: pd.DataFrame, with_warning=False) -> Optional[List[str]]:
-        for i, row in parameters.iterrows():
-            name, value = row['name'], row['value']
-            self.prm[name] = value

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,59 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pyfemtet.opt.history import *
+
+from pyfemtet.opt.interface import AbstractFEMInterface
+
+if TYPE_CHECKING:
+    from pyfemtet.opt.optimizer import AbstractOptimizer
+
+
+__all__ = [
+    'AbstractSurrogateModelInterfaceBase',
+]
+
+
+class AbstractSurrogateModelInterfaceBase(AbstractFEMInterface):
+    current_obj_values: dict[str, float]
+    train_history: History
+
+    def __init__(
+            self,
+            history_path: str = None,
+            train_history: History = None,
+    ):
+
+        # 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):
+        # add_objective された目的のうち、
+        # training data に含まれる名前ならば
+        # fun を「その時点の current_obj_values を返す関数」で
+        # 上書き
+        for obj_name, obj in opt.objectives.items():
+            if obj_name in self.train_history.obj_names:
+                obj.fun = lambda obj_name_=obj_name: self.current_obj_values[obj_name_]
+
+    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,271 @@
+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):
+        AbstractSurrogateModelInterfaceBase.__init__(self, history_path, train_history)
+
+        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,
+            observation_noise: float | str | None = None,
+            feasibility_noise: float | str | None = None,
+            feasibility_cdf_threshold: float | str = 0.5,  # or 'sample_mean'
+    ):
+        AbstractSurrogateModelInterfaceBase.__init__(self, history_path, None)
+
+        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