From 69255280dae5e2c7fb9cb360d7582c7da3a6b46f Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Sun, 17 May 2026 09:58:44 +0300 Subject: [PATCH 01/23] Add Delta-Engine paper with abstract and methodologies Introduce Delta-Engine paper detailing a new physics engine for embedded systems. --- paper/paper.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 paper/paper.md diff --git a/paper/paper.md b/paper/paper.md new file mode 100644 index 0000000..c364512 --- /dev/null +++ b/paper/paper.md @@ -0,0 +1,27 @@ +# Delta-Engine + +## Abstract +Scientific abstractions are one of the very useful techniques to implement software to control embedded microcontrollers for heavy machinery operations. In this paper, we introduce a physics engine that provides a new software paradigm for IO control for embedded systems and robotics based on a mathematical-physical abstraction. + +## Keywords +Embedded Systems - Embedded IO - C Programming Framework - Calculus-based Physics - Multivariate Calculus - Software programming paradigms + +## Knowledge Gaps +There are a couple of knowledge gaps that this software is going to address including, but not limited to: +- [ ] Controlling IO using Scientific Abstractions (e.g., Mathematical/Physical and Chemical Abstractions). + +## Introduction +Delta-Engine is a physics engine that provides a new software architectural paradigm for precisional IO switch and control over embedded systems and robotics without much knowledge in embedded systems, managing states and software engineering paradigms or if they fail to design the system (e.g., Object-oriented programming). It introduces the field of computational physics to the embedded world through providing a virtual machine and a runtime infrastructure based on the Newtonian physics spaces and supporting infrastructure IO libraries for several supported platforms. + +## Methodologies +- Virtualization of physics objects and IO emulation using mathematical and physical abstractions. +- Newtonian physics spaces as Runtime Infrastructure (RTI). +- Implementation of several physics spaces modules (e.g., Kinematics Module - Fluid Mechanics Module). + +## High-level Architecture + +## Implementation Phases and Milestones + +## Integration Phases and Life Applications + +## Future vision and startups From 643ada0d36fdd71f7676995826ae6a7ecb8ed3ba Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Sun, 17 May 2026 10:02:49 +0300 Subject: [PATCH 02/23] Enhance knowledge gaps section in paper.md Expanded the knowledge gaps section to include additional theoretical and practical aspects related to embedded control and hardware implementation. --- paper/paper.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index c364512..5c15356 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -7,8 +7,10 @@ Scientific abstractions are one of the very useful techniques to implement softw Embedded Systems - Embedded IO - C Programming Framework - Calculus-based Physics - Multivariate Calculus - Software programming paradigms ## Knowledge Gaps -There are a couple of knowledge gaps that this software is going to address including, but not limited to: -- [ ] Controlling IO using Scientific Abstractions (e.g., Mathematical/Physical and Chemical Abstractions). +There are a couple of theoretical and practical knowledge gaps that this software is going to address including, but not limited to: +- [ ] Precisional IO Embedded Control of heavy machines and robotics using Scientific Abstractions (e.g., Mathematical/Physical and Chemical Abstractions). +- [ ] Seamless hardware implementation of several physics simulation systems. +- [ ] Single abstraction for software and hardware systems. ## Introduction Delta-Engine is a physics engine that provides a new software architectural paradigm for precisional IO switch and control over embedded systems and robotics without much knowledge in embedded systems, managing states and software engineering paradigms or if they fail to design the system (e.g., Object-oriented programming). It introduces the field of computational physics to the embedded world through providing a virtual machine and a runtime infrastructure based on the Newtonian physics spaces and supporting infrastructure IO libraries for several supported platforms. From 8359e9d66e4899e8a7026fe096105d36d9f1d910 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Fri, 22 May 2026 22:35:14 +0300 Subject: [PATCH 03/23] =?UTF-8?q?Add=20architecture=20diagram=20for=20?= =?UTF-8?q?=CE=94-Engine?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This file contains a detailed graph representation of the Δ-Engine architecture, including various clusters for physics mechanics, IO infrastructure, and platform-dependent toolchains. --- paper/architecture.dot | 287 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 287 insertions(+) create mode 100644 paper/architecture.dot diff --git a/paper/architecture.dot b/paper/architecture.dot new file mode 100644 index 0000000..59b9904 --- /dev/null +++ b/paper/architecture.dot @@ -0,0 +1,287 @@ +digraph newtonian_rti { + subgraph cluster_engine { + fontname="Helvetica" + fontcolor="#CECBF6" + style="rounded,filled" + fillcolor="#8F8F8F" + color="#8F8F8F" + fontcolor="#FFFFFF" + fontsize=12 + penwidth=1.2 + margin=16 + + graph [ + rankdir=TB + fontname="Helvetica" + fontsize=20 + bgcolor="transparent" + pad=0.5 + nodesep=0.3 + ranksep=0.25 + label="Δ-Engine Architecture (GPLv3)" + labelloc=t + labeljust=c + splines=false + compound=true + ] + node [ + fontname="Helvetica" + shape=box + style="rounded,filled" + penwidth=0.8 + width=5.5 + margin="0.25,0.18" + ] + edge [ + fontname="Helvetica" + fontsize=10 + arrowhead=vee + arrowsize=0.7 + penwidth=0.8 + color="#9C9A92" + ] + + + // ── Newtonian RII — Amber ───────────────────────────────────────────── + subgraph cluster_rti { + label="[0] Newtonian RTI — Physics Spaces\nTop-level simulation environment and scene API" + fontname="Helvetica" + fontcolor="#CECBF6" + style="rounded,filled" + fillcolor="#633806" + color="#EF9F27" + fontcolor="#FFFFFF" + fontsize=12 + penwidth=1.2 + margin=16 + + node [ + fontname="Helvetica" + fontsize=11 + shape=box + style="rounded,filled" + fillcolor="#733806" + color="#733806" + fontcolor="#FFFFFF" + penwidth=0.8 + width=1.0 + margin="0.18,0.14" + ] + + _inertia [ label="Inertial Reference Frames" ] + _forceacc [ label="Accelerating Component" ] + _interaction [ label="Interaction Component" ] + + { rank=same _inertia _forceacc _interaction } + + // invisible edges to enforce left-to-right ordering + _inertia -> _forceacc -> _interaction [ style=invis ] + } + + // ── Physics Mechanics cluster ───────────────────────────────────────── + subgraph cluster_physics { + label="[1] Physics Mechanics Modules" + fontname="Helvetica" + fontsize=12 + fontcolor="#FFFFFF" + style="rounded,filled" + fillcolor="#3C3489" + color="#AFA9EC" + penwidth=1.2 + margin=16 + + node [ + fontname="Helvetica" + fontsize=11 + shape=box + style="rounded,filled" + fillcolor="#26215C" + color="#26215C" + fontcolor="#FFFFFF" + penwidth=0.8 + width=1.0 + margin="0.18,0.14" + ] + + PM_mech [ label="Mechanics" ] + PM_fluid [ label="Fluid Dynamics" ] + PM_therm [ label="Thermodynamics" ] + PM_em [ label="Electromagnetism" ] + + { rank=same PM_mech PM_fluid PM_therm PM_em } + + // invisible edges to enforce left-to-right ordering + PM_mech -> PM_fluid -> PM_therm -> PM_em [ style=invis ] + } + + subgraph cluster_sdk { + label="The Electrostatic-Sandbox SDK (GPLv3)" + fontname="Helvetica" + fontcolor="#CECBF6" + style="rounded,filled" + fillcolor="#000000" + color="#000000" + fontcolor="#FFFFFF" + fontsize=12 + penwidth=1.2 + margin=16 + // ── Mathematical Libraries — Blue ───────────────────────────────────── + subgraph cluster_mathlibs { + label="[2] Mathematical Libraries" + fontname="Helvetica" + fontsize=12 + fontcolor="#CECBF6" + style="rounded,filled" + fillcolor="#0C447C" + color="#85B7EB" + fontcolor="#FFFFFF" + penwidth=1.2 + margin=16 + + node [ + fontname="Helvetica" + fontsize=11 + shape=box + style="rounded,filled" + fillcolor="#26215C" + color="#26215C" + fontcolor="#FFFFFF" + penwidth=0.8 + width=1.0 + margin="0.18,0.14" + ] + + _vectors [ label="Vector Math" ] + _calculus [ label="Calculus" ] + _matrix [ label="Matrix Algebra" ] + + { rank=same _vectors _calculus _matrix } + + // invisible edges to enforce left-to-right ordering + _vectors -> _calculus -> _matrix [ style=invis ] + } + + // ── IO VM — Teal ────────────────────────────────────────────────────── + + subgraph cluster_vmio { + label="[3] IO VM (VMIO)\nVirtualised IO interface — platform-agnostic dispatch" + fontname="Helvetica" + fontsize=12 + fontcolor="#CECBF6" + style="rounded,filled" + fillcolor="#085041" + color="#5DCAA5" + fontcolor="#FFFFFF" + penwidth=1.2 + margin=16 + + node [ + fontname="Helvetica" + fontsize=11 + shape=box + style="rounded,filled" + fillcolor="#115022" + color="#115022" + fontcolor="#FFFFFF" + penwidth=0.8 + width=1.0 + margin="0.18,0.14" + ] + + _analog [ label="Analog Driver" ] + _digital [ label="Digital Driver" ] + _comm [ label="Comm Driver" ] + _memory [ label="Memory Driver" ] + + { rank=same _analog _digital _comm _memory } + + // invisible edges to enforce left-to-right ordering + _analog -> _digital -> _comm -> _memory [ style=invis ] + } + + // ── IO Infrastructure — Coral ───────────────────────────────────────── + + subgraph cluster_io { + label="[4] IO Infrastructure" + fontname="Helvetica" + fontsize=12 + fontcolor="#CECBF6" + style="rounded,filled" + fillcolor="#712B13" + color="#F0997B" + fontcolor="#FFFFFF" + penwidth=1.2 + margin=16 + + node [ + fontname="Helvetica" + fontsize=11 + shape=box + style="rounded,filled" + fillcolor="#912B13" + color="#912B13" + fontcolor="#FFFFFF" + penwidth=0.8 + width=1.0 + margin="0.18,0.14" + ] + + _gpio [ label="GPIO" ] + _spi [ label="SPI" ] + _i2c [ label="I2C" ] + _pwm [ label="PWM" ] + _adc [ label="ADC" ] + _eeprom [ label="EEPROM" ] + + { rank=same _gpio _spi _i2c _pwm _adc _eeprom } + + // invisible edges to enforce left-to-right ordering + _gpio -> _spi -> _i2c -> _pwm -> _adc -> _eeprom [ style=invis ] + } + } + + // ── Platform targets — Gray ─────────────────────────────────────────── + subgraph cluster_toolchain { + label="[5] Platform-dependent Toolchain" + fontname="Helvetica" + fontsize=12 + fontcolor="#CECBF6" + style="rounded,filled" + fillcolor="#444441" + color="#B4B2A9" + fontcolor="#FFFFFF" + penwidth=1.2 + margin=16 + + node [ + fontname="Helvetica" + fontsize=11 + shape=box + style="rounded,filled" + fillcolor="#545451" + color="#B4B2A9" + fontcolor="#FFFFFF" + penwidth=0.8 + width=1.0 + margin="0.18,0.14" + ] + + _avr [ label="AVR" ] + _arm [ label="ARM" ] + _x86 [ label="x86" ] + _android [ label="Android" ] + + { rank=same _avr _arm _x86 _android } + + // invisible edges to enforce left-to-right ordering + _avr -> _arm -> _x86 -> _android [ style=invis ] + } + + // ── Spine edges ─────────────────────────────────────────────────────── + _interaction -> PM_em [style=invis] [ lhead=cluster_physics ] + PM_em -> _matrix [style=invis] [ ltail=cluster_physics ] + _matrix -> _memory [style=invis] + _memory -> _eeprom [style=invis] + _eeprom -> _android [style=invis] + } +} From d4f7523e75f702dc7635252ba34d3f46595e80e1 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Fri, 22 May 2026 22:38:41 +0300 Subject: [PATCH 04/23] Add high-level architecture image to paper --- paper/paper.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/paper/paper.md b/paper/paper.md index 5c15356..7914c5c 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -21,6 +21,8 @@ Delta-Engine is a physics engine that provides a new software architectural para - Implementation of several physics spaces modules (e.g., Kinematics Module - Fluid Mechanics Module). ## High-level Architecture +architecture + ## Implementation Phases and Milestones From 49bf2222d8055f7bb56d4b0f6b30a98e489a18e7 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 12:02:48 +0300 Subject: [PATCH 05/23] =?UTF-8?q?Add=20SES=20graph=20definition=20for=20?= =?UTF-8?q?=CE=94-Engine=20Architecture?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This file defines a graph structure for the System Entity Structure (SES) of the Δ-Engine Architecture, detailing subsystems, nodes, and their relationships. --- paper/ses-mb.dot | 372 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 372 insertions(+) create mode 100644 paper/ses-mb.dot diff --git a/paper/ses-mb.dot b/paper/ses-mb.dot new file mode 100644 index 0000000..838baa9 --- /dev/null +++ b/paper/ses-mb.dot @@ -0,0 +1,372 @@ +digraph ses { + graph [ + rankdir=TB + fontname="Helvetica" + fontsize=13 + bgcolor="transparent" + pad=0.5 + nodesep=0.4 + ranksep=0.4 + label="System Entity Structure (SES) — Δ-Engine Architecture (GPLv3)" + labelloc=t + labeljust=c + splines=false + compound=true + ] + node [ + fontname="Helvetica" + shape=box + style="rounded,filled" + penwidth=0.8 + margin="0.22,0.16" + ] + edge [ + fontname="Helvetica" + fontsize=10 + arrowhead=vee + arrowsize=0.7 + penwidth=0.8 + color="#9C9A92" + ] + + // ── ROOT ──────────────────────────────────────────────────────────────── + subgraph cluster_root { + label="Δ-Engine · Root subsystem · GPLv3" + fontname="Helvetica" + fontsize=13 + fontcolor="#FFFFFF" + style="rounded,filled" + fillcolor="#444441" + color="#B4B2A9" + penwidth=1.4 + margin=20 + + // ── [0] Newtonian RTI ───────────────────────────────────────────── + subgraph cluster_rti { + label="[0] Newtonian RTI\nPhysics spaces" + fontname="Helvetica" + fontsize=11 + fontcolor="#FFFFFF" + style="rounded,filled" + fillcolor="#633806" + color="#EF9F27" + penwidth=1.2 + margin=14 + + EN_rti [ + label="Physics spaces\n(entity node)" + fillcolor="#3C3489" + color="#AFA9EC" + fontcolor="#CECBF6" + fontsize=10 + width=1.6 + ] + + node [ fillcolor="#085041" color="#5DCAA5" fontcolor="#9FE1CB" fontsize=10 width=0.9 ] + IRF [ label="Inertial\nRef. Frame" ] + ACC [ label="Accel.\nComponent" ] + INT [ label="Interact.\nComponent" ] + + { rank=IRF ACC INT } + IRF -> ACC -> INT [ style=invis ] + EN_rti -> IRF [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_rti -> ACC [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_rti -> INT [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + + // ── [1] Physics Mechanics — specialization of EN_rti ───────── + subgraph cluster_physics { + label="[1] Physics Mechanics\n« specialization » of Physics spaces" + fontname="Helvetica" + fontsize=11 + fontcolor="#FFFFFF" + style="rounded,filled" + fillcolor="#26215C" + color="#AFA9EC" + penwidth=1.4 + margin=14 + + EN_phys [ + label="Mech. modules\n(specialization node)" + fillcolor="#3C3489" + color="#AFA9EC" + fontcolor="#CECBF6" + fontsize=10 + width=1.8 + ] + + node [ fillcolor="#085041" color="#5DCAA5" fontcolor="#9FE1CB" fontsize=10 width=0.9 ] + MCH [ label="Mechanics" ] + FLD [ label="Fluid\nDynamics" ] + THM [ label="Thermo-\ndynamics" ] + EM [ label="Electro-\nmagnetism" ] + + { rank=MCH FLD THM EM } + MCH -> FLD -> THM -> EM [ style=invis ] + EN_phys -> MCH [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_phys -> FLD [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_phys -> THM [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_phys -> EM [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + } + } + + // specialization arc: diamond tail → vee head + EN_rti -> EN_phys [ + label="« specialize »" + style=solid + arrowhead=normal + arrowtail=diamond + dir=both + color="#EF9F27" + fontcolor="#EF9F27" + fontsize=9 + penwidth=1.2 + lhead=cluster_physics + ] + + // ── SDK ─────────────────────────────────────────────────────────── + subgraph cluster_sdk { + label="Electrostatic-Sandbox SDK · GPLv3" + fontname="Helvetica" + fontsize=12 + fontcolor="#FFFFFF" + style="rounded,filled" + fillcolor="#2C2C2A" + color="#888780" + penwidth=1.4 + margin=16 + + subgraph cluster_math { + label="[2] Mathematical Libraries" + fontname="Helvetica" + fontsize=11 + fontcolor="#FFFFFF" + style="rounded,filled" + fillcolor="#0C447C" + color="#85B7EB" + penwidth=1.2 + margin=14 + + EN_math [ + label="Math ops\n(entity node)" + fillcolor="#3C3489" + color="#AFA9EC" + fontcolor="#CECBF6" + fontsize=10 + width=1.4 + ] + + node [ fillcolor="#085041" color="#5DCAA5" fontcolor="#9FE1CB" fontsize=10 width=0.9 ] + VEC [ label="Vector\nMath" ] + CAL [ label="Calculus" ] + MAT [ label="Matrix\nAlgebra" ] + + { rank=VEC CAL MAT } + VEC -> CAL -> MAT [ style=invis ] + EN_math -> VEC [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_math -> CAL [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_math -> MAT [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + } + + subgraph cluster_vmio { + label="[3] IO VM (VMIO)\nVirtualised IO — platform-agnostic dispatch" + fontname="Helvetica" + fontsize=11 + fontcolor="#FFFFFF" + style="rounded,filled" + fillcolor="#085041" + color="#5DCAA5" + penwidth=1.2 + margin=14 + + EN_vmio [ + label="IO drivers\n(entity node)" + fillcolor="#3C3489" + color="#AFA9EC" + fontcolor="#CECBF6" + fontsize=10 + width=1.4 + ] + + node [ fillcolor="#085041" color="#1D9E75" fontcolor="#9FE1CB" fontsize=10 width=0.9 ] + ANG [ label="Analog\nDriver" ] + DIG [ label="Digital\nDriver" ] + COM [ label="Comm\nDriver" ] + MEM [ label="Memory\nDriver" ] + + { rank=ANG DIG COM MEM } + ANG -> DIG -> COM -> MEM [ style=invis ] + EN_vmio -> ANG [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_vmio -> DIG [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_vmio -> COM [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_vmio -> MEM [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + + // ── [4] IO Infrastructure — aspect of VMIO ───────────── + subgraph cluster_io { + label="[4] IO Infrastructure\n" + fontname="Helvetica" + fontsize=11 + fontcolor="#FFFFFF" + style="rounded,filled" + fillcolor="#712B13" + color="#F0997B" + penwidth=1.2 + margin=14 + + EN_io [ + label="HW peripherals\n(entity node)" + fillcolor="#3C3489" + color="#AFA9EC" + fontcolor="#CECBF6" + fontsize=10 + width=1.6 + ] + + node [ fillcolor="#085041" color="#5DCAA5" fontcolor="#9FE1CB" fontsize=10 width=0.9 ] + GPIO [ label="GPIO" ] + SPI [ label="SPI" ] + I2C [ label="I2C" ] + PWM [ label="PWM" ] + ADC [ label="ADC" ] + EEPROM [ label="EEPROM" ] + + { rank=GPIO SPI I2C PWM ADC EEPROM } + GPIO -> SPI -> I2C -> PWM -> ADC -> EEPROM [ style=invis ] + EN_io -> GPIO [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_io -> SPI [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_io -> I2C [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_io -> PWM [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_io -> ADC [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_io -> EEPROM [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + } + } + + EN_vmio -> EN_io [ + label="« aspect-of »" + style=dashed + arrowhead=none + arrowtail=diamond + dir=both + color="#EF9F27" + fontcolor="#EF9F27" + fontsize=9 + penwidth=1.2 + lhead=cluster_physics + ] + } + + // ── [5] Toolchain ───────────────────────────────────────────────── + subgraph cluster_toolchain { + label="[5] Platform-dependent Toolchain" + fontname="Helvetica" + fontsize=11 + fontcolor="#FFFFFF" + style="rounded,filled" + fillcolor="#444441" + color="#B4B2A9" + penwidth=1.2 + margin=14 + + EN_tc [ + label="Arch. targets\n(entity node)" + fillcolor="#3C3489" + color="#AFA9EC" + fontcolor="#CECBF6" + fontsize=10 + width=1.4 + ] + + node [ fillcolor="#085041" color="#5DCAA5" fontcolor="#9FE1CB" fontsize=10 width=0.9 ] + AVR [ label="AVR" ] + ARM [ label="ARM" ] + X86 [ label="x86" ] + ANDROID [ label="Android" ] + + { rank=same AVR ARM X86 ANDROID } + AVR -> ARM -> X86 -> ANDROID [ style=invis ] + EN_tc -> AVR [ + style=solid + arrowhead=normal + arrowtail=diamond + dir=both + color="#EF9F27" + fontcolor="#EF9F27" + fontsize=9 + penwidth=1.2 + lhead=cluster_physics + ] + EN_tc -> ARM [ + label="« specialize »" + style=solid + arrowhead=normal + arrowtail=diamond + dir=both + color="#EF9F27" + fontcolor="#EF9F27" + fontsize=9 + penwidth=1.2 + lhead=cluster_physics + ] + EN_tc -> X86 [ + style=solid + arrowhead=normal + arrowtail=diamond + dir=both + color="#EF9F27" + fontcolor="#EF9F27" + fontsize=9 + penwidth=1.2 + lhead=cluster_physics + ] + EN_tc -> ANDROID [ + style=solid + arrowhead=normal + arrowtail=diamond + dir=both + color="#EF9F27" + fontcolor="#EF9F27" + fontsize=9 + penwidth=1.2 + ] + } + + // Formal Linkage using Axioms among entities from different subsystems + EN_phys -> EN_math [ + label="« axiomatic-formal linkage »" + style=dashed + arrowhead=diamond + arrowtail=diamond + dir=both + color="#EF9F27" + fontcolor="#EF9F27" + fontsize=9 + penwidth=1.2 + lhead=cluster_physics + ] + + EN_math -> EN_vmio [ + label="« axiomatic-formal linkage »" + style=dashed + arrowhead=diamond + arrowtail=diamond + dir=both + color="#EF9F27" + fontcolor="#EF9F27" + fontsize=9 + penwidth=1.2 + lhead=cluster_physics + ] + + EN_tc -> EN_io [ + label="« axiomatic-formal linkage »" + style=dashed + arrowhead=diamond + arrowtail=diamond + dir=both + color="#EF9F27" + fontcolor="#EF9F27" + fontsize=9 + penwidth=1.2 + lhead=cluster_physics + ] + } +} From b00255bd45e89f8314fbf27f1e091d4cb7606bd8 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 12:04:52 +0300 Subject: [PATCH 06/23] Add additional image to high-level architecture section --- paper/paper.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/paper/paper.md b/paper/paper.md index 7914c5c..ebd74c4 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -23,6 +23,8 @@ Delta-Engine is a physics engine that provides a new software architectural para ## High-level Architecture architecture +ses-mb + ## Implementation Phases and Milestones From 40dcff9c5905eae0809a4f0e1bd56eb55506d050 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 12:09:00 +0300 Subject: [PATCH 07/23] Update paper.md to include references section Replaced 'Future vision and startups' section with 'References' and added reference links. --- paper/paper.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index ebd74c4..caa02fd 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -30,4 +30,8 @@ Delta-Engine is a physics engine that provides a new software architectural para ## Integration Phases and Life Applications -## Future vision and startups +## References +- [SES/MB Framework by Throsten Pawletta](https://dl.acm.org/doi/10.5555/3108244.3108245) +- [The Feynman Lectures Caltech University](https://www.feynmanlectures.caltech.edu/) +- [Fundamentals of Physics for Scientists and Engineers by Paul Tipler]() +- [Thomas' Calculus]() From 9e3c7483e1b57cf5aafbd75c1932dc47c20822f0 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 20:19:53 +0300 Subject: [PATCH 08/23] Document architectural models and subsystems Added descriptions of two architectural models and their subsystems. --- paper/paper.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/paper/paper.md b/paper/paper.md index caa02fd..0a0235e 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -25,6 +25,23 @@ Delta-Engine is a physics engine that provides a new software architectural para ses-mb +Two architectural models are being proposed here; a **hierarchial model** representing a hardware abstraction layer using a mathematical/physical abstraction, and a **System-Entity-Structure/Model-Base (SES/MB) model** to model the same system components into several subsytems; those subsystems display some components that may be formally linked with components from other subsystems (e.g., the formal linkage among Math Libraries, Mechanics Libraries, and the VMIO Libraries that enable a chained dispatch from Physics to IO). + +### Subsystems: +* Atomic Newtonian RTI: a subsystem that groups the runtime infrastructure components; its instantiation reveals the base Newtonian physics of inertia, acceleration, and object interaction in space. + * Molecular Component. + * Inertial Ref. frame Component. + * Acceleration Component. + * Interaction Component. +* Physics Mechanics: a specialized subsystem of the Newtonian RTI; grouping the different types of objects in the universe that experience inertia, acceleration/deceleration, and interaction with other objects. + * Mechanics Module. + * Fluid Dynamics Module. + * Thermodynamics Module. + * Electromagnetism Module. +* Mathematical Libraries. +* VMIO. +* IO Infrastructure. +* Platform-dependent toolchain. ## Implementation Phases and Milestones From 7e93ca0f0d87d2d53b4e5059937fbaad051bdf11 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 20:21:44 +0300 Subject: [PATCH 09/23] Revise Knowledge Gaps section in paper.md Updated section title and added details on knowledge gaps. --- paper/paper.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index 0a0235e..ecbd4ae 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -6,7 +6,7 @@ Scientific abstractions are one of the very useful techniques to implement softw ## Keywords Embedded Systems - Embedded IO - C Programming Framework - Calculus-based Physics - Multivariate Calculus - Software programming paradigms -## Knowledge Gaps +## Knowledge Gaps (Statement of Need) There are a couple of theoretical and practical knowledge gaps that this software is going to address including, but not limited to: - [ ] Precisional IO Embedded Control of heavy machines and robotics using Scientific Abstractions (e.g., Mathematical/Physical and Chemical Abstractions). - [ ] Seamless hardware implementation of several physics simulation systems. From 689fe10e2a990a65f18396c9d1f7911f7c11aac7 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 20:37:54 +0300 Subject: [PATCH 10/23] Enhance subsystem descriptions in paper.md Expanded descriptions for various subsystems including Mathematical Libraries, Virtualized IO, IO Infrastructure, and Platform-dependent toolchain. --- paper/paper.md | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index ecbd4ae..3210393 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -38,10 +38,27 @@ Two architectural models are being proposed here; a **hierarchial model** repres * Fluid Dynamics Module. * Thermodynamics Module. * Electromagnetism Module. -* Mathematical Libraries. -* VMIO. -* IO Infrastructure. -* Platform-dependent toolchain. +* Mathematical Libraries: a subsystem housing the base continous and discrete mathematical layer of the operations involved in the Physics Subsystems (both the Atomic/Newtonian RTI and the Physics Mechanics Subsystems). + * Calculus Module. + * VectorMath Module. + * Matrix Algebra Module. +* Virtualized IO (VMIO): a subsystem involving a platform-independent layer of driver modules to operate on the lower level platform-dependent IO infrastructure based on the output data from the Mathematical/Physical layers. + * Analog Driver Module. + * Digital Driver Module. + * Comm Driver Module. + * Memory Driver Module. +* IO Infrastructure: a subsystem involving a more platform specific dependent layer of the hardware IO; grouped together in a thin abstraction layer that encapsulates a procedural runtime for the hardware IO involved; links statically with **the Platform-dependent toolchain**. + * GPIO Module. + * PWM Module. + * UART Module. + * SPI Module. + * I2C Module. + * EEPROM Module. +* Platform-dependent toolchain: a subsystem involving a platform-dependent layer of the hardware IO and the operating system operations that are encapsulated directly by the IO Infrastructure subsystem and indirectly by the Platform-agnostic VMIO subsystem. + * Android Userspace Runtime. + * AVR Runtime. + * ARM Runtime. + * x86 Userspace Runtime. ## Implementation Phases and Milestones From 341985b2f32ed26097a0f16165fab56cadfc931e Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 20:41:33 +0300 Subject: [PATCH 11/23] Update label in Newtonian RTI to Atomic Newtonian --- paper/ses-mb.dot | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/paper/ses-mb.dot b/paper/ses-mb.dot index 838baa9..075dab3 100644 --- a/paper/ses-mb.dot +++ b/paper/ses-mb.dot @@ -43,7 +43,7 @@ digraph ses { // ── [0] Newtonian RTI ───────────────────────────────────────────── subgraph cluster_rti { - label="[0] Newtonian RTI\nPhysics spaces" + label="[0] Atomic Newtonian RTI\nPhysics spaces" fontname="Helvetica" fontsize=11 fontcolor="#FFFFFF" @@ -63,15 +63,17 @@ digraph ses { ] node [ fillcolor="#085041" color="#5DCAA5" fontcolor="#9FE1CB" fontsize=10 width=0.9 ] + MOL [ label="Molecular\nComponent" ] IRF [ label="Inertial\nRef. Frame" ] ACC [ label="Accel.\nComponent" ] INT [ label="Interact.\nComponent" ] { rank=IRF ACC INT } - IRF -> ACC -> INT [ style=invis ] + MOL -> IRF -> ACC -> INT [ style=invis ] EN_rti -> IRF [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] EN_rti -> ACC [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] EN_rti -> INT [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] + EN_rti -> MOL [ style=dashed color="#AFA9EC" arrowhead=none penwidth=0.6 ] // ── [1] Physics Mechanics — specialization of EN_rti ───────── subgraph cluster_physics { From 8363525e246680aa57db3562ccfe5fe878049e3b Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 20:43:38 +0300 Subject: [PATCH 12/23] Update label and components in architecture.dot --- paper/architecture.dot | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/paper/architecture.dot b/paper/architecture.dot index 59b9904..d9e6a51 100644 --- a/paper/architecture.dot +++ b/paper/architecture.dot @@ -44,7 +44,7 @@ digraph newtonian_rti { // ── Newtonian RII — Amber ───────────────────────────────────────────── subgraph cluster_rti { - label="[0] Newtonian RTI — Physics Spaces\nTop-level simulation environment and scene API" + label="[0] Atomic Newtonian RTI — Physics Spaces\nTop-level simulation environment and scene API" fontname="Helvetica" fontcolor="#CECBF6" style="rounded,filled" @@ -67,15 +67,16 @@ digraph newtonian_rti { width=1.0 margin="0.18,0.14" ] - - _inertia [ label="Inertial Reference Frames" ] + + _molecular [ label="Molecular Component" ] + _inertia [ label="Inertial Ref. Frames Component" ] _forceacc [ label="Accelerating Component" ] _interaction [ label="Interaction Component" ] - { rank=same _inertia _forceacc _interaction } + { rank=same _molecular _inertia _forceacc _interaction } // invisible edges to enforce left-to-right ordering - _inertia -> _forceacc -> _interaction [ style=invis ] + _molecular -> _inertia -> _forceacc -> _interaction [ style=invis ] } // ── Physics Mechanics cluster ───────────────────────────────────────── From db66be8bb4793d34820167c99c56e5f8e6a45820 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 21:57:52 +0300 Subject: [PATCH 13/23] Enhance paper with detailed design and examples Added detailed design section explaining the use of Entity-Component System (ECS) and Automata Theory for modeling the physics engine. Included examples and remarks on system interactions. --- paper/paper.md | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index 3210393..3961784 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -19,6 +19,8 @@ Delta-Engine is a physics engine that provides a new software architectural para - Virtualization of physics objects and IO emulation using mathematical and physical abstractions. - Newtonian physics spaces as Runtime Infrastructure (RTI). - Implementation of several physics spaces modules (e.g., Kinematics Module - Fluid Mechanics Module). +- Implementation methodologies involve using **Entity-Component-System (ECS)** to implement the structure of the physics engine together with **Automata Theory**; such that, each component of the physics architecture could be represented by a system of component objects. + ## High-level Architecture architecture @@ -58,7 +60,24 @@ Two architectural models are being proposed here; a **hierarchial model** repres * Android Userspace Runtime. * AVR Runtime. * ARM Runtime. - * x86 Userspace Runtime. + * x86 Userspace Runtime. + +### Detailed Design: +Detailed design could be carried out using the **Entity-Component System (ECS) Framework** to model the structure of the engine, and the **Automata Theory** to model the behavior of the engine. Both could be linked via the system part of the ECS; ECS systems can be state machines; either deterministic or non-deterministic; cyclic or non-cyclic in runtime behavior. + +> [!NOTE] +> ## Example: +> A physics object; a ball; has the following: +> (1) A component that is attached to the **Inertial Ref. Frame System** through an entity `ID_BALL`. +> (2) A component that is attached to the **Acceleration/Deceleration System** through an entity `ID_BALL`. +> (3) A component that is attached to the **Molecular System** through an entity `ID_BALL`. +> (4) A component that is attached to the **Interaction System** through an entity `ID_BALL`. +> (5) A component that is attached to the **Mechanics System** through an entity `ID_BALL`. +> +> ## Remarks: +> * It's not ideal to add the ball object to the **Fluid Dynamics System**; therefore, both the **Mechanics** and the **Fluid Dynamics** are specializations of the **Atomic/Newtonian RTI Subsystem**. +> * The collection of the previous systems represent the core of the Delta-Engine; the **Atomic/Newtonian RTI Subsystem**. +> * Systems are operated using State-Machines; either deterministic or non-deterministic in nature; cyclic or non-cyclic. ## Implementation Phases and Milestones From b751da4348246c9d4000cf1caad6190980896171 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 21:59:21 +0300 Subject: [PATCH 14/23] Fix formatting of example list in paper.md --- paper/paper.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index 3961784..f71876c 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -68,11 +68,11 @@ Detailed design could be carried out using the **Entity-Component System (ECS) F > [!NOTE] > ## Example: > A physics object; a ball; has the following: -> (1) A component that is attached to the **Inertial Ref. Frame System** through an entity `ID_BALL`. -> (2) A component that is attached to the **Acceleration/Deceleration System** through an entity `ID_BALL`. -> (3) A component that is attached to the **Molecular System** through an entity `ID_BALL`. -> (4) A component that is attached to the **Interaction System** through an entity `ID_BALL`. -> (5) A component that is attached to the **Mechanics System** through an entity `ID_BALL`. +> 1) A component that is attached to the **Inertial Ref. Frame System** through an entity `ID_BALL`. +> 2) A component that is attached to the **Acceleration/Deceleration System** through an entity `ID_BALL`. +> 3) A component that is attached to the **Molecular System** through an entity `ID_BALL`. +> 4) A component that is attached to the **Interaction System** through an entity `ID_BALL`. +> 5) A component that is attached to the **Mechanics System** through an entity `ID_BALL`. > > ## Remarks: > * It's not ideal to add the ball object to the **Fluid Dynamics System**; therefore, both the **Mechanics** and the **Fluid Dynamics** are specializations of the **Atomic/Newtonian RTI Subsystem**. From 25a547c69c47f446e7872444a48b01f2ba29a2eb Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 22:04:18 +0300 Subject: [PATCH 15/23] Refine methodologies section in paper.md Removed redundant mention of ECS and Automata Theory in methodologies section. --- paper/paper.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index f71876c..73d832c 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -16,11 +16,11 @@ There are a couple of theoretical and practical knowledge gaps that this softwar Delta-Engine is a physics engine that provides a new software architectural paradigm for precisional IO switch and control over embedded systems and robotics without much knowledge in embedded systems, managing states and software engineering paradigms or if they fail to design the system (e.g., Object-oriented programming). It introduces the field of computational physics to the embedded world through providing a virtual machine and a runtime infrastructure based on the Newtonian physics spaces and supporting infrastructure IO libraries for several supported platforms. ## Methodologies +- The Abstract architectural design methodologies involve using the **Hardware-Abstraction Layer (HAL)** to model the structure of the engine in a hierarchial form and the **System-Entity-Structure/Model-Base (SES/MB) Framework** to model the structure of the engine in a more detailed form and model the relation among the subsystems and the components of the engine. +- The Detailed-design methodologies involve using **Entity-Component-System (ECS)** to implement the structure of the physics engine together with the **Automata Theory**; such that, each component of the physics architecture could be represented by a system of component objects. - Virtualization of physics objects and IO emulation using mathematical and physical abstractions. - Newtonian physics spaces as Runtime Infrastructure (RTI). - Implementation of several physics spaces modules (e.g., Kinematics Module - Fluid Mechanics Module). -- Implementation methodologies involve using **Entity-Component-System (ECS)** to implement the structure of the physics engine together with **Automata Theory**; such that, each component of the physics architecture could be represented by a system of component objects. - ## High-level Architecture architecture From ecf05c24a478fd8fcaf25cb456f6bfa377f80030 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Thu, 28 May 2026 22:05:53 +0300 Subject: [PATCH 16/23] Enhance methodologies section in paper.md Expanded on the Detailed-design methodologies section to include state-machine encapsulation in the ECS framework. --- paper/paper.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index 73d832c..d0feaec 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -17,7 +17,7 @@ Delta-Engine is a physics engine that provides a new software architectural para ## Methodologies - The Abstract architectural design methodologies involve using the **Hardware-Abstraction Layer (HAL)** to model the structure of the engine in a hierarchial form and the **System-Entity-Structure/Model-Base (SES/MB) Framework** to model the structure of the engine in a more detailed form and model the relation among the subsystems and the components of the engine. -- The Detailed-design methodologies involve using **Entity-Component-System (ECS)** to implement the structure of the physics engine together with the **Automata Theory**; such that, each component of the physics architecture could be represented by a system of component objects. +- The Detailed-design methodologies involve using **Entity-Component-System (ECS)** to implement the structure of the physics engine together with the **Automata Theory**; such that, each component of the physics architecture could be represented by a system of component objects, and the system part of the ECS encapsulates state-machines; either deterministic or non-deterministic; with cyclic or non-cyclic runtime. - Virtualization of physics objects and IO emulation using mathematical and physical abstractions. - Newtonian physics spaces as Runtime Infrastructure (RTI). - Implementation of several physics spaces modules (e.g., Kinematics Module - Fluid Mechanics Module). From b0d12bee6a24deec314eed7121ec01c3c446ada4 Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Fri, 29 May 2026 15:56:43 +0300 Subject: [PATCH 17/23] Update remarks on ball object components and systems Clarified remarks regarding the ball object's components and their ideal system attachments. --- paper/paper.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index d0feaec..b175793 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -75,8 +75,11 @@ Detailed design could be carried out using the **Entity-Component System (ECS) F > 5) A component that is attached to the **Mechanics System** through an entity `ID_BALL`. > > ## Remarks: -> * It's not ideal to add the ball object to the **Fluid Dynamics System**; therefore, both the **Mechanics** and the **Fluid Dynamics** are specializations of the **Atomic/Newtonian RTI Subsystem**. -> * The collection of the previous systems represent the core of the Delta-Engine; the **Atomic/Newtonian RTI Subsystem**. +> * It's not ideal to add a component of the ball object to the **Fluid Dynamics System**; therefore, both the **Mechanics** and the **Fluid Dynamics** are specializations of the **Atomic/Newtonian RTI Subsystem**. +> * It would be ideal to attach a component of the ball object to the **Fluid Dynamics System**, only if the ball is highly deformable and could be expressed in terms of fluid or semi-fluid properties (e.g., the ball is a "thrombus" in biomedical simulation). +> * If that ball object is otherwise, a metallic object; it would be ideal to attach a component of it under the **Electromagnetism System**; as it could be electromagnetized under a magnetic field. +> * A ball object could have { **a standard mechanical component**, **a deformable component**, and **a magnetizable component** } at the same time to enable the different types of simulations accordingly under their respective systems { **Mechanics System**, **Fluid Dynamics System**, and **Electromagnetism System**}, respectively. +> * The collection of the previous systems represent the core of the Delta-Engine; the **Atomic/Newtonian RTI Subsystem** and its specialization **Physics Mechanics**. > * Systems are operated using State-Machines; either deterministic or non-deterministic in nature; cyclic or non-cyclic. ## Implementation Phases and Milestones From 493e6becf4fd55f8ebec3a1a7b7703912901424d Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Fri, 29 May 2026 16:00:28 +0300 Subject: [PATCH 18/23] paper.md: updated keywords * Added missing keywords for architectural design. * Added missing keywords for detailed design. --- paper/paper.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index b175793..fff4508 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -4,7 +4,7 @@ Scientific abstractions are one of the very useful techniques to implement software to control embedded microcontrollers for heavy machinery operations. In this paper, we introduce a physics engine that provides a new software paradigm for IO control for embedded systems and robotics based on a mathematical-physical abstraction. ## Keywords -Embedded Systems - Embedded IO - C Programming Framework - Calculus-based Physics - Multivariate Calculus - Software programming paradigms +Embedded Systems - Embedded IO - C Programming Framework - Calculus-based Physics - Multivariate Calculus - Software programming paradigms - System Entity Structure/Model Base (SES/MB) - Hardware Abstraction Layer (HAL) - Entity Component System (ECS) - Automata Theory ## Knowledge Gaps (Statement of Need) There are a couple of theoretical and practical knowledge gaps that this software is going to address including, but not limited to: From d3ba7775e0ea08a5beed6dcfe1d10f3ffd95ed9b Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Sat, 30 May 2026 09:48:20 +0300 Subject: [PATCH 19/23] Revise methodologies and subsystem details in paper Refined methodologies and subsystem descriptions in the paper. Updated references and terminology for clarity. --- paper/paper.md | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/paper/paper.md b/paper/paper.md index fff4508..f90452e 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -16,11 +16,14 @@ There are a couple of theoretical and practical knowledge gaps that this softwar Delta-Engine is a physics engine that provides a new software architectural paradigm for precisional IO switch and control over embedded systems and robotics without much knowledge in embedded systems, managing states and software engineering paradigms or if they fail to design the system (e.g., Object-oriented programming). It introduces the field of computational physics to the embedded world through providing a virtual machine and a runtime infrastructure based on the Newtonian physics spaces and supporting infrastructure IO libraries for several supported platforms. ## Methodologies -- The Abstract architectural design methodologies involve using the **Hardware-Abstraction Layer (HAL)** to model the structure of the engine in a hierarchial form and the **System-Entity-Structure/Model-Base (SES/MB) Framework** to model the structure of the engine in a more detailed form and model the relation among the subsystems and the components of the engine. -- The Detailed-design methodologies involve using **Entity-Component-System (ECS)** to implement the structure of the physics engine together with the **Automata Theory**; such that, each component of the physics architecture could be represented by a system of component objects, and the system part of the ECS encapsulates state-machines; either deterministic or non-deterministic; with cyclic or non-cyclic runtime. - Virtualization of physics objects and IO emulation using mathematical and physical abstractions. - Newtonian physics spaces as Runtime Infrastructure (RTI). -- Implementation of several physics spaces modules (e.g., Kinematics Module - Fluid Mechanics Module). +- The Abstract architectural design methodologies involve using the **Hardware-Abstraction Layer (HAL)** to model the structure of the engine in a hierarchial form and the **System-Entity-Structure/Model-Base (SES/MB) Framework** to model the structure of the engine in a more detailed form and model the relation among the subsystems and the components of the engine. +- The Detailed-design methodologies involve using **Entity-Component-System (ECS)** to implement the structure of the physics engine together with the **Automata Theory**; such that, each component of the physics architecture could be represented by a system of component objects, and the system part of the ECS encapsulates state-machines; either deterministic or non-deterministic; with cyclic or non-cyclic runtime. +- Therefore, the theoretical methodology of the detailed-design is the **Entity-Component-Automata (ECA)**, a formal forge of the ECS and the Automata Theory. +- Implementation of several physics spaces modules (e.g., Kinematics Module - Fluid Mechanics Module); as systems of the ECA. +- Building preset physics components and automata that encapsulate the mathematical/physical abstraction. +- Formal linkage among the automata involved and the hardware drivers layer via callback functions $$\zeta$$; dispatched with each state transition via the transition functions $$\delta$$. ## High-level Architecture architecture @@ -36,7 +39,7 @@ Two architectural models are being proposed here; a **hierarchial model** repres * Acceleration Component. * Interaction Component. * Physics Mechanics: a specialized subsystem of the Newtonian RTI; grouping the different types of objects in the universe that experience inertia, acceleration/deceleration, and interaction with other objects. - * Mechanics Module. + * Solid Mechanics Module. * Fluid Dynamics Module. * Thermodynamics Module. * Electromagnetism Module. @@ -75,19 +78,17 @@ Detailed design could be carried out using the **Entity-Component System (ECS) F > 5) A component that is attached to the **Mechanics System** through an entity `ID_BALL`. > > ## Remarks: -> * It's not ideal to add a component of the ball object to the **Fluid Dynamics System**; therefore, both the **Mechanics** and the **Fluid Dynamics** are specializations of the **Atomic/Newtonian RTI Subsystem**. +> * It's not ideal to add a component of the ball object to the **Fluid Dynamics System**; therefore, both the **Solid Mechanics** and the **Fluid Dynamics** are specializations of the **Atomic/Newtonian RTI Subsystem**. > * It would be ideal to attach a component of the ball object to the **Fluid Dynamics System**, only if the ball is highly deformable and could be expressed in terms of fluid or semi-fluid properties (e.g., the ball is a "thrombus" in biomedical simulation). > * If that ball object is otherwise, a metallic object; it would be ideal to attach a component of it under the **Electromagnetism System**; as it could be electromagnetized under a magnetic field. -> * A ball object could have { **a standard mechanical component**, **a deformable component**, and **a magnetizable component** } at the same time to enable the different types of simulations accordingly under their respective systems { **Mechanics System**, **Fluid Dynamics System**, and **Electromagnetism System**}, respectively. +> * A ball object could have { **a standard mechanical component**, **a deformable component**, and **a magnetizable component** } at the same time to enable the different types of simulations accordingly under their respective systems { **Solid Mechanics System**, **Fluid Dynamics System**, and **Electromagnetism System**}, respectively. > * The collection of the previous systems represent the core of the Delta-Engine; the **Atomic/Newtonian RTI Subsystem** and its specialization **Physics Mechanics**. -> * Systems are operated using State-Machines; either deterministic or non-deterministic in nature; cyclic or non-cyclic. - -## Implementation Phases and Milestones - -## Integration Phases and Life Applications +> * Systems are operated using State-Machines; either deterministic or non-deterministic in nature; cyclic or non-cyclic. +> * The methodology by which the Delta-Engine operates the hardware is via the axiomatic linkage among the layered subsystems of the software, and the pre-compiled platform-agnostic hardware drivers layer. +> * This axiomatic linkage, described in the former bullet, is performed via a callback $$\zeta$$ function through the machines' transition functions $$\delta$$. ## References - [SES/MB Framework by Throsten Pawletta](https://dl.acm.org/doi/10.5555/3108244.3108245) - [The Feynman Lectures Caltech University](https://www.feynmanlectures.caltech.edu/) -- [Fundamentals of Physics for Scientists and Engineers by Paul Tipler]() -- [Thomas' Calculus]() +- [Physics for Scientists and Engineers, 6th Edition](https://www.amazon.com/Physics-Scientists-Engineers-Paul-Tipler/dp/142920124X) +- [Thomas' Calculus, 15th Edition](https://www.pearson.com/en-us/subject-catalog/p/thomas-calculus/P200000007103/9780137616077) From 3c861390c6dc277f120d362269e54dc6dbdac44f Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Sat, 30 May 2026 09:50:40 +0300 Subject: [PATCH 20/23] Enhance ECS framework description with callback functions Expanded the detailed design section to include callback functions in ECS systems. --- paper/paper.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/paper.md b/paper/paper.md index f90452e..8d552ab 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -66,7 +66,7 @@ Two architectural models are being proposed here; a **hierarchial model** repres * x86 Userspace Runtime. ### Detailed Design: -Detailed design could be carried out using the **Entity-Component System (ECS) Framework** to model the structure of the engine, and the **Automata Theory** to model the behavior of the engine. Both could be linked via the system part of the ECS; ECS systems can be state machines; either deterministic or non-deterministic; cyclic or non-cyclic in runtime behavior. +Detailed design could be carried out using the **Entity-Component System (ECS) Framework** to model the structure of the engine, and the **Automata Theory** to model the behavior of the engine. Both could be linked via the system part of the ECS; ECS systems can be state machines with callback functions $$\zeta$$ dispatched after each state-state transition or from the $$\delta$$ transition function; either deterministic or non-deterministic; cyclic or non-cyclic in runtime behavior. > [!NOTE] > ## Example: From aa29e443c488469c550074cf16cfa7cdb71eb40e Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Sat, 30 May 2026 09:53:16 +0300 Subject: [PATCH 21/23] Update references in paper.md Added a reference to the Electrostatic-Sandbox SDK in the paper. --- paper/paper.md | 1 + 1 file changed, 1 insertion(+) diff --git a/paper/paper.md b/paper/paper.md index 8d552ab..f446a69 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -88,6 +88,7 @@ Detailed design could be carried out using the **Entity-Component System (ECS) F > * This axiomatic linkage, described in the former bullet, is performed via a callback $$\zeta$$ function through the machines' transition functions $$\delta$$. ## References +- [The Electrostatic-Sandbox SDK for distributed simulation systems](https://github.com/Electrostat-Lab/Electrostatic-Sandbox) - [SES/MB Framework by Throsten Pawletta](https://dl.acm.org/doi/10.5555/3108244.3108245) - [The Feynman Lectures Caltech University](https://www.feynmanlectures.caltech.edu/) - [Physics for Scientists and Engineers, 6th Edition](https://www.amazon.com/Physics-Scientists-Engineers-Paul-Tipler/dp/142920124X) From d996fda1f6713b8f40b6513c0a0401a566e3690d Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Sat, 30 May 2026 09:57:28 +0300 Subject: [PATCH 22/23] Rename 'Mechanics' to 'Solid Mechanics' --- paper/architecture.dot | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/architecture.dot b/paper/architecture.dot index d9e6a51..6b6bd9c 100644 --- a/paper/architecture.dot +++ b/paper/architecture.dot @@ -104,7 +104,7 @@ digraph newtonian_rti { margin="0.18,0.14" ] - PM_mech [ label="Mechanics" ] + PM_mech [ label="Solid Mechanics" ] PM_fluid [ label="Fluid Dynamics" ] PM_therm [ label="Thermodynamics" ] PM_em [ label="Electromagnetism" ] From 6cae7fb74da6bcba313d0ad932b2883c75035c1f Mon Sep 17 00:00:00 2001 From: "Pavly Gerges (pavl_g)" <60224159+pavly-gerges@users.noreply.github.com> Date: Sat, 30 May 2026 10:16:43 +0300 Subject: [PATCH 23/23] Rename 'Mechanics' to 'Solid Mechanics' --- paper/ses-mb.dot | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/paper/ses-mb.dot b/paper/ses-mb.dot index 075dab3..8f27fa3 100644 --- a/paper/ses-mb.dot +++ b/paper/ses-mb.dot @@ -97,7 +97,7 @@ digraph ses { ] node [ fillcolor="#085041" color="#5DCAA5" fontcolor="#9FE1CB" fontsize=10 width=0.9 ] - MCH [ label="Mechanics" ] + MCH [ label="Solid Mechanics" ] FLD [ label="Fluid\nDynamics" ] THM [ label="Thermo-\ndynamics" ] EM [ label="Electro-\nmagnetism" ]