pypic-poisson 2.5.0__tar.gz

pypic_poisson-2.5.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md Makefile release.py
+recursive-include PyPIC *.py *.f
+recursive-include tests *.py
+recursive-include examples *.py *.md
+global-exclude *.so *.pyd *.pyc

pypic_poisson-2.5.0/Makefile

@@ -0,0 +1,7 @@
+PYTHON ?= python
+
+.PHONY: all f2py
+all: f2py
+
+f2py:
+	$(PYTHON) -m pip install -e .

pypic_poisson-2.5.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: pypic-poisson
+Version: 2.5.0
+Summary: Collection of Python Particle-In-Cell solvers
+Project-URL: Source Code, https://github.com/PyCOMPLETE/PyPIC
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Provides-Extra: examples
+Requires-Dist: matplotlib; extra == "examples"
+Provides-Extra: fftw
+Requires-Dist: pyfftw; extra == "fftw"
+
+# PyPIC
+
+Particle-in-cell solvers for beam simulations. The repository contains the
+`PyPIC` Python package, native Fortran sources, tests, and examples.
+Existing imports such as `from PyPIC.MultiGrid import AddTelescopicGrids` remain
+unchanged.
+The PyPI distribution is named **pypic-poisson**; the unrelated `pypic`
+distribution on PyPI is not this project.
+
+## Installation
+
+Python 3.11 or newer and working C and Fortran compilers are required. For example,
+in a conda environment install `c-compiler` and `fortran-compiler` from conda-forge,
+then activate that environment so its compiler settings are available.
+
+Install the released package with:
+
+```sh
+python -m pip install pypic-poisson
+```
+
+Only source distributions are published: pip compiles the native extensions
+locally. If this checkout was previously installed under the distribution name
+`PyPIC`, uninstall that old distribution (`python -m pip uninstall PyPIC`)
+before installing `pypic-poisson`, since both use the `PyPIC` import namespace.
+
+For development, from the directory containing this checkout:
+
+```sh
+python -m pip install -e ./PyPIC
+```
+
+Or, from inside the checkout:
+
+```sh
+python -m pip install -e .
+```
+
+Pip installs Python build dependencies in an isolated build environment and
+compiles all four core Fortran extensions. No manual `make` step or precompiled
+binaries are needed. NumPy and SciPy are runtime dependencies.
+The legacy GPU and FPPS solvers are no longer included.
+
+Python edits take effect immediately. After changing Fortran
+sources, rerun the installation command to rebuild the extensions. Use
+`python -m pip install .` for a regular installation.
+
+### Optional runtime dependencies
+
+- `python -m pip install -e '.[fftw]'` installs the Python FFTW interface used by
+  FFT solvers.
+- `python -m pip install -e '.[examples]'` adds matplotlib for the example scripts.
+  See [the CPU examples guide](examples/cpu/README.md) for optional dependencies
+  and instructions.
+
+## Development and validation
+
+```sh
+python -m pip install -e '.[tests]'
+python -m pytest
+python -m pip install build
+python -m build
+```
+
+The tests check native-module imports, numerical deposition/interpolation,
+the complex error function, and a Poisson solve.
+`python -m build` creates a source distribution and builds a wheel from it.
+Generated binaries are specific to the Python/platform used for the build.
+
+Legacy CPU plotting scripts are under `examples/cpu/`; automated tests
+are under `tests/`. The root Makefile is only a convenience wrapper around pip.
+Package version metadata lives in `PyPIC/_version.py`.
+
+## Publishing a source release
+
+Set the version in `PyPIC/_version.py`, then install the release tools:
+
+```sh
+python -m pip install build twine
+python release.py --build-only
+```
+
+This builds and checks one source archive in `dist/`, without uploading or
+tagging. After testing the archive, commit and push the release changes, then run:
+
+```sh
+python release.py
+```
+
+The script requires a clean checkout and an unused `v<version>` tag. It builds
+and checks the source archive, uploads only that `.tar.gz` to PyPI using your
+Twine credentials (for example, configured in `~/.pypirc`), then creates and
+pushes the version tag to `origin`. No wheels are uploaded. If the upload
+succeeds but tagging or pushing fails, finish those Git operations manually;
+PyPI does not allow re-uploading the same release file.
+
+Publish `pypic-poisson` before releasing PyECLOUD, which depends on it.

