pyfemtet 0.4.10__py3-none-any.whl → 0.4.12__py3-none-any.whl

pyfemtet/opt/visualization/complex_components/control_femtet.py

@@ -0,0 +1,195 @@
+# type hint
+from dash.development.base_component import Component
+
+# callback
+from dash import Output, Input, State, no_update, callback_context
+from dash.exceptions import PreventUpdate
+
+# components
+from pyfemtet.opt.visualization.wrapped_components import html, dcc, dbc
+
+# the others
+import logging
+import os
+from enum import Enum
+import json
+# noinspection PyUnresolvedReferences
+from pythoncom import com_error
+
+from pyfemtet.opt.visualization.base import PyFemtetApplicationBase, AbstractPage, logger
+from pyfemtet.opt.interface._femtet import FemtetInterface
+
+
+class FemtetState(Enum):
+    unconnected = -1
+    missing = 0
+    connected_but_empty = 1
+    connected = 2
+
+
+class FemtetControl(AbstractPage):
+
+    def __init__(self):
+        super().__init__()
+        self.fem: FemtetInterface = None
+
+    def setup_component(self):
+
+        # noinspection PyAttributeOutsideInit
+        self.dummy = html.Div(
+            id='control-femtet-dummy',
+            hidden=True,
+        )
+
+        # button
+        # noinspection PyAttributeOutsideInit
+        self.connect_femtet_button = dbc.Button(
+            children='Connect to Femtet',
+            id='connect-femtet-button',
+            outline=True,
+            color='primary',
+        )
+
+        # noinspection PyAttributeOutsideInit
+        self.connect_femtet_button_spinner = dbc.Spinner(
+            self.connect_femtet_button,
+            color='primary',
+        )
+
+        # store femtet connection state
+        # noinspection PyAttributeOutsideInit
+        self.femtet_state_prop = 'data-femtet-state'  # must start with "data-"
+        # noinspection PyAttributeOutsideInit
+        self.femtet_state = html.Data(
+            id='femtet-state',
+            **{
+                self.femtet_state_prop: {
+                    'pid': 0,
+                    'alert': '',
+                }
+            }
+        )
+
+    def setup_layout(self):
+        self.layout = [self.dummy, self.femtet_state]
+
+    def setup_callback(self):
+        # setup callback of subpages
+        super().setup_callback()
+
+        app = self.application.app
+
+        # ===== launch femtet and show spinner =====
+        @app.callback(
+            Output(self.femtet_state.id, self.femtet_state_prop),
+            Output(self.connect_femtet_button.id, self.connect_femtet_button.Prop.children),  # for spinner
+            Input(self.connect_femtet_button.id, self.connect_femtet_button.Prop.n_clicks),)
+        def connect_femtet(_):
+
+            # ignore when loaded
+            if callback_context.triggered_id is None:
+                raise PreventUpdate
+
+            # create FemtetInterface arguments
+            kwargs, warning_msg = self.create_femtet_interface_args()
+
+            # try to launch femtet
+            try:
+                self.fem = FemtetInterface(**kwargs)
+
+            except com_error:
+                # model_name is not included in femprj
+                kwargs.update(dict(model_name=None))
+                self.fem = FemtetInterface(**kwargs)
+                warning_msg = 'Analysis model name described in csv does not exist in project.'
+
+            # if 'new' femtet, Interface try to terminate Femtet when the self.fem is reconstructed.
+            self.fem.quit_when_destruct = False
+
+            state_data = {
+                'pid': self.fem.femtet_pid,
+                'alert': warning_msg,
+            }
+
+            return state_data, no_update
+
+    def create_femtet_interface_args(self) -> [dict, str]:
+        """Returns the argument of FemtetInterface and warning message
+
+        # femprj_path=None,
+        # model_name=None,
+        # connect_method='auto',  # dask worker では __init__ の中で 'new' にするので super() の引数にしない。（しても意味がない）
+        # save_pdt='all',  # 'all' or None
+        # strictly_pid_specify=True,  # dask worker では True にしたいので super() の引数にしない。
+        # allow_without_project=False,  # main でのみ True を許容したいので super() の引数にしない。
+        # open_result_with_gui=True,
+        # parametric_output_indexes_use_as_objective=None,
+
+        """
+
+        kwargs = dict(
+            connect_method='auto',
+            femprj_path=None,
+            model_name=None,
+            allow_without_project=True,
+        )
+
+        # check holding history
+        if self.application.history is None:
+            return kwargs, 'History csv is not read yet. Open your project manually.'
+
+        # get metadata
+        additional_metadata = self.application.history.metadata[0]
+
+        # check metadata exists
+        if additional_metadata == '':
+            return kwargs, 'Cannot read project data from csv. Open your project manually.'
+
+        # check the metadata is valid json
+        try:
+            d = json.loads(additional_metadata)
+            femprj_path = os.path.abspath(d['femprj_path'])
+        except (TypeError, json.decoder.JSONDecodeError, KeyError):
+            return kwargs, ('Cannot read project data from csv because of the invalid format. '
+                            'Valid format is like: '
+                            '"{""femprj_path"": ""c:\\path\\to\\sample.femprj"", ""model_name"": ""<model_name>""}". ' 
+                            'Open your project manually.')
+
+        # check containing femprj
+        if femprj_path is None:
+            return kwargs, 'Cannot read project data from csv. Open your project manually.'
+
+        # check femprj exists
+        if not os.path.exists(femprj_path):
+            return kwargs, '.femprj file described in csv is not found. Open your project manually.'
+
+        # at this point, femprj is valid at least.
+        kwargs.update({'femprj_path': femprj_path})
+
+        # check model name
+        model_name = d['model_name'] if 'model_name' in d.keys() else None
+        msg = '' if model_name is not None else 'Analysis model name is not specified. Open your model in the project manually.'
+        kwargs.update({'model_name': model_name})
+        return kwargs, msg
+
+    def check_femtet_state(self) -> FemtetState:
+
+        # check fem is initialized
+        if self.fem is None:
+            return FemtetState.missing
+
+        Femtet = self.fem.Femtet
+
+        # check Femtet is constructed
+        if Femtet is None:
+            return FemtetState.missing
+
+        # check Femtet is alive
+        if not self.fem.femtet_is_alive():
+            return FemtetState.missing
+
+        # check a project is opened
+        if Femtet.Project == '':
+            return FemtetState.connected_but_empty
+
+        return FemtetState.connected

