Develop

examples/swimmer/swimmer.ipynb

 %% Cell type:markdown id: tags:
 
 # Swimmer
 
 Run the dashboard on binder
 [![binder](https://static.mybinder.org/badge_logo.svg)](https://mybinder.org/v2/git/https%3A%2F%2Fgitlab.inria.fr%2Fct%2Fgallery.git/master?urlpath=%2Fproxy%2F5006%2Fswimmer)
 
 <img src="swimmer.jpeg" width=400>
 
 [Thumbnail](swimmer.jpeg)
 
 %% Cell type:code id: tags:
 
 ``` python
 import bocop
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 from IPython.display import HTML
 
 import numpy as np
 import math
 import os,shutil
 import panel as pn
 import param
 pn.extension()
 pn.config.sizing_mode = 'stretch_width'
 
-from bocopwrapper import CallbackF, solve
+os.environ["LC_ALL"]="C" # format pb with ipopt otherwise (Nan values!)
+os.environ["LANG"]="C"
 ```
 
 %% Output
 
 
 
 %% Cell type:code id: tags:
 
 ``` python
+bocop.build(".", cmake_options = '-DCMAKE_CXX_COMPILER=g++');
+from bocopwrapper import CallbackF, solve
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 class petitnageur(CallbackF):
 
     def __init__(self, file, working_file="problem.def", path_def="./def", problem_path="."):
 
         super().__init__()
         self.initialized = False
         self.g_state   = []
         self.g_control = []
 
         self.nrows = 2
         self.ncols = 4
 
         # Init paths
 
         self.path_def     = path_def
         self.problem_path = problem_path
 
         self.file         = os.path.join(problem_path, file)
         self.working_file = os.path.join(problem_path, working_file)
         self.sol_name     = self.file.replace('.def','.sol')
 
         # Params
         self.titles       = ["State 0", "State 1", "State 2", "State 3", "State 4", "State 5", "Control 0", "Control 1"]
-        self.is_build     = False
+        self.is_build     = True
         self.figure       = make_subplots(rows=self.nrows,
                                            cols=self.ncols,
                                            subplot_titles=self.titles
                                           )
 
         self.figure.update_layout(width=1800, height=900, showlegend=False)
 
         for i in range(self.nrows):
             for j in range(self.ncols):
                 self.figure.add_trace(go.Scatter(name = self.titles[i+j], line = dict(color='royalblue')), row=i+1, col=j+1)
 
         # Create copy
         shutil.copyfile(os.path.join(path_def,file), self.working_file)
 
         # Get params from .def
         self.param_list = {}
 
         self.name_list = {"boundarycond.2" : "theta0", "final.time" : "temps final"}
 
         self.lowerbound_list = {}
         self.upperbound_list = {}
         self.time_steps = 0
 
         self.options = bocop.readDefFile(deffile=self.working_file)
 
         for key, value in self.options.items():
             if "boundarycond.2" in key and ("upperbound" in key or "lowerbound" in key) :
                 idx = key.split(".")[1]
                 self.param_list[idx] = value
             elif "state" in key and "lowerbound" in key :
                 idx = key.split(".")[1]
                 self.lowerbound_list[idx]= value
             elif "state" in key and "upperbound" in key :
                 idx = key.split(".")[1]
                 self.upperbound_list[idx]= value
             elif "final.time" in key :
                 self.param_list[key] = value
 
         # Create run button
         self.run_button = pn.widgets.Button(name='Run simulations', button_type="success")
         self.run_button.on_click(self.run)
 
         # Create progress bar
         self.progress_bar = pn.widgets.Progress(sizing_mode='stretch_width')
         self.progress_bar.visible = False
 
         # Create dashboard
         self.dashboard = pn.template.BootstrapTemplate(title='Swimmer simulation')
         self.dashboard.sidebar.append(self.sideBar())
         self.dashboard.main.append(pn.Row(self.figure))
         self.dashboard.servable();
 
         self.label = pn.widgets.StaticText()
 
     def paramTabs(self):
 
         # Create panel tabs
         tabs = pn.Tabs()
 
         # Create 2 column (states and controls)
         col_states    = pn.Column()
 
         # Create widgets for params
         for key, value in self.param_list.items():
 
             name = key
             if name in self.name_list:
                 name = self.name_list[name]
             name_key   = "boundarycond.{idx}".format(idx=key)
             if name_key in self.name_list:
                 name = self.name_list[name_key]
 
             if key in "final.time" :
                 param_widget = pn.widgets.IntInput(name=name, value=int(value))
             else :
                 param_widget = pn.widgets.FloatInput(name=name, value=float(value))
 
             if key.isnumeric():
                 if key in self.lowerbound_list :
                        param_widget.start = float(self.lowerbound_list[key])
                 if key in self.upperbound_list :
                        param_widget.end   = float(self.upperbound_list[key])
 
                 param_bind_lower = pn.bind(bocop.setInDef, key="boundarycond.{idx}.upperbound".format(idx=key),
                                            value=param_widget, deffile=self.working_file)
                 param_bind_upper = pn.bind(bocop.setInDef, key="boundarycond.{idx}.lowerbound".format(idx=key),
                                            value=param_widget, deffile=self.working_file)
 
                 pn.Row(param_bind_lower, param_bind_upper, param_widget)
                 col_states.append(param_widget)
 
             else:
                 param_bind = pn.bind(bocop.setInDef, key=key,
                                            value=param_widget, deffile=self.working_file)
                 pn.Row(param_bind, param_widget)
                 col_states.append(param_widget)
 
 
         tabs.extend([('States', col_states)])
 
         label = pn.widgets.StaticText(value='Parameters :')
 
         return pn.Column(label, tabs)
 
 
     def runButton(self):
         return self.run_button
 
     def sideBar(self):
         return pn.Column('##Settings :', pn.Row(pn.Column(self.paramTabs(),
                                                           self.runButton(),
                                                           self.progress_bar)))
     def mainView(self):
         return self.dashboard
 
     # Callback
     def run(self, event):
         self.g_state   = []
         self.g_control = []
         self.run_button.button_type = "warning"
         self.progress_bar.visible = True
         if not self.is_build:
             self.run_button.name = "Building"
             bocop.build(self.problem_path, cmake_options = '-DCMAKE_CXX_COMPILER=g++');
             self.is_build = True
 
         self.run_button.name = "Running "
         solve(self)
         self.progress_bar.visible = False
         self.run_button.name = "Re-run simulation"
         self.run_button.button_type = "success"
 
     def update(self, iteration):
         if self.initialized:
             len_state = len(self.g_state[iteration])
             for idx in range(len_state):
 
                 i = idx // self.ncols
                 j = idx %  self.ncols
                 self.figure.update_traces(x=self.x_state ,y=self.g_state[iteration][idx],row=i+1,col=j+1)
 
             for idx in range(len(self.g_control[iteration])):
 
                 i = (len_state + idx) // self.ncols
                 j = (len_state + idx) %  self.ncols
                 self.figure.update_traces(x=self.x_control ,y=self.g_control[iteration][idx],row=i+1,col=j+1)
 
 
             objective = self.g_state[iteration][-1][-1]
             self.label.value = f"iteration {iteration}  objective : {objective}"
 
 
             self.figure.update_layout(title = f"iteration {iteration}  objective : {objective}")
             self.dashboard.main[0][0] = self.figure
             return
 
     def handle(self, state, control):
         if not self.initialized:
             self.initialized = True
             self.x_state   = np.arange(len(state[0]))
             self.x_control = np.arange(len(control[0]))
 
         self.g_state.append(np.asarray(state))
         self.g_control.append(np.asarray(control))
         self.update(len(self.g_state) -1)
 
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 prob_1 = petitnageur('problem.def')
 ```