superneuroabm 1.0.0__py3-none-any.whl

superneuroabm/step_functions/synapse/stdp/Three_bit_exp_pair_wise.py

@@ -0,0 +1,133 @@
+"""
+Exponential STDP (Spike-Timing Dependent Plasticity) step function for spiking neural networks
+
+"""
+
+import cupy as cp
+from cupyx import jit
+
+from superneuroabm.step_functions.synapse.util import get_soma_spike
+
+
+@jit.rawkernel(device="cuda")
+def exp_pair_wise_stdp_quantized(
+    tick,
+    agent_index,
+    globals,
+    agent_ids,
+    breeds,
+    locations,
+    synapse_params,  # scale, time constant (tau_rise and tau_fall)
+    learning_params,
+    internal_state,  #
+    internal_learning_state,  # learning state variables
+    synapse_history,  # delay
+    input_spikes_tensor,  # input spikes
+    output_spikes_tensor,
+    internal_states_buffer,
+    internal_learning_states_buffer,
+):
+    t_current = int(tick)
+
+    dt = globals[0]  # time step size
+
+    # Get the synapse parameters:
+    weight = synapse_params[agent_index][0]
+    synaptic_delay = synapse_params[agent_index][1]
+
+    # Get the learning parameters:
+    # stdpType = 0 # Parsed in the learning rule selector
+    tau_pre_stdp = learning_params[agent_index][1]
+    tau_post_stdp = learning_params[agent_index][2]
+    a_exp_pre = learning_params[agent_index][3]
+    a_exp_post = learning_params[agent_index][4]
+    stdp_history_length = learning_params[agent_index][5]
+    # Wmax, Wmin
+
+    pre_trace = internal_learning_state[agent_index][0]
+    post_trace = internal_learning_state[agent_index][1]
+    dW = internal_learning_state[agent_index][2]
+
+    # Get pre and post soma IDs from connectivity (contains agent IDs, not converted by SAGESim)
+    pre_soma_index = locations[agent_index][0]
+    post_soma_index = locations[agent_index][1]
+
+    # Get the pre-soma spike
+    pre_soma_spike = get_soma_spike(
+        tick,
+        agent_index,
+        globals,
+        agent_ids,
+        pre_soma_index,
+        t_current,
+        input_spikes_tensor,
+        output_spikes_tensor,
+    )
+
+    post_soma_spike = get_soma_spike(
+        tick,
+        agent_index,
+        globals,
+        agent_ids,
+        post_soma_index,
+        t_current,
+        input_spikes_tensor,
+        output_spikes_tensor,
+    )
+
+    pre_trace = pre_trace * (1 - dt / tau_pre_stdp) + pre_soma_spike * a_exp_pre
+    post_trace = post_trace * (1 - dt / tau_post_stdp) + post_soma_spike * a_exp_post
+    dW = pre_trace * post_soma_spike - post_trace * pre_soma_spike
+
+    weight += dW  # Update the weight
+
+    # === 3-bit quantization ===
+    wmin = learning_params[agent_index][6]  #0.0 #learning_params[agent_index][6]  # assuming stored in learning_params
+    wmax = learning_params[agent_index][7]  #14.0 #learning_params[agent_index][7]
+    num_levels = learning_params[agent_index][8] #8  # 3 bits -> 8 quantization levels#learning_params[agent_index][8]
+    delta = (wmax - wmin) / (num_levels - 1)
+    # weight = cp.clip(weight, wmin, wmax)
+    weight = weight if weight <= wmax else wmax
+    weight = weight if weight >= wmin else wmin
+    # quantized_weight = cp.round((weight - wmin) / delta) * delta + wmin
+    quantized_weight = cp.rint((weight - wmin) / delta) * delta + wmin
+    # quantized_weight = int((weight - wmin) / delta + 0.5) * delta + wmin
+    weight = quantized_weight
+    # ==========================
+
+    synapse_params[agent_index][0] = weight  # Update quantized weight
+
+    internal_learning_state[agent_index][0] = pre_trace
+    internal_learning_state[agent_index][1] = post_trace
+    internal_learning_state[agent_index][2] = dW
+
+    # Safe buffer indexing: use modulo to prevent out-of-bounds access
+    # When tracking is disabled, buffer length is 1, so t_current % 1 = 0 always
+    buffer_idx = t_current % len(internal_learning_states_buffer[agent_index])
+    internal_learning_states_buffer[agent_index][buffer_idx][0] = pre_trace
+    internal_learning_states_buffer[agent_index][buffer_idx][1] = post_trace
+    internal_learning_states_buffer[agent_index][buffer_idx][2] = dW
+
+    # spike_pre_[t_current] = pre_soma_spike #spike_pre_ is an array of size (stdp_history_length, number of input neurons), pre_soma_spike is (number of input neurons,)
+    # spike_post_[:, t_current] = post_soma_spike#spike_post_ is an array of size (number of output neurons,stdp_history_length), post_soma_spike is (number of output neurons,)
+    # trace_pre_[t_current] = pre_trace #Corresponding traces an array of size (stdp_history_length,number of input neurons), pre_trace is (number of input neurons,)
+    # trace_post_[:, t_current] = post_trace #Corresponding traces is an array of size (number of output neurons,stdp_history_length)
+
+    # if t_current == stdp_history_length:
+    #     dW = cp.dot(spike_post_, trace_pre_)#(1,stdp_history_length) dot (stdp_history_length,1) we might need additional learning rate and multiplicative STDP*(wmax - W)*
+    #     dW -=cp.dot(trace_post_, spike_pre_)#(1,stdp_history_length) dot (stdp_history_length,1),  add learning rat*W for multiplicative STDP
+    #     clipped_dW = cp.clip(dW / stdp_history_length, dw_max, dw_min)  # Clip the weight change if needed
+    #     weight = cp.clip(weight+clipped_dW,wmin, wmax)  # Update the weight
+    #     #reset the traces and spikes buffers
+    #     spike_pre_ = cp.zeros((stdp_history_length, number_of_input_neurons), dtype=cp.float32)
+    #     spike_post_ = cp.zeros((number_of_output_neurons, stdp_history_length), dtype=cp.float32)
+    #     trace_pre_ = cp.zeros((stdp_history_length, number_of_input_neurons), dtype=cp.float32)
+    #     trace_post_ = cp.zeros((number_of_output_neurons, stdp_history_length), dtype=cp.float32)
+
+    internal_state[agent_index][2] = pre_trace
+    internal_state[agent_index][3] = post_trace
+
+    # Safe buffer indexing for internal_states_buffer (reuse buffer_idx from above)
+    state_buffer_idx = t_current % len(internal_states_buffer[agent_index])
+    internal_states_buffer[agent_index][state_buffer_idx][2] = post_soma_spike
+    internal_states_buffer[agent_index][state_buffer_idx][3] = post_trace

