PyParticles3 0.4.0__py3-none-any.whl

pyparticles/utils/pypart_global.py

@@ -0,0 +1,122 @@
+# PyParticles : Particles simulation in python
+# Copyright (C) 2012  Simone Riva
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Project-wide version and optional dependency probes."""
+
+import zlib
+
+
+v_major = 0
+v_minor = 4
+v_revision = 0
+v_prerelease = ""
+
+_GL_INTEROP_WARNING_EMITTED = False
+
+
+def py_particle_version(r="s"):
+    """Return the PyParticles3 compatibility version.
+
+    The string form follows the PyPI distribution version.  The historical
+    tuple form remains a three-integer tuple for compatibility with callers
+    that expect ``(major, minor, revision)``.
+    """
+    if r == "s":
+        return "%d.%d.%d%s" % (v_major, v_minor, v_revision, v_prerelease)
+    return (v_major, v_minor, v_revision)
+
+
+def _warn_if_pyopencl_lacks_gl(cl):
+    """Emit a one-time explanation when only compute OpenCL is available."""
+    global _GL_INTEROP_WARNING_EMITTED
+
+    if _GL_INTEROP_WARNING_EMITTED:
+        return
+
+    have_gl = getattr(cl, "have_gl", None)
+    if have_gl is None:
+        return
+
+    try:
+        gl_enabled = bool(have_gl())
+    except Exception:
+        return
+
+    if gl_enabled:
+        return
+
+    _GL_INTEROP_WARNING_EMITTED = True
+    print("")
+    print("WARNING: PyOpenCL was built without OpenGL interoperability (have_gl=False).")
+    print("OpenCL compute remains available, but CL/GL rendering will use host")
+    print("synchronization and can be much slower for large particle counts.")
+    print("For CL/GL interoperability, rebuild PyOpenCL from source with")
+    print("PYOPENCL_ENABLE_GL=ON and verify that pyopencl.have_gl() is True.")
+    print("")
+
+
+def test_pyopencl():
+    """Return True only when PyOpenCL has at least one usable device."""
+    try:
+        import pyopencl as cl
+    except ImportError:
+        return False
+
+    try:
+        usable = any(platform.get_devices() for platform in cl.get_platforms())
+    except Exception:
+        # Broken/missing ICDs may allow importing pyopencl while still making
+        # every OpenCL operation unusable.
+        return False
+
+    if usable:
+        _warn_if_pyopencl_lacks_gl(cl)
+    return usable
+
+
+def about():
+    mail = zlib.decompress(
+        b"x\x9c+\xce\xcc\xcd\xcfK\xd5+*KtH\xcfM\xcc\xcc\xd1K\xce\xcf\x05\x00R\x9c\x07\xba"
+    ).decode("utf-8")
+
+    message = """
+
+    PyParticles3 is an independent modernization of the original PyParticles
+    particle simulation toolbox created by Simone Riva.
+
+    The project preserves the original educational architecture while adding
+    modern Python compatibility, tests, OpenCL acceleration, OpenCL/OpenGL
+    interoperability, GPU profiling, and updated documentation.
+
+    Modern source: https://github.com/jamaj69/pyparticles
+    Original source: https://github.com/simon-r/PyParticles
+
+    Original copyright (C) 2012 Simone Riva, email: %s
+
+    --------------------------------------------------------------------
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU General Public License for more details.
+    """
+
+    print(message % mail)

pyparticles/utils/time_formatter.py

@@ -0,0 +1,50 @@
+# PyParticles : Particles simulation in python
+# Copyright (C) 2012  Simone Riva
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import time
+
+class MyTimeFormatter( object ):
+    
+    def __init__(self):
+        pass
+
+    
+    def to_str( self , t  ):
+        
+        tf = [ "%4dy " , "%3dd " , "%02dh " , "%02dm " , "%02ds " , "%07.3fms " ]
+        
+        days_y = 365.256363004
+        sec_y = days_y * 3600 * 24
+        
+        years = int( t / sec_y )
+        days  = int( t / (3600*24) - years*days_y )
+        hr    = int( t / 3600 - days*24 - days_y*years*24 )
+        minu  = int( t / 60 - hr*60 - days*(24*60) - days_y*years*24*60 ) 
+        sec   = int( t - minu*60 - hr*3600 - days*(24*3600) - days_y*years*24*60*60 )
+        msec  = float( 1000 * ( t - int( t ) ) )
+        
+        res = ""
+                
+        i = 0
+        f = False
+        for tt in list( [ years , days , hr , minu , sec , msec ] ):
+            if tt > 0 or f : 
+                res = res +  tf[i] % tt
+                f = True
+            i+=1
+            
+        return res

pyparticles3-0.4.0.dist-info/METADATA

@@ -0,0 +1,395 @@
+Metadata-Version: 2.4
+Name: PyParticles3
+Version: 0.4.0
+Summary: Modern educational particle simulation toolbox with OpenCL/OpenGL acceleration
+Author: Simone Riva
+Maintainer: jamaj69
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/jamaj69/pyparticles
+Project-URL: Source, https://github.com/jamaj69/pyparticles
+Project-URL: Documentation, https://github.com/jamaj69/pyparticles#readme
+Project-URL: Issues, https://github.com/jamaj69/pyparticles/issues
+Project-URL: Original Project, https://github.com/simon-r/PyParticles
+Keywords: particles,simulation,physics,opencl,opengl,gpu,scientific-computing,education
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE-gpl-3.0.txt
+Requires-Dist: numpy>=2.0
+Requires-Dist: scipy>=1.14
+Requires-Dist: PyOpenGL>=3.1.7
+Requires-Dist: matplotlib>=3.8
+Provides-Extra: opencl
+Requires-Dist: pyopencl>=2026.1; extra == "opencl"
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5; extra == "docs"
+Requires-Dist: pymdown-extensions>=10; extra == "docs"
+Dynamic: license-file
+
+# PyParticles3
+
+**PyParticles3** is an independent modernization and continuation of Simone Riva's original **PyParticles** project.
+
+The goal is to preserve the original project's unusually clear, educational architecture while updating it for modern Python, NumPy, SciPy, PyOpenGL and PyOpenCL environments. PyParticles3 is also a practical study project for GPU particle simulation, OpenCL acceleration and OpenCL/OpenGL interoperability.
+
+> PyParticles3 is not presented as an official release endorsed by Simone Riva. Original copyright notices and the GPL-3.0-or-later license are preserved.
+
+## Highlights
+
+- simple `ParticlesSet -> Force -> Solver -> Animation/Renderer` architecture;
+- Euler, Leapfrog, Runge-Kutta, Midpoint and Stormer-Verlet style integrators;
+- gravity, springs, constant force, drag, damping, Lennard-Jones, electrostatic and electromagnetic models;
+- constrained particles and constrained force interactions;
+- OpenGL interactive visualization;
+- optional PyOpenCL acceleration;
+- persistent OpenCL buffers to avoid unnecessary PCIe transfers;
+- fused OpenCL integration paths;
+- OpenCL/OpenGL shared VBO rendering;
+- double-buffered CL/GL synchronization with GL fences;
+- asynchronous OpenGL GPU timer queries;
+- an optimized `fountain` example used as a GPU performance case study.
+
+## Installation
+
+The stable release line is **PyParticles3 0.4.0**. The Python import namespace remains `pyparticles`.
+
+PyParticles3 requires Python 3.11 or newer.
+
+### 1. Standard installation
+
+Install PyParticles3 from PyPI:
+
+```bash
+python -m pip install --upgrade pip
+python -m pip install 'PyParticles3==0.4.0'
+```
+
+Verify the installation:
+
+```bash
+pyparticles3 --version
+python -m pyparticles --version
+```
+
+Both commands should report:
+
+```text
+0.4.0
+```
+
+The historical console command remains available for compatibility:
+
+```bash
+pyparticles_app --version
+```
+
+### 2. Installation with OpenCL compute support
+
+Install the optional OpenCL dependency set with:
+
+```bash
+python -m pip install 'PyParticles3[opencl]==0.4.0'
+```
+
+This installs PyOpenCL, but it does **not** install a system OpenCL driver/ICD. A working NVIDIA, Intel, AMD, PoCL or other OpenCL runtime must already be installed on the operating system.
+
+List the OpenCL platforms and devices visible to PyOpenCL:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+
+for pi, platform in enumerate(cl.get_platforms()):
+    print(f"Platform {pi}: {platform.name}")
+    for di, device in enumerate(platform.get_devices()):
+        print(f"  Device {di}: {device.name}")
+PY
+```
+
+PyParticles3 follows PyOpenCL's `PYOPENCL_CTX` selector. For example:
+
+```bash
+PYOPENCL_CTX=0:0 pyparticles3 --demo fountain
+PYOPENCL_CTX=1:0 pyparticles3 --demo fountain
+```
+
+An explicitly selected compute device is never silently replaced by a different OpenCL device merely to obtain OpenCL/OpenGL sharing.
+
+### 3. Check whether PyOpenCL has OpenGL interoperability
+
+The PyPI PyOpenCL wheel can provide fully working OpenCL compute while still being built **without** OpenGL interoperability. Check the installed build explicitly:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+
+print("PyOpenCL :", cl.VERSION_TEXT)
+print("Module   :", cl.__file__)
+print("have_gl  :", cl.have_gl())
+PY
+```
+
+For ordinary OpenCL compute, either value of `have_gl()` is acceptable.
+
+For the high-performance OpenCL/OpenGL shared-buffer path used by the `fountain` demo, PyOpenCL itself must report:
+
+```text
+have_gl  : True
+```
+
+If it reports:
+
+```text
+have_gl  : False
+```
+
+OpenCL compute still works, but PyParticles3 cannot create PyOpenCL `GLBuffer` objects. Rendering then uses host synchronization and can be dramatically slower for large particle counts.
+
+### 4. Build PyOpenCL from source with `have_gl=True`
+
+PyOpenCL's source-build documentation requires the build option `PYOPENCL_ENABLE_GL=ON` to enable OpenGL interoperability.
+
+#### Debian 12 / Debian-family build prerequisites
+
+A typical Debian installation can provide the native build dependencies with:
+
+```bash
+sudo apt update
+sudo apt install \
+    build-essential \
+    python3-dev \
+    cmake \
+    ninja-build \
+    pkg-config \
+    ocl-icd-opencl-dev \
+    libgl-dev \
+    freeglut3-dev
+```
+
+`ocl-icd-opencl-dev` supplies the OpenCL development headers and loader needed to compile against the system OpenCL installation. Your actual OpenCL implementation/ICD, such as the NVIDIA or Intel runtime, remains a separate system component.
+
+If Python comes from pyenv or another custom Python installation, make sure that installation includes its matching Python headers; the system `python3-dev` package applies to Debian's system Python.
+
+#### Rebuild PyOpenCL
+
+Inside the same virtual environment in which PyParticles3 is installed:
+
+```bash
+python -m pip uninstall -y pyopencl
+
+PYOPENCL_ENABLE_GL=ON \
+python -m pip install \
+    --no-binary=pyopencl \
+    --no-cache-dir \
+    -v \
+    'pyopencl==2026.1.4'
+```
+
+`--no-binary=pyopencl` is important: it forces a source build instead of reinstalling the precompiled wheel.
+
+The `0.4.0` release line was qualified with PyOpenCL `2026.1.4`. Newer compatible PyOpenCL releases can also be built from source, but should be tested before being used as a release-validation baseline.
+
+#### Verify the resulting build
+
+Do not assume that a successful compilation enabled GL support. Require it explicitly:
+
+```bash
+python - <<'PY'
+import pyopencl as cl
+
+print("PyOpenCL :", cl.VERSION_TEXT)
+print("Module   :", cl.__file__)
+print("have_gl  :", cl.have_gl())
+
+assert cl.have_gl(), "PyOpenCL was built without OpenGL interoperability"
+PY
+```
+
+The final line must be:
+
+```text
+have_gl  : True
+```
+
+#### Verify the PyParticles3 CL/GL path
+
+Select an OpenCL GPU that can share the active OpenGL context and run:
+
+```bash
+PYOPENCL_CTX=0:0 pyparticles3 --demo fountain
+```
+
+A successful shared-buffer path reports messages similar to:
+
+```text
+OpenCL/OpenGL interop enabled: positions render without host copies
+CL/GL sync: double-buffered VBOs with per-buffer GL fences
+CL/GL position path: X -> VBO device copy (stable)
+Interop device: NVIDIA GeForce ...
+```
+
+`pyopencl.have_gl() == True` means that the **PyOpenCL build** contains GL interoperability support. It does not guarantee that every OpenCL device can share the current OpenGL context. The selected device must also support `cl_khr_gl_sharing` and be compatible with the active GL context.
+
+For example, on a mixed NVIDIA-GPU/Intel-CPU system, an Intel CPU OpenCL device may run all simulation kernels correctly but not advertise `cl_khr_gl_sharing`. PyParticles3 then keeps the Intel device selected and explicitly falls back to host-synchronized rendering instead of moving the computation to NVIDIA.
+
+### 5. System OpenGL requirements
+
+Interactive rendering requires a working OpenGL implementation and FreeGLUT. These are operating-system dependencies and are not installed by pip.
+
+On Debian-family systems, the development packages used above include the common OpenGL/FreeGLUT headers. The graphics driver must still provide a working OpenGL runtime.
+
+### 6. Install from the Git repository
+
+For development or testing the current repository state:
+
+```bash
+git clone https://github.com/jamaj69/pyparticles.git
+cd pyparticles
+
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e '.[dev]'
+```
+
+For development with OpenCL support:
+
+```bash
+python -m pip install -e '.[dev,opencl]'
+```
+
+If CL/GL interoperability is required, rebuild PyOpenCL with `PYOPENCL_ENABLE_GL=ON` after installing the editable package, using the procedure above.
+
+## Current import namespace
+
+The PyParticles3 0.4.x release line intentionally keeps the historical Python import namespace:
+
+```python
+import pyparticles
+```
+
+This avoids mixing a package-wide namespace migration with the first modernized stable release. A future release may introduce a dedicated `pyparticles3` namespace after a controlled compatibility migration.
+
+## Command line
+
+The modern package exposes:
+
+```bash
+pyparticles3 --help
+pyparticles3 --version
+```
+
+The historical command is also kept as a compatibility entry point:
+
+```bash
+pyparticles_app --help
+```
+
+Examples:
+
+```bash
+pyparticles3 --demo springs
+pyparticles3 --demo solar_system
+pyparticles3 --demo bubble
+pyparticles3 --demo gas_lj
+pyparticles3 --demo elmag_field
+pyparticles3 --demo galaxy
+pyparticles3 --demo fountain
+```
+
+## Architecture
+
+```text
+ParticlesSet
+    |
+    +--> Force / MultipleForce
+    |        |
+    |        v
+    +----> ODE Solver
+             |
+             v
+        Animation
+             |
+             v
+          Renderer
+```
+
+The accelerated paths preserve these conceptual roles rather than replacing the whole program with an opaque GPU pipeline.
+
+## OpenCL/OpenGL fountain path
+
+The modern `fountain` demo can keep simulation state resident on the GPU and render from shared OpenGL buffers.
+
+The stable default shared path copies positions from the canonical OpenCL position buffer into a shared OpenGL VBO entirely on the device. The code also contains an optional experimental fused render-mirror path that can write the shared render VBO directly from the integration kernel.
+
+Profiling can be enabled with:
+
+```bash
+PYPARTICLES_PROFILE_CLGL=1 \
+PYPARTICLES_PROFILE_FRAMES=1000 \
+PYPARTICLES_PROFILE_WARMUP=200 \
+pyparticles3 --demo fountain
+```
+
+The experimental fused render mirror is selected with:
+
+```bash
+PYPARTICLES_CLGL_FUSED_MIRROR=1 \
+pyparticles3 --demo fountain
+```
+
+The final `0.4.0` release is based on the validated `0.4.0rc2` code path. The release-candidate baseline on a GeForce GTX 1060 6 GB with 2,000,000 fountain particles produced roughly 278-296 FPS, with the fused physics kernel around 0.760 ms and the device-side X-to-VBO copy around 0.324 ms. Treat these numbers as a hardware-specific regression baseline, not as a general performance guarantee.
+
+## Development
+
+```bash
+git clone https://github.com/jamaj69/pyparticles.git
+cd pyparticles
+
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install -U pip
+python -m pip install -e '.[dev]'
+
+python -m compileall -q pyparticles tests
+python -W default -m unittest discover -v -s tests
+```
+
+Build the PyPI artifacts with:
+
+```bash
+python -m pip install -U build twine
+rm -rf build dist *.egg-info
+python -m build
+python -m twine check dist/*
+```
+
+## Project links
+
+- Source: https://github.com/jamaj69/pyparticles
+- Issues: https://github.com/jamaj69/pyparticles/issues
+- Original project: https://github.com/simon-r/PyParticles
+- PyOpenCL installation/build documentation: https://documen.tician.de/pyopencl/misc.html
+
+When releases are published through PyPI Trusted Publishing from this GitHub repository, PyPI can verify the GitHub project links carried in the distribution metadata.
+
+## Origin and attribution
+
+PyParticles was created by **Simone Riva** in 2012. PyParticles3 is an independent modernization built from that GPL-licensed codebase. The modernization focuses on Python 3 compatibility, modern scientific Python libraries, testing, GPU acceleration, CL/GL interoperability and documentation while preserving the original educational structure.
+
+## License
+
+GPL-3.0-or-later. See `LICENSE-gpl-3.0.txt`.

pyparticles3-0.4.0.dist-info/RECORD

@@ -0,0 +1,100 @@
+pyparticles/__init__.py,sha256=Mqc8FcYcmqLoqBuFBHNM_hBXQVfeaTpzOaJdmcGRf2s,907
+pyparticles/__main__.py,sha256=DimbxF9a6U_jTcTVs3a4Vq0JtN3v1yizDD3fQCieG3c,161
+pyparticles/animation/__init__.py,sha256=YWGJrPjamB49wRPTqdjfo6-T1lUvlLfshIqUGsPNh4Q,857
+pyparticles/animation/animated_cli.py,sha256=kUlNFN7X2UpmPUOdTZtOlscglcKWDUzVVBH7jyLcBYo,1635
+pyparticles/animation/animated_ogl.py,sha256=nZwq9peYMHakqM0ZAXJbdRCBjR3YQaNYs7pYhPvr96w,20897
+pyparticles/animation/animated_ogl_compat.py,sha256=KQNhmiYYCULXryse3gotOOBOJAx-D4l-vfJ-bv5hMfw,8482
+pyparticles/animation/animated_scatter.py,sha256=xLCOUit0zzT99CZf6pzc6iTe9kRG615-ecYS0Duikow,2961
+pyparticles/animation/animation.py,sha256=axKzZ-9xDDntIY9FG4SBHSXJHIPA0I6HAJqHcO7JbNs,7025
+pyparticles/animation/test_animation.py,sha256=TRbb7wA91Z_VBNFxN-vX5_ovkW8UrcNUxVmBG5_DeFE,9773
+pyparticles/demo/__init__.py,sha256=6X6qEyq3c85ivWMm7vJYWHAGCzI3QSm3tGCd70rujq8,1367
+pyparticles/demo/bubble.py,sha256=J-nzKma90z_ytEPQ0x0Dh9gc9vM8jt4koFSx_GFgccw,2983
+pyparticles/demo/electromagnetic_demo.py,sha256=PmjE1VOXqBNSO6pLIFsu8kWEennCvDPVtWprkumopjE,3932
+pyparticles/demo/electrostatic_demo.py,sha256=fsUBVuVxa84Unh64ptaTomycnz-kbcV0AO_k074cToo,3591
+pyparticles/demo/fountain.py,sha256=PkFya7SRERu7BqM4OC9CLuayV_hUx0xxklFGQ3DBpfY,19268
+pyparticles/demo/gas_lennard_jones.py,sha256=ptFopN54bGSfrrSmcD9OcvdpE58fn3Mu5WQSGimL294,2531
+pyparticles/demo/gravity_clusters.py,sha256=qOApDKIwLsmiotbFGOdsSK_UrIIC7HMUruIhgOb_dgM,2080
+pyparticles/demo/solar_system.py,sha256=H-uxt40m8u_J1qK9aKvIwdcBT1T-CI0IZrXJQLHpSTw,7086
+pyparticles/demo/springs.py,sha256=VthvlgVlX_LAH_Ix-1t5WbCtJfJeoI2q6IupzDTP2dI,3840
+pyparticles/demo/springs_constr.py,sha256=VKl8FCKQHEHqMjiN7RJfGUNjflVwziwz6fHC5PnOxaI,4004
+pyparticles/demo/test.py,sha256=eJgVFAfrik4YDp0LXgxiY52eCp0qSN93G7uwV0BP2io,1097
+pyparticles/forces/__init__.py,sha256=SfGt0zuyycRf9l-_fov-zBtjfdynjlwFTmnT1KgAzQk,858
+pyparticles/forces/const_force.py,sha256=jXw3iszRhG6fo6OJrUCcSO0eEaZ-HOiVV_HJK6N88kU,3948
+pyparticles/forces/damping.py,sha256=jIwWqvlNTYJN-mvXqjE7FFsRicl2GYNV57Fk4rEyrGs,5007
+pyparticles/forces/drag.py,sha256=clZ3X9tHn1z2n8O_BDdoTbV5uyLomR3jt0Y9iFhh7Hg,4730
+pyparticles/forces/electromagnetic.py,sha256=gV3_t7TwWqaoqH_j8nFr2rnUm4VS77VT5f-e8MGyTU0,3308
+pyparticles/forces/electromagnetic_field.py,sha256=2h0Nkoi96AYPXm6ijQquOKjL9ZQE5xXtI04QpnAgC6Y,2651
+pyparticles/forces/electrostatic.py,sha256=nt6DIH1pFr7cx7QJyuQkPAIoOdyTkhI51l5AbU8uVN8,2298
+pyparticles/forces/force.py,sha256=9KiF8mXs_fcNhI3GdNHZLmWWripJEZ4FwHLsGnSTBm0,2710
+pyparticles/forces/force_constrained.py,sha256=pRm1O4LUgiYOuMiNpdKOAF0SYmOh-6LCQEqS6IrSBfs,1185
+pyparticles/forces/fused_const_drag.py,sha256=mtG6YHJP8BCZiCJaMRr-RoJbCGdP_p9isY5ABXY--E0,14692
+pyparticles/forces/gravity.py,sha256=oJBljaDvcHpjag_bm4fHsPTCfxw3raKekUgA4ttsXCc,10487
+pyparticles/forces/lennard_jones.py,sha256=54n1ii1R12qgdpFqThdOPDAecNkbuJWcj4y07FINk7M,2210
+pyparticles/forces/linear_spring.py,sha256=L6VAu251z_BV0-AKX-P-rGpZ33E-kJ_Jv5kKRIHgxYU,2392
+pyparticles/forces/linear_spring_constrained.py,sha256=TDvHHypK3WjDucNfNaidtCLLwYi0GGJLhz35AscrPaw,2172
+pyparticles/forces/multiple_force.py,sha256=KvROEsLMq6BMlH5A9qRG5Z5YPCZnUe19sx7414eB6gw,4500
+pyparticles/forces/pseudo_bubble.py,sha256=NblMuNammFJ9lVOgC11FZrYBLlgtkHlxu0fAt_BF2xo,6400
+pyparticles/forces/van_der_waals_force.py,sha256=8GqaCT10BRq6z3ISsrx7DiCets8Lu1Q4zTm-m45IcdE,1705
+pyparticles/forces/vector_field_force.py,sha256=S-Qps149mRaT_cPtljDg1uuynaHz6dbEMvBBZIsZgfI,1607
+pyparticles/geometry/__init__.py,sha256=SfGt0zuyycRf9l-_fov-zBtjfdynjlwFTmnT1KgAzQk,858
+pyparticles/geometry/dist.py,sha256=q842yPnjeBQkDNgHhNZYjCZKc_NzS2eHM4grSPFcfR0,876
+pyparticles/geometry/intersection.py,sha256=un1gI4SnPF9IeBI0Kh9iO8QgWYOTP-08Wf93Qy_kglk,1932
+pyparticles/geometry/transformations.py,sha256=esfLTNC3I1AfZOrz5KF-2mvOIRy91z2MxiGUGcco2Kc,11728
+pyparticles/main/__init__.py,sha256=SfGt0zuyycRf9l-_fov-zBtjfdynjlwFTmnT1KgAzQk,858
+pyparticles/main/main.py,sha256=kGnRj9e_RbstQKBF51nyM3LWifnzLOFnE4lJ0V9hN54,11817
+pyparticles/measures/__init__.py,sha256=SfGt0zuyycRf9l-_fov-zBtjfdynjlwFTmnT1KgAzQk,858
+pyparticles/measures/elastic_potential_energy.py,sha256=msISBKcyfdbuGOkcnClUX97fwChQoVRTBa8L4CdUSnw,2023
+pyparticles/measures/gravitational_potential_energy.py,sha256=MXxoOhrkpC5_NZhC6BKPn7ZUKHPKB2Lp5gQVjVTLt9I,2100
+pyparticles/measures/kinetic_energy.py,sha256=SE9rwyOoTef9Hn2YgqHe7yeGzT5Npyg1pt4iNMZFyts,1983
+pyparticles/measures/mass.py,sha256=sqW2WtIGw5sSRWj3ZgwGr0Fb5GJm1wwH0g4LMB7O58c,1672
+pyparticles/measures/measure.py,sha256=QFJ_PuaRK4vmVMdO_1o9C0IErh7BTnyLgg7UNei_DnQ,5202
+pyparticles/measures/momentum.py,sha256=jQTGa1wWiQ5rH_3luXD9jhYGqvVTj4CKx6auGf2o2Uc,4267
+pyparticles/measures/total_energy.py,sha256=XKv2_gSwgWpcAEWxek1RXV6bibpKMz0yxPDZLG2i3CY,2045
+pyparticles/ode/__init__.py,sha256=SfGt0zuyycRf9l-_fov-zBtjfdynjlwFTmnT1KgAzQk,858
+pyparticles/ode/euler_solver.py,sha256=CK2sxgiTRRlYxF_59L3dKclYJFFYx_ujM-JHKPbhqYA,7208
+pyparticles/ode/euler_solver_constrained.py,sha256=tD8mffDHMEAXCQdPKQUEH0lCKwPlRkbVeC-zW2PEw9A,2034
+pyparticles/ode/leapfrog_solver.py,sha256=B11_90B0fiwk74yaICMIgEXzMKaieCPHY_ejDEhFQBc,1350
+pyparticles/ode/leapfrog_solver_constrained.py,sha256=C2pg4yoK-Rm71RbSRiLIj3HpbpkxHEBLxh6dBMojmtQ,2312
+pyparticles/ode/midpoint_solver.py,sha256=3DTjWVWrf887x_friEKFd67w0vv1FCfEiOU5U2yzy5c,1544
+pyparticles/ode/midpoint_solver_constrained.py,sha256=ry5P4pJdGmI2jM3-0wRAcAccgU6ZijCfzcLWxdlXEn0,2521
+pyparticles/ode/ode_solver.py,sha256=7xchJu3-iykDUs2ARaBQd9sCAr37aan8sMbPqYc91t8,4085
+pyparticles/ode/ode_solver_constrained.py,sha256=E-iV40jp1SPOfYYIgdjL1N60XujOlGDrsqXEoVxTZw4,1550
+pyparticles/ode/runge_kutta_solver.py,sha256=MzjA_igEg2BeRVfgap44yOC4qPjxoWNKuXFPOoawLdk,2842
+pyparticles/ode/runge_kutta_solver_constrained.py,sha256=Ikd8bBnCkyFtgEOe4TQoX3CCIUnMEY1mnmYtRB7sELg,4171
+pyparticles/ode/sim_time.py,sha256=7ed5q-keQHOylD01SzwONG7HcboUbhqYIJXFtfP6grI,1710
+pyparticles/ode/stormer_verlet_solver.py,sha256=RLLR7K93xNN6m7aeN46VNoIlrrwq4jcjWExQ7IVrkJk,1960
+pyparticles/ode/stormer_verlet_solver_constrained.py,sha256=99Kgt4Q8iszgFyKF4uM7lAk1pNslpoIS_gGPC6gb1hI,3051
+pyparticles/ogl/__init__.py,sha256=SfGt0zuyycRf9l-_fov-zBtjfdynjlwFTmnT1KgAzQk,858
+pyparticles/ogl/axis_ogl.py,sha256=uzE1ipA8_W7dyNvFrfkSkioXlcEA33nSkF8gDsC3n_k,6440
+pyparticles/ogl/draw_particles_ogl.py,sha256=DmSh9PQyUPtDcFUxDgDnHtfhTHbDrm1DYT7fbc6Mhp8,9974
+pyparticles/ogl/draw_particles_ogl_compat.py,sha256=IQb8h9g_ggoNgPk-0bZ48WxMU1v6eVu-nzHLHs1DC3Y,17486
+pyparticles/ogl/draw_vector_field.py,sha256=nS00OXtc1UWzGishL6NaAtn-XAokpf79tdA4nrSobw8,6765
+pyparticles/ogl/opencl_gl_vbo.py,sha256=9Ad7-OXpHjmKTYOjn7AcpHNO88QyWdJ4Sn7xzn9A3XE,17276
+pyparticles/ogl/trackball.py,sha256=N50FiUXBmzoJq-pHP1Ld7g7kCb6kpb8UOHKL5epzNNI,4249
+pyparticles/ogl/translate_scene.py,sha256=MMhNAJD9I9pCunN8-6HsYU8DzniiG6xglhSnPW2zO_4,2440
+pyparticles/pset/__init__.py,sha256=SfGt0zuyycRf9l-_fov-zBtjfdynjlwFTmnT1KgAzQk,858
+pyparticles/pset/boundary.py,sha256=BRCnoVTG41AlO3a7qC90JGEejCumW0cXJDVmUg4Qajk,2134
+pyparticles/pset/cluster.py,sha256=QtALI9BJPwVGHmWU9lPCvyAVjQoBvTxcbqHG9YvSKDM,914
+pyparticles/pset/constrained_force_interactions.py,sha256=PGQMVfX5YNBsXWPVALSsX8F9sZ3hs3VHFhlg1Am2lqw,1961
+pyparticles/pset/constrained_x.py,sha256=5J8hqnRw7If-vm4bbW0g1b5PxT4AyrMuy_DNIAnpSJE,5381
+pyparticles/pset/constraint.py,sha256=dFDxswFsvd0RehC7jO8f_s_aGxp8fEJuvqbupyAXLKc,1128
+pyparticles/pset/default_boundary.py,sha256=s77GDU0_2GyvyZaCgCKotmBED6gwMutclggvHPWYsBE,1441
+pyparticles/pset/file_cluster.py,sha256=sGitftkajVWM5AW--cAYPOEd8NsIksvYWVuyqTO-8Pk,3421
+pyparticles/pset/logger.py,sha256=HkPSKI0jEr-UwHLeyLXTE0EEXXztno5bZolk4Wr-5fg,4707
+pyparticles/pset/octree.py,sha256=G1KMPQTjCmZyR1RJ0IZn_bKpw2cvdodxxqvKjJlLk7k,14985
+pyparticles/pset/opencl_context.py,sha256=TQ3nsJotpOHdCxiY6-VQ2LQ5Cn75epB3HLCCr7lYXGs,13270
+pyparticles/pset/particles_set.py,sha256=CMvPYHXkcmPGWrSLOWEz3qi68L7LK5fZte6cvz3wBd8,16543
+pyparticles/pset/periodic_boundary.py,sha256=02QGzAFZPOfbSPQUCWliftAlcjr-GgmaXibWHfL-kfw,1273
+pyparticles/pset/rand_cluster.py,sha256=a3PQ497wen10d5YPPCGlV86Uxyb15W-pWc_ER3D5d6o,5299
+pyparticles/pset/rebound_boundary.py,sha256=VjVXPpsZ--z2rIWJ4fD7JeTwph8schrbTQjdQpVTDH4,2087
+pyparticles/utils/__init__.py,sha256=YWGJrPjamB49wRPTqdjfo6-T1lUvlLfshIqUGsPNh4Q,857
+pyparticles/utils/parse_args.py,sha256=Qaz7z6G5jFO5KaVkMKnN_WcVyDVMol2HoJTuVuRg8q4,2273
+pyparticles/utils/problem_config.py,sha256=6FYatMR2gWq8KS9Amk3cDCOTMxyUXCK3zkLsXHG_muU,23753
+pyparticles/utils/pypart_global.py,sha256=G8XmaGta6lhFFfvH1UNAaHCAmeCwakBD4CM9o6-q4No,4018
+pyparticles/utils/time_formatter.py,sha256=OVOCP2eTfAIlz1XrV3yPelXApI6JmV_Qsr2i5X9HJ38,1660
+pyparticles3-0.4.0.dist-info/licenses/LICENSE-gpl-3.0.txt,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+pyparticles3-0.4.0.dist-info/METADATA,sha256=lv0Ayx5URPWdnBF124awGS9NzTcjZ6v6Ok7776EQDiM,12960
+pyparticles3-0.4.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyparticles3-0.4.0.dist-info/entry_points.txt,sha256=OTWMifSShnvWdMBY6Sjg6kbHDSSBFCfurheDa8eV1sg,105
+pyparticles3-0.4.0.dist-info/top_level.txt,sha256=bsS4msJ7XYbilhsrlVsXGEdg1tHKp3tBlt6myUY3k2A,12
+pyparticles3-0.4.0.dist-info/RECORD,,

pyparticles3-0.4.0.dist-info/WHEEL

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

pyparticles3-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pyparticles3 = pyparticles.main.main:main
+pyparticles_app = pyparticles.main.main:main