PDP-OmniSim/
├── Core/
│   ├── Simulation Engine (Event-driven core)
│   ├── Scheduler (Priority-based event queue)
│   └── Metrics Collector (Real-time analytics)
├── Models/
│   ├── Network Topologies (Graph-based models)
│   ├── Processing Units (CPU/GPU abstractions)
│   └── Communication Protocols (Message passing)
├── Analysis/
│   ├── Statistical Tools (Hypothesis testing)
│   ├── Visualization (Multi-dimensional plots)
│   └── Benchmarking (Performance metrics)
└── Applications/
    ├── Neuroscience (Neural mass models)
    ├── Distributed Computing (Load balancing)
    └── Complex Systems (Cascade failures)

# Small-world networks (Watts-Strogatz)
C = p * ln(N) / N  # Clustering coefficient
L ~ ln(N) / ln(K)  # Characteristic path length

# Scale-free networks (Barabási-Albert)
P(k) ~ k^(-γ)      # Power-law degree distribution

# Wilson-Cowan model for neural populations
dE/dt = -E + S(c₁*E - c₂*I + P)
dI/dt = -I + S(c₃*E - c₄*I + Q)

pip install pdp-omnisim

git clone https://github.com/tlcagford/PDP-OmniSim
cd PDP-OmniSim

# Create virtual environment
python -m venv pdp_env
source pdp_env/bin/activate  # Windows: pdp_env\Scripts\activate

# Install with development dependencies
pip install -e ".[dev]"

# Verify installation
python -c "import pdp_omnisim; print('Installation successful!')"

import pdp_omnisim as pdp
import numpy as np
import matplotlib.pyplot as plt

# Create a neural mass model simulation
sim_config = {
    "num_populations": 4,
    "connectivity": "small_world",
    "simulation_time": 10.0,  # seconds
    "time_step": 0.001,       # 1ms resolution
    "noise_level": 0.1
}

simulator = pdp.NeuralMassSimulator(**sim_config)
results = simulator.run()

# Analyze results
power_spectrum = pdp.analysis.spectral_analysis(results.timeseries)
phase_synchronization = pdp.analysis.phase_sync(results.timeseries)

# Visualize
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
pdp.visualization.plot_timeseries(results.timeseries, ax=axes[0,0])
pdp.visualization.plot_connectivity(simulator.connectivity_matrix, ax=axes[0,1])
pdp.visualization.plot_spectrum(power_spectrum, ax=axes[1,0])
pdp.visualization.plot_synchronization(phase_synchronization, ax=axes[1,1])
plt.tight_layout()
plt.savefig('neural_simulation_results.png', dpi=300, bbox_inches='tight')

from pdp_omnisim import DistributedSystemSimulator
from pdp_omnisim.topology import DataCenterTopology

# Simulate cloud computing environment
dc_topology = DataCenterTopology(
    racks=10,
    servers_per_rack=20,
    network_bandwidth=10,  # Gbps
    storage_latency=0.1    # ms
)

simulator = DistributedSystemSimulator(
    topology=dc_topology,
    workload_type="scientific_computing",
    scheduling_algorithm="heterogeneous_earliest_finish_time",
    failure_model="weibull_distribution"
)

# Run large-scale simulation
metrics = simulator.simulate(
    duration=24 * 3600,  # 24 hours
    warmup_period=3600,  # 1 hour warmup
    random_seed=42
)

print(f"Overall System Efficiency: {metrics.efficiency:.3f}")
print(f"Job Completion Rate: {metrics.completion_rate:.2%}")
print(f"Resource Utilization: {metrics.utilization:.2%}")

import pdp_omnisim.complex_systems as cs

# Study information diffusion in social networks
social_network = cs.SocialNetworkModel(
    num_agents=10000,
    network_type="scale_free",
    opinion_dynamics="bounded_confidence",
    influence_model="linear_threshold"
)

# Simulate rumor spread
initial_seeds = social_network.get_central_nodes(k=10)
diffusion_process = social_network.simulate_diffusion(
    initial_active=initial_seeds,
    max_steps=100,
    threshold=0.3
)

# Analyze cascade properties
cascade_metrics = cs.analyze_cascade(diffusion_process)
critical_points = cs.find_critical_points(diffusion_process)

print(f"Cascade Size: {cascade_metrics.size}")
print(f"Cascade Duration: {cascade_metrics.duration}")
print(f"Virality Coefficient: {cascade_metrics.virality:.3f}")

@software{PDP_OmniSim_2024,
  title = {PDP-OmniSim: Parallel and Distributed Processing Simulation Framework},
  author = {Ford, Tony E.},
  year = {2024},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/tlcagford/PDP-OmniSim}},
  version = {1.0.0}
}