superneuroabm/step_functions/synapse/stdp/exp_pair_wise_stdp.py

@@ -0,0 +1,119 @@
+"""
+Exponential STDP (Spike-Timing Dependent Plasticity) step function for spiking neural networks
+
+"""
+
+import cupy as cp
+from cupyx import jit
+
+from superneuroabm.step_functions.synapse.util import get_soma_spike
+
+
+@jit.rawkernel(device="cuda")
+def exp_pair_wise_stdp(
+    tick,
+    agent_index,
+    globals,
+    agent_ids,
+    breeds,
+    locations,
+    synapse_params,  # scale, time constant (tau_rise and tau_fall)
+    learning_params,
+    internal_state,  #
+    internal_learning_state,  # learning state variables
+    synapse_history,  # delay
+    input_spikes_tensor,  # input spikes
+    output_spikes_tensor,
+    internal_states_buffer,
+    internal_learning_states_buffer,
+):
+    t_current = int(tick)
+
+    dt = globals[0]  # time step size
+
+    # Get the synapse parameters:
+    weight = synapse_params[agent_index][0]
+    synaptic_delay = synapse_params[agent_index][1]
+
+    # Get the learning parameters:
+    # stdpType = 0 # Parsed in the learning rule selector
+    tau_pre_stdp = learning_params[agent_index][1]
+    tau_post_stdp = learning_params[agent_index][2]
+    a_exp_pre = learning_params[agent_index][3]
+    a_exp_post = learning_params[agent_index][4]
+    stdp_history_length = learning_params[agent_index][5]
+    # Wmax, Wmin
+
+    pre_trace = internal_learning_state[agent_index][0]
+    post_trace = internal_learning_state[agent_index][1]
+    dW = internal_learning_state[agent_index][2]
+
+    # locations[agent_index] = [pre_soma_index, post_soma_index]
+    # SAGESim has already converted agent IDs to local indices
+    pre_soma_index = locations[agent_index][0]
+    post_soma_index = locations[agent_index][1]
+
+    # Get the pre-soma spike
+    pre_soma_spike = get_soma_spike(
+        tick,
+        agent_index,
+        globals,
+        agent_ids,
+        pre_soma_index,
+        t_current,
+        input_spikes_tensor,
+        output_spikes_tensor,
+    )
+
+    post_soma_spike = get_soma_spike(
+        tick,
+        agent_index,
+        globals,
+        agent_ids,
+        post_soma_index,
+        t_current,
+        input_spikes_tensor,
+        output_spikes_tensor,
+    )
+
+    pre_trace = pre_trace * (1 - dt / tau_pre_stdp) + pre_soma_spike * a_exp_pre
+    post_trace = post_trace * (1 - dt / tau_post_stdp) + post_soma_spike * a_exp_post
+    dW = pre_trace * post_soma_spike - post_trace * pre_soma_spike
+
+    weight += dW  # Update the weight
+    synapse_params[agent_index][0] = weight  # Update the weight in synapse_params
+
+    internal_learning_state[agent_index][0] = pre_trace
+    internal_learning_state[agent_index][1] = post_trace
+    internal_learning_state[agent_index][2] = dW
+
+    # Safe buffer indexing: use modulo to prevent out-of-bounds access
+    # When tracking is disabled, buffer length is 1, so t_current % 1 = 0 always
+    buffer_idx = t_current % len(internal_learning_states_buffer[agent_index])
+    internal_learning_states_buffer[agent_index][buffer_idx][0] = pre_trace
+    internal_learning_states_buffer[agent_index][buffer_idx][1] = post_trace
+    internal_learning_states_buffer[agent_index][buffer_idx][2] = dW
+
+    # spike_pre_[t_current] = pre_soma_spike #spike_pre_ is an array of size (stdp_history_length, number of input neurons), pre_soma_spike is (number of input neurons,)
+    # spike_post_[:, t_current] = post_soma_spike#spike_post_ is an array of size (number of output neurons,stdp_history_length), post_soma_spike is (number of output neurons,)
+    # trace_pre_[t_current] = pre_trace #Corresponding traces an array of size (stdp_history_length,number of input neurons), pre_trace is (number of input neurons,)
+    # trace_post_[:, t_current] = post_trace #Corresponding traces is an array of size (number of output neurons,stdp_history_length)
+
+    # if t_current == stdp_history_length:
+    #     dW = cp.dot(spike_post_, trace_pre_)#(1,stdp_history_length) dot (stdp_history_length,1) we might need additional learning rate and multiplicative STDP*(wmax - W)*
+    #     dW -=cp.dot(trace_post_, spike_pre_)#(1,stdp_history_length) dot (stdp_history_length,1),  add learning rat*W for multiplicative STDP
+    #     clipped_dW = cp.clip(dW / stdp_history_length, dw_max, dw_min)  # Clip the weight change if needed
+    #     weight = cp.clip(weight+clipped_dW,wmin, wmax)  # Update the weight
+    #     #reset the traces and spikes buffers
+    #     spike_pre_ = cp.zeros((stdp_history_length, number_of_input_neurons), dtype=cp.float32)
+    #     spike_post_ = cp.zeros((number_of_output_neurons, stdp_history_length), dtype=cp.float32)
+    #     trace_pre_ = cp.zeros((stdp_history_length, number_of_input_neurons), dtype=cp.float32)
+    #     trace_post_ = cp.zeros((number_of_output_neurons, stdp_history_length), dtype=cp.float32)
+
+    internal_state[agent_index][2] = pre_trace
+    internal_state[agent_index][3] = post_trace
+
+    # Safe buffer indexing for internal_states_buffer (reuse buffer_idx from above)
+    state_buffer_idx = t_current % len(internal_states_buffer[agent_index])
+    internal_states_buffer[agent_index][state_buffer_idx][2] = post_soma_spike
+    internal_states_buffer[agent_index][state_buffer_idx][3] = post_trace

