pydae 0.56.4__py3-none-any.whl → 0.57__py3-none-any.whl

pydae/build_v2.py

@@ -30,7 +30,7 @@ from cffi import FFI
 
 class builder():   
 
-    def __init__(self,sys,verbose=False):
+    def __init__(self,sys,verbose=False,API=False):
 
         logging.basicConfig(format='%(asctime)s %(message)s', level=logging.INFO)
 
@@ -40,11 +40,12 @@ class builder():
         self.name = self.sys['name']
         self.save_sources = False
         self.string_u2z = ''
-        self.u2z = '\#'
+        self.u2z = r'#'
         self.inirun = True
         self.sparse = False
         self.mkl = False
         self.platform = 'Windows'
+        self.API = API
 
 
         if not os.path.exists('build'):
@@ -118,7 +119,8 @@ class builder():
         x = sym.Matrix(sys['x_list']).T
         y_ini = sym.Matrix(sys['y_ini_list']).T
         y_run = sym.Matrix(sys['y_run_list']).T
-        u_ini = sym.Matrix(list(sys['u_ini_dict'].keys()), real=True)
+        u_ini_list = [sym.Symbol(item,real=True) for item in list(sys['u_ini_dict'].keys())]
+        u_ini = sym.Matrix(u_ini_list).T 
         u_run_list = [sym.Symbol(item,real=True) for item in list(sys['u_run_dict'].keys())]
         u_run = sym.Matrix(u_run_list).T 
         h =  sym.Matrix(list(sys['h_dict'].values())).T   
@@ -802,7 +804,10 @@ class builder():
         if self.mkl:
             class_template = pkgutil.get_data(__name__, "templates/class_dae_template_v2_mkl.py").decode().replace('\r\n','\n') 
         else:
-            class_template = pkgutil.get_data(__name__, "templates/class_dae_template_v2.py").decode().replace('\r\n','\n') 
+            if self.API:
+                class_template = pkgutil.get_data(__name__, "templates/class_dae_template_api.py").decode().replace('\r\n','\n') 
+            else:
+                class_template = pkgutil.get_data(__name__, "templates/class_dae_template_v2.py").decode().replace('\r\n','\n') 
             if self.uz_jacs:
                 uz_jacs_template = pkgutil.get_data(__name__, "templates/uz_jacs_v2.py").decode().replace('\r\n','\n') 
                 class_template += uz_jacs_template
@@ -1341,9 +1346,11 @@ def sym2xyup_mp(sys,full_list,inirun):
     logging.debug('end full_list update with xyup and tipo')
 
 
-def build_numba(sys_dict,verbose=False):
+def build_numba(sys_dict,verbose=False, API=False):
+
+    from pydae.build_v2 import builder 
 
-    b = builder(sys_dict,verbose=verbose)
+    b = builder(sys_dict,verbose=True,API=API)
     b.sparse = False
     b.mkl = False
     b.uz_jacs = False
@@ -1354,6 +1361,8 @@ def build_numba(sys_dict,verbose=False):
     b.template()
     b.compile()
 