pyfemtet/opt/visualization/{_graphs.py → complex_components/main_figure_creator.py}

@@ -1,6 +1,8 @@
 import plotly.graph_objs as go
 import plotly.express as px
 
+from pyfemtet.opt._femopt_core import History
+
 
 class _ColorSet:
     non_domi = {True: '#007bff', False: '#6c757d'}  # color
@@ -37,7 +39,7 @@ _cs = _ColorSet()
 _ss = _SymbolSet()
 
 
-def update_hypervolume_plot(history, df):
+def get_hypervolume_plot(_: History, df):
     df = _ls.localize(df)
 
     # create figure
@@ -58,26 +60,28 @@ def update_hypervolume_plot(history, df):
     return fig
 
 
-def update_default_figure(history, df):
+def get_default_figure(history, df):
+    # df = history.local_data  # monitor process and history process is different workers, so history.local_data is not updated in monitor process.
+    # df = history.actor_data.copy()  # access to actor from flask callback makes termination unstable.
 
     # data setting
     obj_names = history.obj_names
 
-    if len(obj_names) == 0:
-        fig = go.Figure()
+    fig = go.Figure()
 
-    elif len(obj_names) == 1:
-        fig = update_single_objective_plot(history, df)
+    if len(obj_names) == 1:
+        fig = _get_single_objective_plot(history, df)
 
     elif len(obj_names) >= 2:
-        fig = update_multi_objective_pairplot(history, df)
+        fig = _get_multi_objective_pairplot(history, df)
 
     fig.update_traces(hoverinfo="none", hovertemplate=None)
+    fig.update_layout(clickmode='event+select')
 
     return fig
 
 
-def update_single_objective_plot(history, df):
+def _get_single_objective_plot(history, df):
 
     df = _ls.localize(df)
     obj_name = history.obj_names[0]
@@ -125,7 +129,7 @@ def update_single_objective_plot(history, df):
     return fig
 
 
-def update_multi_objective_pairplot(history, df):
+def _get_multi_objective_pairplot(history, df):
     df = _ls.localize(df)
 
     obj_names = history.obj_names
@@ -183,43 +187,3 @@ def update_multi_objective_pairplot(history, df):
     )
 
     return fig
-
-
-def _debug():
-    import os
-
-    os.chdir(os.path.dirname(__file__))
-    csv_path = 'sample.csv'
-
-    show_static_monitor(csv_path)
-
-
-def show_static_monitor(csv_path):
-    from pyfemtet.opt._femopt_core import History
-    from pyfemtet.opt.visualization._monitor import ResultViewerApp
-    _h = History(history_path=csv_path)
-    _monitor = ResultViewerApp(history=_h)
-    _monitor.run()
-
-
-def entry_point():
-    import argparse
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument('csv_path', help='pyfemtet を実行した結果の csv ファイルのパスを指定してください。', type=str)
-
-    # parser.add_argument(
-    #     "-c",
-    #     "--csv-path",
-    #     help="pyfemtet.opt による最適化結果 csv ファイルパス",
-    #     type=str,
-    # )
-
-    args = parser.parse_args()
-
-    if args.csv_path:
-        show_static_monitor(args.csv_path)
-
-
-if __name__ == '__main__':
-    _debug()

