PyParticles3 0.4.0__py3-none-any.whl

pyparticles/pset/rand_cluster.py

@@ -0,0 +1,188 @@
+# 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 numpy as np
+import scipy.spatial.distance as dist
+
+import pyparticles.pset.cluster as clu
+import pyparticles.forces.gravity as gr
+import pyparticles.pset.particles_set as ps
+
+
+class RandCluster(clu.Cluster):
+    def __init__(self):
+        pass
+
+    def insert3(
+        self,
+        X,
+        M=None,
+        V=None,
+        start_indx=0,
+        n=100,
+        centre=(0.0, 0.0, 0.0),
+        radius=1.0,
+        mass_rng=(0.5, 1),
+        vel_rng=(0.5, 1.0),
+        vel_mdl=None,
+        vel_dir=None,
+        randg=np.random.rand,
+        r_min=0.0,
+    ):
+        flag = True
+        si = int(start_indx)
+        ei = int(start_indx + n)
+        rng = range(si, ei)
+        indx = range(si, ei)
+
+        while flag:
+            nn = len(indx)
+            r = randg(nn) * radius
+            theta = np.random.rand(nn) * 2.0 * np.pi
+            phi = np.random.rand(nn) * np.pi
+
+            X[indx, 0] = centre[0] + r * np.cos(theta) * np.sin(phi)
+            X[indx, 1] = centre[1] + r * np.sin(theta) * np.sin(phi)
+            X[indx, 2] = centre[2] + r * np.cos(phi)
+
+            if r_min == 0.0:
+                flag = False
+            else:
+                d = dist.squareform(dist.pdist(X[rng, :]))
+                ax, bx = np.where(np.logical_and(d < r_min, d > 0.0))
+                indx = np.asarray(
+                    start_indx + np.unique(np.concatenate((ax, bx))),
+                    dtype=np.int64,
+                )
+                if len(indx) == 0:
+                    flag = False
+
+        if M is not None:
+            M[si:ei, 0] = mass_rng[0] + randg(n) * (mass_rng[1] - mass_rng[0])
+
+        if V is not None and vel_mdl == "bomb":
+            self.bomb_vel(
+                X,
+                V,
+                n=n,
+                start_indx=start_indx,
+                centre=centre,
+                randg=randg,
+                vel_rng=vel_rng,
+            )
+        elif V is not None and vel_mdl == "const":
+            self.const_vel(
+                X,
+                V,
+                n=n,
+                start_indx=start_indx,
+                randg=randg,
+                vel_rng=vel_rng,
+                vel_dir=vel_dir,
+            )
+
+    def bomb_vel(
+        self,
+        X,
+        V,
+        start_indx=0,
+        n=100,
+        centre=(0.0, 0.0, 0.0),
+        vel_rng=(0.5, 1.0),
+        randg=np.random.rand,
+    ):
+        si = int(start_indx)
+        ei = int(start_indx + n)
+        mX = X[si:ei, :] - centre
+        norms = np.sqrt(np.sum(mX**2.0, axis=1))
+        norms[norms == 0.0] = 1.0
+        U = (mX.T / norms).T
+        V[si:ei, :] += (
+            U.T * (vel_rng[0] + randg(n) * (vel_rng[1] - vel_rng[0]))
+        ).T
+
+    def const_vel(
+        self,
+        X,
+        V,
+        start_indx=0,
+        n=100,
+        vel_rng=(0.5, 1.0),
+        vel_dir=(1, 0, 0),
+        randg=np.random.rand,
+    ):
+        si = int(start_indx)
+        ei = int(start_indx + n)
+        v_dir = np.zeros(V[si:ei, :].shape) + vel_dir
+        V[si:ei, :] += (
+            v_dir.T * (vel_rng[0] + randg(n) * (vel_rng[1] - vel_rng[0]))
+        ).T
+
+
+class RandGalaxyCluster(clu.Cluster):
+    def __init__(self):
+        pass
+
+    def insert3(
+        self,
+        X,
+        M,
+        V,
+        G,
+        start_indx=0,
+        n=-1,
+        centre=(0.0, 0.0, 0.0),
+        radius=1.0,
+        mass_rng=(0.7, 1),
+        std=(3.0, 0.6, 0.2),
+        black_hole_mass=5000.0,
+    ):
+        if n <= 0:
+            n = X.shape[0] - start_indx
+
+        si = int(start_indx)
+        ei = int(start_indx + n)
+        rng = slice(si, ei)
+
+        X[rng, 0] = radius * np.random.normal(0.0, std[0], n)
+        X[rng, 1] = radius * np.random.normal(0.0, std[1], n)
+        X[rng, 2] = radius * np.random.normal(0.0, std[2], n)
+        X[si, :] = np.array([0.0, 0.0, 0.0])
+
+        if M is not None:
+            M[rng] = mass_rng[0] + np.random.rand(n, 1) * (mass_rng[1] - mass_rng[0])
+            M[si] = black_hole_mass
+
+        c = np.cross(X[rng], np.array([0, 0, 1]))
+        norms = np.sqrt(np.sum(c**2, axis=1))
+        nonzero = norms > 0.0
+        c[nonzero] = (c[nonzero].T / norms[nonzero]).T
+        c[~nonzero] = 0.0
+
+        pset = ps.ParticlesSet(n)
+        pset.X[:] = X[rng, :]
+        pset.M[:] = M[rng]
+
+        grav = gr.Gravity(n, Consts=G)
+        grav.set_masses(pset.M)
+        grav.update_force(pset)
+
+        f = np.sqrt(np.sum(grav.F**2, axis=1))
+        r = np.sqrt(np.sum(pset.X**2, axis=1))
+        v = np.sqrt(f * r / pset.M[:, 0])
+
+        V[rng, :] = (v * c.T).T / 1.3
+        X[rng, :] += np.asarray(centre)