superneuroabm/step_functions/synapse/stdp/learning_rule_selector.py

@@ -0,0 +1,72 @@
+from cupyx import jit
+
+from superneuroabm.step_functions.synapse.util import get_soma_spike
+from superneuroabm.step_functions.synapse.stdp.exp_pair_wise_stdp import (
+    exp_pair_wise_stdp,
+)
+from superneuroabm.step_functions.synapse.stdp.Three_bit_exp_pair_wise import (
+    exp_pair_wise_stdp_quantized,
+)
+
+
+@jit.rawkernel(device="cuda")
+def learning_rule_selector(
+    tick,
+    agent_index,
+    globals,
+    agent_ids,
+    breeds,
+    locations,
+    synapse_params,
+    learning_params,  # STDP_function name,
+    internal_state,  #
+    internal_learning_state,
+    synapse_history,  # delay
+    input_spikes_tensor,  # input spikes
+    output_spikes_tensor,
+    internal_states_buffer,
+    internal_learning_states_buffer,
+):
+
+    stdpType = learning_params[agent_index][0]  # 0 for None, 1 for exp_pair_wise_stdp
+    # Wmax, Wmin
+    if stdpType == -1:
+        pass
+    elif stdpType == 0:
+
+        exp_pair_wise_stdp(
+            tick,
+            agent_index,
+            globals,
+            agent_ids,
+            breeds,
+            locations,
+            synapse_params,  # scale, time constant (tau_rise and tau_fall)
+            learning_params,
+            internal_state,  #
+            internal_learning_state,  # learning state variables
+            synapse_history,  # delay
+            input_spikes_tensor,  # input spikes
+            output_spikes_tensor,
+            internal_states_buffer,
+            internal_learning_states_buffer,
+        )
+    elif stdpType == 1:
+
+        exp_pair_wise_stdp_quantized(
+            tick,
+            agent_index,
+            globals,
+            agent_ids,
+            breeds,
+            locations,
+            synapse_params,  # scale, time constant (tau_rise and tau_fall)
+            learning_params,
+            internal_state,  #
+            internal_learning_state,  # learning state variables
+            synapse_history,  # delay
+            input_spikes_tensor,  # input spikes
+            output_spikes_tensor,
+            internal_states_buffer,
+            internal_learning_states_buffer,
+        )

