Merge pull request #8 from ModECI/development

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.streamlit/config.toml

@@ -0,0 +1,6 @@
+[theme]
+primaryColor="#f6b17a"
+backgroundColor="#04043B"
+secondaryBackgroundColor="#424971"
+textColor="#ffffff"
+

README.md

@@ -1,2 +1,12 @@
-# MDF-UI
-User interface for interacting with MDF models
+---
+title: Model Description Format
+emoji: 🐠
+colorFrom: purple
+colorTo: indigo
+sdk: streamlit
+sdk_version: 1.37.0
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,337 @@
+import streamlit as st, pandas as pd, os, io
+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/",
+        'About': "ModECI (Model Exchange and Convergence Initiative) is a multi-investigator collaboration that aims to develop a standardized format for exchanging computational models across diverse software platforms and domains of scientific research and technology development, with a particular focus on neuroscience, Machine Learning and Artificial Intelligence. Refer to https://modeci.org/ for more."
+    })
+
+def reset_simulation_state():
+    """Reset simulation-related session state variables."""
+    if 'simulation_results' in st.session_state:
+        del st.session_state.simulation_results
+    if 'selected_columns' in st.session_state:
+        del st.session_state.selected_columns
+
+def run_simulation(param_inputs, mdf_model, stateful):
+    mod_graph = mdf_model.graphs[0]
+    nodes = mod_graph.nodes
+    all_node_results = {}
+    if stateful:
+        duration = param_inputs["Simulation Duration (s)"]
+        dt = param_inputs["Time Step (s)"]
+    
+        
+        
+        for node in nodes:
+            eg = EvaluableGraph(mod_graph, verbose=False)
+            t = 0
+            times = []
+            node_outputs = {op.value : [] for op in node.output_ports}
+            node_outputs['Time'] = []
+            
+            while t <= duration:
+                times.append(t)
+                if t == 0:
+                    eg.evaluate()
+                else:
+                    eg.evaluate(time_increment=dt)
+
+                node_outputs['Time'].append(t)
+                for op in node.output_ports:
+                    eval_param = eg.enodes[node.id].evaluable_outputs[op.id]
+                    output_value = eval_param.curr_value
+                    if isinstance(output_value, (list, np.ndarray)):
+                        scalar_value = output_value[0] if len(output_value) > 0 else np.nan
+                        node_outputs[op.value].append(float(scalar_value))
+                    else:
+                        node_outputs[op.value].append(float(output_value))
+                t += dt
+            
+            all_node_results[node.id] = pd.DataFrame(node_outputs).set_index('Time')
+        
+        return all_node_results
+    else:
+        for node in nodes:
+            eg = EvaluableGraph(mod_graph, verbose=False)
+            eg.evaluate()
+            all_node_results[node.id] = pd.DataFrame({op.value: [float(eg.enodes[node.id].evaluable_outputs[op.id].curr_value)] for op in node.output_ports})
+            
+    return all_node_results
+def show_simulation_results(all_node_results, stateful_nodes):
+    if all_node_results is not None:
+        for node_id, chart_data in all_node_results.items():
+            st.subheader(f"Results for Node: {node_id}")
+            if node_id in stateful_nodes:
+                if 'selected_columns' not in st.session_state:
+                    st.session_state.selected_columns = {node_id: {col: True for col in chart_data.columns}}
+                elif node_id not in st.session_state.selected_columns:
+                    st.session_state.selected_columns[node_id] = {col: True for col in chart_data.columns}
+                columns = chart_data.columns
+                for column in columns:
+                    st.checkbox(
+                        f"{column}",
+                        value=st.session_state.selected_columns[node_id][column],
+                        key=f"checkbox_{node_id}_{column}",
+                        on_change=update_selected_columns,
+                        args=(node_id, column,)
+                    )
+
+                # Filter the data based on selected checkboxes
+                filtered_data = chart_data[[col for col, selected in st.session_state.selected_columns[node_id].items() if selected]]
+
+                # Display the line chart with filtered data
+                st.line_chart(filtered_data, use_container_width=True, height=400)
+            else:
+                st.write(all_node_results[node_id])
+
+
+def update_selected_columns(node_id, column):
+    st.session_state.selected_columns[node_id][column] = st.session_state[f"checkbox_{node_id}_{column}"]
+
+def show_mdf_graph(mdf_model):
+    st.subheader("MDF Graph")
+    mdf_model.to_graph_image(engine="dot", output_format="png", view_on_render=False, level=3, filename_root=mdf_model.id, only_warn_on_fail=(os.name == "nt"))
+    image_path = mdf_model.id + ".png"
+    st.image(image_path, caption="Model Graph Visualization")
+
+def show_json_output(mdf_model):
+    st.subheader("JSON Model")
+    st.json(mdf_model.to_json())
+
+# st.cache_data()
+def view_tabs(mdf_model, param_inputs, stateful): # view
+    tab1, tab2, tab3 = st.tabs(["Simulation Results", "MDF Graph", "Json Model"])
+    with tab1:
+        if stateful:
+            if 'simulation_results' not in st.session_state:
+                st.session_state.simulation_results = None
+                
+            if st.session_state.simulation_results is not None:
+                show_simulation_results(st.session_state.simulation_results, stateful)
+            else:
+                st.write("Run the simulation to see results.") # model
+        else:
+            if 'simulation_results' not in st.session_state:
+                st.session_state.simulation_results = None
+                
+            if st.session_state.simulation_results is not None:
+                show_simulation_results(st.session_state.simulation_results, stateful)
+            else:
+                st.write("Stateless.")
+
+    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):
+    mod_graph = mdf_model.graphs[0]
+    nodes = mod_graph.nodes
+    parameters = []
+    stateful_nodes = []
+    stateful = False
+
+    for node in nodes:
+        for param in node.parameters:
+            if param.is_stateful():
+                stateful_nodes.append(node.id)
+                stateful = True
+                break
+            else:
+                stateful = False
+
+    param_inputs = {}
+    if stateful:
+        if mdf_model.metadata:
+            preferred_duration = float(mdf_model.metadata.get("preferred_duration", 10))
+            preferred_dt = float(mdf_model.metadata.get("preferred_dt", 0.1))
+        else:
+            preferred_duration = 100
+            preferred_dt = 0.1
+        param_inputs["Simulation Duration (s)"] = preferred_duration
+        param_inputs["Time Step (s)"] = preferred_dt
+
+    with st.form(key="parameter_form"):
+        valid_inputs = True
+        st.write("Model Parameters:")
+
+        for node_index, node in enumerate(nodes):
+            with st.container(border=True):
+                st.write(f"Node: {node.id}")
+                
+                # Create four columns for each node
+                col1, col2, col3, col4 = st.columns(4)
+                
+                for i, param in enumerate(node.parameters):
+                    if isinstance(param.value, str) or param.value is None:
+                        continue  
+                    key = f"{param.id}_{node_index}_{i}"
+                    
+                    # Alternate between columns
+                    current_col = [col1, col2, col3, col4][i % 4]
+                    
+                    with current_col:
+                        if isinstance(param.value, (list, np.ndarray)):
+                            st.write(f"{param.id}:")
+                            value = display_and_edit_array(param.value, key)
+                        else:
+                            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
+                    
+                    param_inputs[param.id] = value
+        if stateful:
+            st.write("Simulation Parameters:")
+            with st.container(border=True):
+                # Add Simulation Duration and Time Step inputs
+                col1, col2 = st.columns(2)
+                with col1:
+                    sim_duration = st.text_input("Simulation Duration (s)", value=str(param_inputs["Simulation Duration (s)"]), key="sim_duration")
+                with col2:
+                    time_step = st.text_input("Time Step (s)", value=str(param_inputs["Time Step (s)"]), key="time_step")
+                
+                try:
+                    param_inputs["Simulation Duration (s)"] = float(sim_duration)
+                except ValueError:
+                    st.error("Invalid input for Simulation Duration. Please enter a valid number.")
+                    valid_inputs = False
+                try:
+                    param_inputs["Time Step (s)"] = float(time_step)
+                except ValueError:
+                    st.error("Invalid input for Time Step. Please enter a valid number.")
+                    valid_inputs = False
+
+        run_button = st.form_submit_button("Run Simulation")
+        
+    if run_button:
+        if valid_inputs:
+            for node in nodes:
+                for param in node.parameters:
+                    if param.id in param_inputs:
+                        param.value = param_inputs[param.id]
+            st.session_state.simulation_results = run_simulation(param_inputs, mdf_model, stateful)
+
+    view_tabs(mdf_model, param_inputs, stateful_nodes)
+
+def upload_file_and_load_to_model():
+   
+    uploaded_file = st.sidebar.file_uploader("Choose a JSON/YAML/BSON file", type=["json", "yaml", "bson"])
+    github_url = st.sidebar.text_input("Enter GitHub raw file URL:", placeholder="Enter GitHub raw file URL")
+    example_models = {
+        "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",
+        "Simple":"./examples/Simple.json",
+        # "Arrays":"./examples/Arrays.json",
+        # "RNN":"./examples/RNNs.json",
+        "IAF":"./examples/IAFs.json",
+        "Izhikevich Test":"./examples/IzhikevichTest.mdf.json"
+    }
+    selected_model = st.sidebar.selectbox("Choose an example model", list(example_models.keys()), index=None, placeholder="Dont have an MDF Model? Try some sample examples here!")
+    
+    if uploaded_file is not None:
+        file_content = uploaded_file.getvalue()
+        file_extension = uploaded_file.name.split('.')[-1].lower()
+        return load_model_from_content(file_content, file_extension)
+
+    if github_url:
+        try:
+            response = requests.get(github_url)
+            response.raise_for_status()
+            file_content = response.content
+            file_extension = github_url.split('.')[-1].lower()
+            return load_model_from_content(file_content, file_extension)
+        except requests.RequestException as e:
+            st.error(f"Error loading file from GitHub: {e}")
+            return None
+
+    
+    if selected_model:
+        return load_mdf_json(example_models[selected_model])
+
+
+
+def load_model_from_content(file_content, file_extension):
+    try:
+        if file_extension == 'json':
+            json_data = json.loads(file_content)
+            mdf_model = Model.from_dict(json_data)
+        elif file_extension in ['yaml', 'yml']:
+            mdf_model = load_mdf_yaml(io.BytesIO(file_content))
+        else:
+            st.error("Unsupported file format. Please use JSON or YAML files.")
+            return None
+        
+        st.session_state.original_mdf_model = mdf_model  # Save the original model
+        st.session_state.mdf_model_yaml = mdf_model  # Save the current model state
+        return mdf_model
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None
+
+
+def main():
+    if "checkbox" not in st.session_state:
+        st.session_state.checkbox = False
+    
+    
+    mdf_model = upload_file_and_load_to_model() # controller
+
+    if mdf_model:
+        header1, header2 = st.columns([1, 8], vertical_alignment="top")
+        with header1:
+            with st.container():
+                st.image("logo.jpg")
+        with header2:
+            with st.container():
+                st.title("MDF: "+ mdf_model.id)
+        
+        parameter_form_to_update_model_and_view(mdf_model)
+    else:
+        header1, header2 = st.columns([1, 8], vertical_alignment="top")
+        with header1:
+            with st.container():
+                st.image("logo.jpg")
+        with header2:
+            with st.container():
+                st.title("Welcome to Model Description Format")
+        st.write("ModECI (Model Exchange and Convergence Initiative) is a multi-investigator collaboration that aims to develop a standardized format for exchanging computational models across diverse software platforms and domains of scientific research and technology development, with a particular focus on neuroscience, Machine Learning and Artificial Intelligence. Refer to https://modeci.org/ for more.")
+        st.header("Lets get started! Choose one of the following methods.")
+if __name__ == "__main__":
+    main()
+
+
+

