Mentions légales du service

Skip to content
Snippets Groups Projects

WIP : Feature/app

Closed WIP : Feature/app
feature/app into master
Closed BADER Wael requested to merge feature/app into master
Viewing commit 89842de3
Prev
Show latest version
1 file
+ 3
− 0
Compare changes
  • Side-by-side
  • Inline
examples/swimmer/swimmer.ipynb
+ 3
− 0
%% 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'
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 = 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')
```