superneuroabm/step_functions/synapse/util.py

@@ -0,0 +1,49 @@
+import math
+import cupy as cp
+from cupyx import jit
+
+
+@jit.rawkernel(device="cuda")
+def get_soma_spike(
+    tick,
+    agent_index,
+    globals,
+    agent_ids,
+    pre_soma_index,  # Used to be pre_soma_id, now it's already an index
+    t_current,
+    input_spikes_tensor,  # input spikes
+    output_spikes_tensor,
+):
+    """
+    Get spike from pre-soma using its local index (already converted by SAGESim).
+
+    Args:
+        pre_soma_index: Local index of the pre-synaptic soma (-1 for external input)
+        globals, agent_ids: Kept for signature compatibility, not used anymore
+
+    NOTE: Due to double buffering, this reads from the PREVIOUS tick's spikes.
+    Somas write spikes at priority 0, synapses read at priority 1, but the
+    write buffer isn't copied to read buffer until after all priorities complete.
+    This introduces a 1-tick synaptic delay, which is actually realistic.
+    """
+    t_current = int(tick)
+
+    if pre_soma_index >= 0:
+        # pre_soma_index is already a local index (no search needed!)
+        # At tick 0, there are no previous spikes, so spike will be 0
+        if t_current > 0:
+            spike = output_spikes_tensor[pre_soma_index][t_current - 1]
+        else:
+            spike = 0.0
+    else:
+        spike = 0.0
+        spike_buffer_max_len = len(input_spikes_tensor[agent_index])
+        i = 0
+
+        # input_spikes_tensor is now flattened as [tick, value, tick, value, ...]
+        # Check i+1 < max_len to avoid reading past array bounds!
+        while i + 1 < spike_buffer_max_len and not cp.isnan(input_spikes_tensor[agent_index][i]):
+            if input_spikes_tensor[agent_index][i] == t_current:      # tick at even index
+                spike += input_spikes_tensor[agent_index][i+1]        # value at odd index
+            i += 2  # Skip by 2 to move to next tick (not i+1!)
+    return spike