environment.yml

@@ -0,0 +1,9 @@
+name: my_environment
+channels:
+  - defaults
+dependencies:
+  - python
+  - pip
+  - modeci_mdf
+  - streamlit
+  - matplotlib

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/ABCD.mdf.json

@@ -0,0 +1,522 @@
+{
+    "ABCD": {
+        "format": "ModECI MDF v0.4",
+        "graphs": {
+            "ABCD": {
+                "notes": "Example of a simplified network",
+                "nodes": {
+                    "A_input": {
+                        "metadata": {
+                            "color": "0.2 0.2 0.2",
+                            "radius": 3,
+                            "region": "region1"
+                        },
+                        "parameters": {
+                            "variable": {
+                                "value": [
+                                    2.0
+                                ]
+                            },
+                            "spike": {
+                                "default_initial_value": [
+                                    0
+                                ],
+                                "conditions": {
+                                    "condition_0_on": {
+                                        "test": "OUTPUT < 0",
+                                        "value": 1
+                                    },
+                                    "condition_0_off": {
+                                        "test": "spike > 0",
+                                        "value": 0
+                                    }
+                                }
+                            },
+                            "V": {
+                                "value": 0
+                            },
+                            "OUTPUT": {
+                                "value": "variable"
+                            }
+                        },
+                        "input_ports": {
+                            "INPUT": {}
+                        },
+                        "output_ports": {
+                            "spike": {
+                                "value": "spike"
+                            },
+                            "V": {
+                                "value": "V"
+                            },
+                            "OUTPUT": {
+                                "value": "OUTPUT"
+                            }
+                        },
+                        "notes": "Cell: [Cell(notes=None, id='a_input', parameters={'variable': 'A_initial'}, neuroml2_source_file=None, lems_source_file='PNL.xml', neuroml2_cell=None, pynn_cell=None, arbor_cell=None, bindsnet_node=None)] is defined in PNL.xml and in Lems is: Component, id: a_input, type: inputNode,\n   parameters: {'variable': '2'}\n   parent: None\n"
+                    },
+                    "A": {
+                        "metadata": {
+                            "color": "0 0.9 0",
+                            "radius": 5,
+                            "region": "region1"
+                        },
+                        "parameters": {
+                            "slope": {
+                                "value": [
+                                    2.0
+                                ]
+                            },
+                            "intercept": {
+                                "value": [
+                                    2.0
+                                ]
+                            },
+                            "spike": {
+                                "default_initial_value": [
+                                    0
+                                ],
+                                "conditions": {
+                                    "condition_0_on": {
+                                        "test": "OUTPUT < 0",
+                                        "value": 1
+                                    },
+                                    "condition_0_off": {
+                                        "test": "spike > 0",
+                                        "value": 0
+                                    }
+                                }
+                            },
+                            "V": {
+                                "value": 0
+                            },
+                            "OUTPUT": {
+                                "value": "INPUT*slope + intercept"
+                            }
+                        },
+                        "input_ports": {
+                            "INPUT": {}
+                        },
+                        "output_ports": {
+                            "spike": {
+                                "value": "spike"
+                            },
+                            "V": {
+                                "value": "V"
+                            },
+                            "OUTPUT": {
+                                "value": "OUTPUT"
+                            }
+                        },
+                        "notes": "Cell: [Cell(notes=None, id='a', parameters=None, neuroml2_source_file=None, lems_source_file='PNL.xml', neuroml2_cell=None, pynn_cell=None, arbor_cell=None, bindsnet_node=None)] is defined in PNL.xml and in Lems is: Component, id: a, type: pnlLinearFunctionTM,\n   parameters: {'slope': '2', 'intercept': '2'}\n   parent: None\n"
+                    },
+                    "B": {
+                        "metadata": {
+                            "color": ".8 .8 .8",
+                            "radius": 5,
+                            "region": "region1"
+                        },
+                        "parameters": {
+                            "gain": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "bias": {
+                                "value": [
+                                    0.0
+                                ]
+                            },
+                            "x_0": {
+                                "value": [
+                                    0.0
+                                ]
+                            },
+                            "offset": {
+                                "value": [
+                                    0.0
+                                ]
+                            },
+                            "spike": {
+                                "default_initial_value": [
+                                    0
+                                ],
+                                "conditions": {
+                                    "condition_0_on": {
+                                        "test": "OUTPUT < 0",
+                                        "value": 1
+                                    },
+                                    "condition_0_off": {
+                                        "test": "spike > 0",
+                                        "value": 0
+                                    }
+                                }
+                            },
+                            "V": {
+                                "value": 0
+                            },
+                            "OUTPUT": {
+                                "value": "1/(1+numpy.exp(-1*gain*(INPUT + bias - x_0)+offset))"
+                            }
+                        },
+                        "input_ports": {
+                            "INPUT": {}
+                        },
+                        "output_ports": {
+                            "spike": {
+                                "value": "spike"
+                            },
+                            "V": {
+                                "value": "V"
+                            },
+                            "OUTPUT": {
+                                "value": "OUTPUT"
+                            }
+                        },
+                        "notes": "Cell: [Cell(notes=None, id='b', parameters=None, neuroml2_source_file=None, lems_source_file='PNL.xml', neuroml2_cell=None, pynn_cell=None, arbor_cell=None, bindsnet_node=None)] is defined in PNL.xml and in Lems is: Component, id: b, type: pnlLogisticFunctionTM,\n   parameters: {'gain': '1.0', 'bias': '0.0', 'x_0': '0.0', 'offset': '0.0'}\n   parent: None\n"
+                    },
+                    "C": {
+                        "metadata": {
+                            "color": "0.7 0.7 0.7",
+                            "radius": 5,
+                            "region": "region1"
+                        },
+                        "parameters": {
+                            "rate": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "bias": {
+                                "value": [
+                                    0.0
+                                ]
+                            },
+                            "scale": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "offset": {
+                                "value": [
+                                    0.0
+                                ]
+                            },
+                            "spike": {
+                                "default_initial_value": [
+                                    0
+                                ],
+                                "conditions": {
+                                    "condition_0_on": {
+                                        "test": "OUTPUT < 0",
+                                        "value": 1
+                                    },
+                                    "condition_0_off": {
+                                        "test": "spike > 0",
+                                        "value": 0
+                                    }
+                                }
+                            },
+                            "V": {
+                                "value": 0
+                            },
+                            "OUTPUT": {
+                                "value": "scale * numpy.exp((rate * INPUT) + bias) + offset"
+                            }
+                        },
+                        "input_ports": {
+                            "INPUT": {}
+                        },
+                        "output_ports": {
+                            "spike": {
+                                "value": "spike"
+                            },
+                            "V": {
+                                "value": "V"
+                            },
+                            "OUTPUT": {
+                                "value": "OUTPUT"
+                            }
+                        },
+                        "notes": "Cell: [Cell(notes=None, id='c', parameters=None, neuroml2_source_file=None, lems_source_file='PNL.xml', neuroml2_cell=None, pynn_cell=None, arbor_cell=None, bindsnet_node=None)] is defined in PNL.xml and in Lems is: Component, id: c, type: pnlExponentialFunctionTM,\n   parameters: {'rate': '1.0', 'bias': '0.0', 'scale': '1.0', 'offset': '0.0'}\n   parent: None\n"
+                    },
+                    "D": {
+                        "metadata": {
+                            "color": "0.7 0 0",
+                            "radius": 5,
+                            "region": "region1"
+                        },
+                        "parameters": {
+                            "rate": {
+                                "value": [
+                                    0.05
+                                ]
+                            },
+                            "time_step_size": {
+                                "value": [
+                                    0.1
+                                ]
+                            },
+                            "spike": {
+                                "default_initial_value": [
+                                    0
+                                ],
+                                "conditions": {
+                                    "condition_0_on": {
+                                        "test": "OUTPUT < 0",
+                                        "value": 1
+                                    },
+                                    "condition_0_off": {
+                                        "test": "spike > 0",
+                                        "value": 0
+                                    }
+                                }
+                            },
+                            "OUTPUT": {
+                                "time_derivative": "(rate * INPUT) / time_step_size",
+                                "default_initial_value": [
+                                    0
+                                ]
+                            },
+                            "V": {
+                                "value": 0
+                            }
+                        },
+                        "input_ports": {
+                            "INPUT": {}
+                        },
+                        "output_ports": {
+                            "spike": {
+                                "value": "spike"
+                            },
+                            "OUTPUT": {
+                                "value": "OUTPUT"
+                            },
+                            "V": {
+                                "value": "V"
+                            }
+                        },
+                        "notes": "Cell: [Cell(notes=None, id='d', parameters=None, neuroml2_source_file=None, lems_source_file='PNL.xml', neuroml2_cell=None, pynn_cell=None, arbor_cell=None, bindsnet_node=None)] is defined in PNL.xml and in Lems is: Component, id: d, type: pnlSimpleIntegratorMechanism,\n   parameters: {'rate': '0.05', 'time_step_size': '0.1s'}\n   parent: None\n"
+                    },
+                    "proj_input_rsDL": {
+                        "parameters": {
+                            "weight": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "SEC": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "rpeer": {
+                                "value": "peer_OUTPUT"
+                            },
+                            "I": {
+                                "value": "weight * rpeer"
+                            }
+                        },
+                        "input_ports": {
+                            "peer_OUTPUT": {}
+                        },
+                        "output_ports": {
+                            "I": {
+                                "value": "I"
+                            }
+                        },
+                        "notes": "Cell: [Synapse(notes=None, id='rsDL', parameters=None, neuroml2_source_file=None, lems_source_file='PNL.xml', pynn_synapse_type=None, pynn_receptor_type=None)] is defined in PNL.xml and in Lems is: Component, id: rsDL, type: synapseDL,\n   parameters: {}\n   parent: None\n"
+                    },
+                    "proj0_rsDL": {
+                        "parameters": {
+                            "weight": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "SEC": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "rpeer": {
+                                "value": "peer_OUTPUT"
+                            },
+                            "I": {
+                                "value": "weight * rpeer"
+                            }
+                        },
+                        "input_ports": {
+                            "peer_OUTPUT": {}
+                        },
+                        "output_ports": {
+                            "I": {
+                                "value": "I"
+                            }
+                        },
+                        "notes": "Cell: [Synapse(notes=None, id='rsDL', parameters=None, neuroml2_source_file=None, lems_source_file='PNL.xml', pynn_synapse_type=None, pynn_receptor_type=None)] is defined in PNL.xml and in Lems is: Component, id: rsDL, type: synapseDL,\n   parameters: {}\n   parent: None\n"
+                    },
+                    "proj1_rsDL": {
+                        "parameters": {
+                            "weight": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "SEC": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "rpeer": {
+                                "value": "peer_OUTPUT"
+                            },
+                            "I": {
+                                "value": "weight * rpeer"
+                            }
+                        },
+                        "input_ports": {
+                            "peer_OUTPUT": {}
+                        },
+                        "output_ports": {
+                            "I": {
+                                "value": "I"
+                            }
+                        },
+                        "notes": "Cell: [Synapse(notes=None, id='rsDL', parameters=None, neuroml2_source_file=None, lems_source_file='PNL.xml', pynn_synapse_type=None, pynn_receptor_type=None)] is defined in PNL.xml and in Lems is: Component, id: rsDL, type: synapseDL,\n   parameters: {}\n   parent: None\n"
+                    },
+                    "proj2_rsDL": {
+                        "parameters": {
+                            "weight": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "SEC": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "rpeer": {
+                                "value": "peer_OUTPUT"
+                            },
+                            "I": {
+                                "value": "weight * rpeer"
+                            }
+                        },
+                        "input_ports": {
+                            "peer_OUTPUT": {}
+                        },
+                        "output_ports": {
+                            "I": {
+                                "value": "I"
+                            }
+                        },
+                        "notes": "Cell: [Synapse(notes=None, id='rsDL', parameters=None, neuroml2_source_file=None, lems_source_file='PNL.xml', pynn_synapse_type=None, pynn_receptor_type=None)] is defined in PNL.xml and in Lems is: Component, id: rsDL, type: synapseDL,\n   parameters: {}\n   parent: None\n"
+                    },
+                    "proj3_rsDL": {
+                        "parameters": {
+                            "weight": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "SEC": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "rpeer": {
+                                "value": "peer_OUTPUT"
+                            },
+                            "I": {
+                                "value": "weight * rpeer"
+                            }
+                        },
+                        "input_ports": {
+                            "peer_OUTPUT": {}
+                        },
+                        "output_ports": {
+                            "I": {
+                                "value": "I"
+                            }
+                        },
+                        "notes": "Cell: [Synapse(notes=None, id='rsDL', parameters=None, neuroml2_source_file=None, lems_source_file='PNL.xml', pynn_synapse_type=None, pynn_receptor_type=None)] is defined in PNL.xml and in Lems is: Component, id: rsDL, type: synapseDL,\n   parameters: {}\n   parent: None\n"
+                    }
+                },
+                "edges": {
+                    "A_TO_proj_input_rsDL": {
+                        "name": "A_TO_proj_input_rsDL",
+                        "sender_port": "OUTPUT",
+                        "receiver_port": "peer_OUTPUT",
+                        "sender": "A",
+                        "receiver": "proj_input_rsDL"
+                    },
+                    "proj_input_rsDL_TO_B": {
+                        "name": "proj_input_rsDL_TO_B",
+                        "sender_port": "I",
+                        "receiver_port": "INPUT",
+                        "sender": "proj_input_rsDL",
+                        "receiver": "B"
+                    },
+                    "A_input_TO_proj0_rsDL": {
+                        "name": "A_input_TO_proj0_rsDL",
+                        "sender_port": "OUTPUT",
+                        "receiver_port": "peer_OUTPUT",
+                        "sender": "A_input",
+                        "receiver": "proj0_rsDL"
+                    },
+                    "proj0_rsDL_TO_A": {
+                        "name": "proj0_rsDL_TO_A",
+                        "sender_port": "I",
+                        "receiver_port": "INPUT",
+                        "sender": "proj0_rsDL",
+                        "receiver": "A"
+                    },
+                    "A_TO_proj1_rsDL": {
+                        "name": "A_TO_proj1_rsDL",
+                        "sender_port": "OUTPUT",
+                        "receiver_port": "peer_OUTPUT",
+                        "sender": "A",
+                        "receiver": "proj1_rsDL"
+                    },
+                    "proj1_rsDL_TO_C": {
+                        "name": "proj1_rsDL_TO_C",
+                        "sender_port": "I",
+                        "receiver_port": "INPUT",
+                        "sender": "proj1_rsDL",
+                        "receiver": "C"
+                    },
+                    "B_TO_proj2_rsDL": {
+                        "name": "B_TO_proj2_rsDL",
+                        "sender_port": "OUTPUT",
+                        "receiver_port": "peer_OUTPUT",
+                        "sender": "B",
+                        "receiver": "proj2_rsDL"
+                    },
+                    "proj2_rsDL_TO_D": {
+                        "name": "proj2_rsDL_TO_D",
+                        "sender_port": "I",
+                        "receiver_port": "INPUT",
+                        "sender": "proj2_rsDL",
+                        "receiver": "D"
+                    },
+                    "C_TO_proj3_rsDL": {
+                        "name": "C_TO_proj3_rsDL",
+                        "sender_port": "OUTPUT",
+                        "receiver_port": "peer_OUTPUT",
+                        "sender": "C",
+                        "receiver": "proj3_rsDL"
+                    },
+                    "proj3_rsDL_TO_D": {
+                        "name": "proj3_rsDL_TO_D",
+                        "sender_port": "I",
+                        "receiver_port": "INPUT",
+                        "sender": "proj3_rsDL",
+                        "receiver": "D"
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,144 @@
+{
+    "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",
+                "nodes": {
+                    "FNpop": {
+                        "metadata": {
+                            "color": "0.2 0.2 0.2",
+                            "radius": 3,
+                            "region": "region1"
+                        },
+                        "parameters": {
+                            "initial_w": {
+                                "value": [
+                                    0.0
+                                ]
+                            },
+                            "initial_v": {
+                                "value": [
+                                    -1.0
+                                ]
+                            },
+                            "a_v": {
+                                "value": [
+                                    -0.3333333333333333
+                                ]
+                            },
+                            "b_v": {
+                                "value": [
+                                    0.0
+                                ]
+                            },
+                            "c_v": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "d_v": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "e_v": {
+                                "value": [
+                                    -1.0
+                                ]
+                            },
+                            "f_v": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "time_constant_v": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "a_w": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "b_w": {
+                                "value": [
+                                    -0.8
+                                ]
+                            },
+                            "c_w": {
+                                "value": [
+                                    0.7
+                                ]
+                            },
+                            "time_constant_w": {
+                                "value": [
+                                    12.5
+                                ]
+                            },
+                            "threshold_exc": {
+                                "value": [
+                                    -1.0
+                                ]
+                            },
+                            "mode": {
+                                "value": [
+                                    1.0
+                                ]
+                            },
+                            "uncorrelated_activity": {
+                                "value": [
+                                    0.0
+                                ]
+                            },
+                            "Iext": {
+                                "value": [
+                                    0.0
+                                ]
+                            },
+                            "MSEC": {
+                                "value": [
+                                    0.001
+                                ]
+                            },
+                            "spike": {
+                                "value": [
+                                    0
+                                ]
+                            },
+                            "V": {
+                                "default_initial_value": "initial_v",
+                                "time_derivative": "(a_v*V*V*V + (1+threshold_exc)*b_v*V*V + (-1*threshold_exc)*c_v*V + d_v + e_v*W + f_v*Iext + INPUT) / (time_constant_v*MSEC)"
+                            },
+                            "W": {
+                                "default_initial_value": "initial_w",
+                                "time_derivative": "(mode*a_w*V + b_w*W + c_w + (1-mode)*uncorrelated_activity) / (time_constant_w*MSEC)"
+                            }
+                        },
+                        "input_ports": {
+                            "INPUT": {}
+                        },
+                        "output_ports": {
+                            "spike": {
+                                "value": "spike"
+                            },
+                            "V": {
+                                "value": "V"
+                            },
+                            "W": {
+                                "value": "W"
+                            }
+                        },
+                        "notes": "Cell: [Cell(notes=None, id='fn', parameters={'initial_w': 'initial_w', 'initial_v': 'initial_v', 'a_v': 'a_v', 'b_v': 'b_v', 'c_v': 'c_v', 'd_v': 'd_v', 'e_v': 'e_v', 'f_v': 'f_v', 'time_constant_v': 'time_constant_v', 'a_w': 'a_w', 'b_w': 'b_w', 'c_w': 'c_w', 'time_constant_w': 'time_constant_w', 'threshold': 'threshold', 'mode': 'mode', 'uncorrelated_activity': 'uncorrelated_activity', 'Iext': 'Iext'}, neuroml2_source_file=None, lems_source_file='FN_Definitions.xml', neuroml2_cell=None, pynn_cell=None, arbor_cell=None, bindsnet_node=None)] is defined in FN_Definitions.xml and in Lems is: Component, id: fn, type: fnCell,\n   parameters: {'initial_w': '0.0', 'initial_v': '-1', 'a_v': '-0.3333333333333333', 'b_v': '0.0', 'c_v': '1.0', 'd_v': '1', 'e_v': '-1.0', 'f_v': '1.0', 'time_constant_v': '1.0', 'a_w': '1.0', 'b_w': '-0.8', 'c_w': '0.7', 'time_constant_w': '12.5', 'threshold_exc': '-1.0', 'mode': '1.0', 'uncorrelated_activity': '0.0', 'Iext': '0'}\n   parent: None\n"
+                    }
+                },
+                "edges": {}
+            }
+        }
+    }
+}

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/IzhikevichTest.mdf.json

@@ -0,0 +1,196 @@
+{
+    "IzhikevichTest": {
+        "format": "ModECI MDF v0.4",
+        "metadata": {
+            "preferred_duration": 0.7,
+            "preferred_dt": 0.0005
+        },
+        "graphs": {
+            "IzhikevichTest": {
+                "notes": "Example Izhikevich",
+                "nodes": {
+                    "izhPop": {
+                        "parameters": {
+                            "v0": {
+                                "value": [
+                                    -0.08
+                                ]
+                            },
+                            "C": {
+                                "value": [
+                                    1e-10
+                                ]
+                            },
+                            "k": {
+                                "value": [
+                                    7e-07
+                                ]
+                            },
+                            "vr": {
+                                "value": [
+                                    -0.06
+                                ]
+                            },
+                            "vt": {
+                                "value": [
+                                    -0.04
+                                ]
+                            },
+                            "vpeak": {
+                                "value": [
+                                    0.035
+                                ]
+                            },
+                            "a": {
+                                "value": [
+                                    30.0
+                                ]
+                            },
+                            "b": {
+                                "value": [
+                                    -2e-09
+                                ]
+                            },
+                            "c": {
+                                "value": [
+                                    -0.05
+                                ]
+                            },
+                            "d": {
+                                "value": [
+                                    1e-10
+                                ]
+                            },
+                            "spike": {
+                                "default_initial_value": [
+                                    0
+                                ],
+                                "conditions": {
+                                    "condition_0_on": {
+                                        "test": "v > vpeak",
+                                        "value": 1
+                                    },
+                                    "condition_0_off": {
+                                        "test": "spike > 0",
+                                        "value": 0
+                                    }
+                                }
+                            },
+                            "v": {
+                                "default_initial_value": "v0",
+                                "conditions": {
+                                    "condition_0": {
+                                        "test": "v > vpeak",
+                                        "value": "c"
+                                    }
+                                },
+                                "time_derivative": "iMemb / C"
+                            },
+                            "u": {
+                                "default_initial_value": "0",
+                                "conditions": {
+                                    "condition_0": {
+                                        "test": "v > vpeak",
+                                        "value": "u + d"
+                                    }
+                                },
+                                "time_derivative": "a * (b * (v-vr) - u)"
+                            },
+                            "iSyn": {
+                                "value": "synapses_i"
+                            },
+                            "iMemb": {
+                                "value": "k * (v-vr) * (v-vt) + iSyn - u"
+                            }
+                        },
+                        "input_ports": {
+                            "synapses_i": {}
+                        },
+                        "output_ports": {
+                            "spike": {
+                                "value": "spike"
+                            },
+                            "v": {
+                                "value": "v"
+                            },
+                            "u": {
+                                "value": "u"
+                            },
+                            "iMemb": {
+                                "value": "iMemb"
+                            }
+                        },
+                        "notes": "Cell: [Cell(notes=None, id='izhCell', parameters={'v0': 'v0', 'C': 'C', 'k': 'k', 'vr': 'vr', 'vt': 'vt', 'vpeak': 'vpeak', 'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd'}, neuroml2_source_file=None, lems_source_file=None, neuroml2_cell='izhikevich2007Cell', pynn_cell=None, arbor_cell=None, bindsnet_node=None)] is defined in None and in Lems is: Component, id: izhCell, type: izhikevich2007Cell,\n   parameters: {'v0': '-80mV', 'C': '100 pF', 'k': '0.7 nS_per_mV', 'vr': '-60 mV', 'vt': '-40 mV', 'vpeak': '35 mV', 'a': '0.03 per_ms', 'b': '-2 nS', 'c': '-50 mV', 'd': '100 pA'}\n   parent: None\n"
+                    },
+                    "InputList_stim": {
+                        "parameters": {
+                            "amplitude": {
+                                "value": [
+                                    1e-10
+                                ]
+                            },
+                            "delay": {
+                                "value": [
+                                    0.1
+                                ]
+                            },
+                            "duration": {
+                                "value": [
+                                    0.5
+                                ]
+                            },
+                            "weight": {
+                                "value": [
+                                    1
+                                ]
+                            },
+                            "i": {
+                                "conditions": {
+                                    "condition_0": {
+                                        "test": "t < delay",
+                                        "value": "0"
+                                    },
+                                    "condition_1": {
+                                        "test": "t >= delay and t < duration + delay",
+                                        "value": "weight * amplitude"
+                                    },
+                                    "condition_2": {
+                                        "test": "t >= duration + delay",
+                                        "value": "0"
+                                    }
+                                }
+                            },
+                            "t": {
+                                "default_initial_value": 0,
+                                "time_derivative": "1"
+                            }
+                        },
+                        "input_ports": {
+                            "spike_input": {
+                                "shape": [
+                                    1
+                                ],
+                                "reduce": "add"
+                            }
+                        },
+                        "output_ports": {
+                            "i": {
+                                "value": "i"
+                            }
+                        },
+                        "notes": "Cell: [InputSource(notes=None, id='iclamp_0', parameters={'amplitude': 'stim_amp', 'delay': 'delay', 'duration': 'duration'}, neuroml2_source_file=None, neuroml2_input='pulseGenerator', lems_source_file=None, pynn_input=None)] is defined in None and in Lems is: Component, id: iclamp_0, type: pulseGenerator,\n   parameters: {'amplitude': '100pA', 'delay': '100ms', 'duration': '500ms'}\n   parent: None\n"
+                    }
+                },
+                "edges": {
+                    "Edge InputList_stim to izhPop": {
+                        "name": "Edge InputList_stim to izhPop",
+                        "sender_port": "i",
+                        "receiver_port": "synapses_i",
+                        "sender": "InputList_stim",
+                        "receiver": "izhPop"
+                    }
+                }
+            }
+        }
+    }
+}

examples/NewtonCoolingModel.json

@@ -0,0 +1,54 @@
+{
+    "NewtonCoolingModel": {
+        "format": "ModECI MDF v0.4",
+        "generating_application": "Python modeci-mdf v0.4.11",
+        "metadata": {
+            "preferred_duration": 100,
+            "preferred_dt": 0.01
+        },
+        "graphs": {
+            "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
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "T_curr"
+                            },
+                            "out_port2": {
+                                "value": "dT_dt"
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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/Simple.json

@@ -0,0 +1,73 @@
+{
+    "Simple": {
+        "format": "ModECI MDF v0.4",
+        "generating_application": "Python modeci-mdf v0.4.11",
+        "graphs": {
+            "simple_example": {
+                "nodes": {
+                    "input_node": {
+                        "parameters": {
+                            "input_level": {
+                                "value": 0.5
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "input_level"
+                            }
+                        }
+                    },
+                    "processing_node": {
+                        "input_ports": {
+                            "input_port1": {}
+                        },
+                        "parameters": {
+                            "lin_slope": {
+                                "value": 0.5
+                            },
+                            "lin_intercept": {
+                                "value": 0
+                            },
+                            "log_gain": {
+                                "value": 3
+                            },
+                            "linear_1": {
+                                "function": "linear",
+                                "args": {
+                                    "variable0": "input_port1",
+                                    "slope": "lin_slope",
+                                    "intercept": "lin_intercept"
+                                }
+                            },
+                            "logistic_1": {
+                                "function": "logistic",
+                                "args": {
+                                    "variable0": "linear_1",
+                                    "gain": "log_gain",
+                                    "bias": 0,
+                                    "offset": 0
+                                }
+                            }
+                        },
+                        "output_ports": {
+                            "output_1": {
+                                "value": "logistic_1"
+                            }
+                        }
+                    }
+                },
+                "edges": {
+                    "input_edge": {
+                        "sender": "input_node",
+                        "receiver": "processing_node",
+                        "sender_port": "out_port",
+                        "receiver_port": "input_port1",
+                        "parameters": {
+                            "weight": 0.55
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

examples/States.json

@@ -0,0 +1,54 @@
+{
+    "States": {
+        "format": "ModECI MDF v0.4",
+        "generating_application": "Python modeci-mdf v0.4.11",
+        "metadata": {
+            "preferred_duration": 10,
+            "preferred_dt": 0.01
+        },
+        "graphs": {
+            "state_example": {
+                "nodes": {
+                    "counter_node": {
+                        "parameters": {
+                            "increment": {
+                                "value": 1
+                            },
+                            "count": {
+                                "value": "count + increment"
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "count"
+                            }
+                        }
+                    },
+                    "sine_node": {
+                        "parameters": {
+                            "amp": {
+                                "value": 3
+                            },
+                            "period": {
+                                "value": 0.4
+                            },
+                            "level": {
+                                "default_initial_value": 0,
+                                "time_derivative": "6.283185 * rate / period"
+                            },
+                            "rate": {
+                                "default_initial_value": 1,
+                                "time_derivative": "-1 * 6.283185 * level / period"
+                            }
+                        },
+                        "output_ports": {
+                            "out_port": {
+                                "value": "amp * level"
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

examples/switched_rlc_circuit.json

@@ -0,0 +1,90 @@
+{   
+    "SwitchedRLC_Circuit": {
+        
+        "format": "ModECI MDF v0.4",
+        "generating_application": "Python modeci-mdf v0.4.10",
+        "metadata": {
+            "preferred_duration": 2,
+            "preferred_dt": 0.001
+        },
+        "graphs": {
+         
+            "SwitchedRLC_Circuit": {
+                "nodes": {
+                   
+                    "V": {
+                        "parameters": {
+                            "Vs": {
+                                "value":"0.5"
+                            },
+                            "R": {
+                                "metadata": {
+                                    "description": "Resistance in Ohms"
+                                },
+                                "value": 100
+                            },
+                            "L": {
+                                "metadata": {
+                                    "description": "Inductance in Henrys"
+                                },
+                                "value": 1
+                            },
+                            "C": {
+                                "metadata": {
+                                    "description": "Capacitance in Farads"
+                                },
+                                "value": 0.001
+                            },
+                            "time": {
+                                "default_initial_value": 0,
+                                "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"
+                            }
+                        },
+                        "output_ports": {
+                            "V_out": {
+                                "value": "V"
+                            },
+                            "i_L_out": {
+                                "value": "i_L"
+                            }
+                            
+                        }
+                    }
+                }
+                
+            }
+            
+            
+        }
+    }
+}

packages.txt

@@ -0,0 +1 @@
+graphviz

requirements.txt

@@ -0,0 +1,9 @@
+streamlit 
+modeci_mdf
+matplotlib==3.5.1
+graphviz 
+ipython
+torch
+modelspec
+graph_scheduler
+streamlit-code-editor