tPerform many stylistic improvements based on pylint - sphere - GPU-based 3D di… | |
git clone git://src.adamsgaard.dk/sphere | |
Log | |
Files | |
Refs | |
LICENSE | |
--- | |
commit 84e33bd162733d251f944d84b1d799bc6951f4b7 | |
parent 626a05132dc7966c24a0f1326342c2c738015d14 | |
Author: Anders Damsgaard <[email protected]> | |
Date: Mon, 2 Sep 2019 14:45:51 +0200 | |
Perform many stylistic improvements based on pylint | |
Diffstat: | |
M python/sphere.py | 3899 +++++++++++++++--------------… | |
1 file changed, 1871 insertions(+), 2028 deletions(-) | |
--- | |
diff --git a/python/sphere.py b/python/sphere.py | |
t@@ -1,6 +1,8 @@ | |
#!/usr/bin/env python | |
import math | |
import os | |
+import subprocess | |
+import pickle as pl | |
import numpy | |
try: | |
import matplotlib | |
t@@ -9,32 +11,30 @@ try: | |
import matplotlib.collections | |
matplotlib.rcParams.update({'font.size': 7, 'font.family': 'serif'}) | |
matplotlib.rc('text', usetex=True) | |
- matplotlib.rcParams['text.latex.preamble']=[r"\usepackage{amsmath}"] | |
+ matplotlib.rcParams['text.latex.preamble'] = [r"\usepackage{amsmath}"] | |
from matplotlib.font_manager import FontProperties | |
- py_mpl=True | |
+ py_mpl = True | |
except ImportError: | |
print('Info: Could not find "matplotlib" python module. ' + | |
'Plotting functionality will be unavailable') | |
- py_mpl=False | |
-import subprocess | |
-import pickle as pl | |
+ py_mpl = False | |
try: | |
import vtk | |
- py_vtk=True | |
+ py_vtk = True | |
except ImportError: | |
print('Info: Could not find "vtk" python module. ' + | |
'Fluid VTK calls will be unavailable') | |
print('Consider installing with `pip install --user vtk`') | |
- py_vtk=False | |
+ py_vtk = False | |
numpy.seterr(all='warn', over='raise') | |
# Sphere version number. This field should correspond to the value in | |
# `../src/version.h`. | |
-VERSION=2.15 | |
+VERSION = 2.15 | |
# Transparency on plot legends | |
-legend_alpha=0.5 | |
+legend_alpha = 0.5 | |
class sim: | |
t@@ -61,295 +61,279 @@ class sim: | |
:type cfd_solver: int | |
''' | |
- def __init__(self, | |
- sid='unnamed', | |
- np=0, | |
- nd=3, | |
- nw=0, | |
- fluid=False, | |
- cfd_solver=0): | |
+ def __init__(self, sid='unnamed', np=0, nd=3, nw=0, fluid=False): | |
# Sphere version number | |
- self.version=numpy.ones(1, dtype=numpy.float64)*VERSION | |
+ self.version = numpy.ones(1, dtype=numpy.float64)*VERSION | |
# The number of spatial dimensions. Values other that 3 do not work | |
- self.nd=int(nd) | |
+ self.nd = int(nd) | |
# The number of particles | |
- self.np=int(np) | |
+ self.np = int(np) | |
# The simulation id (text string) | |
- self.sid=sid | |
+ self.sid = sid | |
## Time parameters | |
# Computational time step length [s] | |
- self.time_dt =numpy.zeros(1, dtype=numpy.float64) | |
+ self.time_dt = numpy.zeros(1, dtype=numpy.float64) | |
# Current time [s] | |
- self.time_current =numpy.zeros(1, dtype=numpy.float64) | |
+ self.time_current = numpy.zeros(1, dtype=numpy.float64) | |
# Total time [s] | |
- self.time_total =numpy.zeros(1, dtype=numpy.float64) | |
+ self.time_total = numpy.zeros(1, dtype=numpy.float64) | |
# File output interval [s] | |
- self.time_file_dt =numpy.zeros(1, dtype=numpy.float64) | |
+ self.time_file_dt = numpy.zeros(1, dtype=numpy.float64) | |
# The number of files written | |
- self.time_step_count=numpy.zeros(1, dtype=numpy.uint32) | |
+ self.time_step_count = numpy.zeros(1, dtype=numpy.uint32) | |
## World dimensions and grid data | |
# The Euclidean coordinate to the origo of the sorting grid | |
- self.origo =numpy.zeros(self.nd, dtype=numpy.float64) | |
+ self.origo = numpy.zeros(self.nd, dtype=numpy.float64) | |
- # The sorting grid size (x,y,z) | |
- self.L =numpy.zeros(self.nd, dtype=numpy.float64) | |
+ # The sorting grid size (x, y, z) | |
+ self.L = numpy.zeros(self.nd, dtype=numpy.float64) | |
# The number of sorting cells in each dimension | |
- self.num =numpy.zeros(self.nd, dtype=numpy.uint32) | |
+ self.num = numpy.zeros(self.nd, dtype=numpy.uint32) | |
# Whether to treat the lateral boundaries as periodic (1) or not (0) | |
- self.periodic=numpy.zeros(1, dtype=numpy.uint32) | |
+ self.periodic = numpy.zeros(1, dtype=numpy.uint32) | |
# Adaptively resize grid to assemblage height (0: no, 1: yes) | |
- self.adaptive=numpy.zeros(1, dtype=numpy.uint32) | |
+ self.adaptive = numpy.zeros(1, dtype=numpy.uint32) | |
## Particle data | |
# Particle position vectors [m] | |
- self.x =numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
+ self.x = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
# Particle radii [m] | |
- self.radius =numpy.ones(self.np, dtype=numpy.float64) | |
+ self.radius = numpy.ones(self.np, dtype=numpy.float64) | |
# The sums of x and y movement [m] | |
- self.xyzsum =numpy.zeros((self.np, 3), dtype=numpy.float64) | |
+ self.xyzsum = numpy.zeros((self.np, 3), dtype=numpy.float64) | |
# The linear velocities [m/s] | |
- self.vel =numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
+ self.vel = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
# Fix the particle horizontal velocities? 0: No, 1: Yes | |
- self.fixvel =numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.fixvel = numpy.zeros(self.np, dtype=numpy.float64) | |
# The linear force vectors [N] | |
- self.force =numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
+ self.force = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
# The angular position vectors [rad] | |
- self.angpos =numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
+ self.angpos = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
# The angular velocity vectors [rad/s] | |
- self.angvel =numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
+ self.angvel = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
# The torque vectors [N*m] | |
- self.torque =numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
+ self.torque = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
# The shear friction energy dissipation rates [W] | |
- self.es_dot =numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.es_dot = numpy.zeros(self.np, dtype=numpy.float64) | |
# The total shear energy dissipations [J] | |
- self.es =numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.es = numpy.zeros(self.np, dtype=numpy.float64) | |
# The viscous energy dissipation rates [W] | |
- self.ev_dot =numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.ev_dot = numpy.zeros(self.np, dtype=numpy.float64) | |
# The total viscois energy dissipation [J] | |
- self.ev =numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.ev = numpy.zeros(self.np, dtype=numpy.float64) | |
# The total particle pressures [Pa] | |
- self.p =numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.p = numpy.zeros(self.np, dtype=numpy.float64) | |
# The gravitational acceleration vector [N*m/s] | |
- self.g =numpy.array([0.0, 0.0, 0.0], dtype=numpy.float64) | |
+ self.g = numpy.array([0.0, 0.0, 0.0], dtype=numpy.float64) | |
# The Hookean coefficient for elastic stiffness normal to the contacts | |
# [N/m] | |
- self.k_n =numpy.ones(1, dtype=numpy.float64) * 1.16e9 | |
+ self.k_n = numpy.ones(1, dtype=numpy.float64) * 1.16e9 | |
# The Hookean coefficient for elastic stiffness tangential to the | |
# contacts [N/m] | |
- self.k_t =numpy.ones(1, dtype=numpy.float64) * 1.16e9 | |
+ self.k_t = numpy.ones(1, dtype=numpy.float64) * 1.16e9 | |
# The Hookean coefficient for elastic stiffness opposite of contact | |
# rotations. UNUSED | |
- self.k_r =numpy.zeros(1, dtype=numpy.float64) | |
+ self.k_r = numpy.zeros(1, dtype=numpy.float64) | |
# Young's modulus for contact stiffness [Pa]. This value is used | |
# instead of the Hookean stiffnesses (k_n, k_t) when self.E is larger | |
# than 0.0. | |
- self.E =numpy.zeros(1, dtype=numpy.float64) | |
+ self.E = numpy.zeros(1, dtype=numpy.float64) | |
# The viscosity normal to the contact [N/(m/s)] | |
- self.gamma_n =numpy.zeros(1, dtype=numpy.float64) | |
+ self.gamma_n = numpy.zeros(1, dtype=numpy.float64) | |
# The viscosity tangential to the contact [N/(m/s)] | |
- self.gamma_t =numpy.zeros(1, dtype=numpy.float64) | |
+ self.gamma_t = numpy.zeros(1, dtype=numpy.float64) | |
# The viscosity to contact rotation [N/(m/s)] | |
- self.gamma_r =numpy.zeros(1, dtype=numpy.float64) | |
+ self.gamma_r = numpy.zeros(1, dtype=numpy.float64) | |
# The coefficient of static friction on the contact [-] | |
- self.mu_s =numpy.ones(1, dtype=numpy.float64) * 0.5 | |
+ self.mu_s = numpy.ones(1, dtype=numpy.float64) * 0.5 | |
# The coefficient of dynamic friction on the contact [-] | |
- self.mu_d =numpy.ones(1, dtype=numpy.float64) * 0.5 | |
+ self.mu_d = numpy.ones(1, dtype=numpy.float64) * 0.5 | |
# The coefficient of rotational friction on the contact [-] | |
- self.mu_r =numpy.zeros(1, dtype=numpy.float64) | |
+ self.mu_r = numpy.zeros(1, dtype=numpy.float64) | |
# The viscosity normal to the walls [N/(m/s)] | |
- self.gamma_wn=numpy.zeros(1, dtype=numpy.float64) | |
+ self.gamma_wn = numpy.zeros(1, dtype=numpy.float64) | |
# The viscosity tangential to the walls [N/(m/s)] | |
- self.gamma_wt=numpy.zeros(1, dtype=numpy.float64) | |
+ self.gamma_wt = numpy.zeros(1, dtype=numpy.float64) | |
# The coeffient of static friction of the walls [-] | |
- self.mu_ws =numpy.ones(1, dtype=numpy.float64) * 0.5 | |
+ self.mu_ws = numpy.ones(1, dtype=numpy.float64) * 0.5 | |
# The coeffient of dynamic friction of the walls [-] | |
- self.mu_wd =numpy.ones(1, dtype=numpy.float64) * 0.5 | |
+ self.mu_wd = numpy.ones(1, dtype=numpy.float64) * 0.5 | |
# The particle density [kg/(m^3)] | |
- self.rho =numpy.ones(1, dtype=numpy.float64) * 2600.0 | |
+ self.rho = numpy.ones(1, dtype=numpy.float64) * 2600.0 | |
# The contact model to use | |
# 1: Normal: elasto-viscous, tangential: visco-frictional | |
# 2: Normal: elasto-viscous, tangential: elasto-visco-frictional | |
- self.contactmodel=numpy.ones(1, dtype=numpy.uint32) * 2 # lin-visc-el | |
+ self.contactmodel = numpy.ones(1, dtype=numpy.uint32) * 2 # lin-visc-el | |
# Capillary bond prefactor | |
- self.kappa =numpy.zeros(1, dtype=numpy.float64) | |
+ self.kappa = numpy.zeros(1, dtype=numpy.float64) | |
# Capillary bond debonding distance [m] | |
- self.db =numpy.zeros(1, dtype=numpy.float64) | |
+ self.db = numpy.zeros(1, dtype=numpy.float64) | |
# Capillary bond liquid volume [m^3] | |
- self.V_b =numpy.zeros(1, dtype=numpy.float64) | |
+ self.V_b = numpy.zeros(1, dtype=numpy.float64) | |
## Wall data | |
# Number of dynamic walls | |
# nw=1: Uniaxial (also used for shear experiments) | |
# nw=2: Biaxial | |
# nw=5: Triaxial | |
- self.nw =int(nw) | |
+ self.nw = int(nw) | |
# Wall modes | |
# 0: Fixed | |
# 1: Normal stress condition | |
# 2: Normal velocity condition | |
# 3: Normal stress and shear stress condition | |
- self.wmode =numpy.zeros(self.nw, dtype=numpy.int32) | |
+ self.wmode = numpy.zeros(self.nw, dtype=numpy.int32) | |
# Wall normals | |
- self.w_n =numpy.zeros((self.nw, self.nd), | |
- dtype=numpy.float64) | |
+ self.w_n = numpy.zeros((self.nw, self.nd), dtype=numpy.float64) | |
if self.nw >= 1: | |
- self.w_n[0,2]=-1.0 | |
+ self.w_n[0, 2] = -1.0 | |
if self.nw >= 2: | |
- self.w_n[1,0]=-1.0 | |
+ self.w_n[1, 0] = -1.0 | |
if self.nw >= 3: | |
- self.w_n[2,0]= 1.0 | |
+ self.w_n[2, 0] = 1.0 | |
if self.nw >= 4: | |
- self.w_n[3,1]=-1.0 | |
+ self.w_n[3, 1] = -1.0 | |
if self.nw >= 5: | |
- self.w_n[4,1]= 1.0 | |
+ self.w_n[4, 1] = 1.0 | |
# Wall positions on the axes that are parallel to the wall normal [m] | |
- self.w_x =numpy.ones(self.nw, dtype=numpy.float64) | |
+ self.w_x = numpy.ones(self.nw, dtype=numpy.float64) | |
# Wall masses [kg] | |
- self.w_m =numpy.zeros(self.nw, dtype=numpy.float64) | |
+ self.w_m = numpy.zeros(self.nw, dtype=numpy.float64) | |
# Wall velocities on the axes that are parallel to the wall normal [m/… | |
- self.w_vel =numpy.zeros(self.nw, dtype=numpy.float64) | |
+ self.w_vel = numpy.zeros(self.nw, dtype=numpy.float64) | |
# Wall forces on the axes that are parallel to the wall normal [m/s] | |
- self.w_force=numpy.zeros(self.nw, dtype=numpy.float64) | |
+ self.w_force = numpy.zeros(self.nw, dtype=numpy.float64) | |
# Wall stress on the axes that are parallel to the wall normal [Pa] | |
- self.w_sigma0 =numpy.zeros(self.nw, dtype=numpy.float64) | |
+ self.w_sigma0 = numpy.zeros(self.nw, dtype=numpy.float64) | |
# Wall stress modulation amplitude [Pa] | |
- self.w_sigma0_A=numpy.zeros(1, dtype=numpy.float64) | |
+ self.w_sigma0_A = numpy.zeros(1, dtype=numpy.float64) | |
# Wall stress modulation frequency [Hz] | |
- self.w_sigma0_f=numpy.zeros(1, dtype=numpy.float64) | |
+ self.w_sigma0_f = numpy.zeros(1, dtype=numpy.float64) | |
# Wall shear stress, enforced when wmode == 3 | |
- self.w_tau_x=numpy.zeros(1, dtype=numpy.float64) | |
+ self.w_tau_x = numpy.zeros(1, dtype=numpy.float64) | |
## Bond parameters | |
# Radius multiplier to the parallel-bond radii | |
- self.lambda_bar=numpy.ones(1, dtype=numpy.float64) | |
+ self.lambda_bar = numpy.ones(1, dtype=numpy.float64) | |
# Number of bonds | |
- self.nb0=0 | |
+ self.nb0 = 0 | |
# Bond tensile strength [Pa] | |
- self.sigma_b=numpy.ones(1, dtype=numpy.float64) * numpy.infty | |
+ self.sigma_b = numpy.ones(1, dtype=numpy.float64) * numpy.infty | |
# Bond shear strength [Pa] | |
- self.tau_b=numpy.ones(1, dtype=numpy.float64) * numpy.infty | |
+ self.tau_b = numpy.ones(1, dtype=numpy.float64) * numpy.infty | |
# Bond pairs | |
- self.bonds=numpy.zeros((self.nb0, 2), dtype=numpy.uint32) | |
+ self.bonds = numpy.zeros((self.nb0, 2), dtype=numpy.uint32) | |
# Parallel bond movement | |
- self.bonds_delta_n=numpy.zeros(self.nb0, dtype=numpy.float64) | |
+ self.bonds_delta_n = numpy.zeros(self.nb0, dtype=numpy.float64) | |
# Shear bond movement | |
- self.bonds_delta_t=numpy.zeros((self.nb0, self.nd), | |
- dtype=numpy.float64) | |
+ self.bonds_delta_t = numpy.zeros((self.nb0, self.nd), dtype=numpy.floa… | |
# Twisting bond movement | |
- self.bonds_omega_n=numpy.zeros(self.nb0, dtype=numpy.float64) | |
+ self.bonds_omega_n = numpy.zeros(self.nb0, dtype=numpy.float64) | |
# Bending bond movement | |
- self.bonds_omega_t=numpy.zeros((self.nb0, self.nd), | |
- dtype=numpy.float64) | |
+ self.bonds_omega_t = numpy.zeros((self.nb0, self.nd), dtype=numpy.floa… | |
## Fluid parameters | |
# Simulate fluid? True: Yes, False: no | |
- self.fluid=fluid | |
+ self.fluid = fluid | |
if self.fluid: | |
# Fluid solver type | |
# 0: Navier Stokes (fluid with inertia) | |
# 1: Stokes-Darcy (fluid without inertia) | |
- self.cfd_solver=numpy.zeros(1, dtype=numpy.int32) | |
+ self.cfd_solver = numpy.zeros(1, dtype=numpy.int32) | |
# Fluid dynamic viscosity [N/(m/s)] | |
- self.mu=numpy.zeros(1, dtype=numpy.float64) | |
+ self.mu = numpy.zeros(1, dtype=numpy.float64) | |
# Fluid velocities [m/s] | |
- self.v_f=numpy.zeros( | |
- (self.num[0], self.num[1], self.num[2], self.nd), | |
- dtype=numpy.float64) | |
+ self.v_f = numpy.zeros((self.num[0], self.num[1], self.num[2], sel… | |
+ dtype=numpy.float64) | |
# Fluid pressures [Pa] | |
- self.p_f=numpy.zeros((self.num[0], self.num[1], self.num[2]), | |
- dtype=numpy.float64) | |
+ self.p_f = numpy.zeros((self.num[0], self.num[1], self.num[2]), | |
+ dtype=numpy.float64) | |
# Fluid cell porosities [-] | |
- self.phi=numpy.zeros((self.num[0], self.num[1], self.num[2]), | |
- dtype=numpy.float64) | |
+ self.phi = numpy.zeros((self.num[0], self.num[1], self.num[2]), | |
+ dtype=numpy.float64) | |
# Fluid cell porosity change [1/s] | |
- self.dphi=numpy.zeros((self.num[0], self.num[1], self.num[2]), | |
- dtype=numpy.float64) | |
+ self.dphi = numpy.zeros((self.num[0], self.num[1], self.num[2]), | |
+ dtype=numpy.float64) | |
# Fluid density [kg/(m^3)] | |
- self.rho_f=numpy.ones(1, dtype=numpy.float64) * 1.0e3 | |
+ self.rho_f = numpy.ones(1, dtype=numpy.float64) * 1.0e3 | |
# Pressure modulation at the top boundary | |
- self.p_mod_A=numpy.zeros(1, dtype=numpy.float64) # Amplitude [Pa] | |
- self.p_mod_f=numpy.zeros(1, dtype=numpy.float64) # Frequency [Hz] | |
- self.p_mod_phi=numpy.zeros(1, dtype=numpy.float64) # Shift [rad] | |
+ self.p_mod_A = numpy.zeros(1, dtype=numpy.float64) # Amplitude [P… | |
+ self.p_mod_f = numpy.zeros(1, dtype=numpy.float64) # Frequency [H… | |
+ self.p_mod_phi = numpy.zeros(1, dtype=numpy.float64) # Shift [rad] | |
## Fluid solver parameters | |
t@@ -358,10 +342,10 @@ class sim: | |
# 0: Dirichlet | |
# 1: Neumann | |
# 2: Periodic (default) | |
- self.bc_xn=numpy.ones(1, dtype=numpy.int32)*2 # Neg. x bc | |
- self.bc_xp=numpy.ones(1, dtype=numpy.int32)*2 # Pos. x bc | |
- self.bc_yn=numpy.ones(1, dtype=numpy.int32)*2 # Neg. y bc | |
- self.bc_yp=numpy.ones(1, dtype=numpy.int32)*2 # Pos. y bc | |
+ self.bc_xn = numpy.ones(1, dtype=numpy.int32)*2 # Neg. x bc | |
+ self.bc_xp = numpy.ones(1, dtype=numpy.int32)*2 # Pos. x bc | |
+ self.bc_yn = numpy.ones(1, dtype=numpy.int32)*2 # Neg. y bc | |
+ self.bc_yp = numpy.ones(1, dtype=numpy.int32)*2 # Pos. y bc | |
# Boundary conditions at the top and bottom of the fluid grid | |
# 0: Dirichlet (default) | |
t@@ -369,96 +353,91 @@ class sim: | |
# 2: Neumann no slip (Navier Stokes), Periodic (Darcy) | |
# 3: Periodic (Navier-Stokes solver only) | |
# 4: Constant flux (Darcy solver only) | |
- self.bc_bot=numpy.zeros(1, dtype=numpy.int32) | |
- self.bc_top=numpy.zeros(1, dtype=numpy.int32) | |
+ self.bc_bot = numpy.zeros(1, dtype=numpy.int32) | |
+ self.bc_top = numpy.zeros(1, dtype=numpy.int32) | |
# Free slip boundaries? 1: yes | |
- self.free_slip_bot=numpy.ones(1, dtype=numpy.int32) | |
- self.free_slip_top=numpy.ones(1, dtype=numpy.int32) | |
+ self.free_slip_bot = numpy.ones(1, dtype=numpy.int32) | |
+ self.free_slip_top = numpy.ones(1, dtype=numpy.int32) | |
# Boundary-normal flux (in case of bc_*=4) | |
- self.bc_bot_flux=numpy.zeros(1, dtype=numpy.float64) | |
- self.bc_top_flux=numpy.zeros(1, dtype=numpy.float64) | |
+ self.bc_bot_flux = numpy.zeros(1, dtype=numpy.float64) | |
+ self.bc_top_flux = numpy.zeros(1, dtype=numpy.float64) | |
# Hold pressures constant in fluid cell (0: True, 1: False) | |
- self.p_f_constant=numpy.zeros( | |
- (self.num[0], self.num[1], self.num[2]), | |
- dtype=numpy.int32) | |
+ self.p_f_constant = numpy.zeros((self.num[0], | |
+ self.num[1], | |
+ self.num[2]), dtype=numpy.int32) | |
# Navier-Stokes | |
if self.cfd_solver[0] == 0: | |
# Smoothing parameter, should be in the range [0.0;1.0[. | |
# 0.0=no smoothing. | |
- self.gamma=numpy.array(0.0) | |
+ self.gamma = numpy.array(0.0) | |
# Under-relaxation parameter, should be in the range ]0.0;1.0]. | |
# 1.0=no under-relaxation | |
- self.theta=numpy.array(1.0) | |
+ self.theta = numpy.array(1.0) | |
# Velocity projection parameter, should be in the range | |
# [0.0;1.0] | |
- self.beta=numpy.array(0.0) | |
+ self.beta = numpy.array(0.0) | |
# Tolerance criteria for the normalized max. residual | |
- self.tolerance=numpy.array(1.0e-3) | |
+ self.tolerance = numpy.array(1.0e-3) | |
# The maximum number of iterations to perform per time step | |
- self.maxiter=numpy.array(1e4) | |
+ self.maxiter = numpy.array(1e4) | |
# The number of DEM time steps to perform between CFD updates | |
- self.ndem=numpy.array(1) | |
+ self.ndem = numpy.array(1) | |
# Porosity scaling factor | |
- self.c_phi=numpy.ones(1, dtype=numpy.float64) | |
+ self.c_phi = numpy.ones(1, dtype=numpy.float64) | |
# Fluid velocity scaling factor | |
- self.c_v=numpy.ones(1, dtype=numpy.float64) | |
+ self.c_v = numpy.ones(1, dtype=numpy.float64) | |
# DEM-CFD time scaling factor | |
- self.dt_dem_fac=numpy.ones(1, dtype=numpy.float64) | |
+ self.dt_dem_fac = numpy.ones(1, dtype=numpy.float64) | |
## Interaction forces | |
- self.f_d=numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
- self.f_p=numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
- self.f_v=numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
- self.f_sum=numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
+ self.f_d = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.f_p = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.f_v = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.f_sum = numpy.zeros((self.np, self.nd), dtype=numpy.float… | |
# Darcy | |
elif self.cfd_solver[0] == 1: | |
# Tolerance criteria for the normalized max. residual | |
- self.tolerance=numpy.array(1.0e-3) | |
+ self.tolerance = numpy.array(1.0e-3) | |
# The maximum number of iterations to perform per time step | |
- self.maxiter=numpy.array(1e4) | |
+ self.maxiter = numpy.array(1e4) | |
# The number of DEM time steps to perform between CFD updates | |
- self.ndem=numpy.array(1) | |
+ self.ndem = numpy.array(1) | |
# Porosity scaling factor | |
- self.c_phi=numpy.ones(1, dtype=numpy.float64) | |
+ self.c_phi = numpy.ones(1, dtype=numpy.float64) | |
# Interaction forces | |
- self.f_p=numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
+ self.f_p = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
# Adiabatic fluid compressibility [1/Pa]. | |
# Fluid bulk modulus=1/self.beta_f | |
- self.beta_f=numpy.ones(1, dtype=numpy.float64)*4.5e-10 | |
+ self.beta_f = numpy.ones(1, dtype=numpy.float64)*4.5e-10 | |
# Hydraulic permeability prefactor [m*m] | |
- self.k_c=numpy.ones(1, dtype=numpy.float64)*4.6e-10 | |
+ self.k_c = numpy.ones(1, dtype=numpy.float64)*4.6e-10 | |
else: | |
raise Exception('Value of cfd_solver not understood (' + \ | |
- str(self.cfd_solver[0]) + ')') | |
+ str(self.cfd_solver[0]) + ')') | |
# Particle color marker | |
- self.color=numpy.zeros(self.np, dtype=numpy.int32) | |
+ self.color = numpy.zeros(self.np, dtype=numpy.int32) | |
def __eq__(self, other): | |
''' | |
t@@ -738,24 +717,24 @@ class sim: | |
return False | |
elif self.c_phi != other.c_phi: | |
print('c_phi') | |
- return(84) | |
+ return 84 | |
elif self.c_v != other.c_v: | |
print('c_v') | |
elif self.dt_dem_fac != other.dt_dem_fac: | |
print('dt_dem_fac') | |
- return(85) | |
+ return 85 | |
elif (self.f_d != other.f_d).any(): | |
print('f_d') | |
- return(86) | |
+ return 86 | |
elif (self.f_p != other.f_p).any(): | |
print('f_p') | |
- return(87) | |
+ return 87 | |
elif (self.f_v != other.f_v).any(): | |
print('f_v') | |
- return(88) | |
+ return 88 | |
elif (self.f_sum != other.f_sum).any(): | |
print('f_sum') | |
- return(89) | |
+ return 89 | |
if self.cfd_solver == 1: | |
if self.tolerance != other.tolerance: | |
t@@ -769,26 +748,26 @@ class sim: | |
return False | |
elif self.c_phi != other.c_phi: | |
print('c_phi') | |
- return(84) | |
+ return 84 | |
elif (self.f_p != other.f_p).any(): | |
print('f_p') | |
- return(86) | |
+ return 86 | |
elif self.beta_f != other.beta_f: | |
print('beta_f') | |
- return(87) | |
+ return 87 | |
elif self.k_c != other.k_c: | |
print('k_c') | |
- return(88) | |
- elif (self.bc_xn != other.bc_xn): | |
+ return 88 | |
+ elif self.bc_xn != other.bc_xn: | |
print('bc_xn') | |
return False | |
- elif (self.bc_xp != other.bc_xp): | |
+ elif self.bc_xp != other.bc_xp: | |
print('bc_xp') | |
return False | |
- elif (self.bc_yn != other.bc_yn): | |
+ elif self.bc_yn != other.bc_yn: | |
print('bc_yn') | |
return False | |
- elif (self.bc_yp != other.bc_yp): | |
+ elif self.bc_yp != other.bc_yp: | |
print('bc_yp') | |
return False | |
t@@ -813,7 +792,7 @@ class sim: | |
if sid == '': | |
return self.sid | |
else: | |
- self.sid=sid | |
+ self.sid = sid | |
def idAppend(self, string): | |
''' | |
t@@ -825,22 +804,12 @@ class sim: | |
''' | |
self.sid += string | |
- def addParticle(self, | |
- x, | |
- radius, | |
- xyzsum=numpy.zeros(3), | |
- vel=numpy.zeros(3), | |
- fixvel=numpy.zeros(1), | |
- force=numpy.zeros(3), | |
- angpos=numpy.zeros(3), | |
- angvel=numpy.zeros(3), | |
- torque=numpy.zeros(3), | |
- es_dot=numpy.zeros(1), | |
- es=numpy.zeros(1), | |
- ev_dot=numpy.zeros(1), | |
- ev=numpy.zeros(1), | |
- p=numpy.zeros(1), | |
- color=0): | |
+ def addParticle(self, x, radius, xyzsum=numpy.zeros(3), vel=numpy.zeros(3), | |
+ fixvel=numpy.zeros(1), force=numpy.zeros(3), | |
+ angpos=numpy.zeros(3), angvel=numpy.zeros(3), | |
+ torque=numpy.zeros(3), es_dot=numpy.zeros(1), | |
+ es=numpy.zeros(1), ev_dot=numpy.zeros(1), | |
+ ev=numpy.zeros(1), p=numpy.zeros(1), color=0): | |
''' | |
Add a single particle to the simulation object. The only required | |
parameters are the position (x) and the radius (radius). | |
t@@ -849,17 +818,17 @@ class sim: | |
:type x: numpy.array | |
:param radius: The particle radius | |
:type radius: float | |
- :param vel: The particle linear velocity (default=[0,0,0]) | |
+ :param vel: The particle linear velocity (default=[0, 0, 0]) | |
:type vel: numpy.array | |
:param fixvel: 0: Do not fix particle velocity (default), 1: Fix | |
horizontal linear velocity, -1: Fix horizontal and vertical linear | |
velocity | |
:type fixvel: float | |
- :param angpos: The particle angular position (default=[0,0,0]) | |
+ :param angpos: The particle angular position (default=[0, 0, 0]) | |
:type angpos: numpy.array | |
- :param angvel: The particle angular velocity (default=[0,0,0]) | |
+ :param angvel: The particle angular velocity (default=[0, 0, 0]) | |
:type angvel: numpy.array | |
- :param torque: The particle torque (default=[0,0,0]) | |
+ :param torque: The particle torque (default=[0, 0, 0]) | |
:type torque: numpy.array | |
:param es_dot: The particle shear energy loss rate (default=0) | |
:type es_dot: float | |
t@@ -873,28 +842,28 @@ class sim: | |
:type p: float | |
''' | |
- self.np=self.np + 1 | |
- | |
- self.x =numpy.append(self.x, [x], axis=0) | |
- self.radius=numpy.append(self.radius, radius) | |
- self.vel =numpy.append(self.vel, [vel], axis=0) | |
- self.xyzsum=numpy.append(self.xyzsum, [xyzsum], axis=0) | |
- self.fixvel=numpy.append(self.fixvel, fixvel) | |
- self.force =numpy.append(self.force, [force], axis=0) | |
- self.angpos=numpy.append(self.angpos, [angpos], axis=0) | |
- self.angvel=numpy.append(self.angvel, [angvel], axis=0) | |
- self.torque=numpy.append(self.torque, [torque], axis=0) | |
- self.es_dot=numpy.append(self.es_dot, es_dot) | |
- self.es =numpy.append(self.es, es) | |
- self.ev_dot=numpy.append(self.ev_dot, ev_dot) | |
- self.ev =numpy.append(self.ev, ev) | |
- self.p =numpy.append(self.p, p) | |
- self.color =numpy.append(self.color, color) | |
+ self.np += 1 | |
+ | |
+ self.x = numpy.append(self.x, [x], axis=0) | |
+ self.radius = numpy.append(self.radius, radius) | |
+ self.vel = numpy.append(self.vel, [vel], axis=0) | |
+ self.xyzsum = numpy.append(self.xyzsum, [xyzsum], axis=0) | |
+ self.fixvel = numpy.append(self.fixvel, fixvel) | |
+ self.force = numpy.append(self.force, [force], axis=0) | |
+ self.angpos = numpy.append(self.angpos, [angpos], axis=0) | |
+ self.angvel = numpy.append(self.angvel, [angvel], axis=0) | |
+ self.torque = numpy.append(self.torque, [torque], axis=0) | |
+ self.es_dot = numpy.append(self.es_dot, es_dot) | |
+ self.es = numpy.append(self.es, es) | |
+ self.ev_dot = numpy.append(self.ev_dot, ev_dot) | |
+ self.ev = numpy.append(self.ev, ev) | |
+ self.p = numpy.append(self.p, p) | |
+ self.color = numpy.append(self.color, color) | |
if self.fluid: | |
- self.f_d =numpy.append(self.f_d, [numpy.zeros(3)], axis=0) | |
- self.f_p =numpy.append(self.f_p, [numpy.zeros(3)], axis=0) | |
- self.f_v =numpy.append(self.f_v, [numpy.zeros(3)], axis=0) | |
- self.f_sum =numpy.append(self.f_sum, [numpy.zeros(3)], axis=0) | |
+ self.f_d = numpy.append(self.f_d, [numpy.zeros(3)], axis=0) | |
+ self.f_p = numpy.append(self.f_p, [numpy.zeros(3)], axis=0) | |
+ self.f_v = numpy.append(self.f_v, [numpy.zeros(3)], axis=0) | |
+ self.f_sum = numpy.append(self.f_sum, [numpy.zeros(3)], axis=0) | |
def deleteParticle(self, i): | |
''' | |
t@@ -918,59 +887,59 @@ class sim: | |
if type(i) == tuple: | |
raise Exception('Cannot parse tuples as index value. ' + | |
- 'Valid types are int, list and numpy.ndarray') | |
- | |
- | |
- self.x =numpy.delete(self.x, i, axis=0) | |
- self.radius=numpy.delete(self.radius, i) | |
- self.vel =numpy.delete(self.vel, i, axis=0) | |
- self.xyzsum=numpy.delete(self.xyzsum, i, axis=0) | |
- self.fixvel=numpy.delete(self.fixvel, i) | |
- self.force =numpy.delete(self.force, i, axis=0) | |
- self.angpos=numpy.delete(self.angpos, i, axis=0) | |
- self.angvel=numpy.delete(self.angvel, i, axis=0) | |
- self.torque=numpy.delete(self.torque, i, axis=0) | |
- self.es_dot=numpy.delete(self.es_dot, i) | |
- self.es =numpy.delete(self.es, i) | |
- self.ev_dot=numpy.delete(self.ev_dot, i) | |
- self.ev =numpy.delete(self.ev, i) | |
- self.p =numpy.delete(self.p, i) | |
- self.color =numpy.delete(self.color, i) | |
+ 'Valid types are int, list and numpy.ndarray') | |
+ | |
+ | |
+ self.x = numpy.delete(self.x, i, axis=0) | |
+ self.radius = numpy.delete(self.radius, i) | |
+ self.vel = numpy.delete(self.vel, i, axis=0) | |
+ self.xyzsum = numpy.delete(self.xyzsum, i, axis=0) | |
+ self.fixvel = numpy.delete(self.fixvel, i) | |
+ self.force = numpy.delete(self.force, i, axis=0) | |
+ self.angpos = numpy.delete(self.angpos, i, axis=0) | |
+ self.angvel = numpy.delete(self.angvel, i, axis=0) | |
+ self.torque = numpy.delete(self.torque, i, axis=0) | |
+ self.es_dot = numpy.delete(self.es_dot, i) | |
+ self.es = numpy.delete(self.es, i) | |
+ self.ev_dot = numpy.delete(self.ev_dot, i) | |
+ self.ev = numpy.delete(self.ev, i) | |
+ self.p = numpy.delete(self.p, i) | |
+ self.color = numpy.delete(self.color, i) | |
if self.fluid: | |
# Darcy and Navier-Stokes | |
- self.f_p =numpy.delete(self.f_p, i, axis=0) | |
+ self.f_p = numpy.delete(self.f_p, i, axis=0) | |
if self.cfd_solver[0] == 0: # Navier-Stokes | |
- self.f_d =numpy.delete(self.f_d, i, axis=0) | |
- self.f_v =numpy.delete(self.f_v, i, axis=0) | |
- self.f_sum =numpy.delete(self.f_sum, i, axis=0) | |
+ self.f_d = numpy.delete(self.f_d, i, axis=0) | |
+ self.f_v = numpy.delete(self.f_v, i, axis=0) | |
+ self.f_sum = numpy.delete(self.f_sum, i, axis=0) | |
def deleteAllParticles(self): | |
''' | |
Deletes all particles in the simulation object. | |
''' | |
- self.np =0 | |
- self.x =numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.radius =numpy.ones(self.np, dtype=numpy.float64) | |
- self.xyzsum =numpy.zeros((self.np, 3), dtype=numpy.float64) | |
- self.vel =numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.fixvel =numpy.zeros(self.np, dtype=numpy.float64) | |
- self.force =numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.angpos =numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.angvel =numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.torque =numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.es_dot =numpy.zeros(self.np, dtype=numpy.float64) | |
- self.es =numpy.zeros(self.np, dtype=numpy.float64) | |
- self.ev_dot =numpy.zeros(self.np, dtype=numpy.float64) | |
- self.ev =numpy.zeros(self.np, dtype=numpy.float64) | |
- self.p =numpy.zeros(self.np, dtype=numpy.float64) | |
- self.color =numpy.zeros(self.np, dtype=numpy.int32) | |
- self.f_d =numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.f_p =numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.f_v =numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.f_sum =numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.np = 0 | |
+ self.x = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.radius = numpy.ones(self.np, dtype=numpy.float64) | |
+ self.xyzsum = numpy.zeros((self.np, 3), dtype=numpy.float64) | |
+ self.vel = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.fixvel = numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.force = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.angpos = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.angvel = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.torque = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.es_dot = numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.es = numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.ev_dot = numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.ev = numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.p = numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.color = numpy.zeros(self.np, dtype=numpy.int32) | |
+ self.f_d = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.f_p = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.f_v = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.f_sum = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
def readbin(self, targetbin, verbose=True, bonds=True, sigma0mod=True, | |
- esysparticle=False): | |
+ esysparticle=False): | |
''' | |
Reads a target ``sphere`` binary file. | |
t@@ -994,368 +963,327 @@ class sim: | |
:type esysparticle: bool | |
''' | |
- fh=None | |
+ fh = None | |
try: | |
if verbose: | |
print("Input file: {0}".format(targetbin)) | |
- fh=open(targetbin, "rb") | |
+ fh = open(targetbin, "rb") | |
# Read the file version | |
- self.version=numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.version = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
# Read the number of dimensions and particles | |
- self.nd=int(numpy.fromfile(fh, dtype=numpy.int32, count=1)) | |
- self.np=int(numpy.fromfile(fh, dtype=numpy.uint32, count=1)) | |
+ self.nd = int(numpy.fromfile(fh, dtype=numpy.int32, count=1)) | |
+ self.np = int(numpy.fromfile(fh, dtype=numpy.uint32, count=1)) | |
# Read the time variables | |
- self.time_dt=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.time_current =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.time_total =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.time_file_dt =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.time_step_count =\ | |
- numpy.fromfile(fh, dtype=numpy.uint32, count=1) | |
+ self.time_dt = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.time_current = numpy.fromfile(fh, dtype=numpy.float64, count=… | |
+ self.time_total = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.time_file_dt = numpy.fromfile(fh, dtype=numpy.float64, count=… | |
+ self.time_step_count = numpy.fromfile(fh, dtype=numpy.uint32, coun… | |
# Allocate array memory for particles | |
- self.x =numpy.empty((self.np, self.nd), dtype=numpy.float64) | |
- self.radius =numpy.empty(self.np, dtype=numpy.float64) | |
- self.xyzsum =numpy.empty((self.np, 3), dtype=numpy.float64) | |
- self.vel =numpy.empty((self.np, self.nd), dtype=numpy.float64) | |
- self.fixvel =numpy.empty(self.np, dtype=numpy.float64) | |
- self.es_dot =numpy.empty(self.np, dtype=numpy.float64) | |
- self.es =numpy.empty(self.np, dtype=numpy.float64) | |
- self.ev_dot =numpy.empty(self.np, dtype=numpy.float64) | |
- self.ev =numpy.empty(self.np, dtype=numpy.float64) | |
- self.p =numpy.empty(self.np, dtype=numpy.float64) | |
+ self.x = numpy.empty((self.np, self.nd), dtype=numpy.float64) | |
+ self.radius = numpy.empty(self.np, dtype=numpy.float64) | |
+ self.xyzsum = numpy.empty((self.np, 3), dtype=numpy.float64) | |
+ self.vel = numpy.empty((self.np, self.nd), dtype=numpy.float64) | |
+ self.fixvel = numpy.empty(self.np, dtype=numpy.float64) | |
+ self.es_dot = numpy.empty(self.np, dtype=numpy.float64) | |
+ self.es = numpy.empty(self.np, dtype=numpy.float64) | |
+ self.ev_dot = numpy.empty(self.np, dtype=numpy.float64) | |
+ self.ev = numpy.empty(self.np, dtype=numpy.float64) | |
+ self.p = numpy.empty(self.np, dtype=numpy.float64) | |
# Read remaining data from binary | |
- self.origo=numpy.fromfile(fh, dtype=numpy.float64, count=self.nd) | |
- self.L=numpy.fromfile(fh, dtype=numpy.float64, count=self.nd) | |
- self.num=numpy.fromfile(fh, dtype=numpy.uint32, count=self.nd) | |
- self.periodic=numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
+ self.origo = numpy.fromfile(fh, dtype=numpy.float64, count=self.nd) | |
+ self.L = numpy.fromfile(fh, dtype=numpy.float64, count=self.nd) | |
+ self.num = numpy.fromfile(fh, dtype=numpy.uint32, count=self.nd) | |
+ self.periodic = numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
if self.version >= 2.14: | |
- self.adaptive=numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
+ self.adaptive = numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
else: | |
- self.adaptive=numpy.zeros(1, dtype=numpy.float64) | |
+ self.adaptive = numpy.zeros(1, dtype=numpy.float64) | |
# Per-particle vectors | |
for i in numpy.arange(self.np): | |
- self.x[i,:] =\ | |
+ self.x[i, :] =\ | |
numpy.fromfile(fh, dtype=numpy.float64, count=self.nd) | |
self.radius[i] =\ | |
numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
if self.version >= 1.03: | |
- self.xyzsum=numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=self.np*3).reshape(self.np,3) | |
+ self.xyzsum = numpy.fromfile(fh, dtype=numpy.float64,\ | |
+ count=self.np*3).reshape(self.np, 3) | |
else: | |
- self.xyzsum=numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=self.np*2).reshape(self.np,2) | |
+ self.xyzsum = numpy.fromfile(fh, dtype=numpy.float64,\ | |
+ count=self.np*2).reshape(self.np, 2) | |
for i in numpy.arange(self.np): | |
- self.vel[i,:] =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=self.nd) | |
- self.fixvel[i] =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- | |
- self.force=numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=self.np*self.nd).reshape(self.np, self.nd) | |
- | |
- self.angpos=numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=self.np*self.nd).reshape(self.np, self.nd) | |
- self.angvel=numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=self.np*self.nd).reshape(self.np, self.nd) | |
- self.torque=numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=self.np*self.nd).reshape(self.np, self.nd) | |
+ self.vel[i, :] = numpy.fromfile(fh, dtype=numpy.float64, count… | |
+ self.fixvel[i] = numpy.fromfile(fh, dtype=numpy.float64, count… | |
+ | |
+ self.force = numpy.fromfile(fh, dtype=numpy.float64,\ | |
+ count=self.np*self.nd)\ | |
+ .reshape(self.np, self.nd) | |
+ | |
+ self.angpos = numpy.fromfile(fh, dtype=numpy.float64,\ | |
+ count=self.np*self.nd)\ | |
+ .reshape(self.np, self.nd) | |
+ self.angvel = numpy.fromfile(fh, dtype=numpy.float64,\ | |
+ count=self.np*self.nd)\ | |
+ .reshape(self.np, self.nd) | |
+ self.torque = numpy.fromfile(fh, dtype=numpy.float64,\ | |
+ count=self.np*self.nd)\ | |
+ .reshape(self.np, self.nd) | |
if esysparticle: | |
return | |
# Per-particle single-value parameters | |
- self.es_dot=numpy.fromfile(fh, dtype=numpy.float64, count=self.np) | |
- self.es =numpy.fromfile(fh, dtype=numpy.float64, count=self.np) | |
- self.ev_dot=numpy.fromfile(fh, dtype=numpy.float64, count=self.np) | |
- self.ev =numpy.fromfile(fh, dtype=numpy.float64, count=self.np) | |
- self.p =numpy.fromfile(fh, dtype=numpy.float64, count=self.np) | |
+ self.es_dot = numpy.fromfile(fh, dtype=numpy.float64, count=self.n… | |
+ self.es = numpy.fromfile(fh, dtype=numpy.float64, count=self.np) | |
+ self.ev_dot = numpy.fromfile(fh, dtype=numpy.float64, count=self.n… | |
+ self.ev = numpy.fromfile(fh, dtype=numpy.float64, count=self.np) | |
+ self.p = numpy.fromfile(fh, dtype=numpy.float64, count=self.np) | |
# Constant, global physical parameters | |
- self.g =numpy.fromfile(fh, dtype=numpy.float64, count=self.nd) | |
- self.k_n =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.k_t =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.k_r =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.g = numpy.fromfile(fh, dtype=numpy.float64, count=self.nd) | |
+ self.k_n = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.k_t = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.k_r = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
if self.version >= 2.13: | |
- self.E=numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.E = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
else: | |
- self.E=numpy.zeros(1, dtype=numpy.float64) | |
- self.gamma_n =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.gamma_t =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.gamma_r =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.mu_s =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.mu_d =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.mu_r =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.gamma_wn =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.gamma_wt =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.mu_ws =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.mu_wd =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.rho =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.contactmodel=numpy.fromfile(fh, dtype=numpy.uint32, count=1) | |
- self.kappa =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.db =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.V_b =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.E = numpy.zeros(1, dtype=numpy.float64) | |
+ self.gamma_n = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.gamma_t = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.gamma_r = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.mu_s = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.mu_d = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.mu_r = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.gamma_wn = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.gamma_wt = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.mu_ws = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.mu_wd = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.rho = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.contactmodel = numpy.fromfile(fh, dtype=numpy.uint32, count=1) | |
+ self.kappa = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.db = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.V_b = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
# Wall data | |
- self.nw =int(numpy.fromfile(fh, dtype=numpy.uint32, count=1)) | |
- self.wmode =numpy.empty(self.nw, dtype=numpy.int32) | |
- self.w_n =numpy.empty(self.nw*self.nd, dtype=numpy.float64)\ | |
- .reshape(self.nw,self.nd) | |
- self.w_x =numpy.empty(self.nw, dtype=numpy.float64) | |
- self.w_m =numpy.empty(self.nw, dtype=numpy.float64) | |
- self.w_vel =numpy.empty(self.nw, dtype=numpy.float64) | |
- self.w_force=numpy.empty(self.nw, dtype=numpy.float64) | |
- self.w_sigma0 =numpy.empty(self.nw, dtype=numpy.float64) | |
- | |
- self.wmode =numpy.fromfile(fh, dtype=numpy.int32, count=self.nw) | |
+ self.nw = int(numpy.fromfile(fh, dtype=numpy.uint32, count=1)) | |
+ self.wmode = numpy.empty(self.nw, dtype=numpy.int32) | |
+ self.w_n = numpy.empty(self.nw*self.nd, dtype=numpy.float64)\ | |
+ .reshape(self.nw, self.nd) | |
+ self.w_x = numpy.empty(self.nw, dtype=numpy.float64) | |
+ self.w_m = numpy.empty(self.nw, dtype=numpy.float64) | |
+ self.w_vel = numpy.empty(self.nw, dtype=numpy.float64) | |
+ self.w_force = numpy.empty(self.nw, dtype=numpy.float64) | |
+ self.w_sigma0 = numpy.empty(self.nw, dtype=numpy.float64) | |
+ | |
+ self.wmode = numpy.fromfile(fh, dtype=numpy.int32, count=self.nw) | |
for i in numpy.arange(self.nw): | |
- self.w_n[i,:] =\ | |
+ self.w_n[i, :] =\ | |
numpy.fromfile(fh, dtype=numpy.float64, count=self.nd) | |
- self.w_x[i] =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.w_x[i] = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
for i in numpy.arange(self.nw): | |
- self.w_m[i] =numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.w_vel[i]=numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.w_force[i] =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.w_sigma0[i]= numpy.fromfile(fh, dtype=numpy.float64, coun… | |
+ self.w_m[i] = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.w_vel[i] = numpy.fromfile(fh, dtype=numpy.float64, count=… | |
+ self.w_force[i] = numpy.fromfile(fh, dtype=numpy.float64, coun… | |
+ self.w_sigma0[i] = numpy.fromfile(fh, dtype=numpy.float64, cou… | |
if sigma0mod: | |
- self.w_sigma0_A=numpy.fromfile(fh, dtype=numpy.float64, count=… | |
- self.w_sigma0_f=numpy.fromfile(fh, dtype=numpy.float64, count=… | |
+ self.w_sigma0_A = numpy.fromfile(fh, dtype=numpy.float64, coun… | |
+ self.w_sigma0_f = numpy.fromfile(fh, dtype=numpy.float64, coun… | |
if self.version >= 2.1: | |
- self.w_tau_x=numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.w_tau_x = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
else: | |
- self.w_tau_x=numpy.zeros(1, dtype=numpy.float64) | |
+ self.w_tau_x = numpy.zeros(1, dtype=numpy.float64) | |
if bonds: | |
# Inter-particle bonds | |
- self.lambda_bar =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.nb0=int(numpy.fromfile(fh, dtype=numpy.uint32, count=1)) | |
- self.sigma_b=numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.tau_b=numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.bonds=numpy.empty((self.nb0, 2), dtype=numpy.uint32) | |
+ self.lambda_bar = numpy.fromfile(fh, dtype=numpy.float64, coun… | |
+ self.nb0 = int(numpy.fromfile(fh, dtype=numpy.uint32, count=1)) | |
+ self.sigma_b = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.tau_b = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.bonds = numpy.empty((self.nb0, 2), dtype=numpy.uint32) | |
for i in numpy.arange(self.nb0): | |
- self.bonds[i,0]=numpy.fromfile(fh, dtype=numpy.uint32, | |
- count=1) | |
- self.bonds[i,1]=numpy.fromfile(fh, dtype=numpy.uint32, | |
- count=1) | |
- self.bonds_delta_n=numpy.fromfile(fh, dtype=numpy.float64, | |
- count=self.nb0) | |
- self.bonds_delta_t=numpy.fromfile(fh, dtype=numpy.float64, | |
- count=self.nb0*self.nd).reshape(self.nb0, self.nd) | |
- self.bonds_omega_n=numpy.fromfile(fh, dtype=numpy.float64, | |
- count=self.nb0) | |
- self.bonds_omega_t=numpy.fromfile(fh, dtype=numpy.float64, | |
- count=self.nb0*self.nd).reshape(self.nb0, self.nd) | |
+ self.bonds[i, 0] = numpy.fromfile(fh, dtype=numpy.uint32, … | |
+ self.bonds[i, 1] = numpy.fromfile(fh, dtype=numpy.uint32, … | |
+ self.bonds_delta_n = numpy.fromfile(fh, dtype=numpy.float64, | |
+ count=self.nb0) | |
+ self.bonds_delta_t = numpy.fromfile(fh, dtype=numpy.float64, | |
+ count=self.nb0*self.nd)\ | |
+ .reshape(self.nb0, self.nd) | |
+ self.bonds_omega_n = numpy.fromfile(fh, dtype=numpy.float64, | |
+ count=self.nb0) | |
+ self.bonds_omega_t = numpy.fromfile(fh, dtype=numpy.float64, | |
+ count=self.nb0*self.nd)\ | |
+ .reshape(self.nb0, self.nd) | |
else: | |
- self.nb0=0 | |
+ self.nb0 = 0 | |
if self.fluid: | |
if self.version >= 2.0: | |
- self.cfd_solver=numpy.fromfile(fh, dtype=numpy.int32, | |
- count=1) | |
+ self.cfd_solver = numpy.fromfile(fh, dtype=numpy.int32, co… | |
else: | |
- self.cfd_solver=numpy.zeros(1, dtype=numpy.int32) | |
- | |
- self.mu=numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- | |
- self.v_f=numpy.empty( | |
- (self.num[0], self.num[1], self.num[2], self.nd), | |
- dtype=numpy.float64) | |
- self.p_f=\ | |
- numpy.empty((self.num[0],self.num[1],self.num[2]), | |
- dtype=numpy.float64) | |
- self.phi=\ | |
- numpy.empty((self.num[0],self.num[1],self.num[2]), | |
- dtype=numpy.float64) | |
- self.dphi=\ | |
- numpy.empty((self.num[0],self.num[1],self.num[2]), | |
- dtype=numpy.float64) | |
+ self.cfd_solver = numpy.zeros(1, dtype=numpy.int32) | |
+ | |
+ self.mu = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ | |
+ self.v_f = numpy.empty((self.num[0], | |
+ self.num[1], | |
+ self.num[2], | |
+ self.nd), dtype=numpy.float64) | |
+ self.p_f = numpy.empty((self.num[0], | |
+ self.num[1], | |
+ self.num[2]), dtype=numpy.float64) | |
+ self.phi = numpy.empty((self.num[0], | |
+ self.num[1], | |
+ self.num[2]), dtype=numpy.float64) | |
+ self.dphi = numpy.empty((self.num[0], | |
+ self.num[1], | |
+ self.num[2]), dtype=numpy.float64) | |
for z in numpy.arange(self.num[2]): | |
for y in numpy.arange(self.num[1]): | |
for x in numpy.arange(self.num[0]): | |
- self.v_f[x,y,z,0]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=1) | |
- self.v_f[x,y,z,1]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=1) | |
- self.v_f[x,y,z,2]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=1) | |
- self.p_f[x,y,z]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=1) | |
- self.phi[x,y,z]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=1) | |
- self.dphi[x,y,z]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64,\ | |
- count=1)/(self.time_dt*self.ndem) | |
+ self.v_f[x, y, z, 0] = numpy.fromfile(fh, | |
+ dtype=numpy.flo… | |
+ count=1) | |
+ self.v_f[x, y, z, 1] = numpy.fromfile(fh, | |
+ dtype=numpy.flo… | |
+ count=1) | |
+ self.v_f[x, y, z, 2] = numpy.fromfile(fh, | |
+ dtype=numpy.flo… | |
+ count=1) | |
+ self.p_f[x, y, z] = numpy.fromfile(fh, dtype=numpy… | |
+ count=1) | |
+ self.phi[x, y, z] = numpy.fromfile(fh, dtype=numpy… | |
+ count=1) | |
+ self.dphi[x, y, z] = numpy.fromfile(fh, dtype=nump… | |
+ count=1)\ | |
+ /(self.time_dt*self.ndem) | |
if self.version >= 0.36: | |
- self.rho_f =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.p_mod_A =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.p_mod_f =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.p_mod_phi =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.rho_f = numpy.fromfile(fh, dtype=numpy.float64, count… | |
+ self.p_mod_A = numpy.fromfile(fh, dtype=numpy.float64, cou… | |
+ self.p_mod_f = numpy.fromfile(fh, dtype=numpy.float64, cou… | |
+ self.p_mod_phi = numpy.fromfile(fh, dtype=numpy.float64, c… | |
if self.version >= 2.12 and self.cfd_solver[0] == 1: | |
- self.bc_xn =\ | |
- numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
- self.bc_xp =\ | |
- numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
- self.bc_yn =\ | |
- numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
- self.bc_yp =\ | |
- numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
- | |
- self.bc_bot =\ | |
- numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
- self.bc_top =\ | |
- numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
- self.free_slip_bot =\ | |
- numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
- self.free_slip_top =\ | |
- numpy.fromfile(fh, dtype=numpy.int32, count=1) | |
+ self.bc_xn = numpy.fromfile(fh, dtype=numpy.int32, cou… | |
+ self.bc_xp = numpy.fromfile(fh, dtype=numpy.int32, cou… | |
+ self.bc_yn = numpy.fromfile(fh, dtype=numpy.int32, cou… | |
+ self.bc_yp = numpy.fromfile(fh, dtype=numpy.int32, cou… | |
+ | |
+ self.bc_bot = numpy.fromfile(fh, dtype=numpy.int32, count=… | |
+ self.bc_top = numpy.fromfile(fh, dtype=numpy.int32, count=… | |
+ self.free_slip_bot = numpy.fromfile(fh, dtype=numpy.int32,… | |
+ self.free_slip_top = numpy.fromfile(fh, dtype=numpy.int32,… | |
if self.version >= 2.11: | |
- self.bc_bot_flux =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.bc_top_flux =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.bc_bot_flux = numpy.fromfile(fh, dtype=numpy.floa… | |
+ count=1) | |
+ self.bc_top_flux = numpy.fromfile(fh, dtype=numpy.floa… | |
+ count=1) | |
else: | |
- self.bc_bot_flux=numpy.zeros(1, dtype=numpy.float64) | |
- self.bc_top_flux=numpy.zeros(1, dtype=numpy.float64) | |
+ self.bc_bot_flux = numpy.zeros(1, dtype=numpy.float64) | |
+ self.bc_top_flux = numpy.zeros(1, dtype=numpy.float64) | |
if self.version >= 2.15: | |
- self.p_f_constant=\ | |
- numpy.empty((self.num[0],self.num[1],self.num[2]), | |
- dtype=numpy.int32) | |
+ self.p_f_constant = numpy.empty((self.num[0], | |
+ self.num[1], | |
+ self.num[2]), | |
+ dtype=numpy.int32) | |
for z in numpy.arange(self.num[2]): | |
for y in numpy.arange(self.num[1]): | |
for x in numpy.arange(self.num[0]): | |
- self.p_f_constant[x,y,z]=\ | |
- numpy.fromfile(fh, | |
- dtype=numpy.int32, | |
- count=1) | |
+ self.p_f_constant[x, y, z] = \ | |
+ numpy.fromfile(fh, dtype=numpy.int32, … | |
else: | |
- self.p_f_constant=numpy.zeros( | |
- (self.num[0], self.num[1], self.num[2]), | |
- dtype=numpy.int32) | |
+ self.p_f_constant = numpy.zeros((self.num[0], | |
+ self.num[1], | |
+ self.num[2]), | |
+ dtype=numpy.int32) | |
if self.version >= 2.0 and self.cfd_solver == 0: | |
- self.gamma=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.theta=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.beta =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.tolerance =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.maxiter=\ | |
- numpy.fromfile(fh, dtype=numpy.uint32, count=1) | |
+ self.gamma = numpy.fromfile(fh, dtype=numpy.float64, count… | |
+ self.theta = numpy.fromfile(fh, dtype=numpy.float64, count… | |
+ self.beta = numpy.fromfile(fh, dtype=numpy.float64, count=… | |
+ self.tolerance = numpy.fromfile(fh, dtype=numpy.float64, c… | |
+ self.maxiter = numpy.fromfile(fh, dtype=numpy.uint32, coun… | |
if self.version >= 1.01: | |
- self.ndem=\ | |
- numpy.fromfile(fh, dtype=numpy.uint32, count=1) | |
+ self.ndem = numpy.fromfile(fh, dtype=numpy.uint32, cou… | |
else: | |
- self.ndem=1 | |
+ self.ndem = 1 | |
if self.version >= 1.04: | |
- self.c_phi=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=… | |
- self.c_v =\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.c_phi = numpy.fromfile(fh, dtype=numpy.float64, c… | |
+ self.c_v = numpy.fromfile(fh, dtype=numpy.float64, cou… | |
if self.version == 1.06: | |
- self.c_a =\ | |
- numpy.fromfile(fh, \ | |
- dtype=numpy.float64, count=1) | |
+ self.c_a = numpy.fromfile(fh, dtype=numpy.float64, | |
+ count=1) | |
elif self.version >= 1.07: | |
- self.dt_dem_fac =\ | |
- numpy.fromfile(fh, \ | |
- dtype=numpy.float64, count=1) | |
+ self.dt_dem_fac = numpy.fromfile(fh, dtype=numpy.f… | |
+ count=1) | |
else: | |
- self.c_a=numpy.ones(1, dtype=numpy.float64) | |
+ self.c_a = numpy.ones(1, dtype=numpy.float64) | |
else: | |
- self.c_phi=numpy.ones(1, dtype=numpy.float64) | |
- self.c_v=numpy.ones(1, dtype=numpy.float64) | |
+ self.c_phi = numpy.ones(1, dtype=numpy.float64) | |
+ self.c_v = numpy.ones(1, dtype=numpy.float64) | |
if self.version >= 1.05: | |
- self.f_d=numpy.empty_like(self.x) | |
- self.f_p=numpy.empty_like(self.x) | |
- self.f_v=numpy.empty_like(self.x) | |
- self.f_sum=numpy.empty_like(self.x) | |
+ self.f_d = numpy.empty_like(self.x) | |
+ self.f_p = numpy.empty_like(self.x) | |
+ self.f_v = numpy.empty_like(self.x) | |
+ self.f_sum = numpy.empty_like(self.x) | |
for i in numpy.arange(self.np): | |
- self.f_d[i,:]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, | |
- count=self.nd) | |
+ self.f_d[i, :] = numpy.fromfile(fh, dtype=numpy.fl… | |
+ count=self.nd) | |
for i in numpy.arange(self.np): | |
- self.f_p[i,:]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, | |
- count=self.nd) | |
+ self.f_p[i, :] = numpy.fromfile(fh, dtype=numpy.fl… | |
+ count=self.nd) | |
for i in numpy.arange(self.np): | |
- self.f_v[i,:]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, | |
- count=self.nd) | |
+ self.f_v[i, :] = numpy.fromfile(fh, dtype=numpy.fl… | |
+ count=self.nd) | |
for i in numpy.arange(self.np): | |
- self.f_sum[i,:]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, | |
- count=self.nd) | |
+ self.f_sum[i, :] = numpy.fromfile(fh, dtype=numpy.… | |
+ count=self.nd) | |
else: | |
- self.f_d=numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
- self.f_p=numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
- self.f_v=numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
- self.f_sum=numpy.zeros((self.np, self.nd), | |
- dtype=numpy.float64) | |
+ self.f_d = numpy.zeros((self.np, self.nd), | |
+ dtype=numpy.float64) | |
+ self.f_p = numpy.zeros((self.np, self.nd), | |
+ dtype=numpy.float64) | |
+ self.f_v = numpy.zeros((self.np, self.nd), | |
+ dtype=numpy.float64) | |
+ self.f_sum = numpy.zeros((self.np, self.nd), | |
+ dtype=numpy.float64) | |
elif self.version >= 2.0 and self.cfd_solver == 1: | |
- self.tolerance=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.maxiter=\ | |
- numpy.fromfile(fh, dtype=numpy.uint32, count=1) | |
- self.ndem=numpy.fromfile(fh, dtype=numpy.uint32, count=1) | |
- self.c_phi=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- self.f_p=numpy.empty_like(self.x) | |
+ self.tolerance = numpy.fromfile(fh, dtype=numpy.float64, c… | |
+ self.maxiter = numpy.fromfile(fh, dtype=numpy.uint32, coun… | |
+ self.ndem = numpy.fromfile(fh, dtype=numpy.uint32, count=1) | |
+ self.c_phi = numpy.fromfile(fh, dtype=numpy.float64, count… | |
+ self.f_p = numpy.empty_like(self.x) | |
for i in numpy.arange(self.np): | |
- self.f_p[i,:]=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, | |
- count=self.nd) | |
- self.beta_f=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
- | |
- self.k_c=\ | |
- numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
+ self.f_p[i, :] = numpy.fromfile(fh, dtype=numpy.float6… | |
+ count=self.nd) | |
+ self.beta_f = numpy.fromfile(fh, dtype=numpy.float64, coun… | |
+ self.k_c = numpy.fromfile(fh, dtype=numpy.float64, count=1) | |
if self.version >= 1.02: | |
- self.color =\ | |
- numpy.fromfile(fh, dtype=numpy.int32, count=self.np) | |
+ self.color = numpy.fromfile(fh, dtype=numpy.int32, count=self.… | |
else: | |
- self.color=numpy.zeros(self.np, dtype=numpy.int32) | |
+ self.color = numpy.zeros(self.np, dtype=numpy.int32) | |
finally: | |
- self.version[0]=VERSION | |
+ self.version[0] = VERSION | |
if fh is not None: | |
fh.close() | |
t@@ -1371,13 +1299,13 @@ class sim: | |
:param verbose: Show diagnostic information (default=True) | |
:type verbose: bool | |
''' | |
- fh=None | |
- try : | |
- targetbin=folder + "/" + self.sid + ".bin" | |
+ fh = None | |
+ try: | |
+ targetbin = folder + "/" + self.sid + ".bin" | |
if verbose: | |
print("Output file: {0}".format(targetbin)) | |
- fh=open(targetbin, "wb") | |
+ fh = open(targetbin, "wb") | |
# Write the current version number | |
fh.write(self.version.astype(numpy.float64)) | |
t@@ -1402,14 +1330,14 @@ class sim: | |
# Per-particle vectors | |
for i in numpy.arange(self.np): | |
- fh.write(self.x[i,:].astype(numpy.float64)) | |
+ fh.write(self.x[i, :].astype(numpy.float64)) | |
fh.write(self.radius[i].astype(numpy.float64)) | |
if self.np > 0: | |
fh.write(self.xyzsum.astype(numpy.float64)) | |
for i in numpy.arange(self.np): | |
- fh.write(self.vel[i,:].astype(numpy.float64)) | |
+ fh.write(self.vel[i, :].astype(numpy.float64)) | |
fh.write(self.fixvel[i].astype(numpy.float64)) | |
if self.np > 0: | |
t@@ -1451,7 +1379,7 @@ class sim: | |
for i in numpy.arange(self.nw): | |
fh.write(self.wmode[i].astype(numpy.int32)) | |
for i in numpy.arange(self.nw): | |
- fh.write(self.w_n[i,:].astype(numpy.float64)) | |
+ fh.write(self.w_n[i, :].astype(numpy.float64)) | |
fh.write(self.w_x[i].astype(numpy.float64)) | |
for i in numpy.arange(self.nw): | |
t@@ -1468,8 +1396,8 @@ class sim: | |
fh.write(self.sigma_b.astype(numpy.float64)) | |
fh.write(self.tau_b.astype(numpy.float64)) | |
for i in numpy.arange(self.nb0): | |
- fh.write(self.bonds[i,0].astype(numpy.uint32)) | |
- fh.write(self.bonds[i,1].astype(numpy.uint32)) | |
+ fh.write(self.bonds[i, 0].astype(numpy.uint32)) | |
+ fh.write(self.bonds[i, 1].astype(numpy.uint32)) | |
fh.write(self.bonds_delta_n.astype(numpy.float64)) | |
fh.write(self.bonds_delta_t.astype(numpy.float64)) | |
fh.write(self.bonds_omega_n.astype(numpy.float64)) | |
t@@ -1482,13 +1410,13 @@ class sim: | |
for z in numpy.arange(self.num[2]): | |
for y in numpy.arange(self.num[1]): | |
for x in numpy.arange(self.num[0]): | |
- fh.write(self.v_f[x,y,z,0].astype(numpy.float64)) | |
- fh.write(self.v_f[x,y,z,1].astype(numpy.float64)) | |
- fh.write(self.v_f[x,y,z,2].astype(numpy.float64)) | |
- fh.write(self.p_f[x,y,z].astype(numpy.float64)) | |
- fh.write(self.phi[x,y,z].astype(numpy.float64)) | |
- fh.write(self.dphi[x,y,z].astype(numpy.float64)* | |
- self.time_dt*self.ndem) | |
+ fh.write(self.v_f[x, y, z, 0].astype(numpy.float64… | |
+ fh.write(self.v_f[x, y, z, 1].astype(numpy.float64… | |
+ fh.write(self.v_f[x, y, z, 2].astype(numpy.float64… | |
+ fh.write(self.p_f[x, y, z].astype(numpy.float64)) | |
+ fh.write(self.phi[x, y, z].astype(numpy.float64)) | |
+ fh.write(self.dphi[x, y, z].astype(numpy.float64)* | |
+ self.time_dt*self.ndem) | |
fh.write(self.rho_f.astype(numpy.float64)) | |
fh.write(self.p_mod_A.astype(numpy.float64)) | |
t@@ -1511,7 +1439,7 @@ class sim: | |
for z in numpy.arange(self.num[2]): | |
for y in numpy.arange(self.num[1]): | |
for x in numpy.arange(self.num[0]): | |
- fh.write(self.p_f_constant[x,y,z].astype( | |
+ fh.write(self.p_f_constant[x, y, z].astype( | |
numpy.int32)) | |
# Navier Stokes | |
t@@ -1528,13 +1456,13 @@ class sim: | |
fh.write(self.dt_dem_fac.astype(numpy.float64)) | |
for i in numpy.arange(self.np): | |
- fh.write(self.f_d[i,:].astype(numpy.float64)) | |
+ fh.write(self.f_d[i, :].astype(numpy.float64)) | |
for i in numpy.arange(self.np): | |
- fh.write(self.f_p[i,:].astype(numpy.float64)) | |
+ fh.write(self.f_p[i, :].astype(numpy.float64)) | |
for i in numpy.arange(self.np): | |
- fh.write(self.f_v[i,:].astype(numpy.float64)) | |
+ fh.write(self.f_v[i, :].astype(numpy.float64)) | |
for i in numpy.arange(self.np): | |
- fh.write(self.f_sum[i,:].astype(numpy.float64)) | |
+ fh.write(self.f_sum[i, :].astype(numpy.float64)) | |
# Darcy | |
elif self.cfd_solver[0] == 1: | |
t@@ -1544,7 +1472,7 @@ class sim: | |
fh.write(self.ndem.astype(numpy.uint32)) | |
fh.write(self.c_phi.astype(numpy.float64)) | |
for i in numpy.arange(self.np): | |
- fh.write(self.f_p[i,:].astype(numpy.float64)) | |
+ fh.write(self.f_p[i, :].astype(numpy.float64)) | |
fh.write(self.beta_f.astype(numpy.float64)) | |
fh.write(self.k_c.astype(numpy.float64)) | |
t@@ -1627,8 +1555,8 @@ class sim: | |
print('skipping ' + fn_vtk + | |
': file exists and is newer than ' + fn) | |
if self.fluid: | |
- fn_vtk = "../output/fluid-{0}.{1:0=5}.vti".format( | |
- self.sid, i) | |
+ fn_vtk = "../output/fluid-{0}.{1:0=5}.vti" \ | |
+ .format(self.sid, i) | |
if os.path.isfile(fn_vtk) and \ | |
(os.path.getmtime(fn) < os.path.getmtime(fn_vtk)): | |
if verbose: | |
t@@ -1660,7 +1588,7 @@ class sim: | |
if verbose: | |
print("\tto") | |
sb.writeFluidVTK(verbose=verbose, | |
- cell_centered=cell_centered) | |
+ cell_centered=cell_centered) | |
else: | |
sb.writeFluidVTK(verbose=False, cell_centered=cell_centere… | |
t@@ -1697,20 +1625,20 @@ class sim: | |
:type verbose: bool | |
''' | |
- fh=None | |
- try : | |
- targetbin=folder + '/' + self.sid + '.vtu' # unstructured grid | |
+ fh = None | |
+ try: | |
+ targetbin = folder + '/' + self.sid + '.vtu' # unstructured grid | |
if verbose: | |
print('Output file: ' + targetbin) | |
- fh=open(targetbin, 'w') | |
+ fh = open(targetbin, 'w') | |
# the VTK data file format is documented in | |
# http://www.vtk.org/VTK/img/file-formats.pdf | |
fh.write('<?xml version="1.0"?>\n') # XML header | |
fh.write('<VTKFile type="UnstructuredGrid" version="0.1" ' | |
- + 'byte_order="LittleEndian">\n') # VTK header | |
+ + 'byte_order="LittleEndian">\n') # VTK header | |
fh.write(' <UnstructuredGrid>\n') | |
fh.write(' <Piece NumberOfPoints="%d" NumberOfCells="0">\n' \ | |
% (self.np)) | |
t@@ -1718,10 +1646,10 @@ class sim: | |
# Coordinates for each point (positions) | |
fh.write(' <Points>\n') | |
fh.write(' <DataArray name="Position [m]" type="Float32" ' | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
- fh.write('%f %f %f ' % (self.x[i,0], self.x[i,1], self.x[i,2])) | |
+ fh.write('%f %f %f ' % (self.x[i, 0], self.x[i, 1], self.x[i, … | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
fh.write(' </Points>\n') | |
t@@ -1731,7 +1659,7 @@ class sim: | |
# Radii | |
fh.write(' <DataArray type="Float32" Name="Diameter" ' | |
- + 'format="ascii">\n') | |
+ + 'format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f ' % (self.radius[i]*2.0)) | |
t@@ -1740,21 +1668,21 @@ class sim: | |
# Displacements (xyzsum) | |
fh.write(' <DataArray type="Float32" Name="Displacement [m]… | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f %f %f ' % \ | |
- (self.xyzsum[i,0], self.xyzsum[i,1], self.xyzsum[i,2]… | |
+ (self.xyzsum[i, 0], self.xyzsum[i, 1], self.xyzsum[i,… | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
# Velocity | |
fh.write(' <DataArray type="Float32" Name="Velocity [m/s]" ' | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f %f %f ' % \ | |
- (self.vel[i,0], self.vel[i,1], self.vel[i,2])) | |
+ (self.vel[i, 0], self.vel[i, 1], self.vel[i, 2])) | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
t@@ -1763,53 +1691,57 @@ class sim: | |
if self.cfd_solver == 0: # Navier Stokes | |
# Fluid interaction force | |
fh.write(' <DataArray type="Float32" ' | |
- + 'Name="Fluid force total [N]" ' | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + 'Name="Fluid force total [N]" ' | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f %f %f ' % \ | |
- (self.f_sum[i,0], self.f_sum[i,1], \ | |
- self.f_sum[i,2])) | |
+ (self.f_sum[i, 0], self.f_sum[i, 1], \ | |
+ self.f_sum[i, 2])) | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
# Fluid drag force | |
fh.write(' <DataArray type="Float32" ' | |
- + 'Name="Fluid drag force [N]" ' | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + 'Name="Fluid drag force [N]" ' | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f %f %f ' % \ | |
- (self.f_d[i,0], self.f_d[i,1], self.f_d[i,2])) | |
+ (self.f_d[i, 0], | |
+ self.f_d[i, 1], | |
+ self.f_d[i, 2])) | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
# Fluid pressure force | |
fh.write(' <DataArray type="Float32" ' | |
- + 'Name="Fluid pressure force [N]" ' | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + 'Name="Fluid pressure force [N]" ' | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f %f %f ' % \ | |
- (self.f_p[i,0], self.f_p[i,1], self.f_p[i,2])) | |
+ (self.f_p[i, 0], self.f_p[i, 1], self.f_p[i, 2])) | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
if self.cfd_solver == 0: # Navier Stokes | |
# Fluid viscous force | |
fh.write(' <DataArray type="Float32" ' | |
- + 'Name="Fluid viscous force [N]" ' | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + 'Name="Fluid viscous force [N]" ' | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f %f %f ' % \ | |
- (self.f_v[i,0], self.f_v[i,1], self.f_v[i,2])) | |
+ (self.f_v[i, 0], | |
+ self.f_v[i, 1], | |
+ self.f_v[i, 2])) | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
# fixvel | |
fh.write(' <DataArray type="Float32" Name="FixedVel" ' | |
- + 'format="ascii">\n') | |
+ + 'format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f ' % (self.fixvel[i])) | |
t@@ -1818,50 +1750,54 @@ class sim: | |
# Force | |
fh.write(' <DataArray type="Float32" Name="Force [N]" ' | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
- fh.write('%f %f %f ' % \ | |
- (self.force[i,0], self.force[i,1], self.force[i,2])) | |
+ fh.write('%f %f %f ' % (self.force[i, 0], | |
+ self.force[i, 1], | |
+ self.force[i, 2])) | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
# Angular Position | |
fh.write(' <DataArray type="Float32" Name="Angular position' | |
- + '[rad]" ' | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + '[rad]" ' | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
- fh.write('%f %f %f ' % \ | |
- (self.angpos[i,0], self.angpos[i,1], self.angpos[i,2])) | |
+ fh.write('%f %f %f ' % (self.angpos[i, 0], | |
+ self.angpos[i, 1], | |
+ self.angpos[i, 2])) | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
# Angular Velocity | |
fh.write(' <DataArray type="Float32" Name="Angular velocity' | |
- + ' [rad/s]" ' | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + ' [rad/s]" ' | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
- fh.write('%f %f %f ' % \ | |
- (self.angvel[i,0], self.angvel[i,1], self.angvel[i,2])) | |
+ fh.write('%f %f %f ' % (self.angvel[i, 0], | |
+ self.angvel[i, 1], | |
+ self.angvel[i, 2])) | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
# Torque | |
fh.write(' <DataArray type="Float32" Name="Torque [Nm]" ' | |
- + 'NumberOfComponents="3" format="ascii">\n') | |
+ + 'NumberOfComponents="3" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
- fh.write('%f %f %f ' % \ | |
- (self.torque[i,0], self.torque[i,1], self.torque[i,2])) | |
+ fh.write('%f %f %f ' % (self.torque[i, 0], | |
+ self.torque[i, 1], | |
+ self.torque[i, 2])) | |
fh.write('\n') | |
fh.write(' </DataArray>\n') | |
# Shear energy rate | |
fh.write(' <DataArray type="Float32" Name="Shear Energy ' | |
- + 'Rate [J/s]" ' | |
- + 'format="ascii">\n') | |
+ + 'Rate [J/s]" ' | |
+ + 'format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f ' % (self.es_dot[i])) | |
t@@ -1870,7 +1806,7 @@ class sim: | |
# Shear energy | |
fh.write(' <DataArray type="Float32" Name="Shear Energy [J]… | |
- + ' format="ascii">\n') | |
+ + ' format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f ' % (self.es[i])) | |
t@@ -1879,7 +1815,7 @@ class sim: | |
# Viscous energy rate | |
fh.write(' <DataArray type="Float32" ' | |
- + 'Name="Viscous Energy Rate [J/s]" format="ascii">\n') | |
+ + 'Name="Viscous Energy Rate [J/s]" format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f ' % (self.ev_dot[i])) | |
t@@ -1888,8 +1824,8 @@ class sim: | |
# Shear energy | |
fh.write(' <DataArray type="Float32" ' | |
- + 'Name="Viscous Energy [J]" ' | |
- + 'format="ascii">\n') | |
+ + 'Name="Viscous Energy [J]" ' | |
+ + 'format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f ' % (self.ev[i])) | |
t@@ -1898,7 +1834,7 @@ class sim: | |
# Pressure | |
fh.write(' <DataArray type="Float32" Name="Pressure [Pa]" ' | |
- + 'format="ascii">\n') | |
+ + 'format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%f ' % (self.p[i])) | |
t@@ -1907,7 +1843,7 @@ class sim: | |
# Color | |
fh.write(' <DataArray type="Int32" Name="Type color" ' | |
- + 'format="ascii">\n') | |
+ + 'format="ascii">\n') | |
fh.write(' ') | |
for i in range(self.np): | |
fh.write('%d ' % (self.color[i])) | |
t@@ -1918,13 +1854,13 @@ class sim: | |
fh.write(' </PointData>\n') | |
fh.write(' <Cells>\n') | |
fh.write(' <DataArray type="Int32" Name="connectivity" ' | |
- + 'format="ascii">\n') | |
+ + 'format="ascii">\n') | |
fh.write(' </DataArray>\n') | |
fh.write(' <DataArray type="Int32" Name="offsets" ' | |
- + 'format="ascii">\n') | |
+ + 'format="ascii">\n') | |
fh.write(' </DataArray>\n') | |
fh.write(' <DataArray type="UInt8" Name="types" ' | |
- + 'format="ascii">\n') | |
+ + 'format="ascii">\n') | |
fh.write(' </DataArray>\n') | |
fh.write(' </Cells>\n') | |
fh.write(' </Piece>\n') | |
t@@ -1955,45 +1891,45 @@ class sim: | |
print('Error: vtk module not found, cannot writeVTKforces.') | |
return | |
- filename=folder + '/forces-' + self.sid + '.vtp' # Polygon data | |
+ filename = folder + '/forces-' + self.sid + '.vtp' # Polygon data | |
# points mark the particle centers | |
- points=vtk.vtkPoints() | |
+ points = vtk.vtkPoints() | |
# lines mark the particle connectivity | |
- lines=vtk.vtkCellArray() | |
+ lines = vtk.vtkCellArray() | |
# colors | |
- #colors=vtk.vtkUnsignedCharArray() | |
+ #colors = vtk.vtkUnsignedCharArray() | |
#colors.SetNumberOfComponents(3) | |
#colors.SetName('Colors') | |
#colors.SetNumberOfTuples(self.overlaps.size) | |
# scalars | |
- forces=vtk.vtkDoubleArray() | |
+ forces = vtk.vtkDoubleArray() | |
forces.SetName("Force [N]") | |
forces.SetNumberOfComponents(1) | |
#forces.SetNumberOfTuples(self.overlaps.size) | |
forces.SetNumberOfValues(self.overlaps.size) | |
- stresses=vtk.vtkDoubleArray() | |
+ stresses = vtk.vtkDoubleArray() | |
stresses.SetName("Stress [Pa]") | |
stresses.SetNumberOfComponents(1) | |
stresses.SetNumberOfValues(self.overlaps.size) | |
for i in numpy.arange(self.overlaps.size): | |
- points.InsertNextPoint(self.x[self.pairs[0,i],:]) | |
- points.InsertNextPoint(self.x[self.pairs[1,i],:]) | |
- line=vtk.vtkLine() | |
+ points.InsertNextPoint(self.x[self.pairs[0, i], :]) | |
+ points.InsertNextPoint(self.x[self.pairs[1, i], :]) | |
+ line = vtk.vtkLine() | |
line.GetPointIds().SetId(0, 2*i) # index of particle 1 | |
line.GetPointIds().SetId(1, 2*i + 1) # index of particle 2 | |
lines.InsertNextCell(line) | |
- #colors.SetTupleValue(i, [100,100,100]) | |
+ #colors.SetTupleValue(i, [100, 100, 100]) | |
forces.SetValue(i, self.f_n_magn[i]) | |
stresses.SetValue(i, self.sigma_contacts[i]) | |
# initalize VTK data structure | |
- polydata=vtk.vtkPolyData() | |
+ polydata = vtk.vtkPolyData() | |
polydata.SetPoints(points) | |
polydata.SetLines(lines) | |
t@@ -2006,7 +1942,7 @@ class sim: | |
#polydata.GetPointData().SetScalars(stresses) # default scalar | |
# write VTK XML image data file | |
- writer=vtk.vtkXMLPolyDataWriter() | |
+ writer = vtk.vtkXMLPolyDataWriter() | |
writer.SetFileName(filename) | |
if vtk.VTK_MAJOR_VERSION <= 5: | |
writer.SetInput(polydata) | |
t@@ -2019,7 +1955,7 @@ class sim: | |
def writeFluidVTK(self, folder='../output/', cell_centered=True, | |
- verbose=True): | |
+ verbose=True): | |
''' | |
Writes a VTK file for the fluid grid to the ``../output/`` folder by | |
default. The file name will be in the format ``fluid-<self.sid>.vti``. | |
t@@ -2075,11 +2011,11 @@ class sim: | |
print('Error: vtk module not found, cannot writeFluidVTK.') | |
return | |
- filename=folder + '/fluid-' + self.sid + '.vti' # image grid | |
+ filename = folder + '/fluid-' + self.sid + '.vti' # image grid | |
# initalize VTK data structure | |
- grid=vtk.vtkImageData() | |
- dx=(self.L-self.origo)/self.num # cell center spacing | |
+ grid = vtk.vtkImageData() | |
+ dx = (self.L-self.origo)/self.num # cell center spacing | |
if cell_centered: | |
grid.SetOrigin(self.origo) | |
else: | |
t@@ -2091,7 +2027,7 @@ class sim: | |
grid.SetDimensions(self.num) # no. of points in each direction | |
# array of scalars: hydraulic pressures | |
- pres=vtk.vtkDoubleArray() | |
+ pres = vtk.vtkDoubleArray() | |
pres.SetName("Pressure [Pa]") | |
pres.SetNumberOfComponents(1) | |
if cell_centered: | |
t@@ -2100,7 +2036,7 @@ class sim: | |
pres.SetNumberOfTuples(grid.GetNumberOfPoints()) | |
# array of vectors: hydraulic velocities | |
- vel=vtk.vtkDoubleArray() | |
+ vel = vtk.vtkDoubleArray() | |
vel.SetName("Velocity [m/s]") | |
vel.SetNumberOfComponents(3) | |
if cell_centered: | |
t@@ -2109,7 +2045,7 @@ class sim: | |
vel.SetNumberOfTuples(grid.GetNumberOfPoints()) | |
# array of scalars: porosities | |
- poros=vtk.vtkDoubleArray() | |
+ poros = vtk.vtkDoubleArray() | |
poros.SetName("Porosity [-]") | |
poros.SetNumberOfComponents(1) | |
if cell_centered: | |
t@@ -2118,7 +2054,7 @@ class sim: | |
poros.SetNumberOfTuples(grid.GetNumberOfPoints()) | |
# array of scalars: porosity change | |
- dporos=vtk.vtkDoubleArray() | |
+ dporos = vtk.vtkDoubleArray() | |
dporos.SetName("Porosity change [1/s]") | |
dporos.SetNumberOfComponents(1) | |
if cell_centered: | |
t@@ -2128,7 +2064,7 @@ class sim: | |
# array of scalars: Reynold's number | |
self.ReynoldsNumber() | |
- Re=vtk.vtkDoubleArray() | |
+ Re = vtk.vtkDoubleArray() | |
Re.SetName("Reynolds number [-]") | |
Re.SetNumberOfComponents(1) | |
if cell_centered: | |
t@@ -2139,7 +2075,7 @@ class sim: | |
# Find permeabilities if the Darcy solver is used | |
if self.cfd_solver[0] == 1: | |
self.findPermeabilities() | |
- k=vtk.vtkDoubleArray() | |
+ k = vtk.vtkDoubleArray() | |
k.SetName("Permeability [m*m]") | |
k.SetNumberOfComponents(1) | |
if cell_centered: | |
t@@ -2148,7 +2084,7 @@ class sim: | |
k.SetNumberOfTuples(grid.GetNumberOfPoints()) | |
self.findHydraulicConductivities() | |
- K=vtk.vtkDoubleArray() | |
+ K = vtk.vtkDoubleArray() | |
K.SetName("Conductivity [m/s]") | |
K.SetNumberOfComponents(1) | |
if cell_centered: | |
t@@ -2156,7 +2092,7 @@ class sim: | |
else: | |
K.SetNumberOfTuples(grid.GetNumberOfPoints()) | |
- p_f_constant=vtk.vtkDoubleArray() | |
+ p_f_constant = vtk.vtkDoubleArray() | |
p_f_constant.SetName("Constant pressure [-]") | |
p_f_constant.SetNumberOfComponents(1) | |
if cell_centered: | |
t@@ -2168,16 +2104,16 @@ class sim: | |
for z in range(self.num[2]): | |
for y in range(self.num[1]): | |
for x in range(self.num[0]): | |
- idx=x + self.num[0]*y + self.num[0]*self.num[1]*z; | |
- pres.SetValue(idx, self.p_f[x,y,z]) | |
- vel.SetTuple(idx, self.v_f[x,y,z,:]) | |
- poros.SetValue(idx, self.phi[x,y,z]) | |
- dporos.SetValue(idx, self.dphi[x,y,z]) | |
- Re.SetValue(idx, self.Re[x,y,z]) | |
+ idx = x + self.num[0]*y + self.num[0]*self.num[1]*z | |
+ pres.SetValue(idx, self.p_f[x, y, z]) | |
+ vel.SetTuple(idx, self.v_f[x, y, z, :]) | |
+ poros.SetValue(idx, self.phi[x, y, z]) | |
+ dporos.SetValue(idx, self.dphi[x, y, z]) | |
+ Re.SetValue(idx, self.Re[x, y, z]) | |
if self.cfd_solver[0] == 1: | |
- k.SetValue(idx, self.k[x,y,z]) | |
- K.SetValue(idx, self.K[x,y,z]) | |
- p_f_constant.SetValue(idx, self.p_f_constant[x,y,z]) | |
+ k.SetValue(idx, self.k[x, y, z]) | |
+ K.SetValue(idx, self.K[x, y, z]) | |
+ p_f_constant.SetValue(idx, self.p_f_constant[x, y, z]) | |
# add pres array to grid | |
if cell_centered: | |
t@@ -2202,7 +2138,7 @@ class sim: | |
grid.GetPointData().AddArray(p_f_constant) | |
# write VTK XML image data file | |
- writer=vtk.vtkXMLImageDataWriter() | |
+ writer = vtk.vtkXMLImageDataWriter() | |
writer.SetFileName(filename) | |
#writer.SetInput(grid) # deprecated from VTK 6 | |
writer.SetInputData(grid) | |
t@@ -2227,25 +2163,25 @@ class sim: | |
return | |
# create a rendering window and renderer | |
- ren=vtk.vtkRenderer() | |
- renWin=vtk.vtkRenderWindow() | |
+ ren = vtk.vtkRenderer() | |
+ renWin = vtk.vtkRenderWindow() | |
renWin.AddRenderer(ren) | |
# create a renderwindowinteractor | |
- iren=vtk.vtkRenderWindowInteractor() | |
+ iren = vtk.vtkRenderWindowInteractor() | |
iren.SetRenderWindow(renWin) | |
if coloring.any(): | |
- #min_value=numpy.min(coloring) | |
- max_value=numpy.max(coloring) | |
- #min_rgb=numpy.array([50, 50, 50]) | |
- #max_rgb=numpy.array([255, 255, 255]) | |
+ #min_value = numpy.min(coloring) | |
+ max_value = numpy.max(coloring) | |
+ #min_rgb = numpy.array([50, 50, 50]) | |
+ #max_rgb = numpy.array([255, 255, 255]) | |
#def color(value): | |
#return (max_rgb - min_rgb) * (value - min_value) | |
def red(ratio): | |
- return numpy.fmin(1.0, 0.209*ratio**3. - 2.49*ratio**2. | |
- + 3.0*ratio + 0.0109) | |
+ return numpy.fmin(1.0, 0.209*ratio**3. - 2.49*ratio**2. + 3.0*… | |
+ + 0.0109) | |
def green(ratio): | |
return numpy.fmin(1.0, -2.44*ratio**2. + 2.15*ratio + 0.369) | |
def blue(ratio): | |
t@@ -2254,28 +2190,28 @@ class sim: | |
for i in numpy.arange(self.np): | |
# create source | |
- source=vtk.vtkSphereSource() | |
- source.SetCenter(self.x[i,:]) | |
+ source = vtk.vtkSphereSource() | |
+ source.SetCenter(self.x[i, :]) | |
source.SetRadius(self.radius[i]) | |
source.SetThetaResolution(resolution) | |
source.SetPhiResolution(resolution) | |
# mapper | |
- mapper=vtk.vtkPolyDataMapper() | |
+ mapper = vtk.vtkPolyDataMapper() | |
if vtk.VTK_MAJOR_VERSION <= 5: | |
mapper.SetInput(source.GetOutput()) | |
else: | |
mapper.SetInputConnection(source.GetOutputPort()) | |
# actor | |
- actor=vtk.vtkActor() | |
+ actor = vtk.vtkActor() | |
actor.SetMapper(mapper) | |
# color | |
if coloring.any(): | |
- ratio=coloring[i]/max_value | |
- r,g,b=red(ratio), green(ratio), blue(ratio) | |
- actor.GetProperty().SetColor(r,g,b) | |
+ ratio = coloring[i]/max_value | |
+ r, g, b = red(ratio), green(ratio), blue(ratio) | |
+ actor.GetProperty().SetColor(r, g, b) | |
# assign actor to the renderer | |
ren.AddActor(actor) | |
t@@ -2299,7 +2235,7 @@ class sim: | |
:func:`readstep`. | |
''' | |
- fn='../output/' + self.sid + '.output00000.bin' | |
+ fn = '../output/' + self.sid + '.output00000.bin' | |
self.readbin(fn, verbose) | |
def readsecond(self, verbose=True): | |
t@@ -2313,7 +2249,7 @@ class sim: | |
See also :func:`readbin()`, :func:`readfirst()`, :func:`readlast()`, | |
and :func:`readstep`. | |
''' | |
- fn='../output/' + self.sid + '.output00001.bin' | |
+ fn = '../output/' + self.sid + '.output00001.bin' | |
self.readbin(fn, verbose) | |
def readstep(self, step, verbose=True): | |
t@@ -2329,7 +2265,7 @@ class sim: | |
See also :func:`readbin()`, :func:`readfirst()`, :func:`readlast()`, | |
and :func:`readsecond`. | |
''' | |
- fn="../output/{0}.output{1:0=5}.bin".format(self.sid, step) | |
+ fn = "../output/{0}.output{1:0=5}.bin".format(self.sid, step) | |
self.readbin(fn, verbose) | |
def readlast(self, verbose=True): | |
t@@ -2343,8 +2279,8 @@ class sim: | |
See also :func:`readbin()`, :func:`readfirst()`, :func:`readsecond`, a… | |
:func:`readstep`. | |
''' | |
- lastfile=status(self.sid) | |
- fn="../output/{0}.output{1:0=5}.bin".format(self.sid, lastfile) | |
+ lastfile = status(self.sid) | |
+ fn = "../output/{0}.output{1:0=5}.bin".format(self.sid, lastfile) | |
self.readbin(fn, verbose) | |
def readTime(self, time, verbose=True): | |
t@@ -2360,20 +2296,20 @@ class sim: | |
''' | |
self.readfirst(verbose=False) | |
- t_first=self.currentTime() | |
- n_first=self.time_step_count[0] | |
+ t_first = self.currentTime() | |
+ n_first = self.time_step_count[0] | |
self.readlast(verbose=False) | |
- t_last=self.currentTime() | |
- n_last=self.time_step_count[0] | |
+ t_last = self.currentTime() | |
+ n_last = self.time_step_count[0] | |
if time < t_first or time > t_last: | |
raise Exception('Error: The specified time {} s is outside the ' + | |
- 'range of output files [{}; {}] s.'.format(time, \ | |
- t_first, t_last)) | |
+ 'range of output files [{}; {}] s.' | |
+ .format(time, t_first, t_last)) | |
- dt_dn=(t_last - t_first)/(n_last - n_first) | |
- step=int((time - t_first)/dt_dn) + n_first + 1 | |
+ dt_dn = (t_last - t_first)/(n_last - n_first) | |
+ step = int((time - t_first)/dt_dn) + n_first + 1 | |
self.readstep(step, verbose=verbose) | |
def generateRadii(self, psd='logn', mean=440e-6, variance=8.8e-9, | |
t@@ -2403,26 +2339,26 @@ class sim: | |
''' | |
if psd == 'logn': # Log-normal probability distribution | |
- mu=math.log(\ | |
- (mean**2)/math.sqrt(variance+mean**2)) | |
- sigma=math.sqrt(math.log(variance/(mean**2)+1)) | |
- self.radius=numpy.random.lognormal(mu, sigma, self.np) | |
+ mu = math.log((mean**2)/math.sqrt(variance+mean**2)) | |
+ sigma = math.sqrt(math.log(variance/(mean**2)+1)) | |
+ self.radius = numpy.random.lognormal(mu, sigma, self.np) | |
elif psd == 'uni': # Uniform distribution | |
- radius_min=mean - variance | |
- radius_max=mean + variance | |
- self.radius=numpy.random.uniform(radius_min, radius_max, self.np) | |
+ radius_min = mean - variance | |
+ radius_max = mean + variance | |
+ self.radius = numpy.random.uniform(radius_min, radius_max, self.np) | |
else: | |
raise Exception('Particle size distribution type not understood (' | |
- + str(psd) + '). Valid values are \'uni\' or \'logn\'') | |
+ + str(psd) + '). ' | |
+ + 'Valid values are \'uni\' or \'logn\'') | |
# Show radii as histogram | |
if histogram and py_mpl: | |
- fig=plt.figure(figsize=(8,8)) | |
- figtitle='Particle size distribution, {0} particles'.format(\ | |
- self.np) | |
- fig.text(0.5,0.95,figtitle,horizontalalignment='center',\ | |
- fontproperties=FontProperties(size=18)) | |
- bins=20 | |
+ fig = plt.figure(figsize=(8, 8)) | |
+ figtitle = 'Particle size distribution, {0} particles'\ | |
+ .format(self.np) | |
+ fig.text(0.5, 0.95, figtitle, horizontalalignment='center', | |
+ fontproperties=FontProperties(size=18)) | |
+ bins = 20 | |
# Create histogram | |
plt.hist(self.radius, bins) | |
t@@ -2452,24 +2388,24 @@ class sim: | |
if r_small >= r_large: | |
raise Exception("r_large should be larger than r_small") | |
- V_small=V_sphere(r_small) | |
- V_large=V_sphere(r_large) | |
- nlarge=int(V_small/V_large * ratio * self.np) # ignore void volume | |
+ V_small = V_sphere(r_small) | |
+ V_large = V_sphere(r_large) | |
+ nlarge = int(V_small/V_large * ratio * self.np) # ignore void volume | |
- self.radius[:]=r_small | |
- self.radius[0:nlarge]=r_large | |
+ self.radius[:] = r_small | |
+ self.radius[0:nlarge] = r_large | |
numpy.random.shuffle(self.radius) | |
# Test volumetric ratio | |
- V_small_total=V_small * (self.np - nlarge) | |
- V_large_total=V_large * nlarge | |
+ V_small_total = V_small * (self.np - nlarge) | |
+ V_large_total = V_large * nlarge | |
if abs(V_large_total/V_small_total - ratio) > 1.0e5: | |
raise Exception("Volumetric ratio seems wrong") | |
if verbose: | |
print("generateBimodalRadii created " + str(nlarge) | |
- + " large particles, and " + str(self.np - nlarge) | |
- + " small") | |
+ + " large particles, and " + str(self.np - nlarge) | |
+ + " small") | |
def checkerboardColors(self, nx=6, ny=6, nz=6): | |
''' | |
t@@ -2482,17 +2418,17 @@ class sim: | |
:param nz: Number of color values along the z azis | |
:type nz: int | |
''' | |
- x_min=numpy.min(self.x[:,0]) | |
- x_max=numpy.max(self.x[:,0]) | |
- y_min=numpy.min(self.x[:,1]) | |
- y_max=numpy.max(self.x[:,1]) | |
- z_min=numpy.min(self.x[:,2]) | |
- z_max=numpy.max(self.x[:,2]) | |
+ x_min = numpy.min(self.x[:, 0]) | |
+ x_max = numpy.max(self.x[:, 0]) | |
+ y_min = numpy.min(self.x[:, 1]) | |
+ y_max = numpy.max(self.x[:, 1]) | |
+ z_min = numpy.min(self.x[:, 2]) | |
+ z_max = numpy.max(self.x[:, 2]) | |
for i in numpy.arange(self.np): | |
- ix=numpy.floor((self.x[i,0] - x_min)/(x_max/nx)) | |
- iy=numpy.floor((self.x[i,1] - y_min)/(y_max/ny)) | |
- iz=numpy.floor((self.x[i,2] - z_min)/(z_max/nz)) | |
- self.color[i]=(-1)**ix + (-1)**iy + (-1)**iz | |
+ ix = numpy.floor((self.x[i, 0] - x_min)/(x_max/nx)) | |
+ iy = numpy.floor((self.x[i, 1] - y_min)/(y_max/ny)) | |
+ iz = numpy.floor((self.x[i, 2] - z_min)/(z_max/nz)) | |
+ self.color[i] = (-1)**ix + (-1)**iy + (-1)**iz | |
def contactModel(self, contactmodel): | |
''' | |
t@@ -2505,7 +2441,7 @@ class sim: | |
(visco-frictional=1, elasto-visco-frictional=2) | |
:type contactmodel: int | |
''' | |
- self.contactmodel[0]=contactmodel | |
+ self.contactmodel[0] = contactmodel | |
def wall0iz(self): | |
''' | |
t@@ -2526,7 +2462,7 @@ class sim: | |
See also :func:`periodicBoundariesXY()` and | |
:func:`periodicBoundariesX()` | |
''' | |
- self.periodic[0]=0 | |
+ self.periodic[0] = 0 | |
def periodicBoundariesXY(self): | |
''' | |
t@@ -2535,7 +2471,7 @@ class sim: | |
See also :func:`normalBoundariesXY()` and | |
:func:`periodicBoundariesX()` | |
''' | |
- self.periodic[0]=1 | |
+ self.periodic[0] = 1 | |
def periodicBoundariesX(self): | |
''' | |
t@@ -2544,7 +2480,7 @@ class sim: | |
See also :func:`normalBoundariesXY()` and | |
:func:`periodicBoundariesXY()` | |
''' | |
- self.periodic[0]=2 | |
+ self.periodic[0] = 2 | |
def adaptiveGrid(self): | |
''' | |
t@@ -2555,7 +2491,7 @@ class sim: | |
See also :func:`staticGrid()` | |
''' | |
- self.adaptive[0]=1 | |
+ self.adaptive[0] = 1 | |
def staticGrid(self): | |
''' | |
t@@ -2563,9 +2499,9 @@ class sim: | |
See also :func:`adaptiveGrid()` | |
''' | |
- self.adaptive[0]=0 | |
+ self.adaptive[0] = 0 | |
- def initRandomPos(self, gridnum=numpy.array([12, 12, 36])): | |
+ def initRandomPos(self, gridnum=numpy.array([12, 12, 36]), dx=-1.0): | |
''' | |
Initialize particle positions in completely random configuration. Radii | |
*must* be set beforehand. If the x and y boundaries are set as periodi… | |
t@@ -2582,39 +2518,39 @@ class sim: | |
''' | |
# Calculate cells in grid | |
- self.num=gridnum | |
+ self.num = gridnum | |
+ r_max = numpy.max(self.radius) | |
# Cell configuration | |
if dx > 0.0: | |
- cellsize=dx | |
+ cellsize = dx | |
else: | |
- cellsize=2.1 * numpy.amax(self.radius) | |
+ cellsize = 2.1 * numpy.amax(self.radius) | |
# World size | |
- self.L=self.num * cellsize | |
- | |
+ self.L = self.num * cellsize | |
# Particle positions randomly distributed without overlap | |
for i in range(self.np): | |
- overlaps=True | |
+ overlaps = True | |
while overlaps: | |
- overlaps=False | |
+ overlaps = False | |
# Draw random position | |
for d in range(self.nd): | |
- self.x[i,d]=(self.L[d] - self.origo[d] - 2*r_max) \ | |
+ self.x[i, d] = (self.L[d] - self.origo[d] - 2*r_max) \ | |
* numpy.random.random_sample() \ | |
+ self.origo[d] + r_max | |
# Check other particles for overlaps | |
for j in range(i-1): | |
- delta=self.x[i] - self.x[j] | |
- delta_len=math.sqrt(numpy.dot(delta,delta)) \ | |
- - (self.radius[i] + self.radius[j]) | |
+ delta = self.x[i] - self.x[j] | |
+ delta_len = math.sqrt(numpy.dot(delta, delta)) \ | |
+ - (self.radius[i] + self.radius[j]) | |
if delta_len < 0.0: | |
- overlaps=True | |
+ overlaps = True | |
print("\rFinding non-overlapping particle positions, " | |
- + "{0} % complete".format(numpy.ceil(i/self.np*100))) | |
+ + "{0} % complete".format(numpy.ceil(i/self.np*100))) | |
# Print newline | |
print() | |
t@@ -2639,34 +2575,33 @@ class sim: | |
# Cell configuration | |
if dx > 0.0: | |
- cellsize_min=dx | |
+ cellsize_min = dx | |
else: | |
if self.np < 1: | |
- raise Exception('Error: You need to define dx in ' | |
- 'defineWorldBoundaries if there are no particles in ' | |
- 'the simulation.') | |
- cellsize_min=2.1 * numpy.amax(self.radius) | |
+ raise Exception('Error: You need to define dx in ' + | |
+ 'defineWorldBoundaries if there are no ' + | |
+ 'particles in the simulation.') | |
+ cellsize_min = 2.1 * numpy.amax(self.radius) | |
# Lower boundary of the sorting grid | |
- self.origo[:]=origo[:] | |
+ self.origo[:] = origo[:] | |
# Upper boundary of the sorting grid | |
- self.L[:]=L[:] | |
+ self.L[:] = L[:] | |
# Adjust the number of sorting cells along each axis to fit the largest | |
# particle size and the world size | |
- self.num[0]=numpy.ceil((self.L[0]-self.origo[0])/cellsize_min) | |
- self.num[1]=numpy.ceil((self.L[1]-self.origo[1])/cellsize_min) | |
- self.num[2]=numpy.ceil((self.L[2]-self.origo[2])/cellsize_min) | |
+ self.num[0] = numpy.ceil((self.L[0]-self.origo[0])/cellsize_min) | |
+ self.num[1] = numpy.ceil((self.L[1]-self.origo[1])/cellsize_min) | |
+ self.num[2] = numpy.ceil((self.L[2]-self.origo[2])/cellsize_min) | |
#if (self.num.any() < 4): | |
#if (self.num[0] < 4 or self.num[1] < 4 or self.num[2] < 4): | |
if self.num[0] < 3 or self.num[1] < 3 or self.num[2] < 3: | |
raise Exception("Error: The grid must be at least 3 cells in each " | |
- + "direction\nGrid: x={}, y={}, z={}\n".format(\ | |
- self.num[0], self.num[1], self.num[2]) | |
- + "Please increase the world size.") | |
- | |
+ + "direction\nGrid: x={}, y={}, z={}\n" | |
+ .format(self.num[0], self.num[1], self.num[2]) | |
+ + "Please increase the world size.") | |
def initGrid(self, dx=-1): | |
''' | |
t@@ -2683,22 +2618,21 @@ class sim: | |
# Cell configuration | |
if dx > 0.0: | |
- cellsize_min=dx | |
+ cellsize_min = dx | |
else: | |
- cellsize_min=2.1 * numpy.amax(self.radius) | |
- self.num[0]=numpy.ceil((self.L[0]-self.origo[0])/cellsize_min) | |
- self.num[1]=numpy.ceil((self.L[1]-self.origo[1])/cellsize_min) | |
- self.num[2]=numpy.ceil((self.L[2]-self.origo[2])/cellsize_min) | |
+ cellsize_min = 2.1 * numpy.amax(self.radius) | |
+ self.num[0] = numpy.ceil((self.L[0]-self.origo[0])/cellsize_min) | |
+ self.num[1] = numpy.ceil((self.L[1]-self.origo[1])/cellsize_min) | |
+ self.num[2] = numpy.ceil((self.L[2]-self.origo[2])/cellsize_min) | |
if self.num[0] < 4 or self.num[1] < 4 or self.num[2] < 4: | |
raise Exception("Error: The grid must be at least 3 cells in each " | |
- + "direction\nGrid: x={}, y={}, z={}".format(\ | |
- self.num[0], self.num[1], self.num[2])) | |
+ + "direction\nGrid: x={}, y={}, z={}" | |
+ .format(self.num[0], self.num[1], self.num[2])) | |
# Put upper wall at top boundary | |
if self.nw > 0: | |
- self.w_x[0]=self.L[0] | |
- | |
+ self.w_x[0] = self.L[0] | |
def initGridAndWorldsize(self, margin=2.0): | |
''' | |
t@@ -2712,31 +2646,30 @@ class sim: | |
''' | |
# Cell configuration | |
- r_max=numpy.amax(self.radius) | |
+ r_max = numpy.amax(self.radius) | |
# Max. and min. coordinates of world | |
- self.origo=numpy.array([numpy.amin(self.x[:,0] - self.radius[:]), | |
- numpy.amin(self.x[:,1] - self.radius[:]), | |
- numpy.amin(self.x[:,2] - self.radius[:])]) \ | |
- - margin*r_max | |
- self.L=numpy.array([numpy.amax(self.x[:,0] + self.radius[:]), | |
- numpy.amax(self.x[:,1] + self.radius[:]), | |
- numpy.amax(self.x[:,2] + self.radius[:])]) \ | |
- + margin*r_max | |
- | |
- cellsize_min=2.1 * r_max | |
- self.num[0]=numpy.ceil((self.L[0]-self.origo[0])/cellsize_min) | |
- self.num[1]=numpy.ceil((self.L[1]-self.origo[1])/cellsize_min) | |
- self.num[2]=numpy.ceil((self.L[2]-self.origo[2])/cellsize_min) | |
+ self.origo = numpy.array([numpy.amin(self.x[:, 0] - self.radius[:]), | |
+ numpy.amin(self.x[:, 1] - self.radius[:]), | |
+ numpy.amin(self.x[:, 2] - self.radius[:])]) \ | |
+ - margin*r_max | |
+ self.L = numpy.array([numpy.amax(self.x[:, 0] + self.radius[:]), | |
+ numpy.amax(self.x[:, 1] + self.radius[:]), | |
+ numpy.amax(self.x[:, 2] + self.radius[:])]) \ | |
+ + margin*r_max | |
+ | |
+ cellsize_min = 2.1 * r_max | |
+ self.num[0] = numpy.ceil((self.L[0]-self.origo[0])/cellsize_min) | |
+ self.num[1] = numpy.ceil((self.L[1]-self.origo[1])/cellsize_min) | |
+ self.num[2] = numpy.ceil((self.L[2]-self.origo[2])/cellsize_min) | |
if self.num[0] < 4 or self.num[1] < 4 or self.num[2] < 4: | |
raise Exception("Error: The grid must be at least 3 cells in each " | |
- + "direction, num=" + str(self.num)) | |
+ + "direction, num=" + str(self.num)) | |
# Put upper wall at top boundary | |
if self.nw > 0: | |
- self.w_x[0]=self.L[0] | |
- | |
+ self.w_x[0] = self.L[0] | |
def initGridPos(self, gridnum=numpy.array([12, 12, 36])): | |
''' | |
t@@ -2750,19 +2683,19 @@ class sim: | |
''' | |
# Calculate cells in grid | |
- self.num=numpy.asarray(gridnum) | |
+ self.num = numpy.asarray(gridnum) | |
# World size | |
- r_max=numpy.amax(self.radius) | |
- cellsize=2.1 * r_max | |
- self.L=self.num * cellsize | |
+ r_max = numpy.amax(self.radius) | |
+ cellsize = 2.1 * r_max | |
+ self.L = self.num * cellsize | |
# Check whether there are enough grid cells | |
if (self.num[0]*self.num[1]*self.num[2]-(2**3)) < self.np: | |
print("Error! The grid is not sufficiently large.") | |
raise NameError('Error! The grid is not sufficiently large.') | |
- gridpos=numpy.zeros(self.nd, dtype=numpy.uint32) | |
+ gridpos = numpy.zeros(self.nd, dtype=numpy.uint32) | |
# Make sure grid is sufficiently large if every second level is moved | |
if self.periodic[0] == 1: | |
t@@ -2774,32 +2707,30 @@ class sim: | |
print("Error! The grid is not sufficiently large.") | |
raise NameError('Error! The grid is not sufficiently large.') | |
- | |
# Particle positions randomly distributed without overlap | |
for i in range(self.np): | |
# Find position in 3d mesh from linear index | |
- gridpos[0]=(i % (self.num[0])) | |
- gridpos[1]=numpy.floor(i/(self.num[0])) % (self.num[0]) | |
- gridpos[2]=numpy.floor(i/((self.num[0])*(self.num[1]))) #\ | |
+ gridpos[0] = (i % (self.num[0])) | |
+ gridpos[1] = numpy.floor(i/(self.num[0])) % (self.num[0]) | |
+ gridpos[2] = numpy.floor(i/((self.num[0])*(self.num[1]))) #\ | |
#% ((self.num[0])*(self.num[1])) | |
for d in range(self.nd): | |
- self.x[i,d]=gridpos[d] * cellsize + 0.5*cellsize | |
+ self.x[i, d] = gridpos[d] * cellsize + 0.5*cellsize | |
# Allow pushing every 2.nd level out of lateral boundaries | |
if self.periodic[0] == 1: | |
# Offset every second level | |
if gridpos[2] % 2: | |
- self.x[i,0] += 0.5*cellsize | |
- self.x[i,1] += 0.5*cellsize | |
+ self.x[i, 0] += 0.5*cellsize | |
+ self.x[i, 1] += 0.5*cellsize | |
# Readjust grid to correct size | |
if self.periodic[0] == 1: | |
self.num[0] += 1 | |
self.num[1] += 1 | |
- | |
def initRandomGridPos(self, gridnum=numpy.array([12, 12, 32]), | |
padding=2.1): | |
''' | |
t@@ -2819,46 +2750,47 @@ class sim: | |
''' | |
# Calculate cells in grid | |
- coarsegrid=numpy.floor(numpy.asarray(gridnum)/2) | |
+ coarsegrid = numpy.floor(numpy.asarray(gridnum)/2) | |
# World size | |
- r_max=numpy.amax(self.radius) | |
+ r_max = numpy.amax(self.radius) | |
# Cells in grid 2*size to make space for random offset | |
- cellsize=padding * r_max * 2 | |
+ cellsize = padding * r_max * 2 | |
# Check whether there are enough grid cells | |
if ((coarsegrid[0]-1)*(coarsegrid[1]-1)*(coarsegrid[2]-1)) < self.np: | |
print("Error! The grid is not sufficiently large.") | |
raise NameError('Error! The grid is not sufficiently large.') | |
- gridpos=numpy.zeros(self.nd, dtype=numpy.uint32) | |
+ gridpos = numpy.zeros(self.nd, dtype=numpy.uint32) | |
# Particle positions randomly distributed without overlap | |
for i in range(self.np): | |
# Find position in 3d mesh from linear index | |
- gridpos[0]=(i % (coarsegrid[0])) | |
- gridpos[1]=numpy.floor(i/(coarsegrid[0]))%(coarsegrid[1]) # Thanks… | |
- gridpos[2]=numpy.floor(i/((coarsegrid[0])*(coarsegrid[1]))) | |
+ gridpos[0] = (i % (coarsegrid[0])) | |
+ gridpos[1] = numpy.floor(i/(coarsegrid[0]))%(coarsegrid[1]) # Than… | |
+ gridpos[2] = numpy.floor(i/((coarsegrid[0])*(coarsegrid[1]))) | |
# Place particles in grid structure, and randomly adjust the | |
# positions within the oversized cells (uniform distribution) | |
for d in range(self.nd): | |
- r=self.radius[i]*1.05 | |
- self.x[i,d]=gridpos[d] * cellsize \ | |
- + ((cellsize-r) - r) * numpy.random.random_sample() + r | |
+ r = self.radius[i]*1.05 | |
+ self.x[i, d] = gridpos[d] * cellsize \ | |
+ + ((cellsize-r) - r) \ | |
+ * numpy.random.random_sample() + r | |
# Calculate new grid with cell size equal to max. particle diameter | |
- x_max=numpy.max(self.x[:,0] + self.radius) | |
- y_max=numpy.max(self.x[:,1] + self.radius) | |
- z_max=numpy.max(self.x[:,2] + self.radius) | |
+ x_max = numpy.max(self.x[:, 0] + self.radius) | |
+ y_max = numpy.max(self.x[:, 1] + self.radius) | |
+ z_max = numpy.max(self.x[:, 2] + self.radius) | |
# Adjust size of world | |
- self.num[0]=numpy.ceil(x_max/cellsize) | |
- self.num[1]=numpy.ceil(y_max/cellsize) | |
- self.num[2]=numpy.ceil(z_max/cellsize) | |
- self.L=self.num * cellsize | |
+ self.num[0] = numpy.ceil(x_max/cellsize) | |
+ self.num[1] = numpy.ceil(y_max/cellsize) | |
+ self.num[2] = numpy.ceil(z_max/cellsize) | |
+ self.L = self.num * cellsize | |
def createBondPair(self, i, j, spacing=-0.1): | |
''' | |
t@@ -2875,41 +2807,41 @@ class sim: | |
:type spacing: float | |
''' | |
- x_i=self.x[i] | |
- r_i=self.radius[i] | |
- r_j=self.radius[j] | |
- dist_ij=(r_i + r_j)*(1.0 + spacing) | |
+ x_i = self.x[i] | |
+ r_i = self.radius[i] | |
+ r_j = self.radius[j] | |
+ dist_ij = (r_i + r_j)*(1.0 + spacing) | |
- dazi=numpy.random.rand(1) * 360.0 # azimuth | |
- azi=numpy.radians(dazi) | |
- dang=numpy.random.rand(1) * 180.0 - 90.0 # angle | |
- ang=numpy.radians(dang) | |
+ dazi = numpy.random.rand(1) * 360.0 # azimuth | |
+ azi = numpy.radians(dazi) | |
+ dang = numpy.random.rand(1) * 180.0 - 90.0 # angle | |
+ ang = numpy.radians(dang) | |
- x_j=numpy.copy(x_i) | |
- x_j[0]=x_j[0] + dist_ij * numpy.cos(azi) * numpy.cos(ang) | |
- x_j[1]=x_j[1] + dist_ij * numpy.sin(azi) * numpy.cos(ang) | |
- x_j[2]=x_j[2] + dist_ij * numpy.sin(ang) * numpy.cos(azi) | |
- self.x[j]=x_j | |
+ x_j = numpy.copy(x_i) | |
+ x_j[0] = x_j[0] + dist_ij * numpy.cos(azi) * numpy.cos(ang) | |
+ x_j[1] = x_j[1] + dist_ij * numpy.sin(azi) * numpy.cos(ang) | |
+ x_j[2] = x_j[2] + dist_ij * numpy.sin(ang) * numpy.cos(azi) | |
+ self.x[j] = x_j | |
- if self.x[j,0] < self.origo[0]: | |
- self.x[j,0] += x_i[0] - x_j[0] | |
- if self.x[j,1] < self.origo[1]: | |
- self.x[j,1] += x_i[1] - x_j[1] | |
- if self.x[j,2] < self.origo[2]: | |
- self.x[j,2] += x_i[2] - x_j[2] | |
+ if self.x[j, 0] < self.origo[0]: | |
+ self.x[j, 0] += x_i[0] - x_j[0] | |
+ if self.x[j, 1] < self.origo[1]: | |
+ self.x[j, 1] += x_i[1] - x_j[1] | |
+ if self.x[j, 2] < self.origo[2]: | |
+ self.x[j, 2] += x_i[2] - x_j[2] | |
- if self.x[j,0] > self.L[0]: | |
- self.x[j,0] -= abs(x_j[0] - x_i[0]) | |
- if self.x[j,1] > self.L[1]: | |
- self.x[j,1] -= abs(x_j[1] - x_i[1]) | |
- if self.x[j,2] > self.L[2]: | |
- self.x[j,2] -= abs(x_j[2] - x_i[2]) | |
+ if self.x[j, 0] > self.L[0]: | |
+ self.x[j, 0] -= abs(x_j[0] - x_i[0]) | |
+ if self.x[j, 1] > self.L[1]: | |
+ self.x[j, 1] -= abs(x_j[1] - x_i[1]) | |
+ if self.x[j, 2] > self.L[2]: | |
+ self.x[j, 2] -= abs(x_j[2] - x_i[2]) | |
- self.bond(i,j) # register bond | |
+ self.bond(i, j) # register bond | |
# Check that the spacing is correct | |
- x_ij=self.x[i] - self.x[j] | |
- x_ij_length=numpy.sqrt(x_ij.dot(x_ij)) | |
+ x_ij = self.x[i] - self.x[j] | |
+ x_ij_length = numpy.sqrt(x_ij.dot(x_ij)) | |
if (x_ij_length - dist_ij) > dist_ij*0.01: | |
print(x_i); print(r_i) | |
print(x_j); print(r_j) | |
t@@ -2931,16 +2863,16 @@ class sim: | |
:type spacing: float | |
''' | |
- bondparticles=numpy.unique(\ | |
- numpy.random.random_integers(0, high=self.np-1,\ | |
- size=int(self.np*ratio))) | |
+ bondparticles = numpy.unique(numpy.random.random_integers(0, high=self… | |
+ size=int(self.np*r… | |
if bondparticles.size % 2 > 0: | |
- bondparticles=bondparticles[:-1].copy() | |
- bondparticles =\ | |
- bondparticles.reshape(int(bondparticles.size/2), 2).copy() | |
+ bondparticles = bondparticles[:-1].copy() | |
+ bondparticles = bondparticles.reshape(int(bondparticles.size/2), | |
+ 2).copy() | |
for n in numpy.arange(bondparticles.shape[0]): | |
- self.createBondPair(bondparticles[n,0], bondparticles[n,1], spacin… | |
+ self.createBondPair(bondparticles[n, 0], bondparticles[n, 1], | |
+ spacing) | |
def zeroKinematics(self): | |
''' | |
t@@ -2948,18 +2880,17 @@ class sim: | |
when output from one simulation is reused in another simulation. | |
''' | |
- self.force=numpy.zeros((self.np, self.nd)) | |
- self.torque=numpy.zeros((self.np, self.nd)) | |
- self.vel=numpy.zeros(self.np*self.nd, dtype=numpy.float64)\ | |
- .reshape(self.np, self.nd) | |
- self.angvel=numpy.zeros(self.np*self.nd, dtype=numpy.float64)\ | |
- .reshape(self.np, self.nd) | |
- self.angpos=numpy.zeros(self.np*self.nd, dtype=numpy.float64)\ | |
- .reshape(self.np, self.nd) | |
- self.es=numpy.zeros(self.np, dtype=numpy.float64) | |
- self.ev=numpy.zeros(self.np, dtype=numpy.float64) | |
- self.xyzsum=numpy.zeros(self.np*3, dtype=numpy.float64)\ | |
- .reshape(self.np, 3) | |
+ self.force = numpy.zeros((self.np, self.nd)) | |
+ self.torque = numpy.zeros((self.np, self.nd)) | |
+ self.vel = numpy.zeros(self.np*self.nd, dtype=numpy.float64)\ | |
+ .reshape(self.np, self.nd) | |
+ self.angvel = numpy.zeros(self.np*self.nd, dtype=numpy.float64)\ | |
+ .reshape(self.np, self.nd) | |
+ self.angpos = numpy.zeros(self.np*self.nd, dtype=numpy.float64)\ | |
+ .reshape(self.np, self.nd) | |
+ self.es = numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.ev = numpy.zeros(self.np, dtype=numpy.float64) | |
+ self.xyzsum = numpy.zeros(self.np*3, dtype=numpy.float64).reshape(self… | |
def adjustUpperWall(self, z_adjust=1.1): | |
''' | |
t@@ -2971,17 +2902,17 @@ class sim: | |
''' | |
# Initialize upper wall | |
- self.nw=1 | |
- self.wmode=numpy.zeros(1) # fixed BC | |
- self.w_n=numpy.zeros(self.nw*self.nd, dtype=numpy.float64).reshape(\ | |
- self.nw,self.nd) | |
- self.w_n[0,2]=-1.0 | |
- self.w_vel=numpy.zeros(1) | |
- self.w_force=numpy.zeros(1) | |
- self.w_sigma0=numpy.zeros(1) | |
- | |
- self.w_x=numpy.zeros(1) | |
- self.w_m=numpy.zeros(1) | |
+ self.nw = 1 | |
+ self.wmode = numpy.zeros(1) # fixed BC | |
+ self.w_n = numpy.zeros(self.nw*self.nd, dtype=numpy.float64)\ | |
+ .reshape(self.nw, self.nd) | |
+ self.w_n[0, 2] = -1.0 | |
+ self.w_vel = numpy.zeros(1) | |
+ self.w_force = numpy.zeros(1) | |
+ self.w_sigma0 = numpy.zeros(1) | |
+ | |
+ self.w_x = numpy.zeros(1) | |
+ self.w_m = numpy.zeros(1) | |
self.adjustWall(idx=0, adjust=z_adjust) | |
def adjustWall(self, idx, adjust=1.1): | |
t@@ -3001,32 +2932,27 @@ class sim: | |
''' | |
if idx == 0: | |
- dim=2 | |
+ dim = 2 | |
elif idx == 1 or idx == 2: | |
- dim=0 | |
+ dim = 0 | |
elif idx == 3 or idx == 4: | |
- dim=1 | |
+ dim = 1 | |
else: | |
print("adjustWall: idx value not understood") | |
- xmin=numpy.min(self.x[:,dim] - self.radius) | |
- xmax=numpy.max(self.x[:,dim] + self.radius) | |
- | |
- cellsize=self.L[0] / self.num[0] | |
- d_max=numpy.max(self.radius)*2.0 | |
+ xmin = numpy.min(self.x[:, dim] - self.radius) | |
+ xmax = numpy.max(self.x[:, dim] + self.radius) | |
- self.num[dim]=numpy.ceil(((xmax-xmin)*adjust + xmin)/cellsize) | |
- self.L[dim]=(xmax-xmin)*adjust + xmin | |
+ cellsize = self.L[0] / self.num[0] | |
+ self.num[dim] = numpy.ceil(((xmax-xmin)*adjust + xmin)/cellsize) | |
+ self.L[dim] = (xmax-xmin)*adjust + xmin | |
# Initialize upper wall | |
if idx == 0 or idx == 1 or idx == 3: | |
- self.w_x[idx]=numpy.array([xmax]) | |
+ self.w_x[idx] = numpy.array([xmax]) | |
else: | |
- self.w_x[idx]=numpy.array([xmin]) | |
- #self.w_m[idx]=numpy.array([self.rho[0]*self.np*math.pi \ | |
- # *(cellsize/2.0)**3]) | |
- #self.w_m[idx]=numpy.array([self.rho*self.L[0]*self.L[1]*d_max]) | |
- self.w_m[idx]=self.totalMass() | |
+ self.w_x[idx] = numpy.array([xmin]) | |
+ self.w_m[idx] = self.totalMass() | |
def consolidate(self, normal_stress=10e3): | |
''' | |
t@@ -3037,11 +2963,12 @@ class sim: | |
:type normal_stress: float | |
''' | |
- self.nw=1 | |
+ self.nw = 1 | |
if normal_stress <= 0.0: | |
raise Exception('consolidate() error: The normal stress should be ' | |
- 'a positive value, but is ' + str(normal_stress) + ' Pa') | |
+ 'a positive value, but is ' + str(normal_stress) + | |
+ ' Pa') | |
# Zero the kinematics of all particles | |
self.zeroKinematics() | |
t@@ -3050,14 +2977,14 @@ class sim: | |
self.adjustUpperWall() | |
# Set the top wall BC to a value of normal stress | |
- self.wmode=numpy.array([1]) | |
- self.w_sigma0=numpy.ones(1) * normal_stress | |
+ self.wmode = numpy.array([1]) | |
+ self.w_sigma0 = numpy.ones(1) * normal_stress | |
# Set top wall to a certain mass corresponding to the selected normal | |
# stress | |
- #self.w_sigma0=numpy.zeros(1) | |
- #self.w_m[0]=numpy.abs(normal_stress*self.L[0]*self.L[1]/self.g[2]) | |
- self.w_m[0]=self.totalMass() | |
+ #self.w_sigma0 = numpy.zeros(1) | |
+ #self.w_m[0] = numpy.abs(normal_stress*self.L[0]*self.L[1]/self.g[2]) | |
+ self.w_m[0] = self.totalMass() | |
def uniaxialStrainRate(self, wvel=-0.001): | |
''' | |
t@@ -3074,8 +3001,8 @@ class sim: | |
# Initialize upper wall | |
self.adjustUpperWall() | |
- self.wmode=numpy.array([2]) # strain rate BC | |
- self.w_vel=numpy.array([wvel]) | |
+ self.wmode = numpy.array([2]) # strain rate BC | |
+ self.w_vel = numpy.array([wvel]) | |
def triaxial(self, wvel=-0.001, normal_stress=10.0e3): | |
''' | |
t@@ -3094,15 +3021,16 @@ class sim: | |
self.zeroKinematics() | |
# Initialize walls | |
- self.nw=5 # five dynamic walls | |
- self.wmode =numpy.array([2,1,1,1,1]) # BCs (vel, stress, stress, ...) | |
- self.w_vel =numpy.array([1,0,0,0,0]) * wvel | |
- self.w_sigma0=numpy.array([0,1,1,1,1]) * normal_stress | |
- self.w_n=numpy.array(([0,0,-1], [-1,0,0], [1,0,0], [0,-1,0], [0,1,0]), | |
- dtype=numpy.float64) | |
- self.w_x=numpy.zeros(5) | |
- self.w_m=numpy.zeros(5) | |
- self.w_force=numpy.zeros(5) | |
+ self.nw = 5 # five dynamic walls | |
+ self.wmode = numpy.array([2, 1, 1, 1, 1]) # BCs (vel, stress, stress, … | |
+ self.w_vel = numpy.array([1, 0, 0, 0, 0]) * wvel | |
+ self.w_sigma0 = numpy.array([0, 1, 1, 1, 1]) * normal_stress | |
+ self.w_n = numpy.array(([0, 0, -1], [-1, 0, 0], | |
+ [1, 0, 0], [0, -1, 0], [0, 1, 0]), | |
+ dtype=numpy.float64) | |
+ self.w_x = numpy.zeros(5) | |
+ self.w_m = numpy.zeros(5) | |
+ self.w_force = numpy.zeros(5) | |
for i in range(5): | |
self.adjustWall(idx=i) | |
t@@ -3121,60 +3049,60 @@ class sim: | |
:type shear_stress: float or bool | |
''' | |
- self.nw=1 | |
+ self.nw = 1 | |
# Find lowest and heighest point | |
- z_min=numpy.min(self.x[:,2] - self.radius) | |
- z_max=numpy.max(self.x[:,2] + self.radius) | |
+ z_min = numpy.min(self.x[:, 2] - self.radius) | |
+ z_max = numpy.max(self.x[:, 2] + self.radius) | |
# the grid cell size is equal to the max. particle diameter | |
- cellsize=self.L[0] / self.num[0] | |
+ cellsize = self.L[0] / self.num[0] | |
# make grid one cell heigher to allow dilation | |
self.num[2] += 1 | |
- self.L[2]=self.num[2] * cellsize | |
+ self.L[2] = self.num[2] * cellsize | |
# zero kinematics | |
self.zeroKinematics() | |
# Adjust grid and placement of upper wall | |
- self.wmode=numpy.array([1]) | |
+ self.wmode = numpy.array([1]) | |
# Fix horizontal velocity to 0.0 of lowermost particles | |
- d_max_below=numpy.max(self.radius[numpy.nonzero(self.x[:,2] < | |
- (z_max-z_min)*0.3)])*2.0 | |
- I=numpy.nonzero(self.x[:,2] < (z_min + d_max_below)) | |
- self.fixvel[I]=1 | |
- self.angvel[I,0]=0.0 | |
- self.angvel[I,1]=0.0 | |
- self.angvel[I,2]=0.0 | |
- self.vel[I,0]=0.0 # x-dim | |
- self.vel[I,1]=0.0 # y-dim | |
- self.color[I]=-1 | |
+ d_max_below = numpy.max(self.radius[numpy.nonzero(self.x[:, 2] < | |
+ (z_max-z_min)*0.3)])*2.0 | |
+ I = numpy.nonzero(self.x[:, 2] < (z_min + d_max_below)) | |
+ self.fixvel[I] = 1 | |
+ self.angvel[I, 0] = 0.0 | |
+ self.angvel[I, 1] = 0.0 | |
+ self.angvel[I, 2] = 0.0 | |
+ self.vel[I, 0] = 0.0 # x-dim | |
+ self.vel[I, 1] = 0.0 # y-dim | |
+ self.color[I] = -1 | |
# Fix horizontal velocity to specific value of uppermost particles | |
- d_max_top=numpy.max(self.radius[numpy.nonzero(self.x[:,2] > | |
- (z_max-z_min)*0.7)])*2.0 | |
- I=numpy.nonzero(self.x[:,2] > (z_max - d_max_top)) | |
- self.fixvel[I]=1 | |
- self.angvel[I,0]=0.0 | |
- self.angvel[I,1]=0.0 | |
- self.angvel[I,2]=0.0 | |
+ d_max_top = numpy.max(self.radius[numpy.nonzero(self.x[:, 2] > | |
+ (z_max-z_min)*0.7)])*2.0 | |
+ I = numpy.nonzero(self.x[:, 2] > (z_max - d_max_top)) | |
+ self.fixvel[I] = 1 | |
+ self.angvel[I, 0] = 0.0 | |
+ self.angvel[I, 1] = 0.0 | |
+ self.angvel[I, 2] = 0.0 | |
if not shear_stress: | |
- self.vel[I,0]=(z_max-z_min)*shear_strain_rate | |
+ self.vel[I, 0] = (z_max-z_min)*shear_strain_rate | |
else: | |
- self.vel[I,0]=0.0 | |
- self.wmode[0]=3 | |
- self.w_tau_x[0]=float(shear_stress) | |
- self.vel[I,1]=0.0 # y-dim | |
- self.color[I]=-1 | |
+ self.vel[I, 0] = 0.0 | |
+ self.wmode[0] = 3 | |
+ self.w_tau_x[0] = float(shear_stress) | |
+ self.vel[I, 1] = 0.0 # y-dim | |
+ self.color[I] = -1 | |
# Set wall tangential viscosity to zero | |
- self.gamma_wt[0]=0.0 | |
+ self.gamma_wt[0] = 0.0 | |
# Set wall friction coefficients to zero | |
- self.mu_ws[0]=0.0 | |
- self.mu_wd[0]=0.0 | |
+ self.mu_ws[0] = 0.0 | |
+ self.mu_wd[0] = 0.0 | |
def largestFluidTimeStep(self, safety=0.5, v_max=-1.0): | |
''' | |
t@@ -3187,8 +3115,8 @@ class sim: | |
(`self.mu`), and increases with fluid cell size (`self.L/self.num`) | |
and fluid velocities (`self.v_f`). | |
- NOTE: The fluid time step with the Darcy solver is an arbitrarily | |
- large value. In practice, this is not a problem since the short | |
+ NOTE: The fluid time step with the Darcy solver is an arbitrarily | |
+ large value. In practice, this is not a problem since the short | |
DEM time step is stable for fluid computations. | |
:param safety: Safety factor which is multiplied to the largest time | |
t@@ -3204,45 +3132,43 @@ class sim: | |
if self.fluid: | |
# Normalized velocities | |
- v_norm=numpy.empty(self.num[0]*self.num[1]*self.num[2]) | |
- idx=0 | |
+ v_norm = numpy.empty(self.num[0]*self.num[1]*self.num[2]) | |
+ idx = 0 | |
for x in numpy.arange(self.num[0]): | |
for y in numpy.arange(self.num[1]): | |
for z in numpy.arange(self.num[2]): | |
- v_norm[idx]=numpy.sqrt(self.v_f[x,y,z,:].dot(\ | |
- self.v_f[x,y,z,:])) | |
+ v_norm[idx] = numpy.sqrt(self.v_f[x, y, z, :]\ | |
+ .dot(self.v_f[x, y, z, :])) | |
idx += 1 | |
- v_max_obs=numpy.amax(v_norm) | |
+ v_max_obs = numpy.amax(v_norm) | |
if v_max_obs == 0: | |
- v_max_obs=1.0e-7 | |
+ v_max_obs = 1.0e-7 | |
if v_max < 0.0: | |
- v_max=v_max_obs | |
+ v_max = v_max_obs | |
- dx_min=numpy.min(self.L/self.num) | |
- dt_min_cfl=dx_min/v_max | |
+ dx_min = numpy.min(self.L/self.num) | |
+ dt_min_cfl = dx_min/v_max | |
# Navier-Stokes | |
if self.cfd_solver[0] == 0: | |
- dt_min_von_neumann=0.5*dx_min**2/(self.mu[0] + 1.0e-16) | |
- | |
+ dt_min_von_neumann = 0.5*dx_min**2/(self.mu[0] + 1.0e-16) | |
return numpy.min([dt_min_von_neumann, dt_min_cfl])*safety | |
# Darcy | |
elif self.cfd_solver[0] == 1: | |
- self.cellSize() | |
return dt_min_cfl | |
''' | |
# Determine on the base of the diffusivity coefficient | |
# components | |
#self.hydraulicPermeability() | |
- #alpha_max=numpy.max(self.k/(self.beta_f*0.9*self.mu)) | |
- k_max=2.7e-10 # hardcoded in darcy.cuh | |
- phi_min=0.1 # hardcoded in darcy.cuh | |
- alpha_max=k_max/(self.beta_f*phi_min*self.mu) | |
+ #alpha_max = numpy.max(self.k/(self.beta_f*0.9*self.mu)) | |
+ k_max = 2.7e-10 # hardcoded in darcy.cuh | |
+ phi_min = 0.1 # hardcoded in darcy.cuh | |
+ alpha_max = k_max/(self.beta_f*phi_min*self.mu) | |
print(alpha_max) | |
return safety * 1.0/(2.0*alpha_max)*1.0/( | |
1.0/(self.dx[0]**2) + \ | |
t@@ -3252,13 +3178,12 @@ class sim: | |
''' | |
# Determine value on the base of the hydraulic conductivity | |
- g=numpy.max(numpy.abs(self.g)) | |
+ g = numpy.max(numpy.abs(self.g)) | |
# Bulk modulus of fluid | |
- K=1.0/self.beta_f[0] | |
+ K = 1.0/self.beta_f[0] | |
self.hydraulicDiffusivity() | |
- self.cellSize() | |
return safety * 1.0/(2.0*self.D)*1.0/( \ | |
1.0/(self.dx[0]**2) + \ | |
t@@ -3266,13 +3191,6 @@ class sim: | |
1.0/(self.dx[2]**2)) | |
''' | |
- def cellSize(self): | |
- ''' | |
- Calculate the particle sorting (and fluid) cell dimensions. | |
- These values are stored in `self.dx` and are NOT returned. | |
- ''' | |
- self.dx=self.L/self.num | |
- | |
def hydraulicConductivity(self, phi=0.35): | |
''' | |
Determine the hydraulic conductivity (K) [m/s] from the permeability | |
t@@ -3285,13 +3203,13 @@ class sim: | |
:return type: float | |
''' | |
if self.cfd_solver[0] == 1: | |
- k=self.k_c * phi**3/(1.0 - phi**2) | |
- self.K_c=k*self.rho_f*numpy.abs(self.g[2])/self.mu | |
+ k = self.k_c * phi**3/(1.0 - phi**2) | |
+ self.K_c = k*self.rho_f*numpy.abs(self.g[2])/self.mu | |
return self.K_c[0] | |
else: | |
raise Exception('This function only works for the Darcy solver') | |
- def hydraulicPermeability(self, phi_min=0.3, phi_max=0.99): | |
+ def hydraulicPermeability(self): | |
''' | |
Determine the hydraulic permeability (k) [m*m] from the Kozeny-Carman | |
relationship, using the permeability prefactor (`self.k_c`), and the | |
t@@ -3313,9 +3231,10 @@ class sim: | |
(`self.cfd_solver[0] == 1`) | |
''' | |
if self.cfd_solver[0] == 1: | |
- self.hydraulicConductivity() | |
- phi_bar=numpy.mean(self.phi) | |
- self.D=self.K_c/(self.rho_f*g*(self.k_n[0] + phi_bar*K)) | |
+ self.hydraulicConductivity() | |
+ phi_bar = numpy.mean(self.phi) | |
+ self.D = self.K_c/(self.rho_f*self.g[2] | |
+ *(self.k_n[0] + phi_bar*self.K)) | |
else: | |
raise Exception('This function only works for the Darcy solver') | |
t@@ -3345,29 +3264,29 @@ class sim: | |
''' | |
if dt > 0.0: | |
- self.time_dt[0]=dt | |
+ self.time_dt[0] = dt | |
if self.np > 0: | |
print("Warning: Manually specifying the time step length when " | |
- + "simulating particles may produce instabilities.") | |
+ "simulating particles may produce instabilities.") | |
elif self.np > 0: | |
- r_min=numpy.min(self.radius) | |
- m_min=self.rho * 4.0/3.0*numpy.pi*r_min**3 | |
+ r_min = numpy.min(self.radius) | |
+ m_min = self.rho * 4.0/3.0*numpy.pi*r_min**3 | |
if self.E > 0.001: | |
- k_max=numpy.max(numpy.pi/2.0*self.E*self.radius) | |
+ k_max = numpy.max(numpy.pi/2.0*self.E*self.radius) | |
else: | |
- k_max=numpy.max([self.k_n[:], self.k_t[:]]) | |
+ k_max = numpy.max([self.k_n[:], self.k_t[:]]) | |
# Radjaii et al 2011 | |
- self.time_dt[0]=epsilon/(numpy.sqrt(k_max/m_min)) | |
+ self.time_dt[0] = epsilon/(numpy.sqrt(k_max/m_min)) | |
# Zhang and Campbell, 1992 | |
- #self.time_dt[0]=0.075*math.sqrt(m_min/k_max) | |
+ #self.time_dt[0] = 0.075*math.sqrt(m_min/k_max) | |
# Computational time step (O'Sullivan et al, 2003) | |
- #self.time_dt[0]=0.17*math.sqrt(m_min/k_max) | |
+ #self.time_dt[0] = 0.17*math.sqrt(m_min/k_max) | |
elif not self.fluid: | |
raise Exception('Error: Could not automatically set a time step.') | |
t@@ -3376,15 +3295,14 @@ class sim: | |
# by von Neumann stability analysis of the diffusion and advection | |
# terms | |
if self.fluid: | |
- fluid_time_dt=self.largestFluidTimeStep() | |
- self.time_dt[0]=numpy.min([fluid_time_dt, self.time_dt[0]]) | |
- | |
+ fluid_time_dt = self.largestFluidTimeStep() | |
+ self.time_dt[0] = numpy.min([fluid_time_dt, self.time_dt[0]]) | |
# Time at start | |
- self.time_current[0]=current | |
- self.time_total[0]=total | |
- self.time_file_dt[0]=file_dt | |
- self.time_step_count[0]=0 | |
+ self.time_current[0] = current | |
+ self.time_total[0] = total | |
+ self.time_file_dt[0] = file_dt | |
+ self.time_step_count[0] = step_count | |
def dry(self): | |
''' | |
t@@ -3392,7 +3310,7 @@ class sim: | |
See also :func:`wet()` | |
''' | |
- self.fluid=False | |
+ self.fluid = False | |
def wet(self): | |
''' | |
t@@ -3400,7 +3318,7 @@ class sim: | |
See also :func:`dry()` | |
''' | |
- self.fluid=True | |
+ self.fluid = True | |
self.initFluid() | |
def initFluid(self, mu=8.9e-4, rho=1.0e3, p=0.0, hydrostatic=False, | |
t@@ -3426,93 +3344,92 @@ class sim: | |
Accepted values: 0 (Navier Stokes, default) and 1 (Darcy). | |
:type cfd_solver: int | |
''' | |
- self.fluid=True | |
- self.mu=numpy.ones(1, dtype=numpy.float64) * mu | |
- self.rho_f=numpy.ones(1, dtype=numpy.float64) * rho | |
+ self.fluid = True | |
+ self.mu = numpy.ones(1, dtype=numpy.float64) * mu | |
+ self.rho_f = numpy.ones(1, dtype=numpy.float64) * rho | |
- self.p_f=numpy.ones((self.num[0], self.num[1], self.num[2]), | |
- dtype=numpy.float64) * p | |
+ self.p_f = numpy.ones((self.num[0], self.num[1], self.num[2]), | |
+ dtype=numpy.float64) * p | |
if hydrostatic: | |
- dz=self.L[2]/self.num[2] | |
+ dz = self.L[2]/self.num[2] | |
# Zero pressure gradient from grid top to top wall, linear pressure | |
# distribution from top wall to grid bottom | |
if self.nw == 1: | |
- wall0_iz=int(self.w_x[0]/(self.L[2]/self.num[2])) | |
- self.p_f[:,:,wall0_iz:]=p | |
+ wall0_iz = int(self.w_x[0]/(self.L[2]/self.num[2])) | |
+ self.p_f[:, :, wall0_iz:] = p | |
for iz in numpy.arange(wall0_iz - 1): | |
- z=dz*iz + 0.5*dz | |
- depth=self.w_x[0] - z | |
- self.p_f[:,:,iz]=p + (depth-dz) * rho * -self.g[2] | |
+ z = dz*iz + 0.5*dz | |
+ depth = self.w_x[0] - z | |
+ self.p_f[:, :, iz] = p + (depth-dz) * rho * -self.g[2] | |
# Linear pressure distribution from grid top to grid bottom | |
else: | |
for iz in numpy.arange(self.num[2] - 1): | |
- z=dz*iz + 0.5*dz | |
- depth=self.L[2] - z | |
- self.p_f[:,:,iz]=p + (depth-dz) * rho * -self.g[2] | |
+ z = dz*iz + 0.5*dz | |
+ depth = self.L[2] - z | |
+ self.p_f[:, :, iz] = p + (depth-dz) * rho * -self.g[2] | |
- self.v_f=numpy.zeros((self.num[0], self.num[1], self.num[2], self.nd), | |
- dtype=numpy.float64) | |
- self.phi=numpy.ones((self.num[0], self.num[1], self.num[2]), | |
- dtype=numpy.float64) | |
- self.dphi=numpy.zeros((self.num[0], self.num[1], self.num[2]), | |
- dtype=numpy.float64) | |
+ self.v_f = numpy.zeros((self.num[0], self.num[1], self.num[2], self.nd… | |
+ dtype=numpy.float64) | |
+ self.phi = numpy.ones((self.num[0], self.num[1], self.num[2]), | |
+ dtype=numpy.float64) | |
+ self.dphi = numpy.zeros((self.num[0], self.num[1], self.num[2]), | |
+ dtype=numpy.float64) | |
- self.p_mod_A=numpy.zeros(1, dtype=numpy.float64) # Amplitude [Pa] | |
- self.p_mod_f=numpy.zeros(1, dtype=numpy.float64) # Frequency [Hz] | |
- self.p_mod_phi=numpy.zeros(1, dtype=numpy.float64) # Shift [rad] | |
+ self.p_mod_A = numpy.zeros(1, dtype=numpy.float64) # Amplitude [Pa] | |
+ self.p_mod_f = numpy.zeros(1, dtype=numpy.float64) # Frequency [Hz] | |
+ self.p_mod_phi = numpy.zeros(1, dtype=numpy.float64) # Shift [rad] | |
- self.bc_bot=numpy.zeros(1, dtype=numpy.int32) | |
- self.bc_top=numpy.zeros(1, dtype=numpy.int32) | |
- self.free_slip_bot=numpy.ones(1, dtype=numpy.int32) | |
- self.free_slip_top=numpy.ones(1, dtype=numpy.int32) | |
- self.bc_bot_flux=numpy.zeros(1, dtype=numpy.float64) | |
- self.bc_top_flux=numpy.zeros(1, dtype=numpy.float64) | |
+ self.bc_bot = numpy.zeros(1, dtype=numpy.int32) | |
+ self.bc_top = numpy.zeros(1, dtype=numpy.int32) | |
+ self.free_slip_bot = numpy.ones(1, dtype=numpy.int32) | |
+ self.free_slip_top = numpy.ones(1, dtype=numpy.int32) | |
+ self.bc_bot_flux = numpy.zeros(1, dtype=numpy.float64) | |
+ self.bc_top_flux = numpy.zeros(1, dtype=numpy.float64) | |
- self.p_f_constant=numpy.zeros((self.num[0], self.num[1], | |
- self.num[2]), | |
- dtype=numpy.int32) | |
+ self.p_f_constant = numpy.zeros((self.num[0], self.num[1], self.num[2]… | |
+ dtype=numpy.int32) | |
# Fluid solver type | |
# 0: Navier Stokes (fluid with inertia) | |
# 1: Stokes-Darcy (fluid without inertia) | |
- self.cfd_solver=numpy.ones(1)*cfd_solver | |
+ self.cfd_solver = numpy.ones(1)*cfd_solver | |
if self.cfd_solver[0] == 0: | |
- self.gamma=numpy.array(0.0) | |
- self.theta=numpy.array(1.0) | |
- self.beta=numpy.array(0.0) | |
- self.tolerance=numpy.array(1.0e-3) | |
- self.maxiter=numpy.array(1e4) | |
- self.ndem=numpy.array(1) | |
- | |
- self.c_phi=numpy.ones(1, dtype=numpy.float64) | |
- self.c_v=numpy.ones(1, dtype=numpy.float64) | |
- self.dt_dem_fac=numpy.ones(1, dtype=numpy.float64) | |
- | |
- self.f_d=numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.f_p=numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.f_v=numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.f_sum=numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.gamma = numpy.array(0.0) | |
+ self.theta = numpy.array(1.0) | |
+ self.beta = numpy.array(0.0) | |
+ self.tolerance = numpy.array(1.0e-3) | |
+ self.maxiter = numpy.array(1e4) | |
+ self.ndem = numpy.array(1) | |
+ | |
+ self.c_phi = numpy.ones(1, dtype=numpy.float64) | |
+ self.c_v = numpy.ones(1, dtype=numpy.float64) | |
+ self.dt_dem_fac = numpy.ones(1, dtype=numpy.float64) | |
+ | |
+ self.f_d = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.f_p = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.f_v = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.f_sum = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
elif self.cfd_solver[0] == 1: | |
- self.tolerance=numpy.array(1.0e-3) | |
- self.maxiter=numpy.array(1e4) | |
- self.ndem=numpy.array(1) | |
- self.c_phi=numpy.ones(1, dtype=numpy.float64) | |
- self.f_d=numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.beta_f=numpy.ones(1, dtype=numpy.float64)*4.5e-10 | |
- self.f_p=numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
- self.k_c=numpy.ones(1, dtype=numpy.float64)*4.6e-10 | |
- | |
- self.bc_xn=numpy.ones(1, dtype=numpy.int32)*2 | |
- self.bc_xp=numpy.ones(1, dtype=numpy.int32)*2 | |
- self.bc_yn=numpy.ones(1, dtype=numpy.int32)*2 | |
- self.bc_yp=numpy.ones(1, dtype=numpy.int32)*2 | |
+ self.tolerance = numpy.array(1.0e-3) | |
+ self.maxiter = numpy.array(1e4) | |
+ self.ndem = numpy.array(1) | |
+ self.c_phi = numpy.ones(1, dtype=numpy.float64) | |
+ self.f_d = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.beta_f = numpy.ones(1, dtype=numpy.float64)*4.5e-10 | |
+ self.f_p = numpy.zeros((self.np, self.nd), dtype=numpy.float64) | |
+ self.k_c = numpy.ones(1, dtype=numpy.float64)*4.6e-10 | |
+ | |
+ self.bc_xn = numpy.ones(1, dtype=numpy.int32)*2 | |
+ self.bc_xp = numpy.ones(1, dtype=numpy.int32)*2 | |
+ self.bc_yn = numpy.ones(1, dtype=numpy.int32)*2 | |
+ self.bc_yp = numpy.ones(1, dtype=numpy.int32)*2 | |
else: | |
raise Exception('Value of cfd_solver not understood (' + \ | |
t@@ -3531,7 +3448,7 @@ class sim: | |
:return type: float | |
''' | |
if value != -1: | |
- self.time_current[0]=value | |
+ self.time_current[0] = value | |
else: | |
return self.time_current[0] | |
t@@ -3543,7 +3460,7 @@ class sim: | |
The default behavior for the boundary is fixed value (Dirichlet), see | |
:func:`setFluidBottomFixedPressure()`. | |
''' | |
- self.bc_bot[0]=1 | |
+ self.bc_bot[0] = 1 | |
def setFluidBottomNoFlowNoSlip(self): | |
''' | |
t@@ -3553,7 +3470,7 @@ class sim: | |
The default behavior for the boundary is fixed value (Dirichlet), see | |
:func:`setFluidBottomFixedPressure()`. | |
''' | |
- self.bc_bot[0]=2 | |
+ self.bc_bot[0] = 2 | |
def setFluidBottomFixedPressure(self): | |
''' | |
t@@ -3563,7 +3480,7 @@ class sim: | |
This is the default behavior for the boundary. See also | |
:func:`setFluidBottomNoFlow()` | |
''' | |
- self.bc_bot[0]=0 | |
+ self.bc_bot[0] = 0 | |
def setFluidBottomFixedFlux(self, specific_flux): | |
''' | |
t@@ -3575,8 +3492,8 @@ class sim: | |
:param specific_flux: Specific flux values across boundary (positive | |
values upwards), [m/s] | |
''' | |
- self.bc_bot[0]=4 | |
- self.bc_bot_flux[0]=specific_flux | |
+ self.bc_bot[0] = 4 | |
+ self.bc_bot_flux[0] = specific_flux | |
def setFluidTopNoFlow(self): | |
''' | |
t@@ -3586,7 +3503,7 @@ class sim: | |
The default behavior for the boundary is fixed value (Dirichlet), see | |
:func:`setFluidTopFixedPressure()`. | |
''' | |
- self.bc_top[0]=1 | |
+ self.bc_top[0] = 1 | |
def setFluidTopNoFlowNoSlip(self): | |
''' | |
t@@ -3596,7 +3513,7 @@ class sim: | |
The default behavior for the boundary is fixed value (Dirichlet), see | |
:func:`setFluidTopFixedPressure()`. | |
''' | |
- self.bc_top[0]=2 | |
+ self.bc_top[0] = 2 | |
def setFluidTopFixedPressure(self): | |
''' | |
t@@ -3606,7 +3523,7 @@ class sim: | |
This is the default behavior for the boundary. See also | |
:func:`setFluidTopNoFlow()` | |
''' | |
- self.bc_top[0]=0 | |
+ self.bc_top[0] = 0 | |
def setFluidTopFixedFlux(self, specific_flux): | |
''' | |
t@@ -3618,8 +3535,8 @@ class sim: | |
:param specific_flux: Specific flux values across boundary (positive | |
values upwards), [m/s] | |
''' | |
- self.bc_top[0]=4 | |
- self.bc_top_flux[0]=specific_flux | |
+ self.bc_top[0] = 4 | |
+ self.bc_top_flux[0] = specific_flux | |
def setFluidXFixedPressure(self): | |
''' | |
t@@ -3631,8 +3548,8 @@ class sim: | |
:func:`setFluidXNoFlow()`, and | |
:func:`setFluidXPeriodic()` (default) | |
''' | |
- self.bc_xn[0]=0 | |
- self.bc_xp[0]=0 | |
+ self.bc_xn[0] = 0 | |
+ self.bc_xp[0] = 0 | |
def setFluidXNoFlow(self): | |
''' | |
t@@ -3644,8 +3561,8 @@ class sim: | |
:func:`setFluidXNoFlow()`, and | |
:func:`setFluidXPeriodic()` (default) | |
''' | |
- self.bc_xn[0]=1 | |
- self.bc_xp[0]=1 | |
+ self.bc_xn[0] = 1 | |
+ self.bc_xp[0] = 1 | |
def setFluidXPeriodic(self): | |
''' | |
t@@ -3656,8 +3573,8 @@ class sim: | |
:func:`setFluidXFixedPressure()` and | |
:func:`setFluidXNoFlow()` | |
''' | |
- self.bc_xn[0]=2 | |
- self.bc_xp[0]=2 | |
+ self.bc_xn[0] = 2 | |
+ self.bc_xp[0] = 2 | |
def setFluidYFixedPressure(self): | |
''' | |
t@@ -3668,8 +3585,8 @@ class sim: | |
:func:`setFluidYNoFlow()` and | |
:func:`setFluidYPeriodic()` (default) | |
''' | |
- self.bc_yn[0]=0 | |
- self.bc_yp[0]=0 | |
+ self.bc_yn[0] = 0 | |
+ self.bc_yp[0] = 0 | |
def setFluidYNoFlow(self): | |
''' | |
t@@ -3680,8 +3597,8 @@ class sim: | |
:func:`setFluidYFixedPressure()` and | |
:func:`setFluidYPeriodic()` (default) | |
''' | |
- self.bc_yn[0]=1 | |
- self.bc_yp[0]=1 | |
+ self.bc_yn[0] = 1 | |
+ self.bc_yp[0] = 1 | |
def setFluidYPeriodic(self): | |
''' | |
t@@ -3692,8 +3609,8 @@ class sim: | |
:func:`setFluidYFixedPressure()` and | |
:func:`setFluidYNoFlow()` | |
''' | |
- self.bc_yn[0]=2 | |
- self.bc_yp[0]=2 | |
+ self.bc_yn[0] = 2 | |
+ self.bc_yp[0] = 2 | |
def setPermeabilityGrainSize(self, verbose=True): | |
''' | |
t@@ -3705,9 +3622,8 @@ class sim: | |
prefactor. | |
:type verbose: bool | |
''' | |
- self.setPermeabilityPrefactor( | |
- k_c=numpy.mean(self.radius*2.0)**2.0/180.0, | |
- verbose=verbose) | |
+ self.setPermeabilityPrefactor(k_c=numpy.mean(self.radius*2.0)**2.0/180… | |
+ verbose=verbose) | |
def setPermeabilityPrefactor(self, k_c, verbose=True): | |
''' | |
t@@ -3723,11 +3639,11 @@ class sim: | |
:type verbose: bool | |
''' | |
if self.cfd_solver[0] == 1: | |
- self.k_c[0]=k_c | |
+ self.k_c[0] = k_c | |
if verbose: | |
- phi=numpy.array([0.1, 0.35, 0.9]) | |
- k=self.k_c * phi**3/(1.0 - phi**2) | |
- K=k * self.rho_f*numpy.abs(self.g[2])/self.mu | |
+ phi = numpy.array([0.1, 0.35, 0.9]) | |
+ k = self.k_c * phi**3/(1.0 - phi**2) | |
+ K = k * self.rho_f*numpy.abs(self.g[2])/self.mu | |
print('Hydraulic permeability limits for porosity phi=' + \ | |
str(phi) + ':') | |
print('\tk=' + str(k) + ' m*m') | |
t@@ -3736,7 +3652,7 @@ class sim: | |
print('\tK=' + str(K) + ' m/s') | |
else: | |
raise Exception('setPermeabilityPrefactor() only relevant for the ' | |
- + 'Darcy solver (cfd_solver=1)') | |
+ 'Darcy solver (cfd_solver=1)') | |
def findPermeabilities(self): | |
''' | |
t@@ -3748,11 +3664,11 @@ class sim: | |
`self.readbin`. | |
''' | |
if self.cfd_solver[0] == 1: | |
- phi=numpy.clip(self.phi, 0.1, 0.9) | |
- self.k=self.k_c * phi**3/(1.0 - phi**2) | |
+ phi = numpy.clip(self.phi, 0.1, 0.9) | |
+ self.k = self.k_c * phi**3/(1.0 - phi**2) | |
else: | |
raise Exception('findPermeabilities() only relevant for the ' | |
- + 'Darcy solver (cfd_solver=1)') | |
+ 'Darcy solver (cfd_solver=1)') | |
def findHydraulicConductivities(self): | |
''' | |
t@@ -3765,10 +3681,10 @@ class sim: | |
''' | |
if self.cfd_solver[0] == 1: | |
self.findPermeabilities() | |
- self.K=self.k*self.rho_f*numpy.abs(self.g[2])/self.mu | |
+ self.K = self.k*self.rho_f*numpy.abs(self.g[2])/self.mu | |
else: | |
raise Exception('findPermeabilities() only relevant for the ' | |
- + 'Darcy solver (cfd_solver=1)') | |
+ 'Darcy solver (cfd_solver=1)') | |
def defaultParams(self, mu_s=0.5, mu_d=0.5, mu_r=0.0, rho=2600, k_n=1.16e9, | |
k_t=1.16e9, k_r=0, gamma_n=0.0, gamma_t=0.0, gamma_r=0.0, | |
t@@ -3806,19 +3722,19 @@ class sim: | |
''' | |
# Particle material density, kg/m^3 | |
- self.rho=numpy.ones(1, dtype=numpy.float64) * rho | |
+ self.rho = numpy.ones(1, dtype=numpy.float64) * rho | |
### Dry granular material parameters | |
# Contact normal elastic stiffness, N/m | |
- self.k_n=numpy.ones(1, dtype=numpy.float64) * k_n | |
+ self.k_n = numpy.ones(1, dtype=numpy.float64) * k_n | |
# Contact shear elastic stiffness (for contactmodel=2), N/m | |
- self.k_t=numpy.ones(1, dtype=numpy.float64) * k_t | |
+ self.k_t = numpy.ones(1, dtype=numpy.float64) * k_t | |
# Contact rolling elastic stiffness (for contactmodel=2), N/m | |
- self.k_r=numpy.ones(1, dtype=numpy.float64) * k_r | |
+ self.k_r = numpy.ones(1, dtype=numpy.float64) * k_r | |
# Contact normal viscosity. Critical damping: 2*sqrt(m*k_n). | |
# Normal force component elastic if nu=0.0. | |
t@@ -3826,51 +3742,51 @@ class sim: | |
# * nu_frac * 2.0 * math.sqrt(4.0/3.0 * math.pi \ | |
# * numpy.amin(self.radius)**3 \ | |
# * self.rho[0] * self.k_n[0]) | |
- self.gamma_n=numpy.ones(1, dtype=numpy.float64) * gamma_n | |
+ self.gamma_n = numpy.ones(1, dtype=numpy.float64) * gamma_n | |
# Contact shear viscosity, Ns/m | |
- self.gamma_t=numpy.ones(1, dtype=numpy.float64) * gamma_t | |
+ self.gamma_t = numpy.ones(1, dtype=numpy.float64) * gamma_t | |
# Contact rolling viscosity, Ns/m? | |
- self.gamma_r=numpy.ones(1, dtype=numpy.float64) * gamma_r | |
+ self.gamma_r = numpy.ones(1, dtype=numpy.float64) * gamma_r | |
# Contact static shear friction coefficient | |
- #self.mu_s=numpy.ones(1, dtype=numpy.float64) * \ | |
+ #self.mu_s = numpy.ones(1, dtype=numpy.float64) * \ | |
#numpy.tan(numpy.radians(ang_s)) | |
- self.mu_s=numpy.ones(1, dtype=numpy.float64) * mu_s | |
+ self.mu_s = numpy.ones(1, dtype=numpy.float64) * mu_s | |
# Contact dynamic shear friction coefficient | |
- #self.mu_d=numpy.ones(1, dtype=numpy.float64) * \ | |
+ #self.mu_d = numpy.ones(1, dtype=numpy.float64) * \ | |
#numpy.tan(numpy.radians(ang_d)) | |
- self.mu_d=numpy.ones(1, dtype=numpy.float64) * mu_d | |
+ self.mu_d = numpy.ones(1, dtype=numpy.float64) * mu_d | |
# Contact rolling friction coefficient | |
- #self.mu_r=numpy.ones(1, dtype=numpy.float64) * \ | |
+ #self.mu_r = numpy.ones(1, dtype=numpy.float64) * \ | |
#numpy.tan(numpy.radians(ang_r)) | |
- self.mu_r=numpy.ones(1, dtype=numpy.float64) * mu_r | |
+ self.mu_r = numpy.ones(1, dtype=numpy.float64) * mu_r | |
# Wall viscosities | |
- self.gamma_wn[0]=gamma_wn # normal | |
- self.gamma_wt[0]=gamma_wt # sliding | |
+ self.gamma_wn[0] = gamma_wn # normal | |
+ self.gamma_wt[0] = gamma_wt # sliding | |
# Wall friction coefficients | |
- self.mu_ws=self.mu_s # static | |
- self.mu_wd=self.mu_d # dynamic | |
+ self.mu_ws = self.mu_s # static | |
+ self.mu_wd = self.mu_d # dynamic | |
### Parameters related to capillary bonds | |
# Wettability, 0=perfect | |
- theta=0.0; | |
+ theta = 0.0 | |
if capillaryCohesion == 1: | |
# Prefactor | |
- self.kappa[0]=2.0 * math.pi * gamma_t * numpy.cos(theta) | |
- self.V_b[0]=1e-12 # Liquid volume at bond | |
- else : | |
- self.kappa[0]=0.0; # Zero capillary force | |
- self.V_b[0]=0.0; # Zero liquid volume at bond | |
+ self.kappa[0] = 2.0 * math.pi * gamma_t * numpy.cos(theta) | |
+ self.V_b[0] = 1e-12 # Liquid volume at bond | |
+ else: | |
+ self.kappa[0] = 0.0 # Zero capillary force | |
+ self.V_b[0] = 0.0 # Zero liquid volume at bond | |
# Debonding distance | |
- self.db[0]=(1.0 + theta/2.0) * self.V_b**(1.0/3.0) | |
+ self.db[0] = (1.0 + theta/2.0) * self.V_b**(1.0/3.0) | |
def setStiffnessNormal(self, k_n): | |
''' | |
t@@ -3880,7 +3796,7 @@ class sim: | |
:param k_n: The elastic stiffness coefficient [N/m] | |
:type k_n: float | |
''' | |
- self.k_n[0]=k_n | |
+ self.k_n[0] = k_n | |
def setStiffnessTangential(self, k_t): | |
''' | |
t@@ -3890,7 +3806,7 @@ class sim: | |
:param k_t: The elastic stiffness coefficient [N/m] | |
:type k_t: float | |
''' | |
- self.k_t[0]=k_t | |
+ self.k_t[0] = k_t | |
def setYoungsModulus(self, E): | |
''' | |
t@@ -3905,7 +3821,7 @@ class sim: | |
:param E: The elastic modulus [Pa] | |
:type E: float | |
''' | |
- self.E[0]=E | |
+ self.E[0] = E | |
def setDampingNormal(self, gamma, over_damping=False): | |
''' | |
t@@ -3920,9 +3836,9 @@ class sim: | |
See also: :func:`setDampingTangential(gamma)` | |
''' | |
- self.gamma_n[0]=gamma | |
- critical_gamma=2.0*numpy.sqrt(self.smallestMass()*self.k_n[0]) | |
- damping_ratio=gamma/critical_gamma | |
+ self.gamma_n[0] = gamma | |
+ critical_gamma = 2.0*numpy.sqrt(self.smallestMass()*self.k_n[0]) | |
+ damping_ratio = gamma/critical_gamma | |
if damping_ratio < 1.0: | |
print('Info: The system is under-dampened (ratio=' | |
+ str(damping_ratio) | |
t@@ -3931,18 +3847,20 @@ class sim: | |
elif damping_ratio > 1.0: | |
if over_damping: | |
print('Warning: The system is over-dampened (ratio=' | |
- + str(damping_ratio) + ') in the normal component. ' | |
- + '\nCritical damping=' + str(critical_gamma) + '.') | |
+ + str(damping_ratio) + ') in the normal component. ' | |
+ '\nCritical damping=' + str(critical_gamma) + '.') | |
else: | |
raise Exception('Warning: The system is over-dampened (ratio=' | |
- + str(damping_ratio) + ') in the normal component.\n' | |
- + 'Call this function once more with `over_damping=True`… | |
- + 'if this is what you want. \nCritical damping=' | |
- + str(critical_gamma) + '.') | |
+ + str(damping_ratio) + ') in the normal ' | |
+ 'component.\n' | |
+ 'Call this function once more with ' | |
+ '`over_damping=True` if this is what you want.' | |
+ '\nCritical damping=' + str(critical_gamma) + | |
+ '.') | |
else: | |
- print('Warning: The system is critically dampened (ratio=' | |
- + str(damping_ratio) + ') in the normal component. ' | |
- + '\nCritical damping=' + str(critical_gamma) + '.') | |
+ print('Warning: The system is critically dampened (ratio=' + | |
+ str(damping_ratio) + ') in the normal component. ' | |
+ '\nCritical damping=' + str(critical_gamma) + '.') | |
def setDampingTangential(self, gamma, over_damping=False): | |
''' | |
t@@ -3957,8 +3875,8 @@ class sim: | |
See also: :func:`setDampingNormal(gamma)` | |
''' | |
- self.gamma_t[0]=gamma | |
- damping_ratio=gamma/(2.0*numpy.sqrt(self.smallestMass()*self.k_t[0])) | |
+ self.gamma_t[0] = gamma | |
+ damping_ratio = gamma/(2.0*numpy.sqrt(self.smallestMass()*self.k_t[0])) | |
if damping_ratio < 1.0: | |
print('Info: The system is under-dampened (ratio=' | |
+ str(damping_ratio) | |
t@@ -3966,12 +3884,13 @@ class sim: | |
elif damping_ratio > 1.0: | |
if over_damping: | |
print('Warning: The system is over-dampened (ratio=' | |
- + str(damping_ratio) + ') in the tangential component.') | |
+ + str(damping_ratio) + ') in the tangential component.') | |
else: | |
raise Exception('Warning: The system is over-dampened (ratio=' | |
- + str(damping_ratio) + ') in the tangential component.\n' | |
- + 'Call this function once more with `over_damping=True`… | |
- + 'if this is what you want.') | |
+ + str(damping_ratio) + ') in the tangential ' | |
+ 'component.\n' | |
+ 'Call this function once more with ' | |
+ '`over_damping=True` if this is what you want.… | |
else: | |
print('Warning: The system is critically dampened (ratio=' | |
+ str(damping_ratio) + ') in the tangential component.') | |
t@@ -3988,7 +3907,7 @@ class sim: | |
See also: :func:`setDynamicFriction(mu_d)` | |
''' | |
- self.mu_s[0]=mu_s | |
+ self.mu_s[0] = mu_s | |
def setDynamicFriction(self, mu_d): | |
''' | |
t@@ -4005,7 +3924,7 @@ class sim: | |
See also: :func:`setStaticFriction(mu_s)` | |
''' | |
- self.mu_d[0]=mu_d | |
+ self.mu_d[0] = mu_d | |
def setFluidCompressibility(self, beta_f): | |
''' | |
t@@ -4020,10 +3939,10 @@ class sim: | |
See also: :func:`setFluidDensity()` and :func:`setFluidViscosity()` | |
''' | |
if self.cfd_solver[0] == 1: | |
- self.beta_f[0]=beta_f | |
+ self.beta_f[0] = beta_f | |
else: | |
raise Exception('setFluidCompressibility() only relevant for the ' | |
- + 'Darcy solver (cfd_solver=1)') | |
+ 'Darcy solver (cfd_solver=1)') | |
def setFluidViscosity(self, mu): | |
''' | |
t@@ -4037,7 +3956,7 @@ class sim: | |
See also: :func:`setFluidDensity()` and | |
:func:`setFluidCompressibility()` | |
''' | |
- self.mu[0]=mu | |
+ self.mu[0] = mu | |
def setFluidDensity(self, rho_f): | |
''' | |
t@@ -4050,7 +3969,7 @@ class sim: | |
See also: :func:`setFluidViscosity()` and | |
:func:`setFluidCompressibility()` | |
''' | |
- self.rho_f[0]=rho_f | |
+ self.rho_f[0] = rho_f | |
def scaleSize(self, factor): | |
''' | |
t@@ -4082,38 +4001,36 @@ class sim: | |
:type j: int | |
''' | |
- self.lambda_bar[0]=1.0 # Radius multiplier to parallel-bond radii | |
+ self.lambda_bar[0] = 1.0 # Radius multiplier to parallel-bond radii | |
if not hasattr(self, 'bonds'): | |
- self.bonds=numpy.array([[i,j]], dtype=numpy.uint32) | |
- else : | |
- self.bonds=numpy.vstack((self.bonds, [i,j])) | |
+ self.bonds = numpy.array([[i, j]], dtype=numpy.uint32) | |
+ else: | |
+ self.bonds = numpy.vstack((self.bonds, [i, j])) | |
if not hasattr(self, 'bonds_delta_n'): | |
- self.bonds_delta_n=numpy.array([0.0], dtype=numpy.uint32) | |
- else : | |
- #self.bonds_delta_n=numpy.vstack((self.bonds_delta_n, [0.0])) | |
- self.bonds_delta_n=numpy.append(self.bonds_delta_n, [0.0]) | |
+ self.bonds_delta_n = numpy.array([0.0], dtype=numpy.uint32) | |
+ else: | |
+ #self.bonds_delta_n = numpy.vstack((self.bonds_delta_n, [0.0])) | |
+ self.bonds_delta_n = numpy.append(self.bonds_delta_n, [0.0]) | |
if not hasattr(self, 'bonds_delta_t'): | |
- self.bonds_delta_t=numpy.array([[0.0, 0.0, 0.0]],\ | |
- dtype=numpy.uint32) | |
- else : | |
- self.bonds_delta_t=numpy.vstack((self.bonds_delta_t,\ | |
- [0.0, 0.0, 0.0])) | |
+ self.bonds_delta_t = numpy.array([[0.0, 0.0, 0.0]], dtype=numpy.ui… | |
+ else: | |
+ self.bonds_delta_t = numpy.vstack((self.bonds_delta_t, | |
+ [0.0, 0.0, 0.0])) | |
if not hasattr(self, 'bonds_omega_n'): | |
- self.bonds_omega_n=numpy.array([0.0], dtype=numpy.uint32) | |
- else : | |
- #self.bonds_omega_n=numpy.vstack((self.bonds_omega_n, [0.0])) | |
- self.bonds_omega_n=numpy.append(self.bonds_omega_n, [0.0]) | |
+ self.bonds_omega_n = numpy.array([0.0], dtype=numpy.uint32) | |
+ else: | |
+ #self.bonds_omega_n = numpy.vstack((self.bonds_omega_n, [0.0])) | |
+ self.bonds_omega_n = numpy.append(self.bonds_omega_n, [0.0]) | |
if not hasattr(self, 'bonds_omega_t'): | |
- self.bonds_omega_t=numpy.array([[0.0, 0.0, 0.0]],\ | |
- dtype=numpy.uint32) | |
- else : | |
- self.bonds_omega_t=numpy.vstack((self.bonds_omega_t,\ | |
- [0.0, 0.0, 0.0])) | |
+ self.bonds_omega_t = numpy.array([[0.0, 0.0, 0.0]], dtype=numpy.ui… | |
+ else: | |
+ self.bonds_omega_t = numpy.vstack((self.bonds_omega_t, | |
+ [0.0, 0.0, 0.0])) | |
# Increment the number of bonds with one | |
self.nb0 += 1 | |
t@@ -4178,7 +4095,7 @@ class sim: | |
:returns: The total mass in [kg] | |
''' | |
- m=0.0 | |
+ m = 0.0 | |
for i in range(self.np): | |
m += self.mass(i) | |
return m | |
t@@ -4226,7 +4143,7 @@ class sim: | |
:return type: float | |
''' | |
return 0.5*self.mass(idx) \ | |
- *numpy.sqrt(numpy.dot(self.vel[idx,:], self.vel[idx,:]))**2 | |
+ *numpy.sqrt(numpy.dot(self.vel[idx, :], self.vel[idx, :]))**2 | |
def totalKineticEnergy(self): | |
''' | |
t@@ -4234,7 +4151,7 @@ class sim: | |
:returns: The kinetic energy of all particles [J] | |
''' | |
- esum=0.0 | |
+ esum = 0.0 | |
for i in range(self.np): | |
esum += self.kineticEnergy(i) | |
return esum | |
t@@ -4249,7 +4166,7 @@ class sim: | |
:return type: float | |
''' | |
return 0.5*self.momentOfInertia(idx) \ | |
- *numpy.sqrt(numpy.dot(self.angvel[idx,:], self.angvel[idx,:]))**2 | |
+ *numpy.sqrt(numpy.dot(self.angvel[idx, :], self.angvel[idx, :]))**2 | |
def totalRotationalEnergy(self): | |
''' | |
t@@ -4257,7 +4174,7 @@ class sim: | |
:returns: The rotational energy of all particles [J] | |
''' | |
- esum=0.0 | |
+ esum = 0.0 | |
for i in range(self.np): | |
esum += self.rotationalEnergy(i) | |
return esum | |
t@@ -4280,7 +4197,7 @@ class sim: | |
:returns: The normal viscous energy lost by all particles [J] | |
:return type: float | |
''' | |
- esum=0.0 | |
+ esum = 0.0 | |
for i in range(self.np): | |
esum += self.viscousEnergy(i) | |
return esum | |
t@@ -4303,7 +4220,7 @@ class sim: | |
:returns: The total frictional energy lost of all particles [J] | |
:return type: float | |
''' | |
- esum=0.0 | |
+ esum = 0.0 | |
for i in range(self.np): | |
esum += self.frictionalEnergy(i) | |
return esum | |
t@@ -4325,24 +4242,24 @@ class sim: | |
''' | |
if method == 'pot': | |
- m=numpy.ones(self.np)*4.0/3.0*math.pi*self.radius**3*self.rho | |
- return numpy.sum(m*math.sqrt(numpy.dot(self.g,self.g))*self.x[:,2]) | |
+ m = numpy.ones(self.np)*4.0/3.0*math.pi*self.radius**3*self.rho | |
+ return numpy.sum(m*math.sqrt(numpy.dot(self.g, self.g))*self.x[:, … | |
elif method == 'kin': | |
- m=numpy.ones(self.np)*4.0/3.0*math.pi*self.radius**3*self.rho | |
- esum=0.0 | |
+ m = numpy.ones(self.np)*4.0/3.0*math.pi*self.radius**3*self.rho | |
+ esum = 0.0 | |
for i in range(self.np): | |
esum += 0.5*m[i]*math.sqrt(\ | |
- numpy.dot(self.vel[i,:],self.vel[i,:]))**2 | |
+ numpy.dot(self.vel[i, :], self.vel[i, :]))**2 | |
return esum | |
elif method == 'rot': | |
- m=numpy.ones(self.np)*4.0/3.0*math.pi*self.radius**3*self.rho | |
- esum=0.0 | |
+ m = numpy.ones(self.np)*4.0/3.0*math.pi*self.radius**3*self.rho | |
+ esum = 0.0 | |
for i in range(self.np): | |
esum += 0.5*2.0/5.0*m[i]*self.radius[i]**2 \ | |
*math.sqrt(\ | |
- numpy.dot(self.angvel[i,:],self.angvel[i,:]))**2 | |
+ numpy.dot(self.angvel[i, :], self.angvel[i, :]))**2 | |
return esum | |
elif method == 'shear': | |
t@@ -4359,22 +4276,22 @@ class sim: | |
elif method == 'bondpot': | |
if self.nb0 > 0: | |
- R_bar=self.lambda_bar*numpy.minimum(\ | |
- self.radius[self.bonds[:,0]],\ | |
- self.radius[self.bonds[:,1]]) | |
- A=numpy.pi*R_bar**2 | |
- I=0.25*numpy.pi*R_bar**4 | |
- J=I*2.0 | |
- bondpot_fn=numpy.sum(\ | |
+ R_bar = self.lambda_bar*numpy.minimum(\ | |
+ self.radius[self.bonds[:, 0]],\ | |
+ self.radius[self.bonds[:, 1]]) | |
+ A = numpy.pi*R_bar**2 | |
+ I = 0.25*numpy.pi*R_bar**4 | |
+ J = I*2.0 | |
+ bondpot_fn = numpy.sum(\ | |
0.5*A*self.k_n*numpy.abs(self.bonds_delta_n)**2) | |
- bondpot_ft=numpy.sum(\ | |
+ bondpot_ft = numpy.sum(\ | |
0.5*A*self.k_t*numpy.linalg.norm(self.bonds_delta_t)**… | |
- bondpot_tn=numpy.sum(\ | |
+ bondpot_tn = numpy.sum(\ | |
0.5*J*self.k_t*numpy.abs(self.bonds_omega_n)**2) | |
- bondpot_tt=numpy.sum(\ | |
+ bondpot_tt = numpy.sum(\ | |
0.5*I*self.k_n*numpy.linalg.norm(self.bonds_omega_t)**… | |
return bondpot_fn + bondpot_ft + bondpot_tn + bondpot_tt | |
- else : | |
+ else: | |
return 0.0 | |
else: | |
raise Exception('Unknownw energy() method "' + method + '"') | |
t@@ -4388,15 +4305,15 @@ class sim: | |
''' | |
# Find the bulk volume | |
- V_t=(self.L[0] - self.origo[0]) \ | |
+ V_t = (self.L[0] - self.origo[0]) \ | |
*(self.L[1] - self.origo[1]) \ | |
*(self.w_x[0] - self.origo[2]) | |
# Find the volume of solids | |
- V_s=numpy.sum(4.0/3.0 * math.pi * self.radius**3) | |
+ V_s = numpy.sum(4.0/3.0 * math.pi * self.radius**3) | |
# Return the void ratio | |
- e=(V_t - V_s)/V_s | |
+ e = (V_t - V_s)/V_s | |
return e | |
def bulkPorosity(self, trim=True): | |
t@@ -4411,27 +4328,26 @@ class sim: | |
:return type: float | |
''' | |
- V_total=0.0 | |
+ V_total = 0.0 | |
if trim: | |
- min_x=numpy.min(self.x[:,0] - self.radius) | |
- min_y=numpy.min(self.x[:,1] - self.radius) | |
- min_z=numpy.min(self.x[:,2] - self.radius) | |
- max_x=numpy.max(self.x[:,0] + self.radius) | |
- max_y=numpy.max(self.x[:,1] + self.radius) | |
- max_z=numpy.max(self.x[:,2] + self.radius) | |
- V_total=(max_x - min_x)*(max_y - min_y)*(max_z - min_z) | |
+ min_x = numpy.min(self.x[:, 0] - self.radius) | |
+ min_y = numpy.min(self.x[:, 1] - self.radius) | |
+ min_z = numpy.min(self.x[:, 2] - self.radius) | |
+ max_x = numpy.max(self.x[:, 0] + self.radius) | |
+ max_y = numpy.max(self.x[:, 1] + self.radius) | |
+ max_z = numpy.max(self.x[:, 2] + self.radius) | |
+ V_total = (max_x - min_x)*(max_y - min_y)*(max_z - min_z) | |
else: | |
if self.nw == 0: | |
- V_total=self.L[0] * self.L[1] * self.L[2] | |
+ V_total = self.L[0] * self.L[1] * self.L[2] | |
elif self.nw == 1: | |
- V_total=self.L[0] * self.L[1] * self.w_x[0] | |
+ V_total = self.L[0] * self.L[1] * self.w_x[0] | |
if V_total <= 0.0: | |
raise Exception("Could not determine total volume") | |
- | |
# Find the volume of solids | |
- V_solid=numpy.sum(V_sphere(self.radius)) | |
+ V_solid = numpy.sum(V_sphere(self.radius)) | |
return (V_total - V_solid) / V_total | |
def porosity(self, slices=10, verbose=False): | |
t@@ -4453,24 +4369,23 @@ class sim: | |
self.writebin(verbose=False) | |
# Run porosity program on binary | |
- pipe=subprocess.Popen(\ | |
- ["../porosity",\ | |
- "-s","{}".format(slices),\ | |
- "../input/" + self.sid + ".bin"],\ | |
- stdout=subprocess.PIPE) | |
- output, err=pipe.communicate() | |
+ pipe = subprocess.Popen(["../porosity",\ | |
+ "-s", "{}".format(slices), | |
+ "../input/" + self.sid + ".bin"], | |
+ stdout=subprocess.PIPE) | |
+ output, err = pipe.communicate() | |
if err: | |
print(err) | |
raise Exception("Could not run external 'porosity' program") | |
# read one line of output at a time | |
- s2=output.split(b'\n') | |
- depth=[] | |
- porosity=[] | |
+ s2 = output.split(b'\n') | |
+ depth = [] | |
+ porosity = [] | |
for row in s2: | |
if row != '\n' or row != '' or row != ' ': # skip blank lines | |
- s3=row.split(b'\t') | |
+ s3 = row.split(b'\t') | |
if s3 != '' and len(s3) == 2: # make sure line has two vals | |
depth.append(float(s3[0])) | |
porosity.append(float(s3[1])) | |
t@@ -4505,34 +4420,34 @@ class sim: | |
self.writebin(verbose=False) | |
- quiet="" | |
- stdout="" | |
- dryarg="" | |
- fluidarg="" | |
- devicearg="" | |
- valgrindbin="" | |
- cudamemchk="" | |
- binary="sphere" | |
+ quiet = "" | |
+ stdout = "" | |
+ dryarg = "" | |
+ fluidarg = "" | |
+ devicearg = "" | |
+ valgrindbin = "" | |
+ cudamemchk = "" | |
+ binary = "sphere" | |
if not verbose: | |
- quiet="-q " | |
+ quiet = "-q " | |
if hideinputfile: | |
- stdout=" > /dev/null" | |
+ stdout = " > /dev/null" | |
if dry: | |
- dryarg="--dry " | |
+ dryarg = "--dry " | |
if valgrind: | |
- valgrindbin="valgrind -q --track-origins=yes " | |
+ valgrindbin = "valgrind -q --track-origins=yes " | |
if cudamemcheck: | |
- cudamemchk="cuda-memcheck --leak-check full " | |
+ cudamemchk = "cuda-memcheck --leak-check full " | |
if self.fluid: | |
- fluidarg="--fluid " | |
+ fluidarg = "--fluid " | |
if device != -1: | |
- devicearg="-d " + str(device) + " " | |
+ devicearg = "-d " + str(device) + " " | |
- cmd="cd ..; " + valgrindbin + cudamemchk + "./" + binary + " " \ | |
+ cmd = "cd ..; " + valgrindbin + cudamemchk + "./" + binary + " " \ | |
+ quiet + dryarg + fluidarg + devicearg + \ | |
"input/" + self.sid + ".bin " + stdout | |
#print(cmd) | |
- status=subprocess.call(cmd, shell=True) | |
+ status = subprocess.call(cmd, shell=True) | |
if status != 0: | |
print("Warning: the sphere run returned with status " + str(status… | |
t@@ -4582,10 +4497,10 @@ class sim: | |
''' | |
- filename=self.sid + ".sh" | |
- fh=None | |
- try : | |
- fh=open(filename, "w") | |
+ filename = self.sid + ".sh" | |
+ fh = None | |
+ try: | |
+ fh = open(filename, "w") | |
fh.write('#!/bin/sh\n') | |
fh.write('#PBS -N ' + self.sid + '\n') | |
t@@ -4597,7 +4512,7 @@ class sim: | |
fh.write('CUDAPATH=' + cudapath + '\n') | |
fh.write('export PATH=$CUDAPATH/bin:$PATH\n') | |
fh.write('export LD_LIBRARY_PATH=$CUDAPATH/lib64' | |
- + ':$CUDAPATH/lib:$LD_LIBRARY_PATH\n') | |
+ + ':$CUDAPATH/lib:$LD_LIBRARY_PATH\n') | |
fh.write('echo "`whoami`@`hostname`"\n') | |
fh.write('echo "Start at `date`"\n') | |
fh.write('ORIGDIR=' + spheredir + '\n') | |
t@@ -4614,7 +4529,7 @@ class sim: | |
fh.write('cp $WORKDIR/output/* $ORIGDIR/output/\n') | |
fh.write('echo "End at `date`"\n') | |
- finally : | |
+ finally: | |
if fh is not None: | |
fh.close() | |
t@@ -4645,21 +4560,21 @@ class sim: | |
print("Rendering {} images with the raytracer".format(self.sid)) | |
- quiet="" | |
+ quiet = "" | |
if not verbose: | |
- quiet="-q" | |
+ quiet = "-q" | |
# Render images using sphere raytracer | |
if method == "normal": | |
subprocess.call("cd ..; for F in `ls output/" + self.sid | |
- + "*.bin`; do ./sphere " + quiet | |
- + " --render $F; done", shell=True) | |
- else : | |
+ + "*.bin`; do ./sphere " + quiet | |
+ + " --render $F; done", shell=True) | |
+ else: | |
subprocess.call("cd ..; for F in `ls output/" + self.sid | |
- + "*.bin`; do ./sphere " + quiet | |
- + " --method " + method + " {}".format(max_val) | |
- + " -l {}".format(lower_cutoff) | |
- + " --render $F; done", shell=True) | |
+ + "*.bin`; do ./sphere " + quiet | |
+ + " --method " + method + " {}".format(max_val) | |
+ + " -l {}".format(lower_cutoff) | |
+ + " --render $F; done", shell=True) | |
# Convert images to compressed format | |
if verbose: | |
t@@ -4668,7 +4583,7 @@ class sim: | |
def video(self, out_folder="./", video_format="mp4", | |
graphics_folder="../img_out/", graphics_format="png", fps=25, | |
- qscale=1, bitrate=1800, verbose=False): | |
+ verbose=False): | |
''' | |
Uses ffmpeg to combine images to animation. All images should be | |
rendered beforehand using :func:`render()`. | |
t@@ -4707,9 +4622,9 @@ class sim: | |
''' | |
# Displacement of the upper, fixed particles in the shear direction | |
- #xdisp=self.time_current[0] * self.shearVel() | |
- fixvel=numpy.nonzero(self.fixvel > 0.0) | |
- return numpy.max(self.xyzsum[fixvel,0]) | |
+ #xdisp = self.time_current[0] * self.shearVel() | |
+ fixvel = numpy.nonzero(self.fixvel > 0.0) | |
+ return numpy.max(self.xyzsum[fixvel, 0]) | |
def shearVelocity(self): | |
''' | |
t@@ -4723,9 +4638,9 @@ class sim: | |
See also: :func:`shearStrainRate()` and :func:`shearDisplacement()` | |
''' | |
# Displacement of the upper, fixed particles in the shear direction | |
- #xdisp=self.time_current[0] * self.shearVel() | |
- fixvel=numpy.nonzero(self.fixvel > 0.0) | |
- return numpy.max(self.vel[fixvel,0]) | |
+ #xdisp = self.time_current[0] * self.shearVel() | |
+ fixvel = numpy.nonzero(self.fixvel > 0.0) | |
+ return numpy.max(self.vel[fixvel, 0]) | |
def shearVel(self): | |
''' | |
t@@ -4746,10 +4661,10 @@ class sim: | |
''' | |
# Current height | |
- w_x0=self.w_x[0] | |
+ w_x0 = self.w_x[0] | |
# Displacement of the upper, fixed particles in the shear direction | |
- xdisp=self.shearDisplacement() | |
+ xdisp = self.shearDisplacement() | |
# Return shear strain | |
return xdisp/w_x0 | |
t@@ -4766,8 +4681,8 @@ class sim: | |
#return self.shearStrain()/self.time_current[1] | |
# Current height | |
- w_x0=self.w_x[0] | |
- v=self.shearVelocity() | |
+ w_x0 = self.w_x[0] | |
+ v = self.shearVelocity() | |
# Return shear strain rate | |
return v/w_x0 | |
t@@ -4796,11 +4711,12 @@ class sim: | |
''' | |
self.writebin(verbose=False) | |
subprocess.call('cd .. && ./sphere --contacts input/' + self.sid | |
- + '.bin > output/' + self.sid + '.contacts.txt', shell=True) | |
- contactdata=numpy.loadtxt('../output/' + self.sid + '.contacts.txt') | |
- self.pairs=numpy.array((contactdata[:,0], contactdata[:,1]), | |
- dtype=numpy.int32) | |
- self.overlaps=numpy.array(contactdata[:,2]) | |
+ + '.bin > output/' + self.sid + '.contacts.txt', | |
+ shell=True) | |
+ contactdata = numpy.loadtxt('../output/' + self.sid + '.contacts.txt') | |
+ self.pairs = numpy.array((contactdata[:, 0], contactdata[:, 1]), | |
+ dtype=numpy.int32) | |
+ self.overlaps = numpy.array(contactdata[:, 2]) | |
def findCoordinationNumber(self): | |
''' | |
t@@ -4808,10 +4724,10 @@ class sim: | |
particle). Requires a previous call to :func:`findOverlaps()`. Values | |
are stored in ``self.coordinationnumber``. | |
''' | |
- self.coordinationnumber=numpy.zeros(self.np, dtype=numpy.int) | |
+ self.coordinationnumber = numpy.zeros(self.np, dtype=numpy.int) | |
for i in numpy.arange(self.overlaps.size): | |
- self.coordinationnumber[self.pairs[0,i]] += 1 | |
- self.coordinationnumber[self.pairs[1,i]] += 1 | |
+ self.coordinationnumber[self.pairs[0, i]] += 1 | |
+ self.coordinationnumber[self.pairs[1, i]] += 1 | |
def findMeanCoordinationNumber(self): | |
''' | |
t@@ -4834,7 +4750,7 @@ class sim: | |
See also: :func:`findOverlaps()` and :func:`findContactStresses()` | |
''' | |
self.findOverlaps() | |
- self.f_n_magn=self.k_n * numpy.abs(self.overlaps) | |
+ self.f_n_magn = self.k_n * numpy.abs(self.overlaps) | |
def contactSurfaceArea(self, i, j, overlap): | |
''' | |
t@@ -4849,13 +4765,12 @@ class sim: | |
:returns: Contact area [m*m] | |
:return type: float or array of floats | |
''' | |
- r_i=self.radius[i] | |
- r_j=self.radius[j] | |
- d=r_i + r_j + overlap | |
- contact_radius=1./(2.*d)*( | |
- (-d + r_i - r_j)*(-d - r_i + r_j)* | |
- (-d + r_i + r_j)*( d + r_i + r_j) | |
- )**0.5 | |
+ r_i = self.radius[i] | |
+ r_j = self.radius[j] | |
+ d = r_i + r_j + overlap | |
+ contact_radius = 1./(2.*d)*((-d + r_i - r_j)*(-d - r_i + r_j)* | |
+ (-d + r_i + r_j)*(d + r_i + r_j) | |
+ )**0.5 | |
return numpy.pi*contact_radius**2. | |
def contactParticleArea(self, i, j): | |
t@@ -4871,7 +4786,7 @@ class sim: | |
:returns: Contact area [m*m] | |
:return type: float or array of floats | |
''' | |
- r_bar=(self.radius[i] + self.radius[j])*0.5 | |
+ r_bar = (self.radius[i] + self.radius[j])*0.5 | |
return numpy.pi*r_bar**2. | |
def findAllContactSurfaceAreas(self): | |
t@@ -4883,8 +4798,8 @@ class sim: | |
:returns: Array of contact surface areas | |
:return type: array of floats | |
''' | |
- return self.contactSurfaceArea(self.pairs[0,:], self.pairs[1,:], | |
- self.overlaps) | |
+ return self.contactSurfaceArea(self.pairs[0, :], self.pairs[1, :], | |
+ self.overlaps) | |
def findAllAverageParticlePairAreas(self): | |
''' | |
t@@ -4895,7 +4810,7 @@ class sim: | |
:returns: Array of contact surface areas | |
:return type: array of floats | |
''' | |
- return self.contactParticleArea(self.pairs[0,:], self.pairs[1,:]) | |
+ return self.contactParticleArea(self.pairs[0, :], self.pairs[1, :]) | |
def findContactStresses(self, area='average'): | |
''' | |
t@@ -4913,13 +4828,13 @@ class sim: | |
''' | |
self.findNormalForces() | |
if area == 'average': | |
- areas=self.findAllAverageParticlePairAreas() | |
+ areas = self.findAllAverageParticlePairAreas() | |
elif area == 'contact': | |
- areas=self.findAllContactSurfaceAreas() | |
+ areas = self.findAllContactSurfaceAreas() | |
else: | |
raise Exception('Contact area type "' + area + '" not understood') | |
- self.sigma_contacts=self.f_n_magn/areas | |
+ self.sigma_contacts = self.f_n_magn/areas | |
def findLoadedContacts(self, threshold): | |
''' | |
t@@ -4956,13 +4871,14 @@ class sim: | |
self.writebin(verbose=False) | |
- nd='' | |
+ nd = '' | |
if disp == '2d': | |
- nd='-2d ' | |
+ nd = '-2d ' | |
- subprocess.call("cd .. && ./forcechains " + nd + "-f " + outformat \ | |
- + " -lc " + str(lc) + " -uc " + str(uc) + " input/" + self.sid… | |
- + ".bin > python/tmp.gp", shell=True) | |
+ subprocess.call("cd .. && ./forcechains " + nd + "-f " + outformat | |
+ + " -lc " + str(lc) + " -uc " + str(uc) | |
+ + " input/" + self.sid + ".bin > python/tmp.gp", | |
+ shell=True) | |
subprocess.call("gnuplot tmp.gp && rm tmp.gp", shell=True) | |
t@@ -4984,42 +4900,41 @@ class sim: | |
+ ".bin > python/fc-tmp.txt", shell=True) | |
# data will have the shape (numcontacts, 7) | |
- data=numpy.loadtxt("fc-tmp.txt", skiprows=1) | |
+ data = numpy.loadtxt("fc-tmp.txt", skiprows=1) | |
# find the max. value of the normal force | |
- f_n_max=numpy.amax(data[:,6]) | |
+ f_n_max = numpy.amax(data[:, 6]) | |
# specify the lower limit of force chains to do statistics on | |
- f_n_lim=lower_limit * f_n_max * 0.6 | |
+ f_n_lim = lower_limit * f_n_max * 0.6 | |
# find the indexes of these contacts | |
- I=numpy.nonzero(data[:,6] > f_n_lim) | |
+ I = numpy.nonzero(data[:, 6] > f_n_lim) | |
# loop through these contacts and find the strike and dip of the | |
# contacts | |
- strikelist=[] # strike direction of the normal vector, [0:360[ | |
- diplist=[] # dip of the normal vector, [0:90] | |
+ strikelist = [] # strike direction of the normal vector, [0:360[ | |
+ diplist = [] # dip of the normal vector, [0:90] | |
for i in I[0]: | |
- x1=data[i,0] | |
- y1=data[i,1] | |
- z1=data[i,2] | |
- x2=data[i,3] | |
- y2=data[i,4] | |
- z2=data[i,5] | |
+ x1 = data[i, 0] | |
+ y1 = data[i, 1] | |
+ z1 = data[i, 2] | |
+ x2 = data[i, 3] | |
+ y2 = data[i, 4] | |
+ z2 = data[i, 5] | |
if z1 < z2: | |
- xlower=x1; ylower=y1; zlower=z1 | |
- xupper=x2; yupper=y2; zupper=z2 | |
- else : | |
- xlower=x2; ylower=y2; zlower=z2 | |
- xupper=x1; yupper=y1; zupper=z1 | |
+ xlower = x1; ylower = y1; zlower = z1 | |
+ xupper = x2; yupper = y2; zupper = z2 | |
+ else: | |
+ xlower = x2; ylower = y2; zlower = z2 | |
+ xupper = x1; yupper = y1; zupper = z1 | |
# Vector pointing downwards | |
- dx=xlower - xupper | |
- dy=ylower - yupper | |
- dz=zlower - zupper | |
- dhoriz=numpy.sqrt(dx**2 + dy**2) | |
+ dx = xlower - xupper | |
+ dy = ylower - yupper | |
+ dhoriz = numpy.sqrt(dx**2 + dy**2) | |
# Find dip angle | |
diplist.append(math.degrees(math.atan((zupper - zlower)/dhoriz))) | |
t@@ -5027,17 +4942,17 @@ class sim: | |
# Find strike angle | |
if ylower >= yupper: # in first two quadrants | |
strikelist.append(math.acos(dx/dhoriz)) | |
- else : | |
+ else: | |
strikelist.append(2.0*numpy.pi - math.acos(dx/dhoriz)) | |
- plt.figure(figsize=[4,4]) | |
- ax=plt.subplot(111, polar=True) | |
+ plt.figure(figsize=[4, 4]) | |
+ ax = plt.subplot(111, polar=True) | |
ax.scatter(strikelist, diplist, c='k', marker='+') | |
ax.set_rmax(90) | |
ax.set_rticks([]) | |
plt.savefig('fc-' + self.sid + '-rose.' + graphics_format,\ | |
- transparent=True) | |
+ transparent=True) | |
subprocess.call('rm fc-tmp.txt', shell=True) | |
t@@ -5055,32 +4970,31 @@ class sim: | |
return | |
# loop through these contacts and find the strike and dip of the | |
# contacts | |
- strikelist=[] # strike direction of the normal vector, [0:360[ | |
- diplist=[] # dip of the normal vector, [0:90] | |
+ strikelist = [] # strike direction of the normal vector, [0:360[ | |
+ diplist = [] # dip of the normal vector, [0:90] | |
for n in numpy.arange(self.nb0): | |
- i=self.bonds[n,0] | |
- j=self.bonds[n,1] | |
+ i = self.bonds[n, 0] | |
+ j = self.bonds[n, 1] | |
- x1=self.x[i,0] | |
- y1=self.x[i,1] | |
- z1=self.x[i,2] | |
- x2=self.x[j,0] | |
- y2=self.x[j,1] | |
- z2=self.x[j,2] | |
+ x1 = self.x[i, 0] | |
+ y1 = self.x[i, 1] | |
+ z1 = self.x[i, 2] | |
+ x2 = self.x[j, 0] | |
+ y2 = self.x[j, 1] | |
+ z2 = self.x[j, 2] | |
if z1 < z2: | |
- xlower=x1; ylower=y1; zlower=z1 | |
- xupper=x2; yupper=y2; zupper=z2 | |
- else : | |
- xlower=x2; ylower=y2; zlower=z2 | |
- xupper=x1; yupper=y1; zupper=z1 | |
+ xlower = x1; ylower = y1; zlower = z1 | |
+ xupper = x2; yupper = y2; zupper = z2 | |
+ else: | |
+ xlower = x2; ylower = y2; zlower = z2 | |
+ xupper = x1; yupper = y1; zupper = z1 | |
# Vector pointing downwards | |
- dx=xlower - xupper | |
- dy=ylower - yupper | |
- dz=zlower - zupper | |
- dhoriz=numpy.sqrt(dx**2 + dy**2) | |
+ dx = xlower - xupper | |
+ dy = ylower - yupper | |
+ dhoriz = numpy.sqrt(dx**2 + dy**2) | |
# Find dip angle | |
diplist.append(math.degrees(math.atan((zupper - zlower)/dhoriz))) | |
t@@ -5088,16 +5002,16 @@ class sim: | |
# Find strike angle | |
if ylower >= yupper: # in first two quadrants | |
strikelist.append(math.acos(dx/dhoriz)) | |
- else : | |
+ else: | |
strikelist.append(2.0*numpy.pi - math.acos(dx/dhoriz)) | |
- plt.figure(figsize=[4,4]) | |
- ax=plt.subplot(111, polar=True) | |
+ plt.figure(figsize=[4, 4]) | |
+ ax = plt.subplot(111, polar=True) | |
ax.scatter(strikelist, diplist, c='k', marker='+') | |
ax.set_rmax(90) | |
ax.set_rticks([]) | |
plt.savefig('bonds-' + self.sid + '-rose.' + graphics_format,\ | |
- transparent=True) | |
+ transparent=True) | |
def status(self): | |
''' | |
t@@ -5118,7 +5032,7 @@ class sim: | |
:returns: The particle momentum [N*s] | |
:return type: numpy.array | |
''' | |
- return self.rho*V_sphere(self.radius[idx])*self.vel[idx,:] | |
+ return self.rho*V_sphere(self.radius[idx])*self.vel[idx, :] | |
def totalMomentum(self): | |
''' | |
t@@ -5127,7 +5041,7 @@ class sim: | |
:returns: The sum of particle momentums (m*v) [N*s] | |
:return type: numpy.array | |
''' | |
- m_sum=numpy.zeros(3) | |
+ m_sum = numpy.zeros(3) | |
for i in range(self.np): | |
m_sum += self.momentum(i) | |
return m_sum | |
t@@ -5146,40 +5060,40 @@ class sim: | |
return | |
# Bin data and error bars for alternative visualization | |
- h_total=numpy.max(self.x[:,2]) - numpy.min(self.x[:,2]) | |
- h_slice=h_total / zslices | |
+ h_total = numpy.max(self.x[:, 2]) - numpy.min(self.x[:, 2]) | |
+ h_slice = h_total / zslices | |
- zpos=numpy.zeros(zslices) | |
- xdisp=numpy.zeros(zslices) | |
- err=numpy.zeros(zslices) | |
+ zpos = numpy.zeros(zslices) | |
+ xdisp = numpy.zeros(zslices) | |
+ err = numpy.zeros(zslices) | |
for iz in range(zslices): | |
# Find upper and lower boundaries of bin | |
- zlower=iz * h_slice | |
- zupper=zlower + h_slice | |
+ zlower = iz * h_slice | |
+ zupper = zlower + h_slice | |
# Save depth | |
- zpos[iz]=zlower + 0.5*h_slice | |
+ zpos[iz] = zlower + 0.5*h_slice | |
# Find particle indexes within that slice | |
- I=numpy.nonzero((self.x[:,2] > zlower) & (self.x[:,2] < zupper)) | |
+ I = numpy.nonzero((self.x[:, 2] > zlower) & (self.x[:, 2] < zupper… | |
# Save mean x displacement | |
- xdisp[iz]=numpy.mean(self.xyzsum[I,0]) | |
+ xdisp[iz] = numpy.mean(self.xyzsum[I, 0]) | |
# Save x displacement standard deviation | |
- err[iz]=numpy.std(self.xyzsum[I,0]) | |
+ err[iz] = numpy.std(self.xyzsum[I, 0]) | |
plt.figure(figsize=[4, 4]) | |
- ax=plt.subplot(111) | |
- ax.scatter(self.xyzsum[:,0], self.x[:,2], c='gray', marker='+') | |
+ ax = plt.subplot(111) | |
+ ax.scatter(self.xyzsum[:, 0], self.x[:, 2], c='gray', marker='+') | |
ax.errorbar(xdisp, zpos, xerr=err, | |
c='black', linestyle='-', linewidth=1.4) | |
ax.set_xlabel("Horizontal particle displacement, [m]") | |
ax.set_ylabel("Vertical position, [m]") | |
plt.savefig(self.sid + '-sheardisp.' + graphics_format, | |
- transparent=True) | |
+ transparent=True) | |
def porosities(self, graphics_format='pdf', zslices=16): | |
''' | |
t@@ -5196,16 +5110,15 @@ class sim: | |
print('Error: matplotlib module not found, cannot sheardisp.') | |
return | |
- porosity, depth=self.porosity(zslices) | |
+ porosity, depth = self.porosity(zslices) | |
plt.figure(figsize=[4, 4]) | |
- ax=plt.subplot(111) | |
- ax.plot(porosity, depth, | |
- c='black', linestyle='-', linewidth=1.4) | |
+ ax = plt.subplot(111) | |
+ ax.plot(porosity, depth, c='black', linestyle='-', linewidth=1.4) | |
ax.set_xlabel('Horizontally averaged porosity, [-]') | |
ax.set_ylabel('Vertical position, [m]') | |
plt.savefig(self.sid + '-porositiy.' + graphics_format, | |
- transparent=True) | |
+ transparent=True) | |
def thinsection_x1x3(self, x2='center', graphics_format='png', cbmax=None, | |
arrowscale=0.01, velarrowscale=1.0, slipscale=1.0, | |
t@@ -5246,32 +5159,32 @@ class sim: | |
print('Error: matplotlib module not found (thinsection_x1x3).') | |
return | |
- if x2 == 'center' : | |
- x2=(self.L[1] - self.origo[1]) / 2.0 | |
+ if x2 == 'center': | |
+ x2 = (self.L[1] - self.origo[1]) / 2.0 | |
# Initialize plot circle positionsr, radii and pressures | |
- ilist=[] | |
- xlist=[] | |
- ylist=[] | |
- rlist=[] | |
- plist=[] | |
- pmax=0.0 | |
- rmax=0.0 | |
- axlist=[] | |
- aylist=[] | |
- daxlist=[] | |
- daylist=[] | |
- dvxlist=[] | |
- dvylist=[] | |
- # Black circle at periphery of particles with angvel[:,1] > 0.0 | |
- cxlist=[] | |
- cylist=[] | |
- crlist=[] | |
+ ilist = [] | |
+ xlist = [] | |
+ ylist = [] | |
+ rlist = [] | |
+ plist = [] | |
+ pmax = 0.0 | |
+ rmax = 0.0 | |
+ axlist = [] | |
+ aylist = [] | |
+ daxlist = [] | |
+ daylist = [] | |
+ dvxlist = [] | |
+ dvylist = [] | |
+ # Black circle at periphery of particles with angvel[:, 1] > 0.0 | |
+ cxlist = [] | |
+ cylist = [] | |
+ crlist = [] | |
# Loop over all particles, find intersections | |
for i in range(self.np): | |
- delta=abs(self.x[i,1] - x2) # distance between centre and plane | |
+ delta = abs(self.x[i, 1] - x2) # distance between centre and pla… | |
if delta < self.radius[i]: # if the sphere intersects the plane | |
t@@ -5279,60 +5192,60 @@ class sim: | |
ilist.append(i) | |
# Store position on plane | |
- xlist.append(self.x[i,0]) | |
- ylist.append(self.x[i,2]) | |
+ xlist.append(self.x[i, 0]) | |
+ ylist.append(self.x[i, 2]) | |
# Store radius of intersection | |
- r_circ=math.sqrt(self.radius[i]**2 - delta**2) | |
+ r_circ = math.sqrt(self.radius[i]**2 - delta**2) | |
if r_circ > rmax: | |
- rmax=r_circ | |
+ rmax = r_circ | |
rlist.append(r_circ) | |
# Store pos. and radius if it is spinning around pos. y | |
- if self.angvel[i,1] > 0.0: | |
- cxlist.append(self.x[i,0]) | |
- cylist.append(self.x[i,2]) | |
+ if self.angvel[i, 1] > 0.0: | |
+ cxlist.append(self.x[i, 0]) | |
+ cylist.append(self.x[i, 2]) | |
crlist.append(r_circ) | |
# Store pressure | |
- pval=self.p[i] | |
+ pval = self.p[i] | |
if cbmax != None: | |
if pval > cbmax: | |
- pval=cbmax | |
+ pval = cbmax | |
plist.append(pval) | |
# Store rotational velocity data for arrows | |
# Save two arrows per particle | |
- axlist.append(self.x[i,0]) # x starting point of arrow | |
- axlist.append(self.x[i,0]) # x starting point of arrow | |
+ axlist.append(self.x[i, 0]) # x starting point of arrow | |
+ axlist.append(self.x[i, 0]) # x starting point of arrow | |
# y starting point of arrow | |
- aylist.append(self.x[i,2] + r_circ*0.5) | |
+ aylist.append(self.x[i, 2] + r_circ*0.5) | |
# y starting point of arrow | |
- aylist.append(self.x[i,2] - r_circ*0.5) | |
+ aylist.append(self.x[i, 2] - r_circ*0.5) | |
# delta x for arrow end point | |
- daxlist.append(self.angvel[i,1]*arrowscale) | |
+ daxlist.append(self.angvel[i, 1]*arrowscale) | |
# delta x for arrow end point | |
- daxlist.append(-self.angvel[i,1]*arrowscale) | |
+ daxlist.append(-self.angvel[i, 1]*arrowscale) | |
daylist.append(0.0) # delta y for arrow end point | |
daylist.append(0.0) # delta y for arrow end point | |
# Store linear velocity data | |
# delta x for arrow end point | |
- dvxlist.append(self.vel[i,0]*velarrowscale) | |
+ dvxlist.append(self.vel[i, 0]*velarrowscale) | |
# delta y for arrow end point | |
- dvylist.append(self.vel[i,2]*velarrowscale) | |
+ dvylist.append(self.vel[i, 2]*velarrowscale) | |
if r_circ > self.radius[i]: | |
raise Exception("Error, circle radius is larger than the " | |
- + "particle radius") | |
+ "particle radius") | |
if self.p[i] > pmax: | |
- pmax=self.p[i] | |
+ pmax = self.p[i] | |
if verbose: | |
print("Max. pressure of intersecting spheres: " + str(pmax) + " Pa… | |
t@@ -5340,28 +5253,28 @@ class sim: | |
print("Value limited to: " + str(cbmax) + " Pa") | |
# Save circle data | |
- filename='../gnuplot/data/' + self.sid + '-ts-x1x3.txt' | |
- fh=None | |
- try : | |
- fh=open(filename, 'w') | |
+ filename = '../gnuplot/data/' + self.sid + '-ts-x1x3.txt' | |
+ fh = None | |
+ try: | |
+ fh = open(filename, 'w') | |
for (x, y, r, p) in zip(xlist, ylist, rlist, plist): | |
fh.write("{}\t{}\t{}\t{}\n".format(x, y, r, p)) | |
- finally : | |
+ finally: | |
if fh is not None: | |
fh.close() | |
# Save circle data for articles spinning with pos. y | |
- filename='../gnuplot/data/' + self.sid + '-ts-x1x3-circ.txt' | |
- fh=None | |
- try : | |
- fh=open(filename, 'w') | |
+ filename = '../gnuplot/data/' + self.sid + '-ts-x1x3-circ.txt' | |
+ fh = None | |
+ try: | |
+ fh = open(filename, 'w') | |
for (x, y, r) in zip(cxlist, cylist, crlist): | |
fh.write("{}\t{}\t{}\n".format(x, y, r)) | |
- finally : | |
+ finally: | |
if fh is not None: | |
fh.close() | |
t@@ -5369,41 +5282,41 @@ class sim: | |
# radius | |
# Output format: x, y, deltax, deltay | |
# gnuplot> plot '-' using 1:2:3:4 with vectors head filled lt 2 | |
- filename='../gnuplot/data/' + self.sid + '-ts-x1x3-arrows.txt' | |
- fh=None | |
- try : | |
- fh=open(filename, 'w') | |
+ filename = '../gnuplot/data/' + self.sid + '-ts-x1x3-arrows.txt' | |
+ fh = None | |
+ try: | |
+ fh = open(filename, 'w') | |
for (ax, ay, dax, day) in zip(axlist, aylist, daxlist, daylist): | |
fh.write("{}\t{}\t{}\t{}\n".format(ax, ay, dax, day)) | |
- finally : | |
+ finally: | |
if fh is not None: | |
fh.close() | |
# Save linear velocity data | |
# Output format: x, y, deltax, deltay | |
# gnuplot> plot '-' using 1:2:3:4 with vectors head filled lt 2 | |
- filename='../gnuplot/data/' + self.sid + '-ts-x1x3-velarrows.txt' | |
- fh=None | |
- try : | |
- fh=open(filename, 'w') | |
+ filename = '../gnuplot/data/' + self.sid + '-ts-x1x3-velarrows.txt' | |
+ fh = None | |
+ try: | |
+ fh = open(filename, 'w') | |
for (x, y, dvx, dvy) in zip(xlist, ylist, dvxlist, dvylist): | |
fh.write("{}\t{}\t{}\t{}\n".format(x, y, dvx, dvy)) | |
- finally : | |
+ finally: | |
if fh is not None: | |
fh.close() | |
# Check whether there are slips between the particles intersecting the | |
# plane | |
- sxlist=[] | |
- sylist=[] | |
- dsxlist=[] | |
- dsylist=[] | |
- anglelist=[] # angle of the slip vector | |
- slipvellist=[] # velocity of the slip | |
+ sxlist = [] | |
+ sylist = [] | |
+ dsxlist = [] | |
+ dsylist = [] | |
+ anglelist = [] # angle of the slip vector | |
+ slipvellist = [] # velocity of the slip | |
for i in ilist: | |
# Loop through other particles, and check whether they are in | |
t@@ -5413,43 +5326,43 @@ class sim: | |
if i != j: | |
# positions | |
- x_i=self.x[i,:] | |
- x_j=self.x[j,:] | |
+ x_i = self.x[i, :] | |
+ x_j = self.x[j, :] | |
# radii | |
- r_i=self.radius[i] | |
- r_j=self.radius[j] | |
+ r_i = self.radius[i] | |
+ r_j = self.radius[j] | |
# Inter-particle vector | |
- x_ij=x_i - x_j | |
- x_ij_length=numpy.sqrt(x_ij.dot(x_ij)) | |
+ x_ij = x_i - x_j | |
+ x_ij_length = numpy.sqrt(x_ij.dot(x_ij)) | |
# Check for overlap | |
if x_ij_length - (r_i + r_j) < 0.0: | |
# contact plane normal vector | |
- n_ij=x_ij / x_ij_length | |
+ n_ij = x_ij / x_ij_length | |
- vel_i=self.vel[i,:] | |
- vel_j=self.vel[j,:] | |
- angvel_i=self.angvel[i,:] | |
- angvel_j=self.angvel[j,:] | |
+ vel_i = self.vel[i, :] | |
+ vel_j = self.vel[j, :] | |
+ angvel_i = self.angvel[i, :] | |
+ angvel_j = self.angvel[j, :] | |
# Determine the tangential contact surface velocity in | |
# the x,z plane | |
- dot_delta=(vel_i - vel_j) \ | |
+ dot_delta = (vel_i - vel_j) \ | |
+ r_i * numpy.cross(n_ij, angvel_i) \ | |
+ r_j * numpy.cross(n_ij, angvel_j) | |
# Subtract normal component to get tangential velocity | |
- dot_delta_n=n_ij * numpy.dot(dot_delta, n_ij) | |
- dot_delta_t=dot_delta - dot_delta_n | |
+ dot_delta_n = n_ij * numpy.dot(dot_delta, n_ij) | |
+ dot_delta_t = dot_delta - dot_delta_n | |
# Save slip velocity data for gnuplot | |
if dot_delta_t[0] != 0.0 or dot_delta_t[2] != 0.0: | |
# Center position of the contact | |
- cpos=x_i - x_ij * 0.5 | |
+ cpos = x_i - x_ij * 0.5 | |
sxlist.append(cpos[0]) | |
sylist.append(cpos[2]) | |
t@@ -5464,51 +5377,51 @@ class sim: | |
# Write slip lines to text file | |
- filename='../gnuplot/data/' + self.sid + '-ts-x1x3-slips.txt' | |
- fh=None | |
- try : | |
- fh=open(filename, 'w') | |
+ filename = '../gnuplot/data/' + self.sid + '-ts-x1x3-slips.txt' | |
+ fh = None | |
+ try: | |
+ fh = open(filename, 'w') | |
for (sx, sy, dsx, dsy) in zip(sxlist, sylist, dsxlist, dsylist): | |
fh.write("{}\t{}\t{}\t{}\n".format(sx, sy, dsx, dsy)) | |
- finally : | |
+ finally: | |
if fh is not None: | |
fh.close() | |
# Plot thinsection with gnuplot script | |
- gamma=self.shearstrain() | |
+ gamma = self.shearStrain() | |
subprocess.call('''cd ../gnuplot/scripts && gnuplot -e "sid='{}'; ''' \ | |
+ '''gamma='{:.4}'; xmin='{}'; xmax='{}'; ymin='{}'; ''' \ | |
+ '''ymax='{}'" plotts.gp'''.format(\ | |
- self.sid, self.shearstrain(), self.origo[0], self.L[0], \ | |
+ self.sid, self.shearStrain(), self.origo[0], self.L[0], \ | |
self.origo[2], self.L[2]), shell=True) | |
# Find all particles who have a slip velocity higher than slipvel | |
- slipvellimit=0.01 | |
- slipvels=numpy.nonzero(numpy.array(slipvellist) > slipvellimit) | |
+ slipvellimit = 0.01 | |
+ slipvels = numpy.nonzero(numpy.array(slipvellist) > slipvellimit) | |
# Bin slip angle data for histogram | |
- binno=36/2 | |
- hist_ang, bins_ang=numpy.histogram(numpy.array(anglelist)[slipvels],\ | |
+ binno = 36/2 | |
+ hist_ang, bins_ang = numpy.histogram(numpy.array(anglelist)[slipvels],\ | |
bins=binno, density=False) | |
- center_ang=(bins_ang[:-1] + bins_ang[1:]) / 2.0 | |
+ center_ang = (bins_ang[:-1] + bins_ang[1:]) / 2.0 | |
- center_ang_mirr=numpy.concatenate((center_ang, center_ang + math.pi)) | |
- hist_ang_mirr=numpy.tile(hist_ang, 2) | |
+ center_ang_mirr = numpy.concatenate((center_ang, center_ang + math.pi)) | |
+ hist_ang_mirr = numpy.tile(hist_ang, 2) | |
# Write slip angles to text file | |
#numpy.savetxt(self.sid + '-ts-x1x3-slipangles.txt', zip(center_ang,\ | |
#hist_ang), fmt="%f\t%f") | |
- fig=plt.figure() | |
- ax=fig.add_subplot(111, polar=True) | |
+ fig = plt.figure() | |
+ ax = fig.add_subplot(111, polar=True) | |
ax.bar(center_ang_mirr, hist_ang_mirr, width=30.0/180.0) | |
fig.savefig('../img_out/' + self.sid + '-ts-x1x3-slipangles.' + | |
- graphics_format) | |
+ graphics_format) | |
fig.clf() | |
- def plotContacts(self, graphics_format='png', figsize=[4,4], title=None, | |
+ def plotContacts(self, graphics_format='png', figsize=[4, 4], title=None, | |
lower_limit=0.0, upper_limit=1.0, alpha=1.0, | |
return_data=False, outfolder='.', | |
f_min=None, f_max=None, histogram=True, | |
t@@ -5536,86 +5449,83 @@ class sim: | |
+ ".bin > python/contacts-tmp.txt", shell=True) | |
# data will have the shape (numcontacts, 7) | |
- data=numpy.loadtxt('contacts-tmp.txt', skiprows=1) | |
+ data = numpy.loadtxt('contacts-tmp.txt', skiprows=1) | |
# find the max. value of the normal force | |
- f_n_max=numpy.amax(data[:,6]) | |
+ f_n_max = numpy.amax(data[:, 6]) | |
# specify the lower limit of force chains to do statistics on | |
- f_n_lim=lower_limit * f_n_max | |
+ f_n_lim = lower_limit * f_n_max | |
if f_min: | |
- f_n_lim=f_min | |
+ f_n_lim = f_min | |
if f_max: | |
- f_n_max=f_max | |
+ f_n_max = f_max | |
# find the indexes of these contacts | |
- I=numpy.nonzero(data[:,6] >= f_n_lim) | |
+ I = numpy.nonzero(data[:, 6] >= f_n_lim) | |
# loop through these contacts and find the strike and dip of the | |
# contacts | |
# strike direction of the normal vector, [0:360[ | |
- strikelist=numpy.empty(len(I[0])) | |
- diplist=numpy.empty(len(I[0])) # dip of the normal vector, [0:90] | |
- forcemagnitude=data[I,6] | |
- j=0 | |
+ strikelist = numpy.empty(len(I[0])) | |
+ diplist = numpy.empty(len(I[0])) # dip of the normal vector, [0:90] | |
+ forcemagnitude = data[I, 6] | |
+ j = 0 | |
for i in I[0]: | |
- x1=data[i,0] | |
- y1=data[i,1] | |
- z1=data[i,2] | |
- x2=data[i,3] | |
- y2=data[i,4] | |
- z2=data[i,5] | |
+ x1 = data[i, 0] | |
+ y1 = data[i, 1] | |
+ z1 = data[i, 2] | |
+ x2 = data[i, 3] | |
+ y2 = data[i, 4] | |
+ z2 = data[i, 5] | |
if z1 < z2: | |
- xlower=x1; ylower=y1; zlower=z1 | |
- xupper=x2; yupper=y2; zupper=z2 | |
- else : | |
- xlower=x2; ylower=y2; zlower=z2 | |
- xupper=x1; yupper=y1; zupper=z1 | |
+ xlower = x1; ylower = y1; zlower = z1 | |
+ xupper = x2; yupper = y2; zupper = z2 | |
+ else: | |
+ xlower = x2; ylower = y2; zlower = z2 | |
+ xupper = x1; yupper = y1; zupper = z1 | |
# Vector pointing downwards | |
- dx=xlower - xupper | |
- dy=ylower - yupper | |
- dz=zlower - zupper | |
- dhoriz=numpy.sqrt(dx**2 + dy**2) | |
+ dx = xlower - xupper | |
+ dy = ylower - yupper | |
+ dhoriz = numpy.sqrt(dx**2 + dy**2) | |
# Find dip angle | |
- diplist[j]=numpy.degrees(numpy.arctan((zupper - zlower)/dhoriz)) | |
+ diplist[j] = numpy.degrees(numpy.arctan((zupper - zlower)/dhoriz)) | |
# Find strike angle | |
if ylower >= yupper: # in first two quadrants | |
- strikelist[j]=numpy.arccos(dx/dhoriz) | |
- else : | |
- strikelist[j]=2.0*numpy.pi - numpy.arccos(dx/dhoriz) | |
+ strikelist[j] = numpy.arccos(dx/dhoriz) | |
+ else: | |
+ strikelist[j] = 2.0*numpy.pi - numpy.arccos(dx/dhoriz) | |
j += 1 | |
- fig=plt.figure(figsize=figsize) | |
- ax=plt.subplot(111, polar=True) | |
- cs=ax.scatter(strikelist, 90. - diplist, marker='o', | |
- c=forcemagnitude, | |
- s=forcemagnitude/f_n_max*40., | |
- alpha=alpha, | |
- edgecolors='none', | |
- vmin=f_n_max*lower_limit, | |
- vmax=f_n_max*upper_limit, | |
- cmap=matplotlib.cm.get_cmap('afmhot_r')) | |
+ fig = plt.figure(figsize=figsize) | |
+ ax = plt.subplot(111, polar=True) | |
+ cs = ax.scatter(strikelist, 90. - diplist, marker='o', | |
+ c=forcemagnitude, | |
+ s=forcemagnitude/f_n_max*40., | |
+ alpha=alpha, | |
+ edgecolors='none', | |
+ vmin=f_n_max*lower_limit, | |
+ vmax=f_n_max*upper_limit, | |
+ cmap=matplotlib.cm.get_cmap('afmhot_r')) | |
plt.colorbar(cs, extend='max') | |
# plot defined max compressive stress from tau/N ratio | |
ax.scatter(0., # prescribed stress | |
- numpy.degrees(numpy.arctan( | |
- self.shearStress('defined')/ | |
- self.currentNormalStress('defined'))), | |
- marker='o', c='none', edgecolor='blue', s=300) | |
+ numpy.degrees(numpy.arctan(self.shearStress('defined')/ | |
+ self.currentNormalStress('defined'))), | |
+ marker='o', c='none', edgecolor='blue', s=300) | |
ax.scatter(0., # actual stress | |
- numpy.degrees(numpy.arctan( | |
- self.shearStress('effective')/ | |
- self.currentNormalStress('effective'))), | |
- marker='+', color='blue', s=300) | |
+ numpy.degrees(numpy.arctan(self.shearStress('effective')/ | |
+ self.currentNormalStress('effective'))… | |
+ marker='+', color='blue', s=300) | |
ax.set_rmax(90) | |
ax.set_rticks([]) | |
t@@ -5635,8 +5545,8 @@ class sim: | |
fig.clf() | |
if histogram: | |
- #hist, bins=numpy.histogram(datadata[:,6], bins=10) | |
- n, bins, patches=plt.hist(data[:,6], alpha=0.75, facecolor='gray') | |
+ #hist, bins = numpy.histogram(datadata[:, 6], bins=10) | |
+ _, _, _ = plt.hist(data[:, 6], alpha=0.75, facecolor='gray') | |
#plt.xlabel('$\\boldsymbol{f}_\text{n}$ [N]') | |
plt.yscale('log', nonposy='clip') | |
plt.xlabel('Contact load [N]') | |
t@@ -5649,10 +5559,10 @@ class sim: | |
plt.clf() | |
# angle: 0 when vertical, 90 when horizontal | |
- #hist, bins=numpy.histogram(datadata[:,6], bins=10) | |
- n, bins, patches=plt.hist(90. - diplist, bins=range(0, 100, 10), | |
+ #hist, bins = numpy.histogram(datadata[:, 6], bins=10) | |
+ _, _, _ = plt.hist(90. - diplist, bins=range(0, 100, 10), | |
alpha=0.75, facecolor='gray') | |
- theta_sigma1=numpy.degrees(numpy.arctan( | |
+ theta_sigma1 = numpy.degrees(numpy.arctan( | |
self.currentNormalStress('defined')/\ | |
self.shearStress('defined'))) | |
plt.axvline(90. - theta_sigma1, color='k', linestyle='dashed', | |
t@@ -5671,27 +5581,27 @@ class sim: | |
if forcechains: | |
- #color=matplotlib.cm.spectral(data[:,6]/f_n_max) | |
+ #color = matplotlib.cm.spectral(data[:, 6]/f_n_max) | |
for i in I[0]: | |
- x1=data[i,0] | |
- #y1=data[i,1] | |
- z1=data[i,2] | |
- x2=data[i,3] | |
- #y2=data[i,4] | |
- z2=data[i,5] | |
- f_n=data[i,6] | |
+ x1 = data[i, 0] | |
+ #y1 = data[i, 1] | |
+ z1 = data[i, 2] | |
+ x2 = data[i, 3] | |
+ #y2 = data[i, 4] | |
+ z2 = data[i, 5] | |
+ f_n = data[i, 6] | |
- lw_max=1.0 | |
+ lw_max = 1.0 | |
if f_n >= f_n_max: | |
- lw=lw_max | |
+ lw = lw_max | |
else: | |
- lw=(f_n - f_n_lim)/(f_n_max - f_n_lim)*lw_max | |
+ lw = (f_n - f_n_lim)/(f_n_max - f_n_lim)*lw_max | |
#print lw | |
- plt.plot([x1,x2], [z1,z2], '-k', linewidth=lw) | |
+ plt.plot([x1, x2], [z1, z2], '-k', linewidth=lw) | |
- axfc1=plt.gca() | |
+ axfc1 = plt.gca() | |
axfc1.spines['right'].set_visible(False) | |
axfc1.spines['left'].set_visible(False) | |
# Only show ticks on the left and bottom spines | |
t@@ -5738,18 +5648,18 @@ class sim: | |
return | |
if y == -1: | |
- y=self.num[1]/2 | |
+ y = self.num[1]/2 | |
- plt.figure(figsize=[8,8]) | |
+ plt.figure(figsize=[8, 8]) | |
plt.title('Fluid pressures') | |
- imgplt=plt.imshow(self.p_f[:,y,:].T, origin='lower') | |
+ imgplt = plt.imshow(self.p_f[:, y, :].T, origin='lower') | |
imgplt.set_interpolation('nearest') | |
#imgplt.set_interpolation('bicubic') | |
#imgplt.set_cmap('hot') | |
plt.xlabel('$x_1$') | |
plt.ylabel('$x_3$') | |
plt.colorbar() | |
- filename='p_f-' + self.sid + '-y' + str(y) + '.' + graphics_format | |
+ filename = 'p_f-' + self.sid + '-y' + str(y) + '.' + graphics_format | |
plt.savefig(filename, transparent=False) | |
if verbose: | |
print('saved to ' + filename) | |
t@@ -5778,18 +5688,18 @@ class sim: | |
return | |
if z == -1: | |
- z=self.num[2]/2 | |
+ z = self.num[2]/2 | |
- plt.figure(figsize=[8,8]) | |
+ plt.figure(figsize=[8, 8]) | |
plt.title('Fluid pressures') | |
- imgplt=plt.imshow(self.p_f[:,:,z].T, origin='lower') | |
+ imgplt = plt.imshow(self.p_f[:, :, z].T, origin='lower') | |
imgplt.set_interpolation('nearest') | |
#imgplt.set_interpolation('bicubic') | |
#imgplt.set_cmap('hot') | |
plt.xlabel('$x_1$') | |
plt.ylabel('$x_2$') | |
plt.colorbar() | |
- filename='p_f-' + self.sid + '-z' + str(z) + '.' + graphics_format | |
+ filename = 'p_f-' + self.sid + '-z' + str(z) + '.' + graphics_format | |
plt.savefig(filename, transparent=False) | |
if verbose: | |
print('saved to ' + filename) | |
t@@ -5818,13 +5728,13 @@ class sim: | |
return | |
if y == -1: | |
- y=self.num[1]/2 | |
+ y = self.num[1]/2 | |
plt.title('Fluid velocities') | |
- plt.figure(figsize=[8,8]) | |
+ plt.figure(figsize=[8, 8]) | |
plt.subplot(131) | |
- imgplt=plt.imshow(self.v_f[:,y,:,0].T, origin='lower') | |
+ imgplt = plt.imshow(self.v_f[:, y, :, 0].T, origin='lower') | |
imgplt.set_interpolation('nearest') | |
#imgplt.set_interpolation('bicubic') | |
#imgplt.set_cmap('hot') | |
t@@ -5834,7 +5744,7 @@ class sim: | |
plt.colorbar(orientation='horizontal') | |
plt.subplot(132) | |
- imgplt=plt.imshow(self.v_f[:,y,:,1].T, origin='lower') | |
+ imgplt = plt.imshow(self.v_f[:, y, :, 1].T, origin='lower') | |
imgplt.set_interpolation('nearest') | |
#imgplt.set_interpolation('bicubic') | |
#imgplt.set_cmap('hot') | |
t@@ -5844,7 +5754,7 @@ class sim: | |
plt.colorbar(orientation='horizontal') | |
plt.subplot(133) | |
- imgplt=plt.imshow(self.v_f[:,y,:,2].T, origin='lower') | |
+ imgplt = plt.imshow(self.v_f[:, y, :, 2].T, origin='lower') | |
imgplt.set_interpolation('nearest') | |
#imgplt.set_interpolation('bicubic') | |
#imgplt.set_cmap('hot') | |
t@@ -5853,7 +5763,7 @@ class sim: | |
plt.ylabel('$x_3$') | |
plt.colorbar(orientation='horizontal') | |
- filename='v_f-' + self.sid + '-y' + str(y) + '.' + graphics_format | |
+ filename = 'v_f-' + self.sid + '-y' + str(y) + '.' + graphics_format | |
plt.savefig(filename, transparent=False) | |
if verbose: | |
print('saved to ' + filename) | |
t@@ -5881,13 +5791,13 @@ class sim: | |
return | |
if z == -1: | |
- z=self.num[2]/2 | |
+ z = self.num[2]/2 | |
plt.title("Fluid velocities") | |
- plt.figure(figsize=[8,8]) | |
+ plt.figure(figsize=[8, 8]) | |
plt.subplot(131) | |
- imgplt=plt.imshow(self.v_f[:,:,z,0].T, origin='lower') | |
+ imgplt = plt.imshow(self.v_f[:, :, z, 0].T, origin='lower') | |
imgplt.set_interpolation('nearest') | |
#imgplt.set_interpolation('bicubic') | |
#imgplt.set_cmap('hot') | |
t@@ -5897,7 +5807,7 @@ class sim: | |
plt.colorbar(orientation='horizontal') | |
plt.subplot(132) | |
- imgplt=plt.imshow(self.v_f[:,:,z,1].T, origin='lower') | |
+ imgplt = plt.imshow(self.v_f[:, :, z, 1].T, origin='lower') | |
imgplt.set_interpolation('nearest') | |
#imgplt.set_interpolation('bicubic') | |
#imgplt.set_cmap('hot') | |
t@@ -5907,7 +5817,7 @@ class sim: | |
plt.colorbar(orientation='horizontal') | |
plt.subplot(133) | |
- imgplt=plt.imshow(self.v_f[:,:,z,2].T, origin='lower') | |
+ imgplt = plt.imshow(self.v_f[:, :, z, 2].T, origin='lower') | |
imgplt.set_interpolation('nearest') | |
#imgplt.set_interpolation('bicubic') | |
#imgplt.set_cmap('hot') | |
t@@ -5916,7 +5826,7 @@ class sim: | |
plt.ylabel('$x_2$') | |
plt.colorbar(orientation='horizontal') | |
- filename='v_f-' + self.sid + '-z' + str(z) + '.' + graphics_format | |
+ filename = 'v_f-' + self.sid + '-z' + str(z) + '.' + graphics_format | |
plt.savefig(filename, transparent=False) | |
if verbose: | |
print('saved to ' + filename) | |
t@@ -5941,56 +5851,58 @@ class sim: | |
print('Error: matplotlib module not found (plotFluidDiffAdvPresZ).… | |
return | |
- # The v_z values are read from self.v_f[0,0,:,2] | |
- dz=self.L[2]/self.num[2] | |
- rho=self.rho_f | |
+ # The v_z values are read from self.v_f[0, 0, :, 2] | |
+ dz = self.L[2]/self.num[2] | |
+ rho = self.rho_f | |
# Central difference gradients | |
- dvz_dz=(self.v_f[0,0,1:,2] - self.v_f[0,0,:-1,2])/(2.0*dz) | |
- dvzvz_dz=(self.v_f[0,0,1:,2]**2 - self.v_f[0,0,:-1,2]**2)/(2.0*dz) | |
+ dvz_dz = (self.v_f[0, 0, 1:, 2] - self.v_f[0, 0, :-1, 2])/(2.0*dz) | |
+ dvzvz_dz = (self.v_f[0, 0, 1:, 2]**2 - self.v_f[0, 0, :-1, 2]**2)\ | |
+ /(2.0*dz) | |
# Diffusive contribution to velocity change | |
- dvz_diff=2.0*self.mu/rho*dvz_dz*self.time_dt | |
+ dvz_diff = 2.0*self.mu/rho*dvz_dz*self.time_dt | |
# Advective contribution to velocity change | |
- dvz_adv=dvzvz_dz*self.time_dt | |
+ dvz_adv = dvzvz_dz*self.time_dt | |
# Pressure gradient | |
- dp_dz=(self.p_f[0,0,1:] - self.p_f[0,0,:-1])/(2.0*dz) | |
+ dp_dz = (self.p_f[0, 0, 1:] - self.p_f[0, 0, :-1])/(2.0*dz) | |
- cellno=numpy.arange(1, self.num[2]) | |
+ cellno = numpy.arange(1, self.num[2]) | |
- fig=plt.figure() | |
- titlesize=12 | |
+ fig = plt.figure() | |
+ titlesize = 12 | |
- plt.subplot(1,3,1) | |
+ plt.subplot(1, 3, 1) | |
plt.title('Pressure', fontsize=titlesize) | |
plt.ylabel('$i_z$') | |
plt.xlabel('$p_z$') | |
- plt.plot(self.p_f[0,0,:], numpy.arange(self.num[2])) | |
+ plt.plot(self.p_f[0, 0, :], numpy.arange(self.num[2])) | |
plt.grid() | |
- plt.subplot(1,3,2) | |
+ plt.subplot(1, 3, 2) | |
plt.title('Pressure gradient', fontsize=titlesize) | |
plt.ylabel('$i_z$') | |
plt.xlabel('$\Delta p_z$') | |
plt.plot(dp_dz, cellno) | |
plt.grid() | |
- plt.subplot(1,3,3) | |
+ plt.subplot(1, 3, 3) | |
plt.title('Velocity prediction terms', fontsize=titlesize) | |
plt.ylabel('$i_z$') | |
plt.xlabel('$\Delta v_z$') | |
plt.plot(dvz_diff, cellno, label='Diffusion') | |
plt.plot(dvz_adv, cellno, label='Advection') | |
plt.plot(dvz_diff+dvz_adv, cellno, '--', label='Sum') | |
- leg=plt.legend(loc='best', prop={'size':8}) | |
+ leg = plt.legend(loc='best', prop={'size':8}) | |
leg.get_frame().set_alpha(0.5) | |
plt.grid() | |
plt.tight_layout() | |
- filename='../output/{}-diff_adv-t={:.2e}s-mu={:.2e}Pa-s.{}'.format( | |
- self.sid, self.time_current[0], self.mu[0], graphics_format) | |
+ filename = '../output/{}-diff_adv-t={:.2e}s-mu={:.2e}Pa-s.{}'\ | |
+ .format(self.sid, self.time_current[0], self.mu[0], | |
+ graphics_format) | |
plt.savefig(filename) | |
if verbose: | |
print('saved to ' + filename) | |
t@@ -6007,16 +5919,16 @@ class sim: | |
''' | |
# find magnitude of fluid velocity vectors | |
- self.v_f_magn=numpy.empty_like(self.p_f) | |
+ self.v_f_magn = numpy.empty_like(self.p_f) | |
for z in numpy.arange(self.num[2]): | |
for y in numpy.arange(self.num[1]): | |
for x in numpy.arange(self.num[0]): | |
- self.v_f_magn[x,y,z]=\ | |
- self.v_f[x,y,z,:].dot(self.v_f[x,y,z,:]) | |
+ self.v_f_magn[x, y, z] = \ | |
+ self.v_f[x, y, z, :].dot(self.v_f[x, y, z, :]) | |
- self.Re=self.rho_f*self.v_f_magn*self.L[0]/self.num[0]/(self.mu + \ | |
+ Re = self.rho_f*self.v_f_magn*self.L[0]/self.num[0]/(self.mu + \ | |
1.0e-16) | |
- return self.Re | |
+ return Re | |
def plotLoadCurve(self, graphics_format='png', verbose=True): | |
''' | |
t@@ -6037,57 +5949,56 @@ class sim: | |
print('Error: matplotlib module not found (plotLoadCurve).') | |
return | |
- t=numpy.empty(self.status()) | |
- H=numpy.empty_like(t) | |
- sb=sim(self.sid, fluid=self.fluid) | |
+ t = numpy.empty(self.status()) | |
+ H = numpy.empty_like(t) | |
+ sb = sim(self.sid, fluid=self.fluid) | |
sb.readfirst(verbose=False) | |
- load=0.0 | |
for i in numpy.arange(1, self.status()+1): | |
sb.readstep(i, verbose=False) | |
if i == 0: | |
- load=sb.w_sigma0[0] | |
- t[i-1] =sb.time_current[0] | |
- H[i-1]=sb.w_x[0] | |
+ load = sb.w_sigma0[0] | |
+ t[i-1] = sb.time_current[0] | |
+ H[i-1] = sb.w_x[0] | |
# find consolidation parameters | |
- self.H0=H[0] | |
- self.H100=H[-1] | |
- self.H50=(self.H0 + self.H100)/2.0 | |
- T50=0.197 # case I | |
+ H0 = H[0] | |
+ H100 = H[-1] | |
+ H50 = (H0 + H100)/2.0 | |
+ T50 = 0.197 # case I | |
# find the time where 50% of the consolidation (H50) has happened by | |
# linear interpolation. The values in H are expected to be | |
# monotonically decreasing. See Numerical Recipies p. 115 | |
- i_lower=0 | |
- i_upper=self.status()-1 | |
- while (i_upper - i_lower > 1): | |
- i_midpoint=int((i_upper + i_lower)/2) | |
- if self.H50 < H[i_midpoint]: | |
- i_lower=i_midpoint | |
+ i_lower = 0 | |
+ i_upper = self.status()-1 | |
+ while i_upper - i_lower > 1: | |
+ i_midpoint = int((i_upper + i_lower)/2) | |
+ if H50 < H[i_midpoint]: | |
+ i_lower = i_midpoint | |
else: | |
- i_upper=i_midpoint | |
- self.t50=t[i_lower] + (t[i_upper] - t[i_lower]) * \ | |
- (self.H50 - H[i_lower])/(H[i_upper] - H[i_lower]) | |
+ i_upper = i_midpoint | |
+ t50 = t[i_lower] + (t[i_upper] - t[i_lower]) * \ | |
+ (H50 - H[i_lower])/(H[i_upper] - H[i_lower]) | |
- self.c_coeff=T50*self.H50**2.0/(self.t50) | |
+ c_coeff = T50*H50**2.0/(t50) | |
if self.fluid: | |
- e=numpy.mean(sb.phi[:,:,3:-8]) # ignore boundaries | |
+ e = numpy.mean(sb.phi[:, :, 3:-8]) # ignore boundaries | |
else: | |
- e=sb.voidRatio() | |
+ e = sb.voidRatio() | |
- self.phi_bar=e | |
- fig=plt.figure() | |
+ phi_bar = e | |
+ fig = plt.figure() | |
plt.xlabel('Time [s]') | |
plt.ylabel('Height [m]') | |
plt.title('$c_v$=%.2e m$^2$ s$^{-1}$ at %.1f kPa and $e$=%.2f' \ | |
- % (self.c_coeff, sb.w_sigma0[0]/1000.0, e)) | |
+ % (c_coeff, sb.w_sigma0[0]/1000.0, e)) | |
plt.semilogx(t, H, '+-') | |
- plt.axhline(y=self.H0, color='gray') | |
- plt.axhline(y=self.H50, color='gray') | |
- plt.axhline(y=self.H100, color='gray') | |
- plt.axvline(x=self.t50, color='red') | |
+ plt.axhline(y=H0, color='gray') | |
+ plt.axhline(y=H50, color='gray') | |
+ plt.axhline(y=H100, color='gray') | |
+ plt.axvline(x=t50, color='red') | |
plt.grid() | |
- filename=self.sid + '-loadcurve.' + graphics_format | |
+ filename = self.sid + '-loadcurve.' + graphics_format | |
plt.savefig(filename) | |
if verbose: | |
print('saved to ' + filename) | |
t@@ -6102,8 +6013,7 @@ class sim: | |
See also: :func:`plotConvergence()` | |
''' | |
- self.conv=numpy.loadtxt('../output/' + self.sid + '-conv.log', | |
- dtype=numpy.int32) | |
+ return numpy.loadtxt('../output/' + self.sid + '-conv.log', dtype=nump… | |
def plotConvergence(self, graphics_format='png', verbose=True): | |
''' | |
t@@ -6122,15 +6032,15 @@ class sim: | |
print('Error: matplotlib module not found (plotConvergence).') | |
return | |
- fig=plt.figure() | |
- self.convergence() | |
+ fig = plt.figure() | |
+ conv = self.convergence() | |
plt.title('Convergence evolution in CFD solver in "' + self.sid + '"') | |
plt.xlabel('Time step') | |
plt.ylabel('Jacobi iterations') | |
- plt.plot(self.conv[:,0], self.conv[:,1]) | |
+ plt.plot(conv[:, 0], conv[:, 1]) | |
plt.grid() | |
- filename=self.sid + '-conv.' + graphics_format | |
+ filename = self.sid + '-conv.' + graphics_format | |
plt.savefig(filename) | |
if verbose: | |
print('saved to ' + filename) | |
t@@ -6167,17 +6077,17 @@ class sim: | |
print('Error: matplotlib module not found (plotSinFunction).') | |
return | |
- fig=plt.figure(figsize=[8,6]) | |
- steps_left=(self.time_total[0] - self.time_current[0]) \ | |
+ fig = plt.figure(figsize=[8, 6]) | |
+ steps_left = (self.time_total[0] - self.time_current[0]) \ | |
/self.time_file_dt[0] | |
- t=numpy.linspace(self.time_current[0], self.time_total[0], steps_left) | |
- f=baseval + A*numpy.sin(2.0*numpy.pi*f*t + phi) | |
+ t = numpy.linspace(self.time_current[0], self.time_total[0], steps_lef… | |
+ f = baseval + A*numpy.sin(2.0*numpy.pi*f*t + phi) | |
plt.plot(t, f, plotstyle) | |
plt.grid() | |
plt.xlabel(xlabel) | |
plt.ylabel(ylabel) | |
plt.tight_layout() | |
- filename=self.sid + '-sin.' + outformat | |
+ filename = self.sid + '-sin.' + outformat | |
plt.savefig(filename) | |
if verbose: | |
print(filename) | |
t@@ -6199,12 +6109,12 @@ class sim: | |
See also: :func:`setFluidPressureModulation()` and | |
:func:`disableTopWallNormalStressModulation()` | |
''' | |
- self.w_sigma0_A[0]=A | |
- self.w_sigma0_f[0]=f | |
+ self.w_sigma0_A[0] = A | |
+ self.w_sigma0_f[0] = f | |
if plot and py_mpl: | |
self.plotSinFunction(self.w_sigma0[0], A, f, phi=0.0, | |
- xlabel='$t$ [s]', ylabel='$\\sigma_0$ [Pa]') | |
+ xlabel='$t$ [s]', ylabel='$\\sigma_0$ [Pa]') | |
def disableTopWallNormalStressModulation(self): | |
''' | |
t@@ -6232,13 +6142,13 @@ class sim: | |
See also: :func:`setTopWallNormalStressModulation()` and | |
:func:`disableFluidPressureModulation()` | |
''' | |
- self.p_mod_A[0]=A | |
- self.p_mod_f[0]=f | |
- self.p_mod_phi[0]=phi | |
+ self.p_mod_A[0] = A | |
+ self.p_mod_f[0] = f | |
+ self.p_mod_phi[0] = phi | |
if plot: | |
- self.plotSinFunction(self.p_f[0,0,-1], A, f, phi=0.0, | |
- xlabel='$t$ [s]', ylabel='$p_f$ [kPa]') | |
+ self.plotSinFunction(self.p_f[0, 0, -1], A, f, phi=0.0, | |
+ xlabel='$t$ [s]', ylabel='$p_f$ [kPa]') | |
def disableFluidPressureModulation(self): | |
''' | |
t@@ -6262,20 +6172,17 @@ class sim: | |
'(plotPrescribedFluidPressures).') | |
return | |
- fig=plt.figure() | |
- conv=numpy.loadtxt('../output/' + self.sid + '-conv.log') | |
+ fig = plt.figure() | |
plt.title('Prescribed fluid pressures at the top in "' + self.sid + '"… | |
plt.xlabel('Time [s]') | |
plt.ylabel('Pressure [Pa]') | |
- t=numpy.linspace(0,self.time_total,\ | |
- self.time_total/self.time_file_dt) | |
- p=self.p_f[0,0,-1] + \ | |
- self.p_mod_A * \ | |
- numpy.sin(2.0*numpy.pi*self.p_mod_f*t + self.p_mod_phi) | |
+ t = numpy.linspace(0, self.time_total, self.time_total/self.time_file_… | |
+ p = self.p_f[0, 0, -1] + self.p_mod_A * \ | |
+ numpy.sin(2.0*numpy.pi*self.p_mod_f*t + self.p_mod_phi) | |
plt.plot(t, p, '.-') | |
plt.grid() | |
- filename='../output/' + self.sid + '-pres.' + graphics_format | |
+ filename = '../output/' + self.sid + '-pres.' + graphics_format | |
plt.savefig(filename) | |
if verbose: | |
print('saved to ' + filename) | |
t@@ -6294,8 +6201,8 @@ class sim: | |
:return type: numpy.array | |
''' | |
if idx == -1: | |
- idx=range(self.np) | |
- return self.force[idx,:]/(V_sphere(self.radius[idx])*self.rho[0]) + \ | |
+ idx = range(self.np) | |
+ return self.force[idx, :]/(V_sphere(self.radius[idx])*self.rho[0]) + \ | |
self.g | |
def setGamma(self, gamma): | |
t@@ -6315,7 +6222,7 @@ class sim: | |
:func:`setBeta()`, :func:`setTolerance()`, | |
:func:`setDEMstepsPerCFDstep()` and :func:`setMaxIterations()` | |
''' | |
- self.gamma=numpy.asarray(gamma) | |
+ self.gamma = numpy.asarray(gamma) | |
def setTheta(self, theta): | |
''' | |
t@@ -6335,7 +6242,7 @@ class sim: | |
:func:`setBeta()`, :func:`setTolerance()`, | |
:func:`setDEMstepsPerCFDstep()` and :func:`setMaxIterations()` | |
''' | |
- self.theta=numpy.asarray(theta) | |
+ self.theta = numpy.asarray(theta) | |
def setBeta(self, beta): | |
t@@ -6355,7 +6262,7 @@ class sim: | |
:func:`setDEMstepsPerCFDstep()` and | |
:func:`setMaxIterations()` | |
''' | |
- self.beta=numpy.asarray(beta) | |
+ self.beta = numpy.asarray(beta) | |
def setTolerance(self, tolerance): | |
''' | |
t@@ -6373,7 +6280,7 @@ class sim: | |
:func:`setTheta()`, :func:`setBeta()`, :func:`setDEMstepsPerCFDstep()`… | |
:func:`setMaxIterations()` | |
''' | |
- self.tolerance=numpy.asarray(tolerance) | |
+ self.tolerance = numpy.asarray(tolerance) | |
def setMaxIterations(self, maxiter): | |
''' | |
t@@ -6393,7 +6300,7 @@ class sim: | |
:func:`setTheta()`, :func:`setBeta()`, :func:`setDEMstepsPerCFDstep()` | |
and :func:`setTolerance()` | |
''' | |
- self.maxiter=numpy.asarray(maxiter) | |
+ self.maxiter = numpy.asarray(maxiter) | |
def setDEMstepsPerCFDstep(self, ndem): | |
''' | |
t@@ -6409,7 +6316,7 @@ class sim: | |
:func:`setTheta()`, :func:`setBeta()`, :func:`setTolerance()` and | |
:func:`setMaxIterations()`. | |
''' | |
- self.ndem=numpy.asarray(ndem) | |
+ self.ndem = numpy.asarray(ndem) | |
def shearStress(self, type='effective'): | |
''' | |
t@@ -6428,13 +6335,13 @@ class sim: | |
elif type == 'effective': | |
- fixvel=numpy.nonzero(self.fixvel > 0.0) | |
- force=numpy.zeros(3) | |
+ fixvel = numpy.nonzero(self.fixvel > 0.0) | |
+ force = numpy.zeros(3) | |
# Summation of shear stress contributions | |
for i in fixvel[0]: | |
- if self.vel[i,0] > 0.0: | |
- force += -self.force[i,:] | |
+ if self.vel[i, 0] > 0.0: | |
+ force += -self.force[i, :] | |
return force[0]/(self.L[0]*self.L[1]) | |
t@@ -6484,8 +6391,8 @@ class sim: | |
:type smoothing_window: str | |
''' | |
- lastfile=self.status() | |
- sb=sim(sid=self.sid, np=self.np, nw=self.nw, fluid=self.fluid) | |
+ lastfile = self.status() | |
+ sb = sim(sid=self.sid, np=self.np, nw=self.nw, fluid=self.fluid) | |
if not py_mpl: | |
print('Error: matplotlib module not found (visualize).') | |
t@@ -6494,118 +6401,118 @@ class sim: | |
### Plotting | |
if outformat != 'txt': | |
if figsize: | |
- fig=plt.figure(figsize=figsize) | |
+ fig = plt.figure(figsize=figsize) | |
else: | |
- fig=plt.figure(figsize=(8,8)) | |
+ fig = plt.figure(figsize=(8, 8)) | |
if method == 'energy': | |
if figsize: | |
- fig=plt.figure(figsize=figsize) | |
+ fig = plt.figure(figsize=figsize) | |
else: | |
- fig=plt.figure(figsize=(20,8)) | |
+ fig = plt.figure(figsize=(20, 8)) | |
# Allocate arrays | |
- t=numpy.zeros(lastfile-firststep + 1) | |
- Epot=numpy.zeros_like(t) | |
- Ekin=numpy.zeros_like(t) | |
- Erot=numpy.zeros_like(t) | |
- Es =numpy.zeros_like(t) | |
- Ev =numpy.zeros_like(t) | |
- Es_dot=numpy.zeros_like(t) | |
- Ev_dot=numpy.zeros_like(t) | |
- Ebondpot=numpy.zeros_like(t) | |
- Esum=numpy.zeros_like(t) | |
+ t = numpy.zeros(lastfile-firststep + 1) | |
+ Epot = numpy.zeros_like(t) | |
+ Ekin = numpy.zeros_like(t) | |
+ Erot = numpy.zeros_like(t) | |
+ Es = numpy.zeros_like(t) | |
+ Ev = numpy.zeros_like(t) | |
+ Es_dot = numpy.zeros_like(t) | |
+ Ev_dot = numpy.zeros_like(t) | |
+ Ebondpot = numpy.zeros_like(t) | |
+ Esum = numpy.zeros_like(t) | |
# Read energy values from simulation binaries | |
for i in numpy.arange(firststep, lastfile+1): | |
sb.readstep(i, verbose=False) | |
- Epot[i]=sb.energy("pot") | |
- Ekin[i]=sb.energy("kin") | |
- Erot[i]=sb.energy("rot") | |
- Es[i] =sb.energy("shear") | |
- Ev[i] =sb.energy("visc_n") | |
- Es_dot[i]=sb.energy("shearrate") | |
- Ev_dot[i]=sb.energy("visc_n_rate") | |
- Ebondpot[i]=sb.energy("bondpot") | |
- Esum[i]=Epot[i] + Ekin[i] + Erot[i] + Es[i] + Ev[i] +\ | |
+ Epot[i] = sb.energy("pot") | |
+ Ekin[i] = sb.energy("kin") | |
+ Erot[i] = sb.energy("rot") | |
+ Es[i] = sb.energy("shear") | |
+ Ev[i] = sb.energy("visc_n") | |
+ Es_dot[i] = sb.energy("shearrate") | |
+ Ev_dot[i] = sb.energy("visc_n_rate") | |
+ Ebondpot[i] = sb.energy("bondpot") | |
+ Esum[i] = Epot[i] + Ekin[i] + Erot[i] + Es[i] + Ev[i] +\ | |
Ebondpot[i] | |
- t[i]=sb.currentTime() | |
+ t[i] = sb.currentTime() | |
if outformat != 'txt': | |
# Potential energy | |
- ax1=plt.subplot2grid((2,5),(0,0)) | |
+ ax1 = plt.subplot2grid((2, 5), (0, 0)) | |
ax1.set_xlabel('Time [s]') | |
ax1.set_ylabel('Total potential energy [J]') | |
ax1.plot(t, Epot, '+-') | |
ax1.grid() | |
# Kinetic energy | |
- ax2=plt.subplot2grid((2,5),(0,1)) | |
+ ax2 = plt.subplot2grid((2, 5), (0, 1)) | |
ax2.set_xlabel('Time [s]') | |
ax2.set_ylabel('Total kinetic energy [J]') | |
ax2.plot(t, Ekin, '+-') | |
ax2.grid() | |
# Rotational energy | |
- ax3=plt.subplot2grid((2,5),(0,2)) | |
+ ax3 = plt.subplot2grid((2, 5), (0, 2)) | |
ax3.set_xlabel('Time [s]') | |
ax3.set_ylabel('Total rotational energy [J]') | |
ax3.plot(t, Erot, '+-') | |
ax3.grid() | |
# Bond energy | |
- ax4=plt.subplot2grid((2,5),(0,3)) | |
+ ax4 = plt.subplot2grid((2, 5), (0, 3)) | |
ax4.set_xlabel('Time [s]') | |
ax4.set_ylabel('Bond energy [J]') | |
ax4.plot(t, Ebondpot, '+-') | |
ax4.grid() | |
# Total energy | |
- ax5=plt.subplot2grid((2,5),(0,4)) | |
+ ax5 = plt.subplot2grid((2, 5), (0, 4)) | |
ax5.set_xlabel('Time [s]') | |
ax5.set_ylabel('Total energy [J]') | |
ax5.plot(t, Esum, '+-') | |
ax5.grid() | |
# Shear energy rate | |
- ax6=plt.subplot2grid((2,5),(1,0)) | |
+ ax6 = plt.subplot2grid((2, 5), (1, 0)) | |
ax6.set_xlabel('Time [s]') | |
ax6.set_ylabel('Frictional dissipation rate [W]') | |
ax6.plot(t, Es_dot, '+-') | |
ax6.grid() | |
# Shear energy | |
- ax7=plt.subplot2grid((2,5),(1,1)) | |
+ ax7 = plt.subplot2grid((2, 5), (1, 1)) | |
ax7.set_xlabel('Time [s]') | |
ax7.set_ylabel('Total frictional dissipation [J]') | |
ax7.plot(t, Es, '+-') | |
ax7.grid() | |
# Visc_n energy rate | |
- ax8=plt.subplot2grid((2,5),(1,2)) | |
+ ax8 = plt.subplot2grid((2, 5), (1, 2)) | |
ax8.set_xlabel('Time [s]') | |
ax8.set_ylabel('Viscous dissipation rate [W]') | |
ax8.plot(t, Ev_dot, '+-') | |
ax8.grid() | |
# Visc_n energy | |
- ax9=plt.subplot2grid((2,5),(1,3)) | |
+ ax9 = plt.subplot2grid((2, 5), (1, 3)) | |
ax9.set_xlabel('Time [s]') | |
ax9.set_ylabel('Total viscous dissipation [J]') | |
ax9.plot(t, Ev, '+-') | |
ax9.grid() | |
# Combined view | |
- ax10=plt.subplot2grid((2,5),(1,4)) | |
+ ax10 = plt.subplot2grid((2, 5), (1, 4)) | |
ax10.set_xlabel('Time [s]') | |
ax10.set_ylabel('Energy [J]') | |
ax10.plot(t, Epot, '+-g') | |
ax10.plot(t, Ekin, '+-b') | |
ax10.plot(t, Erot, '+-r') | |
- ax10.legend(('$\sum E_{pot}$','$\sum E_{kin}$',\ | |
- '$\sum E_{rot}$'), 'upper right', shadow=True) | |
+ ax10.legend(('$\sum E_{pot}$', '$\sum E_{kin}$', | |
+ '$\sum E_{rot}$'), 'upper right', shadow=True) | |
ax10.grid() | |
if xlim: | |
t@@ -6630,33 +6537,32 @@ class sim: | |
# Allocate arrays on first run | |
if i == firststep: | |
- wforce=numpy.zeros((lastfile+1)*sb.nw,\ | |
+ wforce = numpy.zeros((lastfile+1)*sb.nw,\ | |
dtype=numpy.float64).reshape((lastfile+1), sb.nw) | |
- wvel =numpy.zeros((lastfile+1)*sb.nw,\ | |
+ wvel = numpy.zeros((lastfile+1)*sb.nw,\ | |
dtype=numpy.float64).reshape((lastfile+1), sb.nw) | |
- wpos =numpy.zeros((lastfile+1)*sb.nw,\ | |
+ wpos = numpy.zeros((lastfile+1)*sb.nw,\ | |
dtype=numpy.float64).reshape((lastfile+1), sb.nw) | |
- wsigma0 =numpy.zeros((lastfile+1)*sb.nw,\ | |
+ wsigma0 = numpy.zeros((lastfile+1)*sb.nw,\ | |
dtype=numpy.float64).reshape((lastfile+1), sb.nw) | |
- maxpos=numpy.zeros((lastfile+1), dtype=numpy.float64) | |
- logstress=numpy.zeros((lastfile+1), dtype=numpy.float64) | |
- voidratio=numpy.zeros((lastfile+1), dtype=numpy.float64) | |
+ maxpos = numpy.zeros((lastfile+1), dtype=numpy.float64) | |
+ logstress = numpy.zeros((lastfile+1), dtype=numpy.float64) | |
+ voidratio = numpy.zeros((lastfile+1), dtype=numpy.float64) | |
- wforce[i]=sb.w_force[0] | |
- wvel[i] =sb.w_vel[0] | |
- wpos[i] =sb.w_x[0] | |
- wsigma0[i] =sb.w_sigma0[0] | |
- maxpos[i]=numpy.max(sb.x[:,2]+sb.radius) | |
- logstress[i] =\ | |
- numpy.log((sb.w_force[0]/(sb.L[0]*sb.L[1]))/1000.0) | |
- voidratio[i]=sb.voidRatio() | |
+ wforce[i] = sb.w_force[0] | |
+ wvel[i] = sb.w_vel[0] | |
+ wpos[i] = sb.w_x[0] | |
+ wsigma0[i] = sb.w_sigma0[0] | |
+ maxpos[i] = numpy.max(sb.x[:, 2]+sb.radius) | |
+ logstress[i] = numpy.log((sb.w_force[0]/(sb.L[0]*sb.L[1]))/100… | |
+ voidratio[i] = sb.voidRatio() | |
- t=numpy.linspace(0.0, sb.time_current, lastfile+1) | |
+ t = numpy.linspace(0.0, sb.time_current, lastfile+1) | |
# Plotting | |
if outformat != 'txt': | |
# linear plot of time vs. wall position | |
- ax1=plt.subplot2grid((2,2),(0,0)) | |
+ ax1 = plt.subplot2grid((2, 2), (0, 0)) | |
ax1.set_xlabel('Time [s]') | |
ax1.set_ylabel('Position [m]') | |
ax1.plot(t, wpos, '+-', label="upper wall") | |
t@@ -6664,27 +6570,27 @@ class sim: | |
ax1.legend() | |
ax1.grid() | |
- #ax2=plt.subplot2grid((2,2),(1,0)) | |
+ #ax2 = plt.subplot2grid((2, 2), (1, 0)) | |
#ax2.set_xlabel('Time [s]') | |
#ax2.set_ylabel('Force [N]') | |
#ax2.plot(t, wforce, '+-') | |
# semilog plot of log stress vs. void ratio | |
- ax2=plt.subplot2grid((2,2),(1,0)) | |
+ ax2 = plt.subplot2grid((2, 2), (1, 0)) | |
ax2.set_xlabel('log deviatoric stress [kPa]') | |
ax2.set_ylabel('Void ratio [-]') | |
ax2.plot(logstress, voidratio, '+-') | |
ax2.grid() | |
# linear plot of time vs. wall velocity | |
- ax3=plt.subplot2grid((2,2),(0,1)) | |
+ ax3 = plt.subplot2grid((2, 2), (0, 1)) | |
ax3.set_xlabel('Time [s]') | |
ax3.set_ylabel('Velocity [m/s]') | |
ax3.plot(t, wvel, '+-') | |
ax3.grid() | |
# linear plot of time vs. deviatoric stress | |
- ax4=plt.subplot2grid((2,2),(1,1)) | |
+ ax4 = plt.subplot2grid((2, 2), (1, 1)) | |
ax4.set_xlabel('Time [s]') | |
ax4.set_ylabel('Deviatoric stress [Pa]') | |
ax4.plot(t, wsigma0, '+-', label="$\sigma_0$") | |
t@@ -6704,26 +6610,26 @@ class sim: | |
for i in numpy.arange(firststep, lastfile+1): | |
sb.readstep(i, verbose=False) | |
- vol=(sb.w_x[0]-sb.origo[2]) * (sb.w_x[1]-sb.w_x[2]) \ | |
+ vol = (sb.w_x[0]-sb.origo[2]) * (sb.w_x[1]-sb.w_x[2]) \ | |
* (sb.w_x[3] - sb.w_x[4]) | |
# Allocate arrays on first run | |
if i == firststep: | |
- axial_strain=numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ axial_strain = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
deviatoric_stress =\ | |
numpy.zeros(lastfile+1, dtype=numpy.float64) | |
volumetric_strain =\ | |
numpy.zeros(lastfile+1, dtype=numpy.float64) | |
- w0pos0=sb.w_x[0] | |
- vol0=vol | |
+ w0pos0 = sb.w_x[0] | |
+ vol0 = vol | |
- sigma1=sb.w_force[0]/\ | |
+ sigma1 = sb.w_force[0]/\ | |
((sb.w_x[1]-sb.w_x[2])*(sb.w_x[3]-sb.w_x[4])) | |
- axial_strain[i]=(w0pos0 - sb.w_x[0])/w0pos0 | |
- volumetric_strain[i]=(vol0-vol)/vol0 | |
- deviatoric_stress[i]=sigma1 / sb.w_sigma0[1] | |
+ axial_strain[i] = (w0pos0 - sb.w_x[0])/w0pos0 | |
+ volumetric_strain[i] = (vol0-vol)/vol0 | |
+ deviatoric_stress[i] = sigma1 / sb.w_sigma0[1] | |
#print(lastfile) | |
#print(axial_strain) | |
t@@ -6734,20 +6640,20 @@ class sim: | |
if outformat != 'txt': | |
# linear plot of deviatoric stress | |
- ax1=plt.subplot2grid((2,1),(0,0)) | |
+ ax1 = plt.subplot2grid((2, 1), (0, 0)) | |
ax1.set_xlabel('Axial strain, $\gamma_1$, [-]') | |
ax1.set_ylabel('Deviatoric stress, $\sigma_1 - \sigma_3$, [Pa]… | |
ax1.plot(axial_strain, deviatoric_stress, '+-') | |
#ax1.legend() | |
ax1.grid() | |
- #ax2=plt.subplot2grid((2,2),(1,0)) | |
+ #ax2 = plt.subplot2grid((2, 2), (1, 0)) | |
#ax2.set_xlabel('Time [s]') | |
#ax2.set_ylabel('Force [N]') | |
#ax2.plot(t, wforce, '+-') | |
# semilog plot of log stress vs. void ratio | |
- ax2=plt.subplot2grid((2,1),(1,0)) | |
+ ax2 = plt.subplot2grid((2, 1), (1, 0)) | |
ax2.set_xlabel('Axial strain, $\gamma_1$ [-]') | |
ax2.set_ylabel('Volumetric strain, $\gamma_v$, [-]') | |
ax2.plot(axial_strain, volumetric_strain, '+-') | |
t@@ -6766,130 +6672,119 @@ class sim: | |
# First iteration: Allocate arrays and find constant values | |
if i == firststep: | |
# Shear displacement | |
- self.xdisp =numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ xdisp = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Normal stress | |
- self.sigma_eff= numpy.zeros(lastfile+1, dtype=numpy.float6… | |
+ sigma_eff = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Normal stress | |
- self.sigma_def= numpy.zeros(lastfile+1, dtype=numpy.float6… | |
+ sigma_def = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Shear stress | |
- self.tau =numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ tau = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Upper wall position | |
- self.dilation=numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ dilation = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ | |
+ # Peak shear stress | |
+ tau_p = 0.0 | |
- # Upper wall position | |
- self.tau_p=0.0 # Peak shear stress | |
# Shear strain value of peak sh. stress | |
- self.tau_p_shearstrain=0.0 | |
+ tau_p_shearstrain = 0.0 | |
- fixvel=numpy.nonzero(sb.fixvel > 0.0) | |
- #fixvel_upper=numpy.nonzero(sb.vel[fixvel,0] > 0.0) | |
- shearvel=sb.vel[fixvel,0].max() | |
- w_x0=sb.w_x[0] # Original height | |
- A=sb.L[0] * sb.L[1] # Upper surface area | |
+ fixvel = numpy.nonzero(sb.fixvel > 0.0) | |
+ #fixvel_upper = numpy.nonzero(sb.vel[fixvel, 0] > 0.0) | |
+ shearvel = sb.vel[fixvel, 0].max() | |
+ w_x0 = sb.w_x[0] # Original height | |
+ A = sb.L[0] * sb.L[1] # Upper surface area | |
if i == firststep+1: | |
- w_x0=sb.w_x[0] # Original height | |
+ w_x0 = sb.w_x[0] # Original height | |
# Summation of shear stress contributions | |
for j in fixvel[0]: | |
- if sb.vel[j,0] > 0.0: | |
- self.tau[i] += -sb.force[j,0]/A | |
+ if sb.vel[j, 0] > 0.0: | |
+ tau[i] += -sb.force[j, 0]/A | |
if i > 0: | |
- self.xdisp[i]=self.xdisp[i-1] +sb.time_file_dt[0]*shearvel | |
- self.sigma_eff[i]=sb.w_force[0] / A | |
- self.sigma_def[i]=sb.w_sigma0[0] | |
+ xdisp[i] = self.xdisp[i-1] + \ | |
+ sb.time_file_dt[0]*shearvel | |
+ sigma_eff[i] = sb.w_force[0] / A | |
+ sigma_def[i] = sb.w_sigma0[0] | |
# dilation in meters | |
- #dilation[i]=sb.w_x[0] - w_x0 | |
+ #dilation[i] = sb.w_x[0] - w_x0 | |
# dilation in percent | |
- #dilation[i]=(sb.w_x[0] - w_x0)/w_x0 * 100.0 # dilation in per… | |
+ #dilation[i] = (sb.w_x[0] - w_x0)/w_x0 * 100.0 # dilation in p… | |
# dilation in number of mean particle diameters | |
- d_bar=numpy.mean(self.radius)*2.0 | |
+ d_bar = numpy.mean(self.radius)*2.0 | |
if numpy.isnan(d_bar): | |
- #raise Exception("Error, d_bar is NaN. Please check that t… | |
- # + " radii are initialized.") | |
print('No radii in self.radius, attempting to read first ' | |
- + 'file') | |
+ + 'file') | |
self.readfirst() | |
- d_bar=numpy.mean(self.radius)*2.0 | |
- self.dilation[i]=(sb.w_x[0] - w_x0)/d_bar | |
+ d_bar = numpy.mean(self.radius)*2.0 | |
+ dilation[i] = (sb.w_x[0] - w_x0)/d_bar | |
# Test if this was the max. shear stress | |
- if self.tau[i] > self.tau_p: | |
- self.tau_p=self.tau[i] | |
- self.tau_p_shearstrain=self.xdisp[i]/w_x0 | |
+ if tau[i] > tau_p: | |
+ tau_p = tau[i] | |
+ tau_p_shearstrain = xdisp[i]/w_x0 | |
- self.shear_strain=self.xdisp/w_x0 | |
+ shear_strain = xdisp/w_x0 | |
# Copy values so they can be modified during smoothing | |
- shear_strain=self.shear_strain | |
- tau=self.tau | |
- sigma_def=self.sigma_def | |
+ shear_strain_smooth = self.shear_strain | |
+ tau_smooth = tau | |
+ sigma_def_smooth = sigma_def | |
# Optionally smooth the shear stress | |
if smoothing > 2: | |
- if not smoothing_window in ['flat', 'hanning', 'hamming', | |
- 'bartlett', 'blackman']: | |
+ if smoothing_window not in ['flat', 'hanning', 'hamming', | |
+ 'bartlett', 'blackman']: | |
raise ValueError | |
- s=numpy.r_[2*tau[0]-tau[smoothing:1:-1], tau, | |
- 2*tau[-1]-tau[-1:-smoothing:-1]] | |
+ s = numpy.r_[2*tau[0]-tau[smoothing:1:-1], tau, | |
+ 2*tau[-1]-tau[-1:-smoothing:-1]] | |
if smoothing_window == 'flat': # moving average | |
- w=numpy.ones(smoothing, 'd') | |
+ w = numpy.ones(smoothing, 'd') | |
else: | |
- w=getattr(numpy, smoothing_window)(smoothing) | |
- y=numpy.convolve(w/w.sum(), s, mode='same') | |
- tau=y[smoothing-1:-smoothing+1] | |
+ w = getattr(np, smoothing_window)(smoothing) | |
+ y = numpy.convolve(w/w.sum(), s, mode='same') | |
+ tau_smooth = y[smoothing-1:-smoothing+1] | |
# Plot stresses | |
if outformat != 'txt': | |
- shearinfo="$\\tau_p$={:.3} Pa at $\gamma$={:.3}".format(\ | |
+ shearinfo = "$\\tau_p$={:.3} Pa at $\gamma$={:.3}".format(\ | |
self.tau_p, self.tau_p_shearstrain) | |
fig.text(0.01, 0.01, shearinfo, horizontalalignment='left', | |
fontproperties=FontProperties(size=14)) | |
- ax1=plt.subplot2grid((2,1), (0,0)) | |
+ ax1 = plt.subplot2grid((2, 1), (0, 0)) | |
ax1.set_xlabel('Shear strain [-]') | |
- #ax1.set_ylabel('Stress [Pa]') | |
- #ax1.set_ylabel('Shear friction $\\tau/\\sigma\'$ [-]') | |
ax1.set_ylabel('Shear friction $\\tau/\\sigma_0$ [-]') | |
- #ax1.plot(xdisp / w_x0, sigma_eff, '+-g', label="$\sigma'$") | |
- #ax1.plot(xdisp / w_x0, sigma_def, '+-b', label="$\sigma_0$") | |
- #ax1.plot(xdisp / w_x0, tau, '+-r', label="$\\tau$") | |
if smoothing > 2: | |
- ax1.plot(shear_strain[1:-(smoothing+1)/2], | |
- tau[1:-(smoothing+1)/2] / | |
- sigma_def[1:-(smoothing+1)/2], | |
- '-', label="$\\tau/\\sigma_0$") | |
+ ax1.plot(shear_strain_smooth[1:-(smoothing+1)/2], | |
+ tau_smooth[1:-(smoothing+1)/2] / | |
+ sigma_def_smooth[1:-(smoothing+1)/2], | |
+ '-', label="$\\tau/\\sigma_0$") | |
else: | |
ax1.plot(shear_strain[1:],\ | |
- tau[1:]/sigma_def[1:],\ | |
- #self.tau[1:]/self.sigma_eff[1:],\ | |
- '-', label="$\\tau/\\sigma_0$") | |
- #'.-', label="$\\tau$") | |
- #ax1.legend(loc=4) | |
+ tau[1:]/sigma_def[1:],\ | |
+ '-', label="$\\tau/\\sigma_0$") | |
ax1.grid() | |
# Plot dilation | |
- ax2=plt.subplot2grid((2,1),(1,0)) | |
+ ax2 = plt.subplot2grid((2, 1), (1, 0)) | |
ax2.set_xlabel('Shear strain [-]') | |
- #ax2.set_ylabel('Dilation [m]') | |
- #ax2.set_ylabel('Dilation [%]') | |
ax2.set_ylabel('Dilation, $\Delta h/(2\\bar{r})$ [m]') | |
- #ax2.plot(self.shear_strain, self.dilation, '.-') | |
if smoothing > 2: | |
- ax2.plot(self.shear_strain[1:-(smoothing+1)/2], | |
- self.dilation[1:-(smoothing+1)/2], '-') | |
+ ax2.plot(shear_strain_smooth[1:-(smoothing+1)/2], | |
+ dilation_smooth[1:-(smoothing+1)/2], '-') | |
else: | |
- ax2.plot(self.shear_strain, self.dilation, '-') | |
+ ax2.plot(shear_strain, self.dilation, '-') | |
ax2.grid() | |
if xlim: | |
t@@ -6898,28 +6793,26 @@ class sim: | |
fig.tight_layout() | |
- else : | |
+ else: | |
# Write values to textfile | |
- filename="shear-stresses-{0}.txt".format(self.sid) | |
+ filename = "shear-stresses-{0}.txt".format(self.sid) | |
#print("Writing stress data to " + filename) | |
- fh=None | |
- try : | |
- fh=open(filename, "w") | |
- L=sb.L[2] - sb.origo[2] # Initial height | |
+ fh = None | |
+ try: | |
+ fh = open(filename, "w") | |
for i in numpy.arange(firststep, lastfile+1): | |
# format: shear distance [mm], sigma [kPa], tau [kPa], | |
# Dilation [%] | |
- fh.write("{0}\t{1}\t{2}\t{3}\n".format(xdisp[i], | |
- sigma_eff[i]/1000.0, | |
- tau[i]/1000.0, | |
- dilation[i])) | |
- finally : | |
+ fh.write("{0}\t{1}\t{2}\t{3}\n" | |
+ .format(xdisp[i], sigma_eff[i]/1000.0, | |
+ tau[i]/1000.0, dilation[i])) | |
+ finally: | |
if fh is not None: | |
fh.close() | |
elif method == 'shear-displacement': | |
- time=numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ time = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Read stress values from simulation binaries | |
for i in numpy.arange(firststep, lastfile+1): | |
sb.readstep(i, verbose=False) | |
t@@ -6928,176 +6821,162 @@ class sim: | |
if i == firststep: | |
# Shear displacement | |
- self.xdisp =numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ xdisp = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Normal stress | |
- self.sigma_eff= numpy.zeros(lastfile+1, dtype=numpy.float6… | |
+ sigma_eff = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Normal stress | |
- self.sigma_def= numpy.zeros(lastfile+1, dtype=numpy.float6… | |
+ sigma_def = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Shear stress | |
- self.tau_eff =numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ tau_eff = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Upper wall position | |
- self.dilation=numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ dilation = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Mean porosity | |
- self.phi_bar=numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ phi_bar = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Mean fluid pressure | |
- self.p_f_bar=numpy.zeros(lastfile+1, dtype=numpy.float64) | |
- self.p_f_top=numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ p_f_bar = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ p_f_top = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
# Upper wall position | |
- self.tau_p=0.0 # Peak shear stress | |
+ tau_p = 0.0 # Peak shear stress | |
# Shear strain value of peak sh. stress | |
- self.tau_p_shearstrain=0.0 | |
+ tau_p_shearstrain = 0.0 | |
- fixvel=numpy.nonzero(sb.fixvel > 0.0) | |
- #fixvel_upper=numpy.nonzero(sb.vel[fixvel,0] > 0.0) | |
- w_x0=sb.w_x[0] # Original height | |
- A=sb.L[0]*sb.L[1] # Upper surface area | |
+ fixvel = numpy.nonzero(sb.fixvel > 0.0) | |
+ #fixvel_upper=numpy.nonzero(sb.vel[fixvel, 0] > 0.0) | |
+ w_x0 = sb.w_x[0] # Original height | |
+ A = sb.L[0]*sb.L[1] # Upper surface area | |
- d_bar=numpy.mean(sb.radius)*2.0 | |
+ d_bar = numpy.mean(sb.radius)*2.0 | |
# Shear velocity | |
- self.v=numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ v = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
- time[i]=sb.time_current[0] | |
+ time[i] = sb.time_current[0] | |
if i == firststep+1: | |
- w_x0=sb.w_x[0] # Original height | |
+ w_x0 = sb.w_x[0] # Original height | |
# Summation of shear stress contributions | |
for j in fixvel[0]: | |
- if sb.vel[j,0] > 0.0: | |
- self.tau_eff[i] += -sb.force[j,0]/A | |
+ if sb.vel[j, 0] > 0.0: | |
+ tau_eff[i] += -sb.force[j, 0]/A | |
if i > 0: | |
- self.xdisp[i]=sb.xyzsum[fixvel,0].max() | |
- self.v[i] =sb.vel[fixvel,0].max() | |
+ xdisp[i] = sb.xyzsum[fixvel, 0].max() | |
+ v[i] = sb.vel[fixvel, 0].max() | |
- self.sigma_eff[i]=sb.w_force[0]/A | |
- self.sigma_def[i]=sb.currentNormalStress() | |
+ sigma_eff[i] = sb.w_force[0]/A | |
+ sigma_def[i] = sb.currentNormalStress() | |
# dilation in number of mean particle diameters | |
- self.dilation[i]=(sb.w_x[0] - w_x0)/d_bar | |
+ dilation[i] = (sb.w_x[0] - w_x0)/d_bar | |
- wall0_iz=int(sb.w_x[0]/(sb.L[2]/sb.num[2])) | |
+ wall0_iz = int(sb.w_x[0]/(sb.L[2]/sb.num[2])) | |
if self.fluid: | |
if i > 0: | |
- self.phi_bar[i]=numpy.mean(sb.phi[:,:,0:wall0_iz]) | |
+ phi_bar[i] = numpy.mean(sb.phi[:, :, 0:wall0_iz]) | |
if i == firststep+1: | |
- self.phi_bar[0]=self.phi_bar[1] | |
- self.p_f_bar[i]=numpy.mean(sb.p_f[:,:,0:wall0_iz]) | |
- self.p_f_top[i]=sb.p_f[0,0,-1] | |
+ phi_bar[0] = phi_bar[1] | |
+ p_f_bar[i] = numpy.mean(sb.p_f[:, :, 0:wall0_iz]) | |
+ p_f_top[i] = sb.p_f[0, 0, -1] | |
# Test if this was the max. shear stress | |
- if self.tau_eff[i] > self.tau_p: | |
- self.tau_p=self.tau_eff[i] | |
- self.tau_p_shearstrain=self.xdisp[i]/w_x0 | |
+ if tau_eff[i] > tau_p: | |
+ tau_p = tau_eff[i] | |
+ tau_p_shearstrain = xdisp[i]/w_x0 | |
- self.shear_strain=self.xdisp/w_x0 | |
+ shear_strain = self.xdisp/w_x0 | |
# Plot stresses | |
if outformat != 'txt': | |
if figsize: | |
- fig=plt.figure(figsize=figsize) | |
+ fig = plt.figure(figsize=figsize) | |
else: | |
- fig=plt.figure(figsize=(8,12)) | |
- | |
- #shearinfo="$\\tau_p$={:.3} Pa at $\gamma$={:.3}".format(\ | |
- #self.tau_p, self.tau_p_shearstrain) | |
- #fig.text(0.01, 0.01, shearinfo, horizontalalignment='left', | |
- #fontproperties=FontProperties(size=14)) | |
+ fig = plt.figure(figsize=(8, 12)) | |
# Upper plot | |
- ax1=plt.subplot(3,1,1) | |
- ax1.plot(time, self.xdisp, 'k', label='Displacement') | |
+ ax1 = plt.subplot(3, 1, 1) | |
+ ax1.plot(time, xdisp, 'k', label='Displacement') | |
ax1.set_ylabel('Horizontal displacement [m]') | |
- ax2=ax1.twinx() | |
+ ax2 = ax1.twinx() | |
- #ax2color='#666666' | |
- ax2color='blue' | |
+ #ax2color = '#666666' | |
+ ax2color = 'blue' | |
if self.fluid: | |
- ax2.plot(time, self.phi_bar, color=ax2color, | |
- label='Porosity') | |
+ ax2.plot(time, phi_bar, color=ax2color, label='Porosity') | |
ax2.set_ylabel('Mean porosity $\\bar{\\phi}$ [-]') | |
else: | |
- ax2.plot(time, self.dilation, color=ax2color, | |
- label='Dilation') | |
+ ax2.plot(time, dilation, color=ax2color, label='Dilation') | |
ax2.set_ylabel('Dilation, $\Delta h/(2\\bar{r})$ [-]') | |
for tl in ax2.get_yticklabels(): | |
tl.set_color(ax2color) | |
# Middle plot | |
- ax5=plt.subplot(3, 1, 2, sharex=ax1) | |
- ax5.semilogy(time[1:], self.v[1:], label='Shear velocity') | |
+ ax5 = plt.subplot(3, 1, 2, sharex=ax1) | |
+ ax5.semilogy(time[1:], v[1:], label='Shear velocity') | |
ax5.set_ylabel('Shear velocity [ms$^{-1}$]') | |
# shade stick periods | |
- collection=\ | |
+ collection = \ | |
matplotlib.collections.BrokenBarHCollection.span_where( | |
- time, ymin=1.0e-7, ymax=1.0, | |
- where=numpy.isclose(self.v, 0.0), | |
- facecolor='black', alpha=0.2, | |
- linewidth=0) | |
+ time, ymin=1.0e-7, ymax=1.0, | |
+ where=numpy.isclose(v, 0.0), | |
+ facecolor='black', alpha=0.2, | |
+ linewidth=0) | |
ax5.add_collection(collection) | |
# Lower plot | |
- ax3=plt.subplot(3, 1, 3, sharex=ax1) | |
+ ax3 = plt.subplot(3, 1, 3, sharex=ax1) | |
if sb.w_sigma0_A > 1.0e-3: | |
- lns0=ax3.plot(time, self.sigma_def/1000.0, | |
- '-k', label="$\\sigma_0$") | |
- lns1=ax3.plot(time, self.sigma_eff/1000.0, | |
- '--k', label="$\\sigma'$") | |
- lns2=ax3.plot(time, | |
- numpy.ones_like(time)*sb.w_tau_x/1000.0, | |
- '-r', label="$\\tau$") | |
- lns3=ax3.plot(time, self.tau_eff/1000.0, | |
- '--r', label="$\\tau'$") | |
+ lns0 = ax3.plot(time, sigma_def/1000.0, | |
+ '-k', label="$\\sigma_0$") | |
+ lns1 = ax3.plot(time, sigma_eff/1000.0, | |
+ '--k', label="$\\sigma'$") | |
+ lns2 = ax3.plot(time, numpy.ones_like(time)*sb.w_tau_x/100… | |
+ '-r', label="$\\tau$") | |
+ lns3 = ax3.plot(time, tau_eff/1000.0, | |
+ '--r', label="$\\tau'$") | |
ax3.set_ylabel('Stress [kPa]') | |
- #ax3.legend(loc='upper left') | |
else: | |
- ax3.plot(time, self.tau_eff/sb.w_sigma0[0], | |
- '-k', label="$Shear friction$") | |
+ ax3.plot(time, tau_eff/sb.w_sigma0[0], | |
+ '-k', label="$Shear friction$") | |
ax3.plot([0, time[-1]], | |
- [sb.w_tau_x/self.sigma_def, | |
- sb.w_tau_x/self.sigma_def], | |
- '--k', label="$Applied shear friction$") | |
+ [sb.w_tau_x/sigma_def, sb.w_tau_x/sigma_def], | |
+ '--k', label="$Applied shear friction$") | |
ax3.set_ylabel('Shear friction $\\tau\'/\\sigma_0$ [-]') | |
# axis limits | |
- ax3.set_ylim([sb.w_tau_x/self.sigma_def[0]*0.5, | |
- sb.w_tau_x/self.sigma_def[0]*1.5]) | |
- | |
+ ax3.set_ylim([sb.w_tau_x/sigma_def[0]*0.5, | |
+ sb.w_tau_x/sigma_def[0]*1.5]) | |
if self.fluid: | |
- ax4=ax3.twinx() | |
- #ax4color='#666666' | |
- ax4color=ax2color | |
- lns4=ax4.plot(time, self.p_f_top/1000.0, '-', | |
- color=ax4color, | |
- label='$p_\\text{f}^\\text{forcing}$') | |
- lns5=ax4.plot(time, self.p_f_bar/1000.0, '--', | |
- color=ax4color, | |
- label='$\\bar{p}_\\text{f}$') | |
+ ax4 = ax3.twinx() | |
+ #ax4color = '#666666' | |
+ ax4color = ax2color | |
+ lns4 = ax4.plot(time, p_f_top/1000.0, '-', color=ax4color, | |
+ label='$p_\\text{f}^\\text{forcing}$') | |
+ lns5 = ax4.plot(time, p_f_bar/1000.0, '--', color=ax4color, | |
+ label='$\\bar{p}_\\text{f}$') | |
ax4.set_ylabel('Mean fluid pressure ' | |
- + '$\\bar{p_\\text{f}}$ [kPa]') | |
+ + '$\\bar{p_\\text{f}}$ [kPa]') | |
for tl in ax4.get_yticklabels(): | |
tl.set_color(ax4color) | |
if sb.w_sigma0_A > 1.0e-3: | |
#ax4.legend(loc='upper right') | |
- lns=lns0+lns1+lns2+lns3+lns4+lns5 | |
- labs=[l.get_label() for l in lns] | |
+ lns = lns0+lns1+lns2+lns3+lns4+lns5 | |
+ labs = [l.get_label() for l in lns] | |
ax4.legend(lns, labs, loc='upper right', | |
- fancybox=True, framealpha=legend_alpha) | |
+ fancybox=True, framealpha=legend_alpha) | |
if xlim: | |
ax4.set_xlim(xlim) | |
- | |
# aesthetics | |
ax3.set_xlabel('Time [s]') | |
t@@ -7119,83 +6998,68 @@ class sim: | |
elif method == 'rate-dependence': | |
if figsize: | |
- fig=plt.figure(figsize=figsize) | |
+ fig = plt.figure(figsize=figsize) | |
else: | |
- fig=plt.figure(figsize=(8,6)) | |
+ fig = plt.figure(figsize=(8, 6)) | |
- tau=numpy.empty(sb.status()) | |
- N=numpy.empty(sb.status()) | |
- #v=numpy.empty(sb.status()) | |
- shearstrainrate=numpy.empty(sb.status()) | |
- shearstrain=numpy.empty(sb.status()) | |
+ tau = numpy.empty(sb.status()) | |
+ N = numpy.empty(sb.status()) | |
+ #v = numpy.empty(sb.status()) | |
+ shearstrainrate = numpy.empty(sb.status()) | |
+ shearstrain = numpy.empty(sb.status()) | |
for i in numpy.arange(firststep, sb.status()): | |
sb.readstep(i+1, verbose=False) | |
- #tau=sb.shearStress() | |
- tau[i]=sb.w_tau_x # defined shear stress | |
- #tau[i]=sb.shearStress()[0] # measured shear stress along x | |
- N[i]=sb.currentNormalStress() # defined normal stress | |
- #v[i]=sb.shearVel() | |
- shearstrainrate[i]=sb.shearStrainRate() | |
- shearstrain[i]=sb.shearStrain() | |
+ #tau = sb.shearStress() | |
+ tau[i] = sb.w_tau_x # defined shear stress | |
+ N[i] = sb.currentNormalStress() # defined normal stress | |
+ shearstrainrate[i] = sb.shearStrainRate() | |
+ shearstrain[i] = sb.shearStrain() | |
# remove nonzero sliding velocities and their associated values | |
- #idx=numpy.nonzero(v) | |
- idx=numpy.nonzero(shearstrainrate) | |
- #v_nonzero=v[idx] | |
- shearstrainrate_nonzero=shearstrainrate[idx] | |
- tau_nonzero=tau[idx] | |
- N_nonzero=N[idx] | |
- shearstrain_nonzero=shearstrain[idx] | |
- | |
- ax1=plt.subplot(111) | |
+ idx = numpy.nonzero(shearstrainrate) | |
+ shearstrainrate_nonzero = shearstrainrate[idx] | |
+ tau_nonzero = tau[idx] | |
+ N_nonzero = N[idx] | |
+ shearstrain_nonzero = shearstrain[idx] | |
+ | |
+ ax1 = plt.subplot(111) | |
#ax1.semilogy(N/1000., v) | |
#ax1.semilogy(tau_nonzero/N_nonzero, v_nonzero, '+k') | |
#ax1.plot(tau/N, v, '.') | |
- friction=tau_nonzero/N_nonzero | |
- #CS=ax1.scatter(friction, v_nonzero, c=shearstrain_nonzero, | |
+ friction = tau_nonzero/N_nonzero | |
+ #CS = ax1.scatter(friction, v_nonzero, c=shearstrain_nonzero, | |
#linewidth=0) | |
if cmap: | |
- CS=ax1.scatter(friction, shearstrainrate_nonzero, | |
- c=shearstrain_nonzero, linewidth=0.1, | |
- cmap=cmap) | |
+ CS = ax1.scatter(friction, shearstrainrate_nonzero, | |
+ c=shearstrain_nonzero, linewidth=0.1, | |
+ cmap=cmap) | |
else: | |
- CS=ax1.scatter(friction, shearstrainrate_nonzero, | |
- c=shearstrain_nonzero, linewidth=0.1, | |
- cmap=matplotlib.cm.get_cmap('afmhot')) | |
+ CS = ax1.scatter(friction, shearstrainrate_nonzero, | |
+ c=shearstrain_nonzero, linewidth=0.1, | |
+ cmap=matplotlib.cm.get_cmap('afmhot')) | |
ax1.set_yscale('log') | |
- x_min=numpy.floor(numpy.min(friction)) | |
- x_max=numpy.ceil(numpy.max(friction)) | |
+ x_min = numpy.floor(numpy.min(friction)) | |
+ x_max = numpy.ceil(numpy.max(friction)) | |
ax1.set_xlim([x_min, x_max]) | |
- #y_min=numpy.min(v_nonzero)*0.5 | |
- #y_max=numpy.max(v_nonzero)*2.0 | |
- y_min=numpy.min(shearstrainrate_nonzero)*0.5 | |
- y_max=numpy.max(shearstrainrate_nonzero)*2.0 | |
+ y_min = numpy.min(shearstrainrate_nonzero)*0.5 | |
+ y_max = numpy.max(shearstrainrate_nonzero)*2.0 | |
ax1.set_ylim([y_min, y_max]) | |
- cb=plt.colorbar(CS) | |
+ cb = plt.colorbar(CS) | |
cb.set_label('Shear strain $\\gamma$ [-]') | |
- #ax1.set_xlabel('Effective normal stress [kPa]') | |
ax1.set_xlabel('Friction $\\tau/N$ [-]') | |
- #ax1.set_ylabel('Shear velocity [m/s]') | |
ax1.set_ylabel('Shear strain rate $\\dot{\\gamma}$ [s$^{-1}$]') | |
- ''' | |
- ax2=plt.subplot(212) | |
- ax2.plot(tau/N, v, '.') | |
- ax1.set_xlabel('Friction $\\tau/N$ [-]') | |
- ax1.set_ylabel('Shear velocity [m/s]') | |
- ''' | |
- | |
elif method == 'inertia': | |
- t=numpy.zeros(sb.status()) | |
- I=numpy.zeros(sb.status()) | |
+ t = numpy.zeros(sb.status()) | |
+ I = numpy.zeros(sb.status()) | |
for i in numpy.arange(firststep, sb.status()): | |
sb.readstep(i, verbose=False) | |
- t[i]=sb.currentTime() | |
- I[i]=sb.inertiaParameterPlanarShear() | |
+ t[i] = sb.currentTime() | |
+ I[i] = sb.inertiaParameterPlanarShear() | |
# Plotting | |
if outformat != 'txt': | |
t@@ -7204,7 +7068,7 @@ class sim: | |
ax1.set_xlim(xlim) | |
# linear plot of deviatoric stress | |
- ax1=plt.subplot2grid((1,1),(0,0)) | |
+ ax1 = plt.subplot2grid((1, 1), (0, 0)) | |
ax1.set_xlabel('Time $t$ [s]') | |
ax1.set_ylabel('Inertia parameter $I$ [-]') | |
ax1.semilogy(t, I) | |
t@@ -7219,11 +7083,11 @@ class sim: | |
# Allocate arrays on first run | |
if i == firststep: | |
- p_mean=numpy.zeros(lastfile+1, dtype=numpy.float64) | |
+ p_mean = numpy.zeros(lastfile+1, dtype=numpy.float64) | |
- p_mean[i]=numpy.mean(sb.p_f) | |
+ p_mean[i] = numpy.mean(sb.p_f) | |
- t=numpy.linspace(0.0, sb.time_current, lastfile+1) | |
+ t = numpy.linspace(0.0, sb.time_current, lastfile+1) | |
# Plotting | |
if outformat != 'txt': | |
t@@ -7232,7 +7096,7 @@ class sim: | |
ax1.set_xlim(xlim) | |
# linear plot of deviatoric stress | |
- ax1=plt.subplot2grid((1,1),(0,0)) | |
+ ax1 = plt.subplot2grid((1, 1), (0, 0)) | |
ax1.set_xlabel('Time $t$, [s]') | |
ax1.set_ylabel('Mean fluid pressure, $\\bar{p}_f$, [kPa]') | |
ax1.plot(t, p_mean/1000.0, '+-') | |
t@@ -7242,70 +7106,63 @@ class sim: | |
elif method == 'fluid-pressure': | |
if figsize: | |
- fig=plt.figure(figsize=figsize) | |
+ fig = plt.figure(figsize=figsize) | |
else: | |
- fig=plt.figure(figsize=(8,6)) | |
+ fig = plt.figure(figsize=(8, 6)) | |
sb.readfirst(verbose=False) | |
# cell midpoint cell positions | |
- zpos_c=numpy.zeros(sb.num[2]) | |
- dz=sb.L[2]/sb.num[2] | |
+ zpos_c = numpy.zeros(sb.num[2]) | |
+ dz = sb.L[2]/sb.num[2] | |
for i in numpy.arange(sb.num[2]): | |
- zpos_c[i]=i*dz + 0.5*dz | |
+ zpos_c[i] = i*dz + 0.5*dz | |
- shear_strain=numpy.zeros(sb.status()) | |
- pres=numpy.zeros((sb.num[2], sb.status())) | |
+ shear_strain = numpy.zeros(sb.status()) | |
+ pres = numpy.zeros((sb.num[2], sb.status())) | |
# Read pressure values from simulation binaries | |
for i in numpy.arange(firststep, sb.status()): | |
sb.readstep(i, verbose=False) | |
- pres[:,i]=numpy.average(numpy.average(sb.p_f, axis=0), axis=0) | |
- shear_strain[i]=sb.shearStrain() | |
- t=numpy.linspace(0.0, sb.time_current, lastfile+1) | |
+ pres[:, i] = numpy.average(numpy.average(sb.p_f, axis=0), axis… | |
+ shear_strain[i] = sb.shearStrain() | |
+ t = numpy.linspace(0.0, sb.time_current, lastfile+1) | |
# Plotting | |
if outformat != 'txt': | |
- ax=plt.subplot(1,1,1) | |
+ ax = plt.subplot(1, 1, 1) | |
pres /= 1000.0 # Pa to kPa | |
if xlim: | |
- sb.readstep(10,verbose=False) | |
- gamma_per_i=sb.shearStrain()/10.0 | |
- i_min=int(xlim[0]/gamma_per_i) | |
- i_max=int(xlim[1]/gamma_per_i) | |
- pres=pres[:,i_min:i_max] | |
+ sb.readstep(10, verbose=False) | |
+ gamma_per_i = sb.shearStrain()/10.0 | |
+ i_min = int(xlim[0]/gamma_per_i) | |
+ i_max = int(xlim[1]/gamma_per_i) | |
+ pres = pres[:, i_min:i_max] | |
else: | |
- i_min=0 | |
- i_max=sb.status() | |
+ i_min = 0 | |
+ i_max = sb.status() | |
# use largest difference in p from 0 as +/- limit on colormap | |
#print i_min, i_max | |
- #p_ext=numpy.max(numpy.abs(pres)) | |
- p_ext=numpy.max(numpy.abs(pres[0:9,:])) # for article2 | |
+ p_ext = numpy.max(numpy.abs(pres)) | |
if sb.wmode[0] == 3: | |
- x=t | |
+ x = t | |
else: | |
- x=shear_strain | |
+ x = shear_strain | |
if xlim: | |
- x=x[i_min:i_max] | |
+ x = x[i_min:i_max] | |
if cmap: | |
- im1=ax.pcolormesh( | |
- x, zpos_c, pres, | |
- #cmap=matplotlib.cm.get_cmap('bwr'), | |
- cmap=cmap, | |
- vmin=-p_ext, vmax=p_ext, | |
- rasterized=True) | |
+ im1 = ax.pcolormesh(x, zpos_c, pres, cmap=cmap, | |
+ vmin=-p_ext, vmax=p_ext, | |
+ rasterized=True) | |
else: | |
- im1=ax.pcolormesh( | |
- x, zpos_c, pres, | |
- #cmap=matplotlib.cm.get_cmap('bwr'), | |
- cmap=matplotlib.cm.get_cmap('RdBu_r'), | |
- #cmap=matplotlib.cm.get_cmap('coolwarm'), | |
- vmin=-p_ext, vmax=p_ext, | |
- rasterized=True) | |
+ im1 = ax.pcolormesh(x, zpos_c, pres, | |
+ cmap=matplotlib.cm.get_cmap('RdBu_r'), | |
+ vmin=-p_ext, vmax=p_ext, | |
+ rasterized=True) | |
ax.set_xlim([0, numpy.max(x)]) | |
if sb.w_x[0] < sb.L[2]: | |
ax.set_ylim([zpos_c[0], sb.w_x[0]]) | |
t@@ -7315,18 +7172,15 @@ class sim: | |
ax.set_xlabel('Time $t$ [s]') | |
else: | |
ax.set_xlabel('Shear strain $\\gamma$ [-]') | |
- #ax.set_xlabel('Time $t$ [s]') | |
ax.set_ylabel('Vertical position $z$ [m]') | |
- #ax.set_title(sb.id()) | |
- | |
if xlim: | |
ax.set_xlim([x[0], x[-1]]) | |
# for article2 | |
ax.set_ylim([zpos_c[0], zpos_c[9]]) | |
- cb=plt.colorbar(im1) | |
+ cb = plt.colorbar(im1) | |
cb.set_label('$p_\\text{f}$ [kPa]') | |
cb.solids.set_rasterized(True) | |
plt.tight_layout() | |
t@@ -7336,53 +7190,48 @@ class sim: | |
sb.readfirst(verbose=False) | |
if not sb.fluid: | |
raise Exception('Porosities can only be visualized in wet ' + | |
- 'simulations') | |
+ 'simulations') | |
- wall0_iz=int(sb.w_x[0]/(sb.L[2]/sb.num[2])) | |
+ wall0_iz = int(sb.w_x[0]/(sb.L[2]/sb.num[2])) | |
# cell midpoint cell positions | |
- zpos_c=numpy.zeros(sb.num[2]) | |
- dz=sb.L[2]/sb.num[2] | |
+ zpos_c = numpy.zeros(sb.num[2]) | |
+ dz = sb.L[2]/sb.num[2] | |
for i in numpy.arange(firststep, sb.num[2]): | |
- zpos_c[i]=i*dz + 0.5*dz | |
+ zpos_c[i] = i*dz + 0.5*dz | |
- shear_strain=numpy.zeros(sb.status()) | |
- poros=numpy.zeros((sb.num[2], sb.status())) | |
+ shear_strain = numpy.zeros(sb.status()) | |
+ poros = numpy.zeros((sb.num[2], sb.status())) | |
# Read pressure values from simulation binaries | |
for i in numpy.arange(firststep, sb.status()): | |
sb.readstep(i, verbose=False) | |
- poros[:,i]=numpy.average(numpy.average(sb.phi, axis=0),axis=0) | |
- shear_strain[i]=sb.shearStrain() | |
- t=numpy.linspace(0.0, sb.time_current, lastfile+1) | |
+ poros[:, i] = numpy.average(numpy.average(sb.phi, axis=0), axi… | |
+ shear_strain[i] = sb.shearStrain() | |
+ t = numpy.linspace(0.0, sb.time_current, lastfile+1) | |
# Plotting | |
if outformat != 'txt': | |
- ax=plt.subplot(1,1,1) | |
+ ax = plt.subplot(1, 1, 1) | |
- poros_max=numpy.max(poros[0:wall0_iz-1,1:]) | |
- poros_min=numpy.min(poros) | |
+ poros_max = numpy.max(poros[0:wall0_iz-1, 1:]) | |
+ poros_min = numpy.min(poros) | |
if sb.wmode[0] == 3: | |
- x=t | |
+ x = t | |
else: | |
- x=shear_strain | |
+ x = shear_strain | |
if cmap: | |
- im1=ax.pcolormesh( | |
- x, zpos_c, poros, | |
- cmap=cmap, | |
- vmin=poros_min, vmax=poros_max, | |
- rasterized=True) | |
+ im1 = ax.pcolormesh(x, zpos_c, poros, | |
+ cmap=cmap, | |
+ vmin=poros_min, vmax=poros_max, | |
+ rasterized=True) | |
else: | |
- im1=ax.pcolormesh( | |
- x, zpos_c, poros, | |
- cmap=matplotlib.cm.get_cmap('Blues_r'), | |
- #cmap=matplotlib.cm.get_cmap('bwr'), | |
- #cmap=matplotlib.cm.get_cmap('coolwarm'), | |
- #vmin=-p_ext, vmax=p_ext, | |
- vmin=poros_min, vmax=poros_max, | |
- rasterized=True) | |
+ im1 = ax.pcolormesh(x, zpos_c, poros, | |
+ cmap=matplotlib.cm.get_cmap('Blues_r'), | |
+ vmin=poros_min, vmax=poros_max, | |
+ rasterized=True) | |
ax.set_xlim([0, numpy.max(x)]) | |
if sb.w_x[0] < sb.L[2]: | |
ax.set_ylim([zpos_c[0], sb.w_x[0]]) | |
t@@ -7392,15 +7241,12 @@ class sim: | |
ax.set_xlabel('Time $t$ [s]') | |
else: | |
ax.set_xlabel('Shear strain $\\gamma$ [-]') | |
- #ax.set_xlabel('Time $t$ [s]') | |
ax.set_ylabel('Vertical position $z$ [m]') | |
if xlim: | |
ax.set_xlim(xlim) | |
- #ax.set_title(sb.id()) | |
- | |
- cb=plt.colorbar(im1) | |
+ cb = plt.colorbar(im1) | |
cb.set_label('Mean horizontal porosity $\\bar{\phi}$ [-]') | |
cb.solids.set_rasterized(True) | |
plt.tight_layout() | |
t@@ -7409,31 +7255,30 @@ class sim: | |
elif method == 'contacts': | |
for i in numpy.arange(sb.status()+1): | |
- fn="../output/{0}.output{1:0=5}.bin".format(self.sid, i) | |
- sb.sid=self.sid + ".{:0=5}".format(i) | |
+ fn = "../output/{0}.output{1:0=5}.bin".format(self.sid, i) | |
+ sb.sid = self.sid + ".{:0=5}".format(i) | |
sb.readbin(fn, verbose=True) | |
if f_min and f_max: | |
sb.plotContacts(lower_limit=0.25, upper_limit=0.75, | |
- outfolder='../img_out/', | |
- f_min=f_min, f_max=f_max, | |
- title="t={:.2f} s, $N$={:.0f} kPa".format( | |
- sb.currentTime(), | |
- sb.currentNormalStress('defined')/1000.) | |
- ) | |
+ outfolder='../img_out/', | |
+ f_min=f_min, f_max=f_max, | |
+ title="t={:.2f} s, $N$={:.0f} kPa" | |
+ .format(sb.currentTime(), | |
+ sb.currentNormalStress('defined') | |
+ /1000.)) | |
else: | |
sb.plotContacts(lower_limit=0.25, upper_limit=0.75, | |
- title="t={:.2f} s, $N$={:.0f} kPa".format( | |
- sb.currentTime(), | |
- sb.currentNormalStress('defined')/1000.), | |
- outfolder='../img_out/') | |
+ title="t={:.2f} s, $N$={:.0f} kPa" | |
+ .format(sb.currentTime(), | |
+ sb.currentNormalStress('defined') | |
+ /1000.), outfolder='../img_out/') | |
# render images to movie | |
subprocess.call('cd ../img_out/ && ' + | |
- 'ffmpeg -sameq -i {}.%05d-contacts.png '.format(self.sid) + | |
- '{}-contacts.mp4'.format(self.sid), | |
- #'convert -quality 100 {}.*.png {}-contacts.avi'.format( | |
- #self.sid, self.sid), | |
- shell=True) | |
+ 'ffmpeg -sameq -i {}.%05d-contacts.png ' | |
+ .format(self.sid) + | |
+ '{}-contacts.mp4'.format(self.sid), | |
+ shell=True) | |
else: | |
print("Visualization type '" + method + "' not understood") | |
t@@ -7441,10 +7286,10 @@ class sim: | |
# Optional save of figure content | |
if xlim: | |
- filename='{0}-{1}-{3}.{2}'.format(self.sid, method, outformat, | |
- xlim[-1]) | |
+ filename = '{0}-{1}-{3}.{2}'.format(self.sid, method, outformat, | |
+ xlim[-1]) | |
else: | |
- filename='{0}-{1}.{2}'.format(self.sid, method, outformat) | |
+ filename = '{0}-{1}.{2}'.format(self.sid, method, outformat) | |
if pickle: | |
pl.dump(fig, file(filename + '.pickle', 'w')) | |
t@@ -7472,8 +7317,8 @@ def convert(graphics_format='png', folder='../img_out', … | |
:type remove_ppm: bool | |
''' | |
- #quiet=' > /dev/null' | |
- quiet='' | |
+ #quiet = ' > /dev/null' | |
+ quiet = '' | |
# Convert images | |
subprocess.call('for F in ' + folder \ | |
+ '/*.ppm ; do BASE=`basename $F .ppm`; convert $F ' \ | |
t@@ -7507,15 +7352,15 @@ def render(binary, method='pres', max_val=1e3, lower_c… | |
:param verbose: Show verbose information during ray tracing | |
:type verbose: bool | |
''' | |
- quiet='' | |
+ quiet = '' | |
if not verbose: | |
- quiet='-q' | |
+ quiet = '-q' | |
# Render images using sphere raytracer | |
if method == 'normal': | |
subprocess.call('cd .. ; ./sphere ' + quiet + \ | |
' --render ' + binary, shell=True) | |
- else : | |
+ else: | |
subprocess.call('cd .. ; ./sphere ' + quiet + \ | |
' --method ' + method + ' {}'.format(max_val) + \ | |
' -l {}'.format(lower_cutoff) + \ | |
t@@ -7556,15 +7401,15 @@ def video(project, out_folder='./', video_format='mp4', | |
# quiet, panic, fatal, error, warning, info, verbose, debug | |
loglevel = 'info' | |
if not verbose: | |
- loglevel='error' | |
+ loglevel = 'error' | |
outfile = out_folder + '/' + project + '.' + video_format | |
subprocess.call('ffmpeg -loglevel ' + loglevel + ' ' | |
- + '-i ' + graphics_folder + project + '.output%05d.' | |
- + graphics_format | |
- + ' -c:v libx264 -profile:v high -pix_fmt yuv420p -g 30' | |
- + ' -r {} -y '.format(fps) | |
- + outfile, shell=True) | |
+ + '-i ' + graphics_folder + project + '.output%05d.' | |
+ + graphics_format | |
+ + ' -c:v libx264 -profile:v high -pix_fmt yuv420p -g 30' | |
+ + ' -r {} -y '.format(fps) | |
+ + outfile, shell=True) | |
if verbose: | |
print('saved to ' + outfile) | |
t@@ -7594,11 +7439,11 @@ def thinsectionVideo(project, out_folder="./", video_f… | |
''' | |
# Render thin section images (png) | |
- lastfile=status(project) | |
- sb=sim(fluid=self.fluid) | |
+ lastfile = status(project) | |
+ sb = sim(fluid=False) | |
for i in range(lastfile+1): | |
- fn="../output/{0}.output{1:0=5}.bin".format(project, i) | |
- sb.sid=project + ".output{:0=5}".format(i) | |
+ fn = "../output/{0}.output{1:0=5}.bin".format(project, i) | |
+ sb.sid = project + ".output{:0=5}".format(i) | |
sb.readbin(fn, verbose=False) | |
sb.thinsection_x1x3(cbmax=sb.w_sigma0[0]*4.0) | |
t@@ -7607,15 +7452,15 @@ def thinsectionVideo(project, out_folder="./", video_f… | |
# quiet, panic, fatal, error, warning, info, verbose, debug | |
loglevel = "info" | |
if not verbose: | |
- loglevel="error" | |
+ loglevel = "error" | |
subprocess.call("ffmpeg -qscale {0} -r {1} -b {2} -y ".format(\ | |
- qscale, fps, bitrate) \ | |
- + "-loglevel " + loglevel + " " \ | |
- + "-i ../img_out/" + project + ".output%05d-ts-x1x3.png " \ | |
- + "-vf 'crop=((in_w/2)*2):((in_h/2)*2)' " \ | |
- + out_folder + "/" + project + "-ts-x1x3." + video_format, \ | |
- shell=True) | |
+ qscale, fps, bitrate) | |
+ + "-loglevel " + loglevel + " " | |
+ + "-i ../img_out/" + project + ".output%05d-ts-x1x3.png " | |
+ + "-vf 'crop=((in_w/2)*2):((in_h/2)*2)' " \ | |
+ + out_folder + "/" + project + "-ts-x1x3." + video_format, | |
+ shell=True) | |
def run(binary, verbose=True, hideinputfile=False): | |
''' | |
t@@ -7629,12 +7474,12 @@ def run(binary, verbose=True, hideinputfile=False): | |
:type hideinputfile: bool | |
''' | |
- quiet='' | |
- stdout='' | |
+ quiet = '' | |
+ stdout = '' | |
if not verbose: | |
- quiet='-q' | |
+ quiet = '-q' | |
if hideinputfile: | |
- stdout=' > /dev/null' | |
+ stdout = ' > /dev/null' | |
subprocess.call('cd ..; ./sphere ' + quiet + ' ' + binary + ' ' + stdout, \ | |
shell=True) | |
t@@ -7678,11 +7523,11 @@ def torqueScriptParallel3(obj1, obj2, obj3, email='adc… | |
See also :func:`torqueScript()` | |
''' | |
- filename=obj1.sid + '_' + obj2.sid + '_' + obj3.sid + '.sh' | |
+ filename = obj1.sid + '_' + obj2.sid + '_' + obj3.sid + '.sh' | |
- fh=None | |
- try : | |
- fh=open(filename, "w") | |
+ fh = None | |
+ try: | |
+ fh = open(filename, "w") | |
fh.write('#!/bin/sh\n') | |
fh.write('#PBS -N ' + obj1.sid + '_' + obj2.sid + '_' + obj3.sid + '\n… | |
t@@ -7714,7 +7559,7 @@ def torqueScriptParallel3(obj1, obj2, obj3, email='adc@g… | |
fh.write('echo "End at `date`"\n') | |
return filename | |
- finally : | |
+ finally: | |
if fh is not None: | |
fh.close() | |
t@@ -7730,32 +7575,32 @@ def status(project): | |
:return type: int | |
''' | |
- fh=None | |
- try : | |
- filepath="../output/{0}.status.dat".format(project) | |
- fh=open(filepath) | |
- data=fh.read() | |
+ fh = None | |
+ try: | |
+ filepath = "../output/{0}.status.dat".format(project) | |
+ fh = open(filepath) | |
+ data = fh.read() | |
return int(data.split()[2]) # Return last file number | |
- finally : | |
+ finally: | |
if fh is not None: | |
fh.close() | |
-def cleanup(sim): | |
+def cleanup(sb): | |
''' | |
Removes the input/output files and images belonging to the object simulati… | |
ID from the ``input/``, ``output/`` and ``img_out/`` folders. | |
- :param spherebin: A sim object | |
- :type spherebin: sim | |
+ :param sb: A sphere.sim object | |
+ :type sb: sim | |
''' | |
- subprocess.call("rm -f ../input/" + sim.sid + ".bin", shell=True) | |
- subprocess.call("rm -f ../output/" + sim.sid + ".*.bin", shell=True) | |
- subprocess.call("rm -f ../img_out/" + sim.sid + ".*", shell=True) | |
- subprocess.call("rm -f ../output/" + sim.sid + ".status.dat", shell=True) | |
- subprocess.call("rm -f ../output/" + sim.sid + ".*.vtu", shell=True) | |
- subprocess.call("rm -f ../output/fluid-" + sim.sid + ".*.vti", shell=True) | |
- subprocess.call("rm -f ../output/" + sim.sid + "-conv.png", shell=True) | |
- subprocess.call("rm -f ../output/" + sim.sid + "-conv.log", shell=True) | |
+ subprocess.call("rm -f ../input/" + sb.sid + ".bin", shell=True) | |
+ subprocess.call("rm -f ../output/" + sb.sid + ".*.bin", shell=True) | |
+ subprocess.call("rm -f ../img_out/" + sb.sid + ".*", shell=True) | |
+ subprocess.call("rm -f ../output/" + sb.sid + ".status.dat", shell=True) | |
+ subprocess.call("rm -f ../output/" + sb.sid + ".*.vtu", shell=True) | |
+ subprocess.call("rm -f ../output/fluid-" + sb.sid + ".*.vti", shell=True) | |
+ subprocess.call("rm -f ../output/" + sb.sid + "-conv.png", shell=True) | |
+ subprocess.call("rm -f ../output/" + sb.sid + "-conv.log", shell=True) | |
def V_sphere(r): | |
''' | |
t@@ -7765,5 +7610,3 @@ def V_sphere(r): | |
:return type: float | |
''' | |
return 4.0/3.0 * math.pi * r**3.0 | |
- | |
-# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4 |