pyparticles/pset/rebound_boundary.py

@@ -0,0 +1,68 @@
+# 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.
+
+import numpy as np
+import pyparticles.pset.boundary as bd
+
+
+class ReboundBoundary(bd.Boundary):
+    def __init__(self, bound=(-1, 1), dim=3):
+        self.set_boundary(bound, dim)
+        self.set_normals()
+
+    def set_normals(self):
+        self.__N = np.zeros((2 * self.dim, self.dim))
+
+        if self.dim >= 2:
+            self.__N[0, :2] = np.array([1, 0])
+            self.__N[1, :2] = np.array([-1, 0])
+            self.__N[2, :2] = np.array([0, 1])
+            self.__N[3, :2] = np.array([0, -1])
+
+        if self.dim == 3:
+            self.__N[4, :] = np.array([0, 0, 1])
+            self.__N[5, :] = np.array([0, 0, -1])
+
+    def needs_update(self, p_set):
+        for i in range(self.dim):
+            if np.any(p_set.X[:, i] < self.bound[i, 0]):
+                return True
+            if np.any(p_set.X[:, i] > self.bound[i, 1]):
+                return True
+        return False
+
+    def boundary(self, p_set):
+        v_mi = np.zeros(3)
+        v_mx = np.zeros(3)
+        changed = False
+
+        for i in range(self.dim):
+            j = 2 * i
+            v_mi[:] = 0.0
+            v_mx[:] = 0.0
+
+            b_mi = p_set.X[:, i] < self.bound[i, 0]
+            b_mx = p_set.X[:, i] > self.bound[i, 1]
+
+            if np.any(b_mi) or np.any(b_mx):
+                changed = True
+
+            v_mi[i] = self.bound[i, 0]
+            v_mx[i] = self.bound[i, 1]
+
+            p_set.X[b_mi, :] = p_set.X[b_mi, :] + 2.0 * self.__N[j, :] * (
+                v_mi - p_set.X[b_mi, :]
+            )
+            p_set.X[b_mx, :] = p_set.X[b_mx, :] + 2.0 * self.__N[j, :] * (
+                v_mx - p_set.X[b_mx, :]
+            )
+
+            p_set.V[b_mi, i] = -p_set.V[b_mi, i]
+            p_set.V[b_mx, i] = -p_set.V[b_mx, i]
+
+        return changed

pyparticles/utils/__init__.py

@@ -0,0 +1,21 @@
+# 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 os
+import glob
+
+__all__ = [ os.path.splitext( os.path.basename(f) )[0] for f in glob.glob(os.path.dirname(os.path.abspath(__file__))+"/*.py")]

pyparticles/utils/parse_args.py

@@ -0,0 +1,72 @@
+# 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 argparse
+
+def parse_args():
+    desc = "PyParticles is a particle simulation tool box that support the most diffused numerical integration " 
+    desc = desc + " and forces models "
+
+    parser = argparse.ArgumentParser( description=desc )
+    
+    parser.add_argument("-m", "--config_model",
+        action="store_true",
+        dest="config_model",
+        help="Write out the model of a config file and exit")
+    
+    parser.add_argument( "-d" , "--demo",
+        action="store",
+        choices=[ "springs" , 
+                 "solar_system" , 
+                 "gas_lj" , 
+                 "bubble" , 
+                 "cat_spri" , 
+                 "el_static" , 
+                 "elmag_field" ,
+                 "fountain" ,
+                 "galaxy"] ,
+        dest="demo",
+        default=None ,
+        help="Execute the specified buildin demo"
+        )
+
+    parser.add_argument( "-t" , "--test",
+        action="store",
+        choices=[ "fall" , "harmonic" , "dharmonic" ] ,
+        dest="test",
+        default=None ,
+        help="Execute the specified buildin test")
+
+    parser.add_argument(
+        dest="path_name",
+        nargs='?',
+        default=None
+        )
+    
+    parser.add_argument( "-v" , "--version",
+        action="store_true",
+        dest="version",
+        help="print the current version and exit"
+        )
+    
+    parser.add_argument( "-a" , "--about",
+        action="store_true",
+        dest="about",
+        help="print the about message and exit"
+        )    
+    
+    return parser.parse_args()