superneuroabm/util.py

@@ -0,0 +1,38 @@
+"""
+SuperNeuroABM utilities
+
+"""
+
+from pathlib import Path
+
+import yaml
+
+
+current_dir = Path(__file__).parent
+base_config_fpath = current_dir / "component_base_config.yaml"
+
+
+def load_component_configurations(config_file: str = base_config_fpath) -> dict:
+    """
+    Load component configurations from a YAML file.
+
+    Args:
+        config_file: Path to the YAML configuration file.
+
+    Returns:
+        A dictionary containing the component configurations.
+    """
+    with open(config_file, "r", encoding="utf-8") as f:
+        configurations = yaml.safe_load(f)
+        # Make sure all end values are floats
+        for component_class in configurations:
+            for breed in configurations[component_class]:
+                for config_name in configurations[component_class][breed]:
+                    for type in configurations[component_class][breed][config_name]:
+                        for key, value in configurations[component_class][breed][
+                            config_name
+                        ][type].items():
+                            configurations[component_class][breed][config_name][type][
+                                key
+                            ] = float(value)
+    return configurations

superneuroabm-1.0.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: superneuroabm
+Version: 1.0.0
+Summary: A GPU-based multi-agent simulation framework for neuromorphic computing.
+Home-page: https://github.com/ORNL/superneuroabm
+Author: Chathika Gunaratne, Shruti Kulkarni, Ashish Gautam, Xi Zhang, Prasanna Date
+Author-email: gunaratnecs@ornl.gov
+License: BSD-3-Clause
+Project-URL: Source, https://github.com/ORNL/superneuroabm
+Project-URL: Bug Tracker, https://github.com/ORNL/superneuroabm/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sagesim==0.5.0
+Requires-Dist: pyyaml
+Requires-Dist: networkx
+Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SuperNeuroABM
+
+**SuperNeuroABM** is a GPU-based multi-agent simulation framework for neuromorphic computing. Built on top of [SAGESim](https://github.com/ORNL/SAGESim), it enables fast and scalable simulation of spiking neural networks on both NVIDIA and AMD GPUs.
+
+## Key Features
+
+- **GPU Acceleration**: Leverages CUDA (NVIDIA) or ROCm (AMD) for high-performance simulation
+- **Scalable**: From single GPU to multi-GPU HPC clusters via MPI
+- **Flexible Neuron Models**: Support for various soma and synapse step functions
+- **STDP Support**: Built-in spike-timing-dependent plasticity mechanisms
+- **Network I/O**: Import/export neural network topologies
+
+## Requirements
+
+- Python 3.11+
+- NVIDIA GPU with CUDA drivers **or** AMD GPU with ROCm 5.7.1+
+- MPI implementation (OpenMPI, MPICH, etc.) for multi-GPU execution
+
+## Installation
+
+Your system might require specific steps to install `mpi4py` and/or `cupy` depending on your hardware. In that case, use your system's recommended instructions to install these dependencies first.
+
+```bash
+pip install superneuroabm
+```
+
+## Quick Start
+
+```python
+from superneuroabm.model import SuperNeuroModel
+
+# Create model
+model = SuperNeuroModel()
+
+# Create neurons
+n1 = model.create_neuron()
+n2 = model.create_neuron()
+
+# Connect with synapse
+model.create_synapse(n1, n2, weight=1.0)
+
+# Setup and run
+model.setup(use_gpu=True)
+model.simulate(ticks=100)
+```
+
+## Unit Tests
+
+To run unit tests:
+
+```bash
+python -m unittest tests.test_synapse_and_soma_models
+```
+
+## Publications
+
+[Date, Prasanna, Chathika Gunaratne, Shruti R. Kulkarni, Robert Patton, Mark Coletti, and Thomas Potok. "SuperNeuro: A fast and scalable simulator for neuromorphic computing." In Proceedings of the 2023 International Conference on Neuromorphic Systems, pp. 1-4. 2023.](https://dl.acm.org/doi/abs/10.1145/3589737.3606000)
+
+## License
+
+BSD-3-Clause License - Oak Ridge National Laboratory

superneuroabm-1.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+superneuroabm/__init__.py,sha256=Iai-c25bZkqC-wMZ8wjYwd524ZpliVV9rM_ZTnIPSMU,96
+superneuroabm/component_base_config.yaml,sha256=g8Mhejh_aNelqDZ6hhOCs9keEZj9KZhB-mzpukgr1Bk,4858
+superneuroabm/model.py,sha256=TsN1-ehGir8Gc3xKS6ObfyxxJMLFVvGu0jJ6tJhNL_A,29711
+superneuroabm/util.py,sha256=lAS9Ui42F5w0bIRQ4_TKHymwK3IhmYj3b9oJzcBIU8I,1236
+superneuroabm/io/__init__.py,sha256=ml5mbnr9Y74h2ACu959i5XbWzEFefBojeIhPtQFJGNk,50
+superneuroabm/io/nx.py,sha256=0WyuWRIYLRbvNgTGIMiNWDIQ-Cb5SXzsrKk4_SbV8x4,15966
+superneuroabm/io/synthetic_networks.py,sha256=TO5VnXGGk8QmAQabjgsuzALYAKj3EUBwkZL8p9s5icI,32649
+superneuroabm/step_functions/soma/izh.py,sha256=uZrZRII0b2SrqCTpxpVixapdeG9CuYwTod2alAyRvOw,2983
+superneuroabm/step_functions/soma/lif.py,sha256=Wjq03h6dhoeUUKU0qAHP-8wNauNSm-gq_9c7IZJymss,3740
+superneuroabm/step_functions/soma/lif_soma_adaptive_thr.py,sha256=cf5ShkcV0L8pYaBRnDkB9YtmWzT2YWwqmBzBIFpVyz8,4517
+superneuroabm/step_functions/synapse/single_exp.py,sha256=CJu27OeyEtXr9IDva4zPggbLVaF3ast9pgUtymlIdJc,2059
+superneuroabm/step_functions/synapse/util.py,sha256=YDhy8BiYEfhX7JLXG_y-XlrSTVAe-OBiphkrRrCdjuQ,1855
+superneuroabm/step_functions/synapse/stdp/Low_resolution_synapse.py,sha256=CnqanSudAPM3jRec46IZ4YM-NebYA6y8shyj9BiV3P8,4729
+superneuroabm/step_functions/synapse/stdp/Three-bit_exp_pair_wise.py,sha256=wYQGxMkVOQfH-GQrSBCaMV7XvczHyPON7FMzAlbi4wA,5578
+superneuroabm/step_functions/synapse/stdp/Three_bit_exp_pair_wise.py,sha256=DRPVcBUanL8rZNtkpTmltMcPSd_v8GVVqytKSjhf7b4,5919
+superneuroabm/step_functions/synapse/stdp/exp_pair_wise_stdp.py,sha256=IgktItPgVLN3CvwG0OhrYrBPp9ap7MErbk3t80hY8o4,5128
+superneuroabm/step_functions/synapse/stdp/learning_rule_selector.py,sha256=UTFZLNiBE7Jk9woqbcfabIdTp-1g0CviXlMAgtF4sbk,2075
+superneuroabm-1.0.0.dist-info/licenses/LICENSE,sha256=fbF_nc2RGJWubxK8nWWphBUDBLT1TsdqSydSzTHUZGA,1544
+superneuroabm-1.0.0.dist-info/METADATA,sha256=-2a9L5KntOGo5hnzpXBIO6flUG_-aprf9y3u9J5lwc4,3280
+superneuroabm-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+superneuroabm-1.0.0.dist-info/top_level.txt,sha256=8ZFp3qGDYMaQXEzM4vDONgYPC-MCSUWrWamYPSplAGw,14
+superneuroabm-1.0.0.dist-info/RECORD,,

superneuroabm-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

superneuroabm-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Oak Ridge National Laboratory
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

superneuroabm-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+superneuroabm