pypic_poisson-2.5.0/PyPIC/Bassetti_Erskine.py

@@ -0,0 +1,193 @@
+#----------------------------------------------------------------------
+#                                                                      
+#                           CERN                                       
+#                                                                      
+#     European Organization for Nuclear Research                       
+#                                                                      
+#     
+#     This file is part of the code
+#                                                                      
+# 
+#                  PyPIC Version 2.4.5                     
+#                  
+#                                                                       
+#     Author and contact:   Giovanni IADAROLA 
+#                           BE-ABP Group                               
+#                           CERN                                       
+#                           CH-1211 GENEVA 23                          
+#                           SWITZERLAND  
+#                           giovanni.iadarola@cern.ch                  
+#                                                                      
+#                contact:   Giovanni RUMOLO                            
+#                           BE-ABP Group                               
+#                           CERN                                      
+#                           CH-1211 GENEVA 23                          
+#                           SWITZERLAND  
+#                           giovanni.rumolo@cern.ch                    
+#                                                                      
+#
+#                                                                      
+#     Copyright  CERN,  Geneva  2011  -  Copyright  and  any   other   
+#     appropriate  legal  protection  of  this  computer program and   
+#     associated documentation reserved  in  all  countries  of  the   
+#     world.                                                           
+#                                                                      
+#     Organizations collaborating with CERN may receive this program   
+#     and documentation freely and without charge.                     
+#                                                                      
+#     CERN undertakes no obligation  for  the  maintenance  of  this   
+#     program,  nor responsibility for its correctness,  and accepts   
+#     no liability whatsoever resulting from its use.                  
+#                                                                      
+#     Program  and documentation are provided solely for the use  of   
+#     the organization to which they are distributed.                  
+#                                                                      
+#     This program  may  not  be  copied  or  otherwise  distributed   
+#     without  permission. This message must be retained on this and   
+#     any other authorized copies.                                     
+#                                                                      
+#     The material cannot be sold. CERN should be  given  credit  in   
+#     all references.                                                  
+#----------------------------------------------------------------------
+
+import numpy as np
+from .PyPIC_Scatter_Gather import PyPIC_Scatter_Gather
+from scipy.constants import e, epsilon_0
+from .errffor import errf
+
+
+qe = e
+eps0 = epsilon_0
+
+class Interpolated_Bassetti_Erskine(PyPIC_Scatter_Gather):
+    #@profile
+    def __init__(self, x_aper, y_aper, Dh, sigmax, sigmay, 
+        n_imag_ellip=0, tot_charge=1., verbose=True, allow_scatter_and_solve=False):
+        
+        self.verbose = verbose
+        self.allow_scatter_and_solve = allow_scatter_and_solve
+        
+        if self.verbose:
+            print('Start PIC init.:')
+            print('Bassetti-Erskine, Square Grid')
+
+        self.Dh = Dh
+        super(Interpolated_Bassetti_Erskine, self).__init__(x_aper, y_aper, self.Dh, self.Dh, verbose=self.verbose)
+        
+        xx = self.xg
+        yy = self.yg
+        
+        Ex=np.zeros((len(xx),len(yy)),dtype=complex);
+        Ey=np.zeros((len(xx),len(yy)),dtype=complex);
+        
+        for ii in range(len(xx)):
+
+            if np.mod(ii, len(xx)//20)==0 and self.verbose:
+                print(('Bassetti Erskine evaluation %.0f'%(float(ii)/ float(len(xx))*100)+"""%"""))
+
+            for jj in range(len(yy)):
+                x=xx[ii];
+                y=yy[jj];
+                Ex_imag,Ey_imag  = ImageTerms(x,y,x_aper,y_aper,0,0, n_imag_ellip)
+                Ex_BE,Ey_BE      = BassErsk(x,y,sigmax,sigmay)
+                Ex[ii,jj] = Ex_BE + Ex_imag
+                Ey[ii,jj] = Ey_BE + Ey_imag
+                
+        YY,XX = np.meshgrid(self.yg, self.xg)		
+        self.rho = tot_charge/(2.*np.pi*sigmax*sigmay)*np.exp(-(XX)**2/(2.*sigmax**2)-(YY)**2/(2.*sigmay**2))
+        self.phi = np.zeros((self.Nxg,self.Nyg))
+        self.efx = tot_charge * Ex.real
+        self.efy = tot_charge * Ey.real
+                        
+
+    #@profile    
+    def solve(self, rho = None, flag_verbose = False):
+        if not self.allow_scatter_and_solve:
+            raise ValueError('Bassetti_Erskine: nothing to solve!!!!')
+        
+    def scatter(self,  x_mp, y_mp, nel_mp, charge = -qe, flag_add=False):
+        if not self.allow_scatter_and_solve:
+            raise ValueError('Bassetti_Erskine: what do you want to scatter???!!!!')
+        
+        
+
+
+def wfun(z):
+    x=z.real
+    y=z.imag
+    wx,wy=errf(x,y)
+    return wx+1j*wy
+
+def BassErsk(xin,yin,sigmax,sigmay):
+        
+    x=abs(xin);
+    y=abs(yin);
+    
+    
+    
+    if sigmax>sigmay:
+    
+        S=np.sqrt(2*(sigmax*sigmax-sigmay*sigmay));
+        factBE=1/(2*eps0*np.sqrt(np.pi)*S);
+        etaBE=sigmay/sigmax*x+1j*sigmax/sigmay*y;
+        zetaBE=x+1j*y;
+        
+        val=factBE*(wfun(zetaBE/S)-np.exp( -x*x/(2*sigmax*sigmax)-y*y/(2*sigmay*sigmay))*wfun(etaBE/S) );
+           
+        Ex=abs(val.imag)*np.sign(xin);
+        Ey=abs(val.real)*np.sign(yin);
+    
+    else:
+    
+        S=np.sqrt(2*(sigmay*sigmay-sigmax*sigmax));
+        factBE=1/(2*eps0*np.sqrt(np.pi)*S);
+        etaBE=sigmax/sigmay*y+1j*sigmay/sigmax*x;
+        yetaBE=y+1j*x;
+        
+        val=factBE*(wfun(yetaBE/S)-np.exp( -y*y/(2*sigmay*sigmay)-x*x/(2*sigmax*sigmax))*wfun(etaBE/S) );
+           
+        Ey=abs(val.imag)*np.sign(yin);
+        Ex=abs(val.real)*np.sign(xin);
+         
+    return Ex, Ey
+
+def ImageTerms(x,y,a,b,x0,y0, nimag):
+    
+        
+    eps0=epsilon_0;    
+    
+    if nimag>0 and abs((a-b)/a)>1e-3:    
+        g=np.sqrt(a*a-b*b)
+        z=x+1j*y
+        q=np.arccosh(z/g)
+        mu=q.real
+        phi=q.imag
+        
+        z0=x0+1j*y0
+        q0=np.arccosh(z0/g)
+        mu0=q0.real
+        phi0=q0.imag
+        
+        mu1=0.5*np.log((a+b)/(a-b))
+        
+        Ecpx=0+0j
+        
+        
+        q=np.conj(q)
+        for nn in range(1,nimag+1):
+            Ecpx=Ecpx+np.exp(-nn*mu1) * ( (np.cosh(nn*mu0)*np.cos(nn*phi0)) / (np.cosh(nn*mu1)) + 1j * (np.sinh(nn*mu0)*np.sin(nn*phi0)) / (np.sinh(nn*mu1))   )* (np.sinh(nn*q))/(np.sinh(q))
+            
+        
+        Ecpx=Ecpx/(4*np.pi*eps0)*4/g
+        Ex=Ecpx.real
+        Ey=Ecpx.imag
+    else:
+        if (x0==0) and (y0==0):
+            Ex=0.
+            Ey=0.
+        else:
+            print('This case has not been implemented yet')
+    
+    return Ex, Ey
+
+

pypic_poisson-2.5.0/PyPIC/FFT_OpenBoundary.py

@@ -0,0 +1,257 @@
+#----------------------------------------------------------------------
+#                                                                      
+#                           CERN                                       
+#                                                                      
+#     European Organization for Nuclear Research                       
+#                                                                      
+#     
+#     This file is part of the code:
+#                                                                      
+# 
+#                  PyPIC Version 2.4.5                     
+#                  
+#                                                                       
+#     Author and contact:   Giovanni IADAROLA 
+#                           BE-ABP Group                               
+#                           CERN                                       
+#                           CH-1211 GENEVA 23                          
+#                           SWITZERLAND  
+#                           giovanni.iadarola@cern.ch                  
+#                                                                      
+#                contact:   Giovanni RUMOLO                            
+#                           BE-ABP Group                               
+#                           CERN                                      
+#                           CH-1211 GENEVA 23                          
+#                           SWITZERLAND  
+#                           giovanni.rumolo@cern.ch                    
+#                                                                      
+#
+#                                                                      
+#     Copyright  CERN,  Geneva  2011  -  Copyright  and  any   other   
+#     appropriate  legal  protection  of  this  computer program and   
+#     associated documentation reserved  in  all  countries  of  the   
+#     world.                                                           
+#                                                                      
+#     Organizations collaborating with CERN may receive this program   
+#     and documentation freely and without charge.                     
+#                                                                      
+#     CERN undertakes no obligation  for  the  maintenance  of  this   
+#     program,  nor responsibility for its correctness,  and accepts   
+#     no liability whatsoever resulting from its use.                  
+#                                                                      
+#     Program  and documentation are provided solely for the use  of   
+#     the organization to which they are distributed.                  
+#                                                                      
+#     This program  may  not  be  copied  or  otherwise  distributed   
+#     without  permission. This message must be retained on this and   
+#     any other authorized copies.                                     
+#                                                                      
+#     The material cannot be sold. CERN should be  given  credit  in   
+#     all references.                                                  
+#----------------------------------------------------------------------
+
+import numpy as np
+import scipy.sparse as scsp
+from scipy.sparse.linalg import spsolve
+import scipy.sparse.linalg as ssl
+from .PyPIC_Scatter_Gather import PyPIC_Scatter_Gather
+from scipy.constants import e, epsilon_0
+
+na = lambda x:np.array([x])
+
+qe=e
+eps0=epsilon_0
+
+class FFT_OpenBoundary(PyPIC_Scatter_Gather):
+    #@profile
+    def __init__(self, x_aper, y_aper, Dh=None, dx=None, dy=None, fftlib = 'pyfftw'):
+        
+        print('Start PIC init.:')
+        print('FFT, Open Boundary')
+
+
+        if dx is not None and dy is not None:
+            assert(Dh is None)
+
+        elif Dh!=None:
+            assert(dx is None and dy is None)
+            dx = Dh
+            dy = Dh
+
+        else:
+            raise ValueError('Dh or dx and dy must be specified!!!')
+        
+        super(FFT_OpenBoundary, self).__init__(x_aper, y_aper, dx, dy)
+
+
+        nx = len(self.xg)
+        ny = len(self.yg)
+
+
+        mx = -dx / 2 + np.arange(nx + 1) * dx
+        my = -dy / 2 + np.arange(ny + 1) * dy
+        x, y = np.meshgrid(mx, my)
+        r2 = x ** 2 + y ** 2
+        # Antiderivative
+        tmpfgreen = -(-3 * x * y + x * y * np.log(r2)
+                    + x * x * np.arctan(y / x) + y * y * np.arctan(x / y)) # * 2 / dx / dy
+                   
+        fgreen = np.zeros((2 * ny, 2 * nx))
+        # Integration and circular Green's function
+        fgreen[:ny, :nx] = tmpfgreen[1:, 1:] + tmpfgreen[:-1, :-1] - tmpfgreen[1:, :-1] - tmpfgreen[:-1, 1:]
+        fgreen[ny:, :nx] = fgreen[ny:0:-1, :nx]
+        fgreen[:ny, nx:] = fgreen[:ny, nx:0:-1]
+        fgreen[ny:, nx:] = fgreen[ny:0:-1, nx:0:-1]
+
+        self.fgreen = fgreen
+        self.fgreentr = np.fft.fft2(fgreen).copy()
+        
+        if fftlib == 'pyfftw':
+            try:
+                import pyfftw
+                print('Using PyFFTW')
+                #prepare fftw's
+
+                self.tmprho = (fgreen*(1.+1j))*0.
+                fft_first = pyfftw.builders.fft(self.tmprho[:ny, :], axis = 1, threads = 1)
+
+                self.tmpfft = (fgreen*(1.+1j))*0.
+                self.tmpfft[:ny, :] = fft_first(self.tmprho[:ny, :])
+                fft_second = pyfftw.builders.fft(self.tmpfft, axis = 0, threads = 1)
+                
+                self.phifft = fft_second(self.tmpfft) * self.fgreentr
+                ifft_first = pyfftw.builders.ifft(self.phifft, axis = 0, threads = 1)
+
+                self.tmpifft = ifft_first(self.phifft)
+                ifft_second = pyfftw.builders.ifft(self.tmpifft[:ny, :], axis = 1, threads = 1)
+                self.tmpphi  = (self.fgreen*(1.+1j))*0.
+
+                #@profile
+                def fft2_pyfftw():
+                    self.tmpfft[:ny, :] = fft_first(self.tmprho[:ny, :])
+                    self.phifft = fft_second(self.tmpfft) * self.fgreentr
+                    self.tmpifft = ifft_first(self.phifft)
+                    self.tmpphi[:ny, :] = ifft_second(self.tmpifft[:ny, :])
+
+
+                self.fft2 = fft2_pyfftw
+
+                self.tmpfft = (self.fgreen*(1.+1j))*0.
+                self.tmpifft = (self.fgreen*(1.+1j))*0.
+                
+            except ImportError as err:
+                print('Failed to import pyfftw')
+                print('Got exception: ', err)
+
+                fftlib = 'numpy'
+
+        if fftlib == 'numpy':
+            print('Using numpy FFT')
+
+            self.tmprho = (self.fgreen*(1.+1j))*0.
+            self.tmpphi = (self.fgreen*(1.+1j))*0.
+
+            def fft2_numpy():
+                self.phifft = np.fft.fft2(self.tmprho) * self.fgreentr
+                self.tmpphi = np.fft.ifft2(self.phifft)
+
+            self.fft2 = fft2_numpy
+                
+        elif fftlib != 'pyfftw':
+            raise ValueError('fftlib not recognized!!!!')
+            
+
+        self.rho = np.zeros((self.Nxg,self.Nyg))
+        self.phi = np.zeros((self.Nxg,self.Nyg))
+        self.efx = np.zeros((self.Nxg,self.Nyg))
+        self.efy = np.zeros((self.Nxg,self.Nyg))
+        
+        self.hlpphi = (self.phi*(1.+1j))*0.
+        self.hlpefx = (self.efx*(1.+1j))*0.
+        self.hlpefy = (self.efy*(1.+1j))*0.
+
+        self.tmprho = (self.fgreen*(1.+1j))*0.
+        self.tmpphi = (self.fgreen*(1.+1j))*0.
+
+        self.Dh = Dh
+        self.nx = nx
+        self.ny = ny
+
+
+    #@profile    
+    def solve(self, rho = None, flag_verbose = False):
+        if rho is None:
+            rho = self.rho
+
+        self._solve_core(rho)
+
+        self.phi = np.real(self.hlpphi)
+        self.efx = np.real(self.hlpefx)
+        self.efy = np.real(self.hlpefy) 
+
+
+    def get_state_object(self):
+        state = PyPIC_Scatter_Gather(xg = self.xg, yg = self.yg)
+        
+        state.rho = self.rho.copy()
+        state.phi = self.phi.copy()
+        state.efx = self.efx.copy()
+        state.efy = self.efy.copy()
+        
+        return state
+
+        
+    #~ def load_state_object(self, state):
+        #~ self.rho = state.rho.copy()
+        #~ self.phi = state.phi.copy()
+        #~ self.efx = state.efx.copy()
+        #~ self.efy = state.efy.copy()
+
+        
+    #@profile
+    def solve_states(self, states):
+        
+        states = np.atleast_1d(states)
+
+        if len(states) > 2:
+            raise ValueError('Not implemented yet! Sorry.')
+
+        elif len(states) == 1:
+
+            state = states[0]
+            
+            self._solve_core(state.rho)
+            
+            state.phi = np.real(self.hlpphi)
+            state.efx = np.real(self.hlpefx)
+            state.efy = np.real(self.hlpefy) 
+
+        else:
+            rho = 1*states[0].rho + 1j*states[1].rho
+            
+            self._solve_core(rho)
+            
+            states[1].phi = np.imag(self.hlpphi)
+            states[1].efx = np.imag(self.hlpefx)
+            states[1].efy = np.imag(self.hlpefy)
+            states[0].phi = np.real(self.hlpphi)
+            states[0].efx = np.real(self.hlpefx)
+            states[0].efy = np.real(self.hlpefy)
+
+    #@profile
+    def _solve_core(self, rho):
+
+        self.tmprho[:self.ny, :self.nx] = rho.T
+
+        self.fft2()
+
+        self.hlpphi = 1./(4. * np.pi * eps0)*(self.tmpphi[:self.ny, :self.nx]).T
+
+        self.hlpefx[1:self.Nxg-1,:] = self.hlpphi[0:self.Nxg-2,:] - self.hlpphi[2:self.Nxg,:];  #central difference on internal nodes
+        self.hlpefy[:,1:self.Nyg-1] = self.hlpphi[:,0:self.Nyg-2] - self.hlpphi[:,2:self.Nyg];  #central difference on internal nodes
+        
+        self.hlpefx = self.hlpefx/(2*self.dx)
+        self.hlpefy = self.hlpefy/(2*self.dy)
+
+
+

pypic_poisson-2.5.0/PyPIC/FFT_OpenBoundary_SquareGrid.py

@@ -0,0 +1,59 @@
+#----------------------------------------------------------------------
+#                                                                      
+#                           CERN                                       
+#                                                                      
+#     European Organization for Nuclear Research                       
+#                                                                      
+#     
+#     This file is part of the code:
+#                                                                      
+# 
+#                  PyPIC Version 2.4.5                     
+#                  
+#                                                                       
+#     Author and contact:   Giovanni IADAROLA 
+#                           BE-ABP Group                               
+#                           CERN                                       
+#                           CH-1211 GENEVA 23                          
+#                           SWITZERLAND  
+#                           giovanni.iadarola@cern.ch                  
+#                                                                      
+#                contact:   Giovanni RUMOLO                            
+#                           BE-ABP Group                               
+#                           CERN                                      
+#                           CH-1211 GENEVA 23                          
+#                           SWITZERLAND  
+#                           giovanni.rumolo@cern.ch                    
+#                                                                      
+#
+#                                                                      
+#     Copyright  CERN,  Geneva  2011  -  Copyright  and  any   other   
+#     appropriate  legal  protection  of  this  computer program and   
+#     associated documentation reserved  in  all  countries  of  the   
+#     world.                                                           
+#                                                                      
+#     Organizations collaborating with CERN may receive this program   
+#     and documentation freely and without charge.                     
+#                                                                      
+#     CERN undertakes no obligation  for  the  maintenance  of  this   
+#     program,  nor responsibility for its correctness,  and accepts   
+#     no liability whatsoever resulting from its use.                  
+#                                                                      
+#     Program  and documentation are provided solely for the use  of   
+#     the organization to which they are distributed.                  
+#                                                                      
+#     This program  may  not  be  copied  or  otherwise  distributed   
+#     without  permission. This message must be retained on this and   
+#     any other authorized copies.                                     
+#                                                                      
+#     The material cannot be sold. CERN should be  given  credit  in   
+#     all references.                                                  
+#----------------------------------------------------------------------
+
+from .FFT_OpenBoundary import FFT_OpenBoundary
+
+
+def FFT_OpenBoundary_SquareGrid(x_aper, y_aper, Dh, fftlib = 'pyfftw'):
+    return FFT_OpenBoundary(x_aper, y_aper, Dh, fftlib = fftlib)
+
+