pyfemtet/opt/visualization/complex_components/main_graph.py

@@ -0,0 +1,263 @@
+# type hint
+from dash.development.base_component import Component
+
+# callback
+from dash import Output, Input, State, no_update, callback_context
+from dash.exceptions import PreventUpdate
+
+# components
+from dash import dash_table
+from pyfemtet.opt.visualization.wrapped_components import html, dcc, dbc
+
+# graph
+import pandas as pd
+# import plotly.express as px
+import plotly.graph_objs as go
+
+# the others
+import os
+import base64
+import json
+import numpy as np
+
+from pyfemtet.opt.visualization.complex_components import main_figure_creator
+from pyfemtet.opt.visualization.base import PyFemtetApplicationBase, AbstractPage, logger
+
+
+FLEXBOX_STYLE_ALLOW_VERTICAL_FILL = {
+    'display': 'flex',
+    'flex-direction': 'column',
+    'flex-grow': '1',
+}
+
+
+# noinspection PyAttributeOutsideInit
+class MainGraph(AbstractPage):
+    """"""
+    """
+    +=================+
+    |tab1|tab2|       | <- CardHeader
+    |    +------------+
+    | +-------------+ |
+    | | Loading     | | <- CardBody
+    | | +---------+ | |
+    | | |  graph <-------- ToolTip
+    | | +---------+ | |
+    | +-------------+ |
+    +=================+
+
+        Data(data-selection)
+
+    """
+
+    def __init__(self):
+        self.setup_figure_creator()
+        super().__init__()
+
+    def setup_figure_creator(self):
+        # setup figure creators
+        # list[0] is the default tab
+        self.figure_creators = [
+            dict(
+                tab_id='tab-objective-plot',
+                label='objectives',
+                creator=main_figure_creator.get_default_figure,
+            ),
+            dict(
+                tab_id='tab-hypervolume-plot',
+                label='hypervolume',
+                creator=main_figure_creator.get_hypervolume_plot,
+            ),
+        ]
+
+    def setup_component(self):
+        self.dummy = html.Div(id='main-graph-dummy')
+        self.location = dcc.Location(id='main-graph-location', refresh=True)
+
+        # setup header
+        self.tab_list = [dbc.Tab(label=d['label'], tab_id=d['tab_id']) for d in self.figure_creators]
+        self.tabs = dbc.Tabs(self.tab_list, id='main-graph-tabs')
+        self.card_header = dbc.CardHeader(self.tabs)
+
+        # setup body
+        self.tooltip = dcc.Tooltip(id='main-graph-tooltip')
+
+        # set kwargs of Graph to reconstruct Graph in ProcessMonitor.
+        self.graph_kwargs = dict(
+            id='main-graph',
+            # animate=True,  # THIS CAUSE THE UPDATED DATA / NOT-UPDATED FIGURE STATE.
+            clear_on_unhover=True,
+            style={
+                # 'flex-grow': '1',  # Uncomment if the plotly's specification if fixed, and we can use dcc.Graph with FlexBox.
+                'height': '60vh',
+            },
+            figure=go.Figure()
+        )
+
+        self.graph: dcc.Graph = dcc.Graph(
+            **self.graph_kwargs
+        )  # Graph make an element by js, so Flexbox CSS cannot apply to the graph (The element can be bigger, but cannot be smaller.)
+
+        self.loading = dcc.Loading(
+            children=self.graph,
+            id='loading-main-graph',
+        )  # Loading make an element that doesn't contain a style attribute, so Flexbox CSS cannot apply to the graph
+
+        self.card_body = dbc.CardBody(
+            children=html.Div([self.loading, self.tooltip]),  # If list is passed to CardBody's children, create element that doesn't contain a style attribute, so Flexbox CSS cannot apply to graph
+            id='main-graph-card-body',
+            # style=FLEXBOX_STYLE_ALLOW_VERTICAL_FILL,
+        )
+
+        # setup selection data
+        self.selection_data_property = 'data-selection'  # must be starts with "data-"
+        self.selection_data = html.Data(id='selection-data', **{self.selection_data_property: {}})
+
+        # set data length
+        self.data_length_prop = 'data-df-length'  # must start with "data-"
+        self.data_length = html.Data(id='df-length-data', **{self.data_length_prop: None})
+
+    def setup_layout(self):
+        # setup component
+        self.graph_card = dbc.Card(
+            [
+                self.dummy,
+                self.location,
+                self.data_length,
+                self.card_header,
+                self.card_body,
+                self.selection_data,
+            ],
+            # style=FLEXBOX_STYLE_ALLOW_VERTICAL_FILL,
+        )
+
+        self.layout = self.graph_card
+
+    def setup_callback(self):
+        # setup callback of subpages
+        super().setup_callback()
+
+        app = self.application.app
+
+        # ===== Update Graph =====
+        @app.callback(
+            Output(self.graph.id, 'figure'),
+            Output(self.data_length.id, self.data_length_prop),  # To determine whether Process Monitor should update the graph, the main graph remembers the current amount of data.
+            Input(self.tabs.id, 'active_tab'),
+            Input(self.dummy, 'children'),
+            prevent_initial_call=False,)
+        def redraw_main_graph(active_tab_id, _):
+            logger.debug('====================')
+            logger.debug(f'redraw_main_graph called by {callback_context.triggered_id}')
+            figure, length = self.get_fig_by_tab_id(active_tab_id, with_length=True)
+            return figure, length
+
+        # ===== Save Selection =====
+        @app.callback(
+            Output(self.selection_data.id, self.selection_data_property),
+            Input(self.graph.id, 'selectedData'))
+        def save_selection(data):
+            return data
+
+        # ===== Show Image and Parameter on Hover =====
+        @app.callback(
+            Output(self.tooltip.id, "show"),
+            Output(self.tooltip.id, "bbox"),
+            Output(self.tooltip.id, "children"),
+            Input(self.graph.id, "hoverData"),)
+        def show_hover(hoverData):
+            if hoverData is None:
+                return False, no_update, no_update
+
+            if self.application.history is None:
+                raise PreventUpdate
+
+            # get hover location
+            pt = hoverData["points"][0]
+            bbox = pt["bbox"]
+
+            # get row of the history from customdata defined in main_figure
+            trial = pt['customdata'][0]
+
+            df = self.data_accessor()
+            row = df[df['trial'] == trial]
+
+            # create component
+            title_component = html.H3(f"trial{trial}", style={"color": "darkblue"})
+            img_component = self.create_image_content_if_femtet(trial)
+            tbl_component = self.create_formatted_parameter(row)
+
+            # create layout
+            description = html.Div([
+                title_component,
+                tbl_component,
+            ])
+            tooltip_layout = html.Div([
+                html.Div(img_component, style={'display': 'inline-block', 'margin-right': '10px', 'vertical-align': 'top'}),
+                html.Div(description, style={'display': 'inline-block', 'margin-right': '10px'})
+            ])
+
+            return True, bbox, tooltip_layout
+
+    def create_formatted_parameter(self, row) -> Component:
+        metadata = self.application.history.metadata
+        pd.options.display.float_format = '{:.4e}'.format
+        parameters = row.iloc[:, np.where(np.array(metadata) == 'prm')[0]]
+        names = parameters.columns
+        values = [f'{value:.3e}' for value in parameters.values.ravel()]
+        data = pd.DataFrame(dict(
+            name=names, value=values
+        ))
+        table = dash_table.DataTable(
+            columns=[{'name': col, 'id': col} for col in data.columns],
+            data=data.to_dict('records')
+        )
+        return table
+
+    def create_image_content_if_femtet(self, trial) -> Component:
+        img_url = None
+        metadata = self.application.history.metadata
+        if metadata[0] != '':
+            # get img path
+            d = json.loads(metadata[0])
+            femprj_path = d['femprj_path']
+            model_name = d['model_name']
+            femprj_result_dir = femprj_path.replace('.femprj', '.Results')
+            img_path = os.path.join(femprj_result_dir, f'{model_name}_trial{trial}.jpg')
+            if os.path.exists(img_path):
+                # create encoded image
+                with open(img_path, 'rb') as f:
+                    content = f.read()
+                encoded_image = base64.b64encode(content).decode('utf-8')
+                img_url = 'data:image/jpeg;base64, ' + encoded_image
+        return html.Img(src=img_url, style={"width": "200px"}) if img_url is not None else html.Div()
+
+    def get_fig_by_tab_id(self, tab_id, with_length=False):
+        # If the history is not loaded, do nothing
+        if self.application.history is None:
+            raise PreventUpdate
+
+        # else, get creator by tab_id
+        if tab_id == 'default':
+            creator = self.figure_creators[0]['creator']
+        else:
+            creators = [d['creator'] for d in self.figure_creators if d['tab_id'] == tab_id]
+            if len(creators) == 0:
+                raise PreventUpdate
+            creator = creators[0]
+
+        # create figure
+        df = self.data_accessor()
+        fig = creator(self.application.history, df)
+        if with_length:
+            return fig, len(df)
+        else:
+            return fig
+
+    def data_accessor(self) -> pd.DataFrame:
+        from pyfemtet.opt.visualization.process_monitor.application import ProcessMonitorApplication
+        if isinstance(self.application, ProcessMonitorApplication):
+            df = self.application.local_data
+        else:
+            df = self.application.history.local_data
+        return df