+
+
 def build_mkl(sys_dict,verbose=False,platform='Windows'):
     '''
     
@@ -1376,20 +1385,22 @@ def build_mkl(sys_dict,verbose=False,platform='Windows'):
 def test_numba():
 
     from pydae.models.pendulum.dae import dae
-    from pydae.build_v2 import builder
+    from pydae.build_v2 import builder,build_numba
 
     sys_dict = dae('temp') 
 
-    b = builder(sys_dict,verbose=True)
-    b.sparse = False
-    b.mkl = False
-    b.uz_jacs = False
-    b.dict2system()
-    b.functions()
-    b.jacobians()
-    b.cwrite()
-    b.template()
-    b.compile()
+    build_numba(sys_dict,verbose=True)
+
+    # b = builder(sys_dict,verbose=True)
+    # b.sparse = False
+    # b.mkl = False
+    # b.uz_jacs = False
+    # b.dict2system()
+    # b.functions()
+    # b.jacobians()
+    # b.cwrite()
+    # b.template()
+    # b.compile()
 
     import temp 
 
@@ -1471,4 +1482,4 @@ def test_mkl():
 
 if __name__ == "__main__":
 
-    test_mkl()
+    test_numba()

pydae/models/pendulum/api_test.http

@@ -0,0 +1,106 @@
+### GET measures. Devuelve todas las medidas del POI y de los inversores
+GET http://127.100.0.1:8000/measurements
+Content-Type: application/json
+
+### GET measures. Devuelve todas las medidas del POI y de los inversores
+GET http://10.20.0.2:5500/ppc_measurements
+Content-Type: application/json
+
+### GET measures. Devuelve todas las medidas del POI y de los inversores
+GET http://10.20.0.4:5500/ppc_measurements
+Content-Type: application/json
+
+
+### POST setpoints. POST request to change PPC references. 
+POST http://127.0.0.1:5500/ppc_setpoints
+Content-Type: application/json
+
+{
+    "p_ol_ref":0.0,
+    "q_ol_ref":0.0,
+    "p_s_ref_BESS":0.0
+}
+
+
+
+### POST false measurement liner transformations parameters . 
+POST http://127.100.0.1:8000/meas_pert
+Content-Type: application/json
+
+{
+    "U_SS1":{"m":0.5,"b":0}
+}
+
+
+
+### POST setpoints. POST request to change active and reactive power references at POI. 
+POST http://10.20.0.2:8000/setpoints
+Content-Type: application/json
+
+{
+    "p_ol_ref":0.5,
+    "q_ol_ref":0.5,
+    "p_s_ref_BESS":0.0
+}
+
+
+### POST setpoints. POST request to change active and reactive power references at POI. 
+POST http://10.20.0.2:8000/setpoints
+Content-Type: application/json
+
+{
+    "p_s_ppc_LV0101":1.5e6,
+    "p_s_ppc_LV0102":01.5e6,
+    "p_s_ref_BESS":0.0
+}
+
+
+
+
+### POST setpoints. POST request to change PPC references. 
+POST http://127.0.0.1:5500/ppc_setpoints
+Content-Type: application/json
+
+{
+    "record":true
+}
+
+
+
+### POST setpoints. POST request to change PPC references. 
+POST http://127.0.0.1:5500/ppc_setpoints
+Content-Type: application/json
+
+{
+    "P_POI_ref":0.5,
+    "Q_POI_ref":-0.9
+}
+
+### POST setpoints. POST request to change PPC references. 
+POST http://127.0.0.1:5500/ppc_setpoints
+Content-Type: application/json
+
+{
+    "record":false
+}
+
+
+### POST setpoints. POST request to change PPC references. 
+POST http://127.0.0.1:5500/ppc_setpoints
+Content-Type: application/json
+
+{
+    "stop_ppc":true
+}
+
+
+### POST setpoints. POST request to change PPC references. 
+POST http://127.0.0.1:5500/ppc_params
+Content-Type: application/json
+
+{
+    "K_pp":0.5,
+    "K_pi":5.0,
+    "K_qp":0.5,
+    "K_qi":5.0
+}

pydae/models/pendulum/dae_api.py

@@ -0,0 +1,107 @@
+import numpy as np
+import sympy as sym
+
+
+def dae(model_name):
+    L,G,M,K_d = sym.symbols('L,G,M,K_d', real=True)
+    p_x,p_y,v_x,v_y = sym.symbols('p_x,p_y,v_x,v_y', real=True) 
+    lam,f_x,theta,u_dummy = sym.symbols('lam,f_x,theta,u_dummy', real=True) 
+
+    dp_x = v_x
+    dp_y = v_y
+    dv_x = (-2*p_x*lam + f_x - K_d*v_x)/M
+    dv_y = (-M*G - 2*p_y*lam - K_d*v_y)/M   
+
+    g_1 = p_x**2 + p_y**2 - L**2 -lam*1e-6
+    g_2 = -theta + sym.atan2(p_x,-p_y) + u_dummy
+
+    params_dict = {'L':5.21,'G':9.81,'M':10.0,'K_d':1e-3}  # parameters with default values
+
+    u_ini_dict = {'theta':np.deg2rad(5.0),'u_dummy':0.0}  # input for the initialization problem
+    u_run_dict = {'f_x':0,'u_dummy':0.0}                  # input for the running problem, its value is updated 
+
+    sys_dict = {'name':model_name,
+                'params_dict':params_dict,
+                'f_list':[dp_x,dp_y,dv_x,dv_y],
+                'g_list':[g_1,g_2],
+                'x_list':[ p_x, p_y, v_x, v_y],
+                'y_ini_list':[lam,f_x],
+                'y_run_list':[lam,theta],
+                'u_ini_dict':u_ini_dict,
+                'u_run_dict':u_run_dict,
+                'h_dict':{'E_p':M*G*(p_y+L),'E_k':0.5*M*(v_x**2+v_y**2),
+                          'theta':theta,'f_x':f_x,'lam':lam},
+                'xy_0':{'theta':sym.atan2(p_x,-p_y)}} 
+
+    return sys_dict
+
+
+def test_build():
+    import pydae.build_v2 as db
+    sys_dict = dae('temp')
+
+    
+    b = db.builder(sys_dict,verbose=True,API=True)
+    b.sparse = False
+    b.mkl = False
+    b.platform = 'Windows'
+    b.dict2system()
+    b.functions()
+    b.jacobians()
+    b.cwrite()
+    b.template()
+    b.compile()
+
+
+def test_ini():
+
+    import temp 
+
+    model = temp.model()
+
+    M = 30.0  # mass of the bob (kg)
+    L = 5.21  # length of the pendulum (m)
+    model.ini({'M':M,'L':L,           # parameters setting
+            'theta':np.deg2rad(0)  # initial desired angle = 0º
+            },-1)                  # here -1 means that -1 is considered as initial gess for
+                                    # dynamic and algebraic states
+
+    model.report_x()  # obtained dynamic states
+    model.report_y()  # obtained algebraic states
+    model.report_z()  # obtained outputs
+    model.report_u()  # obtained algebraic states (theta is both state and output; f_x is both input and output)
+    model.report_params()  # considered parameters
+
+def test_api():
+
+    import temp 
+
+    model = temp.model()
+
+    M = 30.0  # mass of the bob (kg)
+    L = 5.21  # length of the pendulum (m)
+    model.ini({'M':M,'L':L,           # parameters setting
+            'theta':np.deg2rad(5)  # initial desired angle = 0º
+            },-1)                  # here -1 means that -1 is considered as initial gess for
+                                    # dynamic and algebraic states
+
+    model.report_x()  # obtained dynamic states
+    model.report_y()  # obtained algebraic states
+    model.report_z()  # obtained outputs
+    model.report_u()  # obtained algebraic states (theta is both state and output; f_x is both input and output)
+    model.report_params()  # considered parameters
+
+
+    # model.run(1.0,{})
+    model.run_api()
+    #model.step(0.000000001,{})
+
+if __name__ == '__main__':
+
+    test_build()
+    test_ini()
+    test_api()
+
+
+
+

pydae/models/pendulum/dashboard.py

@@ -0,0 +1,211 @@
+import panel as pn
+import datetime
+import param
+import asyncio
+import re
+from pydae.svg_tools import svg
+import requests
+import json
+import time
+import matplotlib.pyplot as plt
+import numpy as np
+pn.extension('katex','matplotlib')
+
+t_0 = time.time()
+plot_pane = pn.pane.Matplotlib(sizing_mode='stretch_width')
+
+# A function to generate a new plot
+
+# with open('cuerva_emec_db.svg', 'r') as fobj:
+#     svg_file_content = fobj.read()
+
+# Generate the new SVG
+#s = svg('cuerva_emec_db.svg')
+# s.set_tspan('U_SS1', f"{meas_dict['V_SS1']:5.3f} pu")
+# s.set_tspan('U_SS2', f"{meas_dict['V_SS2']:5.3f} pu")
+# s.set_tspan('U_POI', f"{slider_val:5.3f} pu")
+# s.set_title('GRID_title', f"V = {meas_dict['V_GRID']:5.3f} pu\nP = {meas_dict['p_line_POIHV_GRID'] / 1e6:5.3f} MW\nQ = {meas_dict['q_line_POIHV_GRID'] / 1e6:5.3f} Mvar")
+# s.set_tspan('P_POI', f"{meas_dict['p_line_POI_POIHV'] / 1e6:5.1f} MW")
+# s.set_tspan('Q_POI', f"{meas_dict['q_line_POI_POIHV'] / 1e6:5.1f} Mvar")
+
+# html_code = """
+# <div>
+#   <svg width="200" height="200" xmlns="http://www.w3.org/2000/svg">
+#     <circle id="interactive_circle" cx="100" cy="100" r="50" fill="skyblue">
+#       <title>This is a circle\nHola</title>
+#     </circle>
+#   <text id="time_label" x="50" y="50" font-family="Arial" font-size="24" text-anchor="middle" fill="#333">
+#     Time: 00:00:00
+#   </text>
+#   </svg>
+# </div>
+# """
+
+N_t = 300
+charts_data = {'Times':np.zeros(N_t),
+               'theta':np.zeros(N_t),
+               'f_x':np.zeros(N_t),
+               'k':0, 'N_t':N_t, 't_0':t_0
+               }
+
+# html_code = f"""
+# <div>
+#   {s.tostring()}
+# </div>
+# """
+
+
+#svg_pane = pn.pane.HTML(html_code, width=200, height=200)
+# panel.servable()
+
+
+# Create other widgets
+button1 = pn.widgets.Button(name='Set to Red', button_type='success')
+button2 = pn.widgets.Button(name='Set to Green', button_type='primary')
+slider1 = pn.widgets.IntSlider(name='Circle Radius', start=20, end=100, value=80)
+color_picker = pn.widgets.ColorPicker(name='Circle Color', value='#FF0000')
+
+ 
+sld_f_x_label = pn.pane.LaTeX(r'$\mathsf {f_{x}}$ (Nm):', width=80)
+sld_f_x = pn.widgets.FloatSlider(start=-200.0, end=200.0, value=0.0, step=0.01)
+
+# Crear pestañas con Panel
+tabs_monitor = pn.Tabs(
+#    ('Plant', svg_pane),
+    ('Charts', plot_pane)
+)
+tabs_ctrl = pn.Tabs(
+    ('Enviroment', pn.Column(
+        sld_f_x_label,sld_f_x))
+  #  ('POI', pn.widgets.Button(name='Set to 2', button_type='success')),
+)
+
+# # A reusable function to update the SVG (for buttons and sliders)
+# def update_svg(event=None):
+#     current_svg = svg_pane.object
+    
+#     new_radius = slider1.value
+#     new_color = color_picker.value
+    
+#     if event and event.obj is button1:
+#         new_color = '#FF0000'
+#     elif event and event.obj is button2:
+#         new_color = '#00FF00'
+
+#     # Use regular expressions for more reliable attribute updates
+#     updated_svg = re.sub(
+#         r'(<circle id="interactive_circle".*?)\sfill=".*?"',
+#         r'\1 fill="{}"'.format(new_color),
+#         current_svg
+#     )
+#     updated_svg = re.sub(
+#         r'(<circle id="interactive_circle".*?)\sr=".*?"',
+#         r'\1 r="{}"'.format(new_radius),
+#         updated_svg
+#     )
+
+#     # s.set_tspan('U_SS1', f"{meas_dict['V_SS1']:5.3f} pu")
+#     # s.set_tspan('U_SS2', f"{meas_dict['V_SS2']:5.3f} pu")
+#     # s.set_tspan('U_POI', f"{slider_val:5.3f} pu")
+#     # s.set_title('GRID_title', f"V = {meas_dict['V_GRID']:5.3f} pu\nP = {meas_dict['p_line_POIHV_GRID'] / 1e6:5.3f} MW\nQ = {meas_dict['q_line_POIHV_GRID'] / 1e6:5.3f} Mvar")
+#     # s.set_tspan('P_POI', f"{meas_dict['p_line_POI_POIHV'] / 1e6:5.1f} MW")
+#     # s.set_tspan('Q_POI', f"{meas_dict['q_line_POI_POIHV'] / 1e6:5.1f} Mvar")
+
+    
+#     svg_pane.object = updated_svg
+
+# The asynchronous function to be called periodically
+async def update_time_label():
+    """
+    Asynchronously updates the time label in the SVG.
+    """
+    current_time = datetime.datetime.now().strftime("%H:%M:%S")
+    # current_svg = svg_pane.object
+
+    # # Use a regular expression to update the content of the text element
+    # new_svg = re.sub(
+    #     r'(<tspan id="P_POI".*?>)(.*?)(</tspan>)',
+    #     r'\1Time: {}\3'.format(current_time),
+    #     current_svg,
+    #     flags=re.DOTALL
+    # )
+
+    url = "http://localhost:8000/measurements"
+
+    ppc_ip = '10.30.0.4'
+
+    # http://10.30.0.4:5500/ppc_measurements
+     
+    ##############################################################################
+    url = "http://localhost:8000/measurements"
+    #url = f"http://{ppc_ip}:5500/ppc_measurements"
+    response = requests.get(url, headers={"Content-Type": "application/json"}, timeout=0.5) # Added a timeout
+    response.raise_for_status()
+    meas_dict = response.json()
+    time.sleep(0.05)
+
+    ###############################################################################
+    url = "http://localhost:8000/setpoints"
+    #url = f"http://{ppc_ip}:5500/ppc_setpoints"
+    headers = {"Content-Type": "application/json"}
+    data = {
+        "f_x":float(sld_f_x.value)
+    }
+
+    response = requests.post(url, headers=headers, data=json.dumps(data))
+    
+    # # This is the line that's failing
+    # response.raise_for_status() 
+
+    #response = requests.post(url, headers=headers, data=json.dumps(data))
+
+
+
+    # time.sleep(1.0)
+
+    # # Generate the new SVG
+    # s = svg('cuerva_emec_db.svg')
+    # s.set_tspan('U_SS1', f"{meas_dict['U_SS1']/20e3:5.3f} pu")
+    # s.set_tspan('U_SS2', f"{meas_dict['U_SS2']/20e3:5.3f} pu")
+    # s.set_tspan('U_POI', f"{meas_dict['U_POI']/20e3:5.3f} pu")
+    # #s.set_title('GRID_title', f"V = {meas_dict['V_GRID']:5.3f} pu\nP = {meas_dict['p_line_POIHV_GRID'] / 1e6:5.3f} MW\nQ = {meas_dict['q_line_POIHV_GRID'] / 1e6:5.3f} Mvar")
+    # s.set_tspan('P_POI', f"{meas_dict['p_line_POI_POIHV'] / 1e6:5.2f} MW")
+    # s.set_tspan('Q_POI', f"{meas_dict['q_line_POI_POIHV'] / 1e6:5.2f} Mvar")
+    
+    charts_data['Times'][-1] = time.time() - t_0
+    charts_data['theta'][-1] = meas_dict['theta'] 
+    charts_data['f_x'][-1] = meas_dict['f_x'] 
+
+    charts_data['Times'][0:-1] = charts_data['Times'][1:]
+    charts_data['theta'][0:-1] = charts_data['theta'][1:]
+    charts_data['f_x'][0:-1] = charts_data['f_x'][1:]
+
+    charts_data['k'] += 1
+
+    plt.close('all') # Clear previous plot
+    fig, ax = plt.subplots(figsize=(6, 4))
+    ax.plot(charts_data['Times'], charts_data['theta'], color='blue') # Plot new random data
+    ax.plot(charts_data['Times'], charts_data['f_x'], color='red') # Plot new random data
+
+    plot_pane.object = fig # Assign the new figure to the pane
+
+
+# # Link widgets to the update function
+# button1.on_click(update_svg)
+# button2.on_click(update_svg)
+# slider1.param.watch(update_svg, 'value')
+# color_picker.param.watch(update_svg, 'value')
+
+# Combine all components into a Panel layout
+dashboard = pn.Column(
+        tabs_monitor,
+        tabs_ctrl
+)
+
+# Use pn.io.periodic_async to run the update_time_label function every 1000ms (1 second)
+# The `dashboard.servable()` is required to use periodic functions in a standalone app.
+# In a Jupyter notebook, `dashboard` will automatically display the periodic updates.
+pn.state.add_periodic_callback(update_time_label, period=100)
+
+# Display the dashboard
+dashboard.show()