app working for FN.mdf.json and array inputs

app.py

@@ -3,6 +3,7 @@ from modeci_mdf.mdf import Model, Graph, Node, Parameter, OutputPort
 from modeci_mdf.utils import load_mdf_json, load_mdf, load_mdf_yaml
 from modeci_mdf.execution_engine import EvaluableGraph, EvaluableOutput
 import json
+import numpy as np
 import requests
 st.set_page_config(layout="wide", page_icon="logo.png", page_title="Model Description Format", menu_items={
         'Report a bug': "https://github.com/ModECI/MDF/",
@@ -10,43 +11,98 @@ st.set_page_config(layout="wide", page_icon="logo.png", page_title="Model Descri
     })
 
 # models: Purpose: To store the state of the model and update the model
+import numpy as np
+
 def run_simulation(param_inputs, mdf_model):
     mod_graph = mdf_model.graphs[0]
     nodes = mod_graph.nodes
-    for node in nodes:
-        parameters = node.parameters
-        outputs = node.output_ports
-        eg = EvaluableGraph(mod_graph, verbose=False)
-        # eo = EvaluableOutput(mod_graph, verbose=)
-        duration = param_inputs["Simulation Duration (s)"]
-        dt = param_inputs["Time Step (s)"]
-        print("hi me param_inputs inside run simulation", param_inputs)
-        t = 0
-        times = []
-        output_values = {op.value: [] for op in outputs}
-        while t <= duration:
-            times.append(t)
-            if t == 0:
-                eg.evaluate()
-            else:
-                eg.evaluate(time_increment=dt)
-
-            for param in output_values:
-                if any(operator in param  for operator in "+-/*"):
-                    eval_param = eg.enodes[node.id].evaluable_outputs[param]
-                    
+    with st.spinner('Plotting the curve...'):
+        for node in nodes:
+            parameters = node.parameters
+            outputs = node.output_ports
+            eg = EvaluableGraph(mod_graph, verbose=False)
+            duration = param_inputs["Simulation Duration (s)"]
+            dt = param_inputs["Time Step (s)"]
+            t = 0
+            times = []
+            output_values = {op.value: [] for op in outputs}
+            while t <= duration:
+                times.append(t)
+                if t == 0:
+                    eg.evaluate()
                 else:
-                    eval_param = eg.enodes[node.id].evaluable_parameters[param] 
-                output_values[param].append(eval_param.curr_value)
-            t += dt
+                    eg.evaluate(time_increment=dt)
+
+                for param in output_values:
+                    if any(operator in param for operator in "+-/*"):
+                        eval_param = eg.enodes[node.id].evaluable_outputs[param]
+                    else:
+                        eval_param = eg.enodes[node.id].evaluable_parameters[param] 
+                    output_value = eval_param.curr_value
+                    if isinstance(output_value, (list, np.ndarray)):
+                        # Extract the scalar value from the list or array
+                        scalar_value = output_value[0] if len(output_value) > 0 else np.nan
+                        output_values[param].append(float(scalar_value))  # Convert to Python float
+                    else:
+                        output_values[param].append(float(output_value))  # Convert to Python float
+                t += dt
+        
         chart_data = pd.DataFrame(output_values)
         chart_data['Time'] = times
         chart_data.set_index('Time', inplace=True)
+        print(chart_data)
         show_simulation_results(chart_data)
     return None
-# views: Purpose: To display the state of the model 
+# def run_simulation(param_inputs, mdf_model):
+#     mod_graph = mdf_model.graphs[0]
+#     nodes = mod_graph.nodes
+#     for node in nodes:
+#         parameters = node.parameters
+#         outputs = node.output_ports
+#         eg = EvaluableGraph(mod_graph, verbose=False)
+#         duration = param_inputs["Simulation Duration (s)"]
+#         dt = param_inputs["Time Step (s)"]
+#         t = 0
+#         times = []
+#         output_values = {op.value: [] for op in outputs}
+#         while t <= duration:
+#             times.append(t)
+#             if t == 0:
+#                 eg.evaluate()
+#             else:
+#                 eg.evaluate(time_increment=dt)
+
+#             for param in output_values:
+#                 if any(operator in param for operator in "+-/*"):
+#                     eval_param = eg.enodes[node.id].evaluable_outputs[param]
+#                 else:
+#                     eval_param = eg.enodes[node.id].evaluable_parameters[param] 
+#                 output_value = eval_param.curr_value
+#                 if isinstance(output_value, (list, np.ndarray)):
+#                     # Extract the scalar value from the list or array
+#                     output_values[param].append(output_value[0] if len(output_value) > 0 else np.nan)
+#                 else:
+#                     output_values[param].append(output_value)
+#             t += dt
+        
+#         chart_data = pd.DataFrame(output_values)
+#         chart_data['Time'] = times
+#         chart_data.set_index('Time', inplace=True)
+#         print(chart_data)
+#         show_simulation_results(chart_data)
+#     return None
+
 def show_simulation_results(chart_data):
-    st.line_chart(chart_data, use_container_width=True, height=400)
+    try:
+        st.line_chart(chart_data, use_container_width=True, height=400)
+    except Exception as e:
+        st.error(f"Error plotting chart: {e}")
+        st.write("Chart data types:")
+        st.write(chart_data.dtypes)
+        st.write("Chart data head:")
+        st.write(chart_data.head())
+        st.write("Chart data description:")
+        st.write(chart_data.describe())
 
 def show_mdf_graph(mdf_model):
     st.subheader("MDF Graph")
@@ -61,21 +117,32 @@ def show_json_output(mdf_model):
 def view_tabs(mdf_model, param_inputs): # view
     tab1, tab2, tab3 = st.tabs(["Simulation Results", "MDF Graph", "Json Output"])
     with tab1:
-        # mod_graph = mdf_model.graphs[0]
-        # nodes = mod_graph.nodes
-        # for node in nodes:
-        #     st.write("Node Name: ", node.id)
-        #     node_parameters = {}
-        #     for param in node.parameters:
-        #         node_parameters[param.id] = node_parameters[param.id] = param.value if param.value else param.time_derivative
-        #     st.write("Node Parameters: ", node_parameters)   
         run_simulation(param_inputs, mdf_model) # model
-        #     show_simulation_results(chart_data) # view
     with tab2:
         show_mdf_graph(mdf_model) # view
     with tab3:
         show_json_output(mdf_model) # view
 
+def display_and_edit_array(array, key):
+    if isinstance(array, list):
+        array = np.array(array)
+    
+    rows, cols = array.shape if array.ndim > 1 else (1, len(array))
+    
+    edited_array = []
+    for i in range(rows):
+        row = []
+        for j in range(cols):
+            value = array[i][j] if array.ndim > 1 else array[i]
+            edited_value = st.text_input(f"[{i}][{j}]", value=str(value), key=f"{key}_{i}_{j}")
+            try:
+                row.append(float(edited_value))
+            except ValueError:
+                st.error(f"Invalid input for [{i}][{j}]. Please enter a valid number.")
+        edited_array.append(row)
+    
+    return np.array(edited_array)
+
 def parameter_form_to_update_model_and_view(mdf_model, parameters, param_inputs, mod_graph, nodes):
     with st.form(key="parameter_form"):
         valid_inputs = True
@@ -93,16 +160,21 @@ def parameter_form_to_update_model_and_view(mdf_model, parameters, param_inputs,
                 current_col = col1 if i % 2 == 0 else col2
                 
                 with current_col:
-                    if mdf_model.metadata:
-                        value = st.text_input(f"{param.metadata.get('description', param.id)} ({param.id})", value=str(param.value), key=key)
+                    if isinstance(param.value, (list, np.ndarray)):
+                        st.write(f"{param.id}:")
+                        value = display_and_edit_array(param.value, key)
                     else:
-                        value = st.text_input(f"{param.id}", value=str(param.value), key=key)
+                        if param.metadata:
+                            value = st.text_input(f"{param.metadata.get('description', param.id)} ({param.id})", value=str(param.value), key=key)
+                        else:
+                            value = st.text_input(f"{param.id}", value=str(param.value), key=key)
+                        try:
+                            param_inputs[param.id] = float(value)
+                        except ValueError:
+                            st.error(f"Invalid input for {param.id}. Please enter a valid number.")
+                            valid_inputs = False
                 
-                try:
-                    param_inputs[param.id] = float(value)
-                except ValueError:
-                    st.error(f"Invalid input for {param.id}. Please enter a valid number.")
-                    valid_inputs = False
+                param_inputs[param.id] = value
         st.write("Simulation Parameters:")
         with st.container(border=True):
             # Add Simulation Duration and Time Step inputs
@@ -203,27 +275,41 @@ def upload_file_and_load_to_model():
             st.error(f"Error loading file from GitHub: {e}")
             return None
     # with col2:
+    # example_models = {
+    #     "Newton Cooling Model": "https://raw.githubusercontent.com/ModECI/MDF/development/examples/MDF/NewtonCoolingModel.json",
+    #     "ABCD": "https://raw.githubusercontent.com/ModECI/MDF/main/examples/MDF/ABCD.json",
+    #     "FN": "https://raw.githubusercontent.com/ModECI/MDF/main/examples/MDF/FN.mdf.json",
+    #     "States": "https://raw.githubusercontent.com/ModECI/MDF/main/examples/MDF/States.json",
+    #     "Other Model 4": "https://example.com/other_model_4.json"
+    # }
+    # selected_model = st.selectbox("Choose an example model", list(example_models.keys()), index=None)
+    # if selected_model:
+    #     example_url = example_models[selected_model]
+    #     try:
+    #         response = requests.get(example_url)
+    #         response.raise_for_status()
+    #         file_content = response.content
+    #         file_extension = example_url.split('.')[-1].lower()
+    #         return load_model_from_content(file_content, file_extension)
+    #     except requests.RequestException as e:
+    #         st.error(f"Error loading example model: {e}")
+    #         return None
+    # # st.button("Newton Cooling Model", on_click=load_mdf_json(""))
+    # return None
     example_models = {
-        "Newton Cooling Model": "https://raw.githubusercontent.com/ModECI/MDF/development/examples/MDF/NewtonCoolingModel.json",
-        "ABCD": "https://raw.githubusercontent.com/ModECI/MDF/main/examples/MDF/ABCD.json",
-        "FN": "https://raw.githubusercontent.com/ModECI/MDF/main/examples/MDF/FN.mdf.json",
-        "States": "https://raw.githubusercontent.com/ModECI/MDF/main/examples/MDF/States.json",
-        "Other Model 4": "https://example.com/other_model_4.json"
+        "Newton Cooling Model": "./examples/NewtonCoolingModel.json",
+        # "ABCD": "./examples/ABCD.json",
+        "FN": "./examples/FN.mdf.json",
+        # "States": "./examples/States.json",
+        "Swicthed RLC Circuit": "./examples/switched_rlc_circuit.json",
+        # "Arrays":"./examples/Arrays.json",
+        # "RNN":"./examples/RNNs.json",
+        # "IAF":"./examples/IAFs.json"
     }
     selected_model = st.selectbox("Choose an example model", list(example_models.keys()), index=None)
     if selected_model:
-        example_url = example_models[selected_model]
-        try:
-            response = requests.get(example_url)
-            response.raise_for_status()
-            file_content = response.content
-            file_extension = example_url.split('.')[-1].lower()
-            return load_model_from_content(file_content, file_extension)
-        except requests.RequestException as e:
-            st.error(f"Error loading example model: {e}")
-            return None
-    # st.button("Newton Cooling Model", on_click=load_mdf_json(""))
-    return None
+        return load_mdf_json(example_models[selected_model])
+
 
 
 def load_model_from_content(file_content, file_extension):

examples/ABCD.json

@@ -0,0 +1,185 @@
+{
+    "ABCD": {
+        "format": "ModECI MDF v0.4",
+        "generating_application": "Python modeci-mdf v0.4.10",
+        "graphs": {
+            "abcd_example": {
+                "nodes": {
+                    "input0": {
+                        "metadata": {
+                            "color": ".8 .8 .8"
+                        },
+                        "parameters": {
+                            "input_level": {
+                                "value": 0.0
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "input_level"
+                            }
+                        }
+                    },
+                    "A": {
+                        "metadata": {
+                            "color": ".8 0 0"
+                        },
+                        "input_ports": {
+                            "input_port1": {}
+                        },
+                        "parameters": {
+                            "slope": {
+                                "value": 1.1
+                            },
+                            "intercept": {
+                                "value": 1.2
+                            },
+                            "linear_func": {
+                                "function": "linear",
+                                "args": {
+                                    "variable0": "input_port1",
+                                    "slope": "slope",
+                                    "intercept": "intercept"
+                                }
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "linear_func"
+                            }
+                        }
+                    },
+                    "B": {
+                        "metadata": {
+                            "color": "0 .8 0"
+                        },
+                        "input_ports": {
+                            "input_port1": {}
+                        },
+                        "parameters": {
+                            "gain": {
+                                "value": 2.1
+                            },
+                            "bias": {
+                                "value": 2.2
+                            },
+                            "offset": {
+                                "value": 2.3
+                            },
+                            "logistic_func": {
+                                "function": "logistic",
+                                "args": {
+                                    "variable0": "input_port1",
+                                    "gain": "gain",
+                                    "bias": "bias",
+                                    "offset": "offset"
+                                }
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "logistic_func"
+                            }
+                        }
+                    },
+                    "C": {
+                        "metadata": {
+                            "color": "0 0 .8"
+                        },
+                        "input_ports": {
+                            "input_port1": {
+                                "shape": [
+                                    1
+                                ]
+                            }
+                        },
+                        "parameters": {
+                            "scale": {
+                                "value": 3.1
+                            },
+                            "rate": {
+                                "value": 3.2
+                            },
+                            "bias": {
+                                "value": 3.3
+                            },
+                            "offset": {
+                                "value": 3.4
+                            },
+                            "exponential_func": {
+                                "function": "exponential",
+                                "args": {
+                                    "variable0": "input_port1",
+                                    "scale": "scale",
+                                    "rate": "rate",
+                                    "bias": "bias",
+                                    "offset": "offset"
+                                }
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "exponential_func"
+                            }
+                        }
+                    },
+                    "D": {
+                        "metadata": {
+                            "color": ".8 0 .8"
+                        },
+                        "input_ports": {
+                            "input_port1": {
+                                "shape": [
+                                    1
+                                ]
+                            }
+                        },
+                        "parameters": {
+                            "scale": {
+                                "value": 4.0
+                            },
+                            "sin_func": {
+                                "function": "sin",
+                                "args": {
+                                    "variable0": "input_port1",
+                                    "scale": "scale"
+                                }
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "sin_func"
+                            }
+                        }
+                    }
+                },
+                "edges": {
+                    "edge_input0_A": {
+                        "sender": "input0",
+                        "receiver": "A",
+                        "sender_port": "out_port",
+                        "receiver_port": "input_port1"
+                    },
+                    "edge_A_B": {
+                        "sender": "A",
+                        "receiver": "B",
+                        "sender_port": "out_port",
+                        "receiver_port": "input_port1"
+                    },
+                    "edge_B_C": {
+                        "sender": "B",
+                        "receiver": "C",
+                        "sender_port": "out_port",
+                        "receiver_port": "input_port1"
+                    },
+                    "edge_C_D": {
+                        "sender": "C",
+                        "receiver": "D",
+                        "sender_port": "out_port",
+                        "receiver_port": "input_port1"
+                    }
+                }
+            }
+        }
+    }
+}

examples/Arrays.json

@@ -0,0 +1,93 @@
+{
+    "Arrays": {
+        "format": "ModECI MDF v0.4",
+        "generating_application": "Python modeci-mdf v0.4.11",
+        "graphs": {
+            "array_example": {
+                "nodes": {
+                    "input_node": {
+                        "parameters": {
+                            "input_level": {
+                                "value": [
+                                    [
+                                        1,
+                                        2.0
+                                    ],
+                                    [
+                                        3,
+                                        4
+                                    ]
+                                ]
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "input_level"
+                            }
+                        }
+                    },
+                    "middle_node": {
+                        "input_ports": {
+                            "input_port1": {
+                                "shape": [
+                                    2,
+                                    2
+                                ]
+                            }
+                        },
+                        "parameters": {
+                            "slope": {
+                                "value": 0.5
+                            },
+                            "intercept": {
+                                "value": [
+                                    [
+                                        0.0,
+                                        1.0
+                                    ],
+                                    [
+                                        2.0,
+                                        2.0
+                                    ]
+                                ]
+                            },
+                            "linear_1": {
+                                "function": "linear",
+                                "args": {
+                                    "variable0": "input_port1",
+                                    "slope": "slope",
+                                    "intercept": "intercept"
+                                }
+                            }
+                        },
+                        "output_ports": {
+                            "output_1": {
+                                "value": "linear_1"
+                            }
+                        }
+                    }
+                },
+                "edges": {
+                    "input_edge": {
+                        "sender": "input_node",
+                        "receiver": "middle_node",
+                        "sender_port": "out_port",
+                        "receiver_port": "input_port1",
+                        "parameters": {
+                            "weight": [
+                                [
+                                    1,
+                                    0
+                                ],
+                                [
+                                    0,
+                                    1
+                                ]
+                            ]
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

examples/FN.mdf.json

@@ -1,6 +1,10 @@
 {
     "FN": {
         "format": "ModECI MDF v0.4",
+        "metadata": {
+            "preferred_duration": 0.1,
+            "preferred_dt": 0.00005
+        },
         "graphs": {
             "FN": {
                 "notes": "FitzHugh Nagumo cell model - originally specified in NeuroML/LEMS",

examples/IAFs.json

@@ -0,0 +1,241 @@
+{
+    "IAFs": {
+        "format": "ModECI MDF v0.4",
+        "generating_application": "Python modeci-mdf v0.4.11",
+        "metadata": {
+            "preferred_duration": 100,
+            "preferred_dt": 0.1
+        },
+        "graphs": {
+            "IAFs": {
+                "nodes": {
+                    "current_input_node": {
+                        "parameters": {
+                            "time": {
+                                "default_initial_value": 0,
+                                "time_derivative": "1"
+                            },
+                            "start": {
+                                "value": 20
+                            },
+                            "duration": {
+                                "value": 60
+                            },
+                            "amplitude": {
+                                "value": 10
+                            },
+                            "level": {
+                                "value": 0,
+                                "conditions": [
+                                    {
+                                        "id": "on",
+                                        "test": "time > start",
+                                        "value": "amplitude"
+                                    },
+                                    {
+                                        "id": "off",
+                                        "test": "time > start + duration",
+                                        "value": "amplitude*0"
+                                    }
+                                ]
+                            }
+                        },
+                        "output_ports": {
+                            "current_output": {
+                                "value": "level"
+                            }
+                        }
+                    },
+                    "pre": {
+                        "input_ports": {
+                            "current_input": {
+                                "shape": [
+                                    1
+                                ]
+                            }
+                        },
+                        "parameters": {
+                            "v0": {
+                                "value": [
+                                    -60
+                                ]
+                            },
+                            "erev": {
+                                "value": [
+                                    -70
+                                ]
+                            },
+                            "tau": {
+                                "value": 10.0
+                            },
+                            "thresh": {
+                                "value": [
+                                    -20
+                                ]
+                            },
+                            "spiking": {
+                                "default_initial_value": "0",
+                                "conditions": [
+                                    {
+                                        "id": "is_spiking",
+                                        "test": "v >= thresh",
+                                        "value": "1"
+                                    },
+                                    {
+                                        "id": "not_spiking",
+                                        "test": "v < thresh",
+                                        "value": "0"
+                                    }
+                                ]
+                            },
+                            "v": {
+                                "default_initial_value": "v0",
+                                "time_derivative": "-1 * (v-erev)/tau + current_input",
+                                "conditions": [
+                                    {
+                                        "id": "reset",
+                                        "test": "v > thresh",
+                                        "value": "erev"
+                                    }
+                                ]
+                            }
+                        },
+                        "output_ports": {
+                            "v_output": {
+                                "value": "v"
+                            },
+                            "spiking_output": {
+                                "value": "spiking"
+                            }
+                        }
+                    },
+                    "post": {
+                        "input_ports": {
+                            "current_input": {
+                                "shape": [
+                                    1
+                                ]
+                            }
+                        },
+                        "parameters": {
+                            "v0": {
+                                "value": [
+                                    -60
+                                ]
+                            },
+                            "erev": {
+                                "value": [
+                                    -70
+                                ]
+                            },
+                            "tau": {
+                                "value": 10.0
+                            },
+                            "thresh": {
+                                "value": [
+                                    -20
+                                ]
+                            },
+                            "spiking": {
+                                "default_initial_value": "0",
+                                "conditions": [
+                                    {
+                                        "id": "is_spiking",
+                                        "test": "v >= thresh",
+                                        "value": "1"
+                                    },
+                                    {
+                                        "id": "not_spiking",
+                                        "test": "v < thresh",
+                                        "value": "0"
+                                    }
+                                ]
+                            },
+                            "v": {
+                                "default_initial_value": "v0",
+                                "time_derivative": "-1 * (v-erev)/tau + current_input",
+                                "conditions": [
+                                    {
+                                        "id": "reset",
+                                        "test": "v > thresh",
+                                        "value": "erev"
+                                    }
+                                ]
+                            }
+                        },
+                        "output_ports": {
+                            "v_output": {
+                                "value": "v"
+                            },
+                            "spiking_output": {
+                                "value": "spiking"
+                            }
+                        }
+                    },
+                    "syn_post": {
+                        "input_ports": {
+                            "spike_input": {
+                                "shape": [
+                                    1
+                                ]
+                            }
+                        },
+                        "parameters": {
+                            "syn_tau": {
+                                "value": 10
+                            },
+                            "spike_weights": {
+                                "value": [
+                                    40
+                                ]
+                            },
+                            "weighted_spike": {
+                                "function": "MatMul",
+                                "args": {
+                                    "A": "spike_weights",
+                                    "B": "spike_input"
+                                }
+                            },
+                            "syn_i": {
+                                "default_initial_value": "0",
+                                "time_derivative": "-1 * syn_i",
+                                "conditions": [
+                                    {
+                                        "id": "spike_detected",
+                                        "test": "spike_input > 0",
+                                        "value": "weighted_spike"
+                                    }
+                                ]
+                            }
+                        },
+                        "output_ports": {
+                            "current_output": {
+                                "value": "syn_i"
+                            }
+                        }
+                    }
+                },
+                "edges": {
+                    "input_edge": {
+                        "sender": "current_input_node",
+                        "receiver": "pre",
+                        "sender_port": "current_output",
+                        "receiver_port": "current_input"
+                    },
+                    "post_internal_edge": {
+                        "sender": "syn_post",
+                        "receiver": "post",
+                        "sender_port": "current_output",
+                        "receiver_port": "current_input"
+                    },
+                    "syn_edge": {
+                        "sender": "pre",
+                        "receiver": "syn_post",
+                        "sender_port": "spiking_output",
+                        "receiver_port": "spike_input"
+                    }
+                }
+            }
+        }
+    }
+}

examples/NewtonCoolingModel.json

@@ -2,22 +2,38 @@
     "NewtonCoolingModel": {
         "format": "ModECI MDF v0.4",
         "generating_application": "Python modeci-mdf v0.4.11",
+        "metadata": {
+            "preferred_duration": 100,
+            "preferred_dt": 0.01
+        },
         "graphs": {
-            "cooling_process": {
+            "NewtonCoolingModel": { 
                 "nodes": {
                     "cool_node": {
                         "parameters": {
                             "cooling_coeff": {
+                                "metadata": {
+                                    "description": "Cooling coefficient in 1/s"
+                                },
                                 "value": 0.1
                             },
                             "T_a": {
+                                "metadata": {
+                                    "description": "Ambient temperature in degrees C"
+                                },
                                 "value": 20
                             },
                             "T_curr": {
+                                "metadata": {
+                                    "description": "Current temperature in degrees C"
+                                },
                                 "default_initial_value": 90,
                                 "time_derivative": "dT_dt"
                             },
                             "dT_dt": {
+                                "metadata": {
+                                    "description": "Rate of change of temperature in degrees C/s"
+                                },
                                 "value": "-cooling_coeff*(T_curr - T_a)",
                                 "default_initial_value": 0
                             }
@@ -35,4 +51,4 @@
             }
         }
     }
-}
+}

examples/RNNs.json

@@ -0,0 +1,197 @@
+{
+    "RNNs": {
+        "format": "ModECI MDF v0.4",
+        "generating_application": "Python modeci-mdf v0.4.11",
+        "metadata": {
+            "preferred_duration": 50,
+            "preferred_dt": 0.1
+        },
+        "graphs": {
+            "RNNs": {
+                "nodes": {
+                    "input_node": {
+                        "parameters": {
+                            "t": {
+                                "default_initial_value": 0,
+                                "time_derivative": "1"
+                            },
+                            "amplitude": {
+                                "value": [
+                                    1
+                                ]
+                            },
+                            "period": {
+                                "value": [
+                                    10
+                                ]
+                            },
+                            "level": {
+                                "function": "sin",
+                                "args": {
+                                    "variable0": "2*3.14159*t/period",
+                                    "scale": "amplitude"
+                                }
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "level"
+                            },
+                            "t_out_port": {
+                                "value": "t"
+                            }
+                        }
+                    },
+                    "rnn_node": {
+                        "input_ports": {
+                            "ext_input": {
+                                "shape": [
+                                    5
+                                ]
+                            },
+                            "fb_input": {
+                                "shape": [
+                                    5
+                                ]
+                            }
+                        },
+                        "parameters": {
+                            "M": {
+                                "value": [
+                                    [
+                                        -0.15378707975107808,
+                                        0.961528396769231,
+                                        0.3696594771697266,
+                                        -0.03813619703127813,
+                                        -0.21576496361169895
+                                    ],
+                                    [
+                                        -0.3136439676982612,
+                                        0.45809941476808325,
+                                        -0.12285551064075118,
+                                        -0.8806442067808633,
+                                        -0.20391148933913716
+                                    ],
+                                    [
+                                        0.4759908114640714,
+                                        -0.635016539093,
+                                        -0.6490964877050149,
+                                        0.06310274768367674,
+                                        0.06365517419373212
+                                    ],
+                                    [
+                                        0.2688019171026421,
+                                        0.6988635881555791,
+                                        0.4489106497212705,
+                                        0.22204702135516574,
+                                        0.4448867651404431
+                                    ],
+                                    [
+                                        -0.3540821722936436,
+                                        -0.2764226887553718,
+                                        -0.5434735382420888,
+                                        -0.41257190722234127,
+                                        0.2619522477089755
+                                    ]
+                                ]
+                            },
+                            "g": {
+                                "value": 1.5
+                            },
+                            "x": {
+                                "default_initial_value": [
+                                    0.3929383711957233,
+                                    -0.42772133009924107,
+                                    -0.5462970928715938,
+                                    0.10262953816578246,
+                                    0.43893793957112615
+                                ],
+                                "time_derivative": "-x + g*int_fb + ext_input"
+                            },
+                            "r": {
+                                "function": "tanh",
+                                "args": {
+                                    "variable0": "x",
+                                    "scale": 1
+                                }
+                            },
+                            "int_fb": {
+                                "function": "MatMul",
+                                "args": {
+                                    "A": "M",
+                                    "B": "r"
+                                }
+                            }
+                        },
+                        "output_ports": {
+                            "out_port_x": {
+                                "value": "x"
+                            },
+                            "out_port_r": {
+                                "value": "r"
+                            }
+                        }
+                    },
+                    "readout_node": {
+                        "input_ports": {
+                            "input": {
+                                "shape": [
+                                    5
+                                ]
+                            }
+                        },
+                        "parameters": {
+                            "wr": {
+                                "value": [
+                                    1.0,
+                                    1.0,
+                                    1.0,
+                                    1.0,
+                                    1.0
+                                ]
+                            },
+                            "zi": {
+                                "function": "MatMul",
+                                "args": {
+                                    "A": "input",
+                                    "B": "wr"
+                                }
+                            }
+                        },
+                        "output_ports": {
+                            "z": {
+                                "value": "zi"
+                            }
+                        }
+                    }
+                },
+                "edges": {
+                    "input_edge": {
+                        "sender": "input_node",
+                        "receiver": "rnn_node",
+                        "sender_port": "out_port",
+                        "receiver_port": "ext_input",
+                        "parameters": {
+                            "weight": [
+                                1.0,
+                                0.0,
+                                0.0,
+                                0.0,
+                                0.0
+                            ]
+                        }
+                    },
+                    "readout_edge": {
+                        "sender": "rnn_node",
+                        "receiver": "readout_node",
+                        "sender_port": "out_port_r",
+                        "receiver_port": "input",
+                        "parameters": {
+                            "weight": 1
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

examples/{SwitchedRLC_Circuit.json → switched_rlc_circuit.json}

@@ -1,29 +1,21 @@
-{
+{   
     "SwitchedRLC_Circuit": {
+        
         "format": "ModECI MDF v0.4",
-        "generating_application": "Python modeci-mdf v0.4.11",
+        "generating_application": "Python modeci-mdf v0.4.10",
         "metadata": {
             "preferred_duration": 2,
             "preferred_dt": 0.001
         },
         "graphs": {
+         
             "SwitchedRLC_Circuit": {
                 "nodes": {
+                   
                     "V": {
                         "parameters": {
                             "Vs": {
-                                "conditions": [
-                                    {
-                                        "id": "off",
-                                        "test": "time<0.5",
-                                        "value": "0"
-                                    },
-                                    {
-                                        "id": "on",
-                                        "test": "time>=0.5",
-                                        "value": 0.1
-                                    }
-                                ]
+                                "value":"0.5"
                             },
                             "R": {
                                 "metadata": {
@@ -38,6 +30,9 @@
                                 "value": 1
                             },
                             "C": {
+                                "metadata": {
+                                    "description": "Capacitance in Farads"
+                                },
                                 "value": 0.001
                             },
                             "time": {
@@ -45,17 +40,33 @@
                                 "time_derivative": "1"
                             },
                             "V": {
+                                "metadata": {
+                                    "description": "Voltage across the circuit",
+                                    "plot":"True"
+                                },
                                 "default_initial_value": 0,
                                 "time_derivative": "i_C /C"
                             },
                             "i_R": {
+                                "metadata": {
+                                    "description": "Current through the resistor",
+                                    "plot":"True"
+                                },
                                 "value": "V / R"
                             },
                             "i_L": {
+                                "metadata": {
+                                    "description": "Current through the inductor",
+                                    "plot":"True"
+                                },
                                 "default_initial_value": 0,
                                 "time_derivative": "(Vs - V)/L"
                             },
                             "i_C": {
+                                "metadata": {
+                                    "description": "Current through the capacitor",
+                                    "plot":"True"
+                                },
                                 "value": "i_L-i_R"
                             }
                         },
@@ -66,10 +77,14 @@
                             "i_L_out": {
                                 "value": "i_L"
                             }
+                            
                         }
                     }
                 }
+                
             }
+            
+            
         }
     }
 }