├── LICENSE
├── MPM.py
├── README.md
├── __init__.py
├── constit.py
├── docs
    ├── .nojekyll
    ├── Makefile
    ├── build
    │   ├── doctrees
    │   │   ├── code.doctree
    │   │   ├── environment.pickle
    │   │   ├── getting_started.doctree
    │   │   ├── index.doctree
    │   │   └── tutorial.doctree
    │   └── html
    │   │   ├── .buildinfo
    │   │   ├── _images
    │   │       ├── graphviz-954248157eccad350729229e02db4948a2cf18d7.png
    │   │       └── graphviz-954248157eccad350729229e02db4948a2cf18d7.png.map
    │   │   ├── _sources
    │   │       ├── code.rst.txt
    │   │       ├── getting_started.rst.txt
    │   │       ├── index.rst.txt
    │   │       └── tutorial.rst.txt
    │   │   ├── _static
    │   │       ├── basic.css
    │   │       ├── css
    │   │       │   ├── badge_only.css
    │   │       │   ├── fonts
    │   │       │   │   ├── Roboto-Slab-Bold.woff
    │   │       │   │   ├── Roboto-Slab-Bold.woff2
    │   │       │   │   ├── Roboto-Slab-Regular.woff
    │   │       │   │   ├── Roboto-Slab-Regular.woff2
    │   │       │   │   ├── fontawesome-webfont.eot
    │   │       │   │   ├── fontawesome-webfont.svg
    │   │       │   │   ├── fontawesome-webfont.ttf
    │   │       │   │   ├── fontawesome-webfont.woff
    │   │       │   │   ├── fontawesome-webfont.woff2
    │   │       │   │   ├── lato-bold-italic.woff
    │   │       │   │   ├── lato-bold-italic.woff2
    │   │       │   │   ├── lato-bold.woff
    │   │       │   │   ├── lato-bold.woff2
    │   │       │   │   ├── lato-normal-italic.woff
    │   │       │   │   ├── lato-normal-italic.woff2
    │   │       │   │   ├── lato-normal.woff
    │   │       │   │   └── lato-normal.woff2
    │   │       │   └── theme.css
    │   │       ├── doctools.js
    │   │       ├── documentation_options.js
    │   │       ├── file.png
    │   │       ├── fonts
    │   │       │   ├── FontAwesome.otf
    │   │       │   ├── Lato
    │   │       │   │   ├── lato-bold.eot
    │   │       │   │   ├── lato-bold.ttf
    │   │       │   │   ├── lato-bold.woff
    │   │       │   │   ├── lato-bold.woff2
    │   │       │   │   ├── lato-bolditalic.eot
    │   │       │   │   ├── lato-bolditalic.ttf
    │   │       │   │   ├── lato-bolditalic.woff
    │   │       │   │   ├── lato-bolditalic.woff2
    │   │       │   │   ├── lato-italic.eot
    │   │       │   │   ├── lato-italic.ttf
    │   │       │   │   ├── lato-italic.woff
    │   │       │   │   ├── lato-italic.woff2
    │   │       │   │   ├── lato-regular.eot
    │   │       │   │   ├── lato-regular.ttf
    │   │       │   │   ├── lato-regular.woff
    │   │       │   │   └── lato-regular.woff2
    │   │       │   ├── Roboto-Slab-Bold.woff
    │   │       │   ├── Roboto-Slab-Bold.woff2
    │   │       │   ├── Roboto-Slab-Light.woff
    │   │       │   ├── Roboto-Slab-Light.woff2
    │   │       │   ├── Roboto-Slab-Regular.woff
    │   │       │   ├── Roboto-Slab-Regular.woff2
    │   │       │   ├── Roboto-Slab-Thin.woff
    │   │       │   ├── Roboto-Slab-Thin.woff2
    │   │       │   ├── RobotoSlab
    │   │       │   │   ├── roboto-slab-v7-bold.eot
    │   │       │   │   ├── roboto-slab-v7-bold.ttf
    │   │       │   │   ├── roboto-slab-v7-bold.woff
    │   │       │   │   ├── roboto-slab-v7-bold.woff2
    │   │       │   │   ├── roboto-slab-v7-regular.eot
    │   │       │   │   ├── roboto-slab-v7-regular.ttf
    │   │       │   │   ├── roboto-slab-v7-regular.woff
    │   │       │   │   └── roboto-slab-v7-regular.woff2
    │   │       │   ├── fontawesome-webfont.eot
    │   │       │   ├── fontawesome-webfont.svg
    │   │       │   ├── fontawesome-webfont.ttf
    │   │       │   ├── fontawesome-webfont.woff
    │   │       │   ├── fontawesome-webfont.woff2
    │   │       │   ├── lato-bold-italic.woff
    │   │       │   ├── lato-bold-italic.woff2
    │   │       │   ├── lato-bold.woff
    │   │       │   ├── lato-bold.woff2
    │   │       │   ├── lato-normal-italic.woff
    │   │       │   ├── lato-normal-italic.woff2
    │   │       │   ├── lato-normal.woff
    │   │       │   └── lato-normal.woff2
    │   │       ├── graphviz.css
    │   │       ├── jquery-3.4.1.js
    │   │       ├── jquery.js
    │   │       ├── js
    │   │       │   ├── badge_only.js
    │   │       │   ├── html5shiv-printshiv.min.js
    │   │       │   ├── html5shiv.min.js
    │   │       │   ├── modernizr.min.js
    │   │       │   └── theme.js
    │   │       ├── language_data.js
    │   │       ├── minus.png
    │   │       ├── plus.png
    │   │       ├── pygments.css
    │   │       ├── searchtools.js
    │   │       ├── underscore-1.3.1.js
    │   │       └── underscore.js
    │   │   ├── code.html
    │   │   ├── genindex.html
    │   │   ├── getting_started.html
    │   │   ├── index.html
    │   │   ├── objects.inv
    │   │   ├── py-modindex.html
    │   │   ├── search.html
    │   │   ├── searchindex.js
    │   │   └── tutorial.html
    ├── code.rst
    ├── conf.py
    ├── getting_started.rst
    ├── index.html
    ├── index.rst
    └── tutorial.rst
├── grid.py
├── initialise.py
├── inputs
    ├── PSM_slope_stab.py
    ├── __init__.py
    ├── __pycache__
    │   ├── __init__.cpython-34.pyc
    │   ├── __init__.cpython-35.pyc
    │   ├── ball.cpython-34.pyc
    │   ├── bi_conveyor.cpython-34.pyc
    │   ├── bi_dam_break.cpython-34.pyc
    │   ├── bi_dam_break.cpython-35.pyc
    │   ├── bi_seg_test.cpython-34 (vlan-2689-10-17-109-133.staff.wireless.sydney.edu.au's conflicted copy 2017-11-15).pyc
    │   ├── bi_seg_test.cpython-34.pyc
    │   ├── bi_seg_test.cpython-35.pyc
    │   ├── dam_break.cpython-34.pyc
    │   ├── dam_break.cpython-35.pyc
    │   ├── dp_rate_unit_test.cpython-34.pyc
    │   ├── dp_unit_test.cpython-34.pyc
    │   ├── francois.cpython-34.pyc
    │   ├── poly_avalanche.cpython-34.pyc
    │   ├── poly_avalanche.cpython-35.pyc
    │   ├── poly_seg_test.cpython-35.pyc
    │   ├── pouliquen_unit_test.cpython-34.pyc
    │   ├── seg_unit_test.cpython-34.pyc
    │   ├── silo.cpython-34.pyc
    │   ├── slope_stab.cpython-34.pyc
    │   ├── tri_seg_test.cpython-34.pyc
    │   ├── tunnel.cpython-34.pyc
    │   ├── vicky.cpython-34.pyc
    │   ├── vicky.cpython-35.pyc
    │   ├── vicky_latest.cpython-35.pyc
    │   └── vm_unit_test.cpython-34.pyc
    ├── anisotropy.py
    ├── avalanche.py
    ├── ball.py
    ├── bi_conveyor.py
    ├── bi_dam_break.py
    ├── bi_double_insets.py
    ├── bi_drum.py
    ├── bi_seg_test.py
    ├── bi_square_drum.py
    ├── bi_vertical_chute.py
    ├── bingham_unit_test.py
    ├── brazillian.py
    ├── chuteflow.py
    ├── dam_break.py
    ├── dp_rate_unit_test.py
    ├── dp_unit_test.py
    ├── flow.py
    ├── fluid.py
    ├── francois.py
    ├── gsd.py
    ├── incline.py
    ├── macro.py
    ├── pierre.py
    ├── poly_avalanche.py
    ├── poly_seg_test.py
    ├── pouliquen_unit_test.py
    ├── seg_unit_test.py
    ├── silo.py
    ├── slope_stab.py
    ├── stokes.py
    ├── tri_seg_test.py
    ├── triaxial.py
    ├── tunnel.py
    ├── vicky.py
    ├── vicky_latest.py
    ├── viscous_unit_test.py
    └── vm_unit_test.py
├── integrators.py
├── mplist.py
├── new_integrator.py
├── particle.py
├── plotting.py
└── requirements.txt


/MPM.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/python
  2 | # -*- coding: utf-8 -*-
  3 | """
  4 | 
  5 | The main module. This contains the loop which will be iterated over every timestep.
  6 | 
  7 | """
  8 | 
  9 | import sys
 10 | import matplotlib
 11 | matplotlib.use('Agg')
 12 | # import matplotlib.pyplot as plt
 13 | from numpy import zeros, sum, seterr, mean, amax, amin, abs, nan_to_num, sqrt, minimum
 14 | from plotting import Plotting
 15 | import initialise
 16 | # import MPM
 17 | seterr(all='ignore')
 18 | 
 19 | def time_march(P,G,L):
 20 |     G.wipe(P) # Discard previous grid
 21 |     P.update_forces() # update time dependent gravity
 22 |     L.update_forces(P,G) # pass body forces to material points
 23 |     L.get_reference_node(P,G) # Find node down and left
 24 |     L.get_basis_functions(P,G) # Make basis functions
 25 |     if P.O.check_positions: L.recover_position(P,G) # check basis functions
 26 |     L.get_nodal_mass_momentum(P,G) # Initialise from grid state
 27 |     if P.B.cyclic_lr: G.make_cyclic(P,G,['m','q'])
 28 |     L.update_stress_strain(P,G) # Update stress and strain
 29 |     L.get_nodal_forces(P,G) # Compute internal and external forces
 30 |     G.BCs(P) # Add external forces from BCs
 31 |     G.update_momentum(P) # Compute rate of momentum and update nodes
 32 |     G.calculate_gammadot(P,G)
 33 |     if P.segregate_grid:
 34 |         G.update_pk(P,G) # NOTE: THIS IS BRAND NEW AND PROBABLY BROKEN
 35 |         # if P.B.cyclic_lr: G.make_cyclic(P,G,['phi','pk','s_bar'])
 36 |         G.calculate_phi_increment(P)
 37 |         L.move_grainsize_on_grid(P,G)
 38 |         G.make_cyclic(P,G,['eta'])
 39 |     L.move_material_points(P,G) # Update material points (position and velocity)
 40 |     # Move/Remove any particles that have left the grid
 41 |     if P.B.outlet_left: L.outlet_left(P,G)
 42 |     if P.B.outlet_bottom: L.outlet_bottom(P,G)
 43 |     if P.B.inlet_right: L.inlet_right(P,G)
 44 |     if P.B.inlet_top: L.inlet_top(P,G)
 45 |     if P.B.cyclic_lr: L.cyclic_lr(P,G)
 46 |     return P,G,L
 47 | 
 48 | def main(params):
 49 |     """This is the main loop which is repeated every timestep. Currently, this follows the Update Strain Last paradigm (does it?!?).
 50 | 
 51 |     :param mode: The name of the input file to use.
 52 |     :type mode: str
 53 |     :returns: int -- The return code.
 54 | 
 55 |     """
 56 | 
 57 |     P,G,L = initialise.get_parameters(params)
 58 |     plot = Plotting()
 59 |     P.O.initial_graphs(P,G,L,plot)
 60 | #     if P.O.plot_material_points: plot.draw_material_points(L,P,G,'initial')
 61 | 
 62 |     while P.t <= P.t_f:# Time march
 63 |         P,G,L = time_march(P,G,L)
 64 |         P.O.before_every_timestep(P,G,L,plot)
 65 |         # Output related things
 66 |         # if P.O.measure_energy: P.O.energy[P.tstep] = L.measure_elastic_energy(P,G) # measure energy
 67 | 
 68 |         print('{0:.4f}'.format(P.t*100./P.t_f) + '% Complete, t = ' +
 69 |               '{0:.4f}'.format(P.t) + ', g = ' + str(P.g), end='\r')
 70 | 
 71 |         if (P.t%P.savetime < P.dt) and (P.t != P.dt): # ignore first timestep
 72 |             P.O.after_every_nth_timestep(P,G,L,plot)
 73 | #             if P.O.plot_gsd_mp: plot.draw_gsd_mp(L,P,G)
 74 | #             if P.O.plot_gsd_grid: plot.draw_gsd_grid(L,P,G)
 75 | # #             plot.draw_voronoi(P,G)
 76 | #             if P.O.plot_continuum: plot.draw_continuum(G,P)
 77 | #             if P.O.plot_material_points: plot.draw_material_points(L,P,G)
 78 | #             if P.mode == 'anisotropy': plot.draw_gamma_dot(L,P,G)
 79 | #             if P.O.measure_energy: P.O.measure_E(L,P,G)
 80 | #             # for [field,fieldname] in P.O.save_fields: P.O.save_field(L,P,G,field,fieldname)
 81 | #             if P.O.save_u: plot.save_u(L,P,G)
 82 | #             if P.O.save_s_bar: plot.save_s_bar(L,P,G)
 83 | #             if P.O.save_density: plot.save_density(L,P,G)
 84 | #             if P.O.save_phi_MP: plot.save_phi_MP(L,P,G)
 85 |         P.O.after_every_timestep(P,G,L,plot)
 86 |         # if P.mode == 'dp_unit_test' or P.mode == 'dp_rate_unit_test': P.O.store_p_q(P,G,L,P.tstep)
 87 |         # if P.mode == 'pouliquen_unit_test': P.O.store_mu(P,G,L,P.tstep)
 88 | 
 89 |         # Increment time
 90 |         P.t += P.dt
 91 |         P.tstep += 1
 92 | 
 93 |         if P.time_stepping == 'dynamic': P.update_timestep(P,G)
 94 | 
 95 |         # for p in range(P.phases):
 96 | #             if (P.S[p].law is 'von_mises' or P.S[p].law is 'dp') and not P.has_yielded:
 97 | #             if P.S[p].law is 'von_mises' and not P.has_yielded:
 98 | #                 L.update_timestep(P) # Check for yielding and reduce timestep
 99 | 
100 |     # Final things to do
101 |     P.O.final_graphs(P,G,L,plot)
102 |     # if P.O.plot_material_points: plot.draw_material_points(L,P,G,'final')
103 |     # if P.O.measure_stiffness: P.O.measure_E(L,P,G)
104 |     # if P.O.measure_energy: plot.draw_energy(P)
105 |     # if P.O.plot_gsd_mp: plot.draw_gsd_mp(L,P,G)
106 |     # if P.O.plot_gsd_grid: plot.draw_gsd_grid(L,P,G)
107 |     # if P.O.save_u: plot.save_u(L,P,G)
108 |     # if P.O.save_s_bar: plot.save_s_bar(L,P,G)
109 |     # if P.O.save_density: plot.save_density(L,P,G)
110 |     # if P.O.save_phi_MP: plot.save_phi_MP(L,P,G)
111 |     # if P.mode == 'dp_unit_test' or P.mode == 'dp_rate_unit_test': P.O.draw_p_q(P,G,L,plot,P.tstep)
112 |     # if P.mode == 'pouliquen_unit_test': P.O.draw_mu(P,G,L,plot,P.tstep)
113 |     print('')
114 |     return 0
115 | 
116 | if __name__ == '__main__':
117 |     params = sys.argv[1:]
118 |     status = main(params)
119 |     sys.exit(status)
120 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Polydisperse material point method
 2 | 
 3 | This code implements a basic two dimensional material point method, with additional functionality to additionally calculate segregation during granular flow.
 4 | 
 5 | ## Getting Started
 6 | 
 7 | Just download a copy and follow the [documentation](http://benjym.github.io/poly-mpm/build/html/index.html)!
 8 | 
 9 | ### Prerequisites
10 | 
11 | You will need a full python3 environment installed. I recommend [anaconda](https://www.anaconda.com/download/) for this.
12 | 
13 | 
14 | ## Built With
15 | 
16 | * [Scipy](https://www.scipy.org/)
17 | * [Numpy](http://www.numpy.org/)
18 | * [Matplotlib](https://matplotlib.org/)
19 | 
20 | ## Contributing
21 | 
22 | <!-- Please read [CONTRIBUTING.md](https://gist.github.com/PurpleBooth/b24679402957c63ec426) for details on our code of conduct, and the process for submitting pull requests to us. -->
23 | If you would like to contribute to the code, please contact Benjy at <benjy.marks@sydney.edu.au>
24 | 
25 | 
26 | <!-- ## Versioning
27 | 
28 | We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/your/project/tags). -->
29 | 
30 | ## Authors
31 | 
32 | * [Benjy Marks](www.benjymarks.com)
33 | 
34 | <!-- See also the list of [contributors](https://github.com/your/project/contributors) who participated in this project. -->
35 | 
36 | ## License
37 | 
38 | This project is licensed under the GNU GPL License - see the [LICENSE](LICENSE) file for details
39 | 
40 | <!-- ## Acknowledgments
41 | 
42 | * Hat tip to anyone who's code was used
43 | * Inspiration
44 | * etc -->
45 | 


--------------------------------------------------------------------------------
/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/__init__.py


--------------------------------------------------------------------------------
/docs/.nojekyll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/.nojekyll


--------------------------------------------------------------------------------
/docs/build/doctrees/code.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/doctrees/code.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/environment.pickle:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/doctrees/environment.pickle


--------------------------------------------------------------------------------
/docs/build/doctrees/getting_started.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/doctrees/getting_started.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/index.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/doctrees/index.doctree


--------------------------------------------------------------------------------
/docs/build/doctrees/tutorial.doctree:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/doctrees/tutorial.doctree


--------------------------------------------------------------------------------
/docs/build/html/.buildinfo:
--------------------------------------------------------------------------------
1 | # Sphinx build info version 1
2 | # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
3 | config: 128e7818d31e9644108b99b8eb3ef081
4 | tags: 645f666f9bcd5a90fca523b33c5a78b7
5 | 


--------------------------------------------------------------------------------
/docs/build/html/_images/graphviz-954248157eccad350729229e02db4948a2cf18d7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_images/graphviz-954248157eccad350729229e02db4948a2cf18d7.png


--------------------------------------------------------------------------------
/docs/build/html/_images/graphviz-954248157eccad350729229e02db4948a2cf18d7.png.map:
--------------------------------------------------------------------------------
1 | <map id="foo" name="foo">
2 | </map>
3 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/code.rst.txt:
--------------------------------------------------------------------------------
 1 | Documentation
 2 | **************************
 3 | 
 4 | The code is made up of the following modules:
 5 | 
 6 |     * `Main Module`_
 7 |     * `Material Points`_
 8 |     * `Material Point Lists`_
 9 |     * `Grid Operators`_
10 |     * `Constitutive Models`_
11 |     * `Integrators`_
12 |     * `Plotting`_
13 | 
14 | .. _main_module:
15 | 
16 | Main Module
17 | ==========================
18 | 
19 | .. automodule:: MPM
20 |    :members:
21 | 
22 | .. _material_points:
23 | 
24 | Material Points
25 | ==========================
26 | 
27 | .. autoclass:: particle.Particle
28 |    :members:
29 | 
30 | .. _material_point_lists:
31 | 
32 | Material Point Lists
33 | ==========================
34 | 
35 | .. automodule:: mplist
36 |    :members:
37 | 
38 | .. _grid_operators:
39 | 
40 | Grid Operators
41 | ==========================
42 | 
43 | .. automodule:: grid
44 |    :members:
45 | 
46 | .. _constitutive_models:
47 | 
48 | Constitutive Models
49 | ==========================
50 | 
51 | .. automodule:: constit
52 |    :members:
53 | 
54 | .. _pde_integrators:
55 | 
56 | Integrators
57 | ==========================
58 | 
59 | .. automodule:: integrators
60 |   :members:
61 | 
62 | 
63 | .. _custom_plotting:
64 | 
65 | Plotting
66 | ==========================
67 | 
68 | .. automodule:: plotting
69 |    :members:
70 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/getting_started.rst.txt:
--------------------------------------------------------------------------------
 1 | .. _getting_started:
 2 | 
 3 | 
 4 | ***************
 5 | Getting started
 6 | ***************
 7 | 
 8 | .. _installation:
 9 | 
10 | Installation
11 | =============================
12 | 
13 | For this to run, you will need the following installed
14 | 
15 |     * Python 2.7+/3+
16 |     * NumPy
17 |     * Matplotlib
18 | 
19 | If running on Mac OS X, I recommend installing the Anaconda_ package. On Ubuntu, just type::
20 |     
21 |     sudo apt-get install python python-numpy python-matplotlib
22 | 
23 | .. _Anaconda: https://www.continuum.io/downloads
24 | 
25 | .. _example:
26 | 
27 | Running an example
28 | =============================
29 | 
30 | Parameters for each simulation are contained in separate files in the inputs directory. For example, to run the simulation described by :file:`inputs/ball.py`, run the following in the terminal::
31 | 
32 |   python MPM.py ball
33 | 
34 | By default, the output files should be contained in :file:`~/Documents/poly-mpm`.
35 | 
36 | 
37 | Loading example data
38 | =============================
39 | 
40 | This is a fairly convoluted process, but is kind of summarised here:
41 | 
42 | .. graphviz::
43 | 
44 |    digraph foo {
45 |       "input file" -> "inititalise" -> "params.Params instance";
46 |    }
47 |    
48 | Any data which is not provided in the input file will be created with a default value in :file:`initialise.py`. This complete data is then passed into the params.Params instance, which is used for the rest of the simulation.


--------------------------------------------------------------------------------
/docs/build/html/_sources/index.rst.txt:
--------------------------------------------------------------------------------
 1 | .. poly-mpm documentation master file, created by
 2 |    sphinx-quickstart on Tue May  3 11:30:20 2016.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | Welcome to poly-mpm's documentation!
 7 | ====================================
 8 | 
 9 | Contents:
10 | 
11 | .. toctree::
12 |    :maxdepth: 2
13 | 
14 |    getting_started.rst
15 |    tutorial.rst
16 |    code.rst
17 |    
18 | Indices and tables
19 | ==================
20 | 
21 | * :ref:`genindex`
22 | * :ref:`modindex`
23 | * :ref:`search`
24 | 
25 | 


--------------------------------------------------------------------------------
/docs/build/html/_sources/tutorial.rst.txt:
--------------------------------------------------------------------------------
  1 | .. _tutorial:
  2 | 
  3 | 
  4 | ***************
  5 | Tutorial
  6 | ***************
  7 | 
  8 | 
  9 | Looking at the input file
 10 | =============================
 11 | 
 12 | Load up the file :file:`inputs/ball.py` in your favourite text editor. I like `atom <https://atom.io/>`_.
 13 | 
 14 | The Params class
 15 | =============================
 16 | 
 17 | This contains all of the parameters for controlling a single simulation. Some global information is stored here, such as timestepping and gravity values. Other information is stored in subclasses. A convenience method is also provided for updating gravity, or any other parameters, as many simulations require a slow ramp up in gravity, rather than applying a step function::
 18 | 
 19 |     class Params():
 20 |         def __init__(self,mode):
 21 |             self.dt = 1e-4 # timestep (s)
 22 |             self.savetime = 0.01
 23 |             self.t_f = 5.#100*self.dt # final time (s)
 24 |             self.nt = int(self.t_f/self.dt) # number of timesteps
 25 |             self.max_g = -10. # gravity (ms^-2)
 26 |             self.theta = 0.*pi/180. # slope angle (degrees)
 27 |             self.G = Grid_Params()
 28 |             self.B = Boundary_Params()
 29 |             self.O = Output_Params()
 30 |             self.S = Solid_Params()
 31 | 
 32 |         def update_forces(self):
 33 |             t_c = .5
 34 |             self.g=self.max_g
 35 | 
 36 | The Grid_Params class
 37 | =============================
 38 | 
 39 | This describes the :math:`x` and :math:`y` extents of the grid, as well as their resolution. This is pretty inflexible at the moment, and only allows for regular cartesian grids on a rectangular domain::
 40 | 
 41 |     class Grid_Params():
 42 |         def __init__(self):
 43 |             self.x_m = -1.0 # (m)
 44 |             self.x_M = 1.0 # (m)
 45 |             self.y_m = 0.0 # (m)
 46 |             self.y_M = 2.0 # (m)
 47 |             self.nx = 21 # number of grid edges in x direction
 48 |             self.ny = 21 # number of grid edges in y direction
 49 | 
 50 | The Boundary_Params class
 51 | =============================
 52 | 
 53 | Here all of the boundaries of the grid are defined. For this example, only the bottom of the grid has a boundary. It is also not rough (``self.roughness`` has not been set to  ``True``)::
 54 | 
 55 |     class Boundary_Params():
 56 |         def __init__(self):
 57 |             self.has_bottom = True
 58 | 
 59 | The Solid_Params class
 60 | =============================
 61 | 
 62 | This defines the properties of each material point. The lists ``self.X`` and ``self.Y`` define initial positions of each material point, up to ``self.n`` points in total. The constitutive model to use is defined by ``self.law`` --- this needs to be the same as the class in :file:`constit.py`. In this example, material points are placed onto a set of ``nr`` concentric circles with centre at ``c``, largest radius ``r`` and ``nphi`` material points around the largest circle.::
 63 | 
 64 |     class Solid_Params():
 65 |         def __init__(self):
 66 |             self.X = []
 67 |             self.Y = []
 68 |             self.n = 0
 69 | 
 70 |             self.rho = 1000. # density (kg/m^3)
 71 | 
 72 |     #         self.law = 'elastic'
 73 |             self.law = 'von_mises'
 74 |     #         self.law = 'dp'
 75 | 
 76 |             self.E = 1.e6 # elastic modulus (Pa)
 77 |             self.nu = 0.3 # poisson's ratio
 78 |             self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 79 |             self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 80 | 
 81 |             # for von_mises
 82 |             self.k = self.E/100.
 83 | 
 84 |             # for dp
 85 |             self.s = 5.
 86 |             self.beta = 10.
 87 |             self.mu = 0.5
 88 | 
 89 |             nr = 20 # particles in radial direction
 90 |             nphi = 50 # particles around circumference
 91 |             r = 0.3 # radius
 92 |             c = [0.,1.] # centre
 93 | 
 94 |             for i in linspace(0,r,nr):
 95 |                 dnphi = around(nphi*i/r) # number in this ring
 96 |                 for j in linspace(0,(1.-1./(dnphi))*2*pi,dnphi):
 97 |                     self.X.append(c[0]+i*sin(j))
 98 |                     self.Y.append(c[1]+i*cos(j))
 99 |                     self.n += 1
100 |             self.A = pi*0.2**2/self.n # area (m^2)
101 | 
102 | The Output_Params class
103 | =============================
104 | 
105 | This class defines what should be output from the simulation. Here, the continuum values and material point values are both show, using custom sizes for the respective figures.::
106 | 
107 |     class Output_Params():
108 |         def __init__(self):
109 |             self.continuum_fig_size = [10,6]
110 |             self.mp_fig_size = [10,10]
111 |             self.plot_continuum = True
112 |             self.plot_material_points = True
113 | 


--------------------------------------------------------------------------------
/docs/build/html/_static/css/badge_only.css:
--------------------------------------------------------------------------------
1 | .fa:before{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/Roboto-Slab-Bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/Roboto-Slab-Bold.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/Roboto-Slab-Bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/Roboto-Slab-Bold.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/Roboto-Slab-Regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/Roboto-Slab-Regular.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/Roboto-Slab-Regular.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/Roboto-Slab-Regular.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/fontawesome-webfont.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/fontawesome-webfont.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-bold-italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/lato-bold-italic.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-bold-italic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/lato-bold-italic.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/lato-bold.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/lato-bold.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-normal-italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/lato-normal-italic.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-normal-italic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/lato-normal-italic.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-normal.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/lato-normal.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/css/fonts/lato-normal.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/css/fonts/lato-normal.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/documentation_options.js:
--------------------------------------------------------------------------------
 1 | var DOCUMENTATION_OPTIONS = {
 2 |     URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
 3 |     VERSION: '1.1',
 4 |     LANGUAGE: 'None',
 5 |     COLLAPSE_INDEX: false,
 6 |     BUILDER: 'html',
 7 |     FILE_SUFFIX: '.html',
 8 |     HAS_SOURCE: true,
 9 |     SOURCELINK_SUFFIX: '.txt',
10 |     NAVIGATION_WITH_KEYS: false
11 | };


--------------------------------------------------------------------------------
/docs/build/html/_static/file.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/file.png


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/FontAwesome.otf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/FontAwesome.otf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-bold.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-bold.eot


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-bold.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-bold.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-bold.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-bolditalic.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-bolditalic.eot


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-bolditalic.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-bolditalic.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-bolditalic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-bolditalic.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-bolditalic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-bolditalic.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-italic.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-italic.eot


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-italic.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-italic.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-italic.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-italic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-italic.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-regular.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-regular.eot


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-regular.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-regular.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Lato/lato-regular.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Lato/lato-regular.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Roboto-Slab-Bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Roboto-Slab-Bold.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Roboto-Slab-Bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Roboto-Slab-Bold.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Roboto-Slab-Light.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Roboto-Slab-Light.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Roboto-Slab-Light.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Roboto-Slab-Light.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Roboto-Slab-Regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Roboto-Slab-Regular.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Roboto-Slab-Regular.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Roboto-Slab-Regular.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Roboto-Slab-Thin.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Roboto-Slab-Thin.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/Roboto-Slab-Thin.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/Roboto-Slab-Thin.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.eot


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.eot


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/fontawesome-webfont.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/fontawesome-webfont.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/lato-bold-italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/lato-bold-italic.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/lato-bold-italic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/lato-bold-italic.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/lato-bold.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/lato-bold.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/lato-bold.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/lato-bold.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/lato-normal-italic.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/lato-normal-italic.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/lato-normal-italic.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/lato-normal-italic.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/lato-normal.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/lato-normal.woff


--------------------------------------------------------------------------------
/docs/build/html/_static/fonts/lato-normal.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/fonts/lato-normal.woff2


--------------------------------------------------------------------------------
/docs/build/html/_static/graphviz.css:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * graphviz.css
 3 |  * ~~~~~~~~~~~~
 4 |  *
 5 |  * Sphinx stylesheet -- graphviz extension.
 6 |  *
 7 |  * :copyright: Copyright 2007-2020 by the Sphinx team, see AUTHORS.
 8 |  * :license: BSD, see LICENSE for details.
 9 |  *
10 |  */
11 | 
12 | img.graphviz {
13 |     border: 0;
14 |     max-width: 100%;
15 | }
16 | 
17 | object.graphviz {
18 |     max-width: 100%;
19 | }
20 | 


--------------------------------------------------------------------------------
/docs/build/html/_static/js/badge_only.js:
--------------------------------------------------------------------------------
1 | !function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=4)}({4:function(e,t,r){}});


--------------------------------------------------------------------------------
/docs/build/html/_static/js/html5shiv-printshiv.min.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @preserve HTML5 Shiv 3.7.3-pre | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
3 | */
4 | !function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x<style>"+b+"</style>",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=y.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=y.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),y.elements=c+" "+a,j(b)}function f(a){var b=x[a[v]];return b||(b={},w++,a[v]=w,x[w]=b),b}function g(a,c,d){if(c||(c=b),q)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():u.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||t.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),q)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return y.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(y,b.frag)}function j(a){a||(a=b);var d=f(a);return!y.shivCSS||p||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),q||i(a,d),a}function k(a){for(var b,c=a.getElementsByTagName("*"),e=c.length,f=RegExp("^(?:"+d().join("|")+")$","i"),g=[];e--;)b=c[e],f.test(b.nodeName)&&g.push(b.applyElement(l(b)));return g}function l(a){for(var b,c=a.attributes,d=c.length,e=a.ownerDocument.createElement(A+":"+a.nodeName);d--;)b=c[d],b.specified&&e.setAttribute(b.nodeName,b.nodeValue);return e.style.cssText=a.style.cssText,e}function m(a){for(var b,c=a.split("{"),e=c.length,f=RegExp("(^|[\\s,>+~])("+d().join("|")+")(?=[[\\s,>+~#.:]|$)","gi"),g="$1"+A+"\\:$2";e--;)b=c[e]=c[e].split("}"),b[b.length-1]=b[b.length-1].replace(f,g),c[e]=b.join("}");return c.join("{")}function n(a){for(var b=a.length;b--;)a[b].removeNode()}function o(a){function b(){clearTimeout(g._removeSheetTimer),d&&d.removeNode(!0),d=null}var d,e,g=f(a),h=a.namespaces,i=a.parentWindow;return!B||a.printShived?a:("undefined"==typeof h[A]&&h.add(A),i.attachEvent("onbeforeprint",function(){b();for(var f,g,h,i=a.styleSheets,j=[],l=i.length,n=Array(l);l--;)n[l]=i[l];for(;h=n.pop();)if(!h.disabled&&z.test(h.media)){try{f=h.imports,g=f.length}catch(o){g=0}for(l=0;g>l;l++)n.push(f[l]);try{j.push(h.cssText)}catch(o){}}j=m(j.reverse().join("")),e=k(a),d=c(a,j)}),i.attachEvent("onafterprint",function(){n(e),clearTimeout(g._removeSheetTimer),g._removeSheetTimer=setTimeout(b,500)}),a.printShived=!0,a)}var p,q,r="3.7.3",s=a.html5||{},t=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,u=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,v="_html5shiv",w=0,x={};!function(){try{var a=b.createElement("a");a.innerHTML="<xyz></xyz>",p="hidden"in a,q=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){p=!0,q=!0}}();var y={elements:s.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:r,shivCSS:s.shivCSS!==!1,supportsUnknownElements:q,shivMethods:s.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=y,j(b);var z=/^$|\b(?:all|print)\b/,A="html5shiv",B=!q&&function(){var c=b.documentElement;return!("undefined"==typeof b.namespaces||"undefined"==typeof b.parentWindow||"undefined"==typeof c.applyElement||"undefined"==typeof c.removeNode||"undefined"==typeof a.attachEvent)}();y.type+=" print",y.shivPrint=o,o(b),"object"==typeof module&&module.exports&&(module.exports=y)}("undefined"!=typeof window?window:this,document);


--------------------------------------------------------------------------------
/docs/build/html/_static/js/html5shiv.min.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
3 | */
4 | !function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x<style>"+b+"</style>",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=t.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=t.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),t.elements=c+" "+a,j(b)}function f(a){var b=s[a[q]];return b||(b={},r++,a[q]=r,s[r]=b),b}function g(a,c,d){if(c||(c=b),l)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():p.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||o.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),l)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return t.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(t,b.frag)}function j(a){a||(a=b);var d=f(a);return!t.shivCSS||k||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),l||i(a,d),a}var k,l,m="3.7.3-pre",n=a.html5||{},o=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,p=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,q="_html5shiv",r=0,s={};!function(){try{var a=b.createElement("a");a.innerHTML="<xyz></xyz>",k="hidden"in a,l=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){k=!0,l=!0}}();var t={elements:n.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:m,shivCSS:n.shivCSS!==!1,supportsUnknownElements:l,shivMethods:n.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=t,j(b),"object"==typeof module&&module.exports&&(module.exports=t)}("undefined"!=typeof window?window:this,document);


--------------------------------------------------------------------------------
/docs/build/html/_static/js/theme.js:
--------------------------------------------------------------------------------
1 | !function(n){var e={};function t(i){if(e[i])return e[i].exports;var o=e[i]={i:i,l:!1,exports:{}};return n[i].call(o.exports,o,o.exports,t),o.l=!0,o.exports}t.m=n,t.c=e,t.d=function(n,e,i){t.o(n,e)||Object.defineProperty(n,e,{enumerable:!0,get:i})},t.r=function(n){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(n,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(n,"__esModule",{value:!0})},t.t=function(n,e){if(1&e&&(n=t(n)),8&e)return n;if(4&e&&"object"==typeof n&&n&&n.__esModule)return n;var i=Object.create(null);if(t.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:n}),2&e&&"string"!=typeof n)for(var o in n)t.d(i,o,function(e){return n[e]}.bind(null,o));return i},t.n=function(n){var e=n&&n.__esModule?function(){return n.default}:function(){return n};return t.d(e,"a",e),e},t.o=function(n,e){return Object.prototype.hasOwnProperty.call(n,e)},t.p="",t(t.s=0)}([function(n,e,t){t(1),n.exports=t(3)},function(n,e,t){(function(){var e="undefined"!=typeof window?window.jQuery:t(2);n.exports.ThemeNav={navBar:null,win:null,winScroll:!1,winResize:!1,linkScroll:!1,winPosition:0,winHeight:null,docHeight:null,isRunning:!1,enable:function(n){var t=this;void 0===n&&(n=!0),t.isRunning||(t.isRunning=!0,e((function(e){t.init(e),t.reset(),t.win.on("hashchange",t.reset),n&&t.win.on("scroll",(function(){t.linkScroll||t.winScroll||(t.winScroll=!0,requestAnimationFrame((function(){t.onScroll()})))})),t.win.on("resize",(function(){t.winResize||(t.winResize=!0,requestAnimationFrame((function(){t.onResize()})))})),t.onResize()})))},enableSticky:function(){this.enable(!0)},init:function(n){n(document);var e=this;this.navBar=n("div.wy-side-scroll:first"),this.win=n(window),n(document).on("click","[data-toggle='wy-nav-top']",(function(){n("[data-toggle='wy-nav-shift']").toggleClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift")})).on("click",".wy-menu-vertical .current ul li a",(function(){var t=n(this);n("[data-toggle='wy-nav-shift']").removeClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift"),e.toggleCurrent(t),e.hashChange()})).on("click","[data-toggle='rst-current-version']",(function(){n("[data-toggle='rst-versions']").toggleClass("shift-up")})),n("table.docutils:not(.field-list,.footnote,.citation)").wrap("<div class='wy-table-responsive'></div>"),n("table.docutils.footnote").wrap("<div class='wy-table-responsive footnote'></div>"),n("table.docutils.citation").wrap("<div class='wy-table-responsive citation'></div>"),n(".wy-menu-vertical ul").not(".simple").siblings("a").each((function(){var t=n(this);expand=n('<span class="toctree-expand"></span>'),expand.on("click",(function(n){return e.toggleCurrent(t),n.stopPropagation(),!1})),t.prepend(expand)}))},reset:function(){var n=encodeURI(window.location.hash)||"#";try{var e=$(".wy-menu-vertical"),t=e.find('[href="'+n+'"]');if(0===t.length){var i=$('.document [id="'+n.substring(1)+'"]').closest("div.section");0===(t=e.find('[href="#'+i.attr("id")+'"]')).length&&(t=e.find('[href="#"]'))}t.length>0&&($(".wy-menu-vertical .current").removeClass("current"),t.addClass("current"),t.closest("li.toctree-l1").addClass("current"),t.closest("li.toctree-l1").parent().addClass("current"),t.closest("li.toctree-l1").addClass("current"),t.closest("li.toctree-l2").addClass("current"),t.closest("li.toctree-l3").addClass("current"),t.closest("li.toctree-l4").addClass("current"),t.closest("li.toctree-l5").addClass("current"),t[0].scrollIntoView())}catch(n){console.log("Error expanding nav for anchor",n)}},onScroll:function(){this.winScroll=!1;var n=this.win.scrollTop(),e=n+this.winHeight,t=this.navBar.scrollTop()+(n-this.winPosition);n<0||e>this.docHeight||(this.navBar.scrollTop(t),this.winPosition=n)},onResize:function(){this.winResize=!1,this.winHeight=this.win.height(),this.docHeight=$(document).height()},hashChange:function(){this.linkScroll=!0,this.win.one("hashchange",(function(){this.linkScroll=!1}))},toggleCurrent:function(n){var e=n.closest("li");e.siblings("li.current").removeClass("current"),e.siblings().find("li.current").removeClass("current"),e.find("> ul li.current").removeClass("current"),e.toggleClass("current")}},"undefined"!=typeof window&&(window.SphinxRtdTheme={Navigation:n.exports.ThemeNav,StickyNav:n.exports.ThemeNav}),function(){for(var n=0,e=["ms","moz","webkit","o"],t=0;t<e.length&&!window.requestAnimationFrame;++t)window.requestAnimationFrame=window[e[t]+"RequestAnimationFrame"],window.cancelAnimationFrame=window[e[t]+"CancelAnimationFrame"]||window[e[t]+"CancelRequestAnimationFrame"];window.requestAnimationFrame||(window.requestAnimationFrame=function(e,t){var i=(new Date).getTime(),o=Math.max(0,16-(i-n)),r=window.setTimeout((function(){e(i+o)}),o);return n=i+o,r}),window.cancelAnimationFrame||(window.cancelAnimationFrame=function(n){clearTimeout(n)})}()}).call(window)},function(n,e){n.exports=jQuery},function(n,e,t){}]);


--------------------------------------------------------------------------------
/docs/build/html/_static/minus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/minus.png


--------------------------------------------------------------------------------
/docs/build/html/_static/plus.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/_static/plus.png


--------------------------------------------------------------------------------
/docs/build/html/_static/pygments.css:
--------------------------------------------------------------------------------
 1 | pre { line-height: 125%; margin: 0; }
 2 | td.linenos pre { color: #000000; background-color: #f0f0f0; padding-left: 5px; padding-right: 5px; }
 3 | span.linenos { color: #000000; background-color: #f0f0f0; padding-left: 5px; padding-right: 5px; }
 4 | td.linenos pre.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
 5 | span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
 6 | .highlight .hll { background-color: #ffffcc }
 7 | .highlight { background: #eeffcc; }
 8 | .highlight .c { color: #408090; font-style: italic } /* Comment */
 9 | .highlight .err { border: 1px solid #FF0000 } /* Error */
10 | .highlight .k { color: #007020; font-weight: bold } /* Keyword */
11 | .highlight .o { color: #666666 } /* Operator */
12 | .highlight .ch { color: #408090; font-style: italic } /* Comment.Hashbang */
13 | .highlight .cm { color: #408090; font-style: italic } /* Comment.Multiline */
14 | .highlight .cp { color: #007020 } /* Comment.Preproc */
15 | .highlight .cpf { color: #408090; font-style: italic } /* Comment.PreprocFile */
16 | .highlight .c1 { color: #408090; font-style: italic } /* Comment.Single */
17 | .highlight .cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
18 | .highlight .gd { color: #A00000 } /* Generic.Deleted */
19 | .highlight .ge { font-style: italic } /* Generic.Emph */
20 | .highlight .gr { color: #FF0000 } /* Generic.Error */
21 | .highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
22 | .highlight .gi { color: #00A000 } /* Generic.Inserted */
23 | .highlight .go { color: #333333 } /* Generic.Output */
24 | .highlight .gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
25 | .highlight .gs { font-weight: bold } /* Generic.Strong */
26 | .highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
27 | .highlight .gt { color: #0044DD } /* Generic.Traceback */
28 | .highlight .kc { color: #007020; font-weight: bold } /* Keyword.Constant */
29 | .highlight .kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
30 | .highlight .kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
31 | .highlight .kp { color: #007020 } /* Keyword.Pseudo */
32 | .highlight .kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
33 | .highlight .kt { color: #902000 } /* Keyword.Type */
34 | .highlight .m { color: #208050 } /* Literal.Number */
35 | .highlight .s { color: #4070a0 } /* Literal.String */
36 | .highlight .na { color: #4070a0 } /* Name.Attribute */
37 | .highlight .nb { color: #007020 } /* Name.Builtin */
38 | .highlight .nc { color: #0e84b5; font-weight: bold } /* Name.Class */
39 | .highlight .no { color: #60add5 } /* Name.Constant */
40 | .highlight .nd { color: #555555; font-weight: bold } /* Name.Decorator */
41 | .highlight .ni { color: #d55537; font-weight: bold } /* Name.Entity */
42 | .highlight .ne { color: #007020 } /* Name.Exception */
43 | .highlight .nf { color: #06287e } /* Name.Function */
44 | .highlight .nl { color: #002070; font-weight: bold } /* Name.Label */
45 | .highlight .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
46 | .highlight .nt { color: #062873; font-weight: bold } /* Name.Tag */
47 | .highlight .nv { color: #bb60d5 } /* Name.Variable */
48 | .highlight .ow { color: #007020; font-weight: bold } /* Operator.Word */
49 | .highlight .w { color: #bbbbbb } /* Text.Whitespace */
50 | .highlight .mb { color: #208050 } /* Literal.Number.Bin */
51 | .highlight .mf { color: #208050 } /* Literal.Number.Float */
52 | .highlight .mh { color: #208050 } /* Literal.Number.Hex */
53 | .highlight .mi { color: #208050 } /* Literal.Number.Integer */
54 | .highlight .mo { color: #208050 } /* Literal.Number.Oct */
55 | .highlight .sa { color: #4070a0 } /* Literal.String.Affix */
56 | .highlight .sb { color: #4070a0 } /* Literal.String.Backtick */
57 | .highlight .sc { color: #4070a0 } /* Literal.String.Char */
58 | .highlight .dl { color: #4070a0 } /* Literal.String.Delimiter */
59 | .highlight .sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
60 | .highlight .s2 { color: #4070a0 } /* Literal.String.Double */
61 | .highlight .se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
62 | .highlight .sh { color: #4070a0 } /* Literal.String.Heredoc */
63 | .highlight .si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
64 | .highlight .sx { color: #c65d09 } /* Literal.String.Other */
65 | .highlight .sr { color: #235388 } /* Literal.String.Regex */
66 | .highlight .s1 { color: #4070a0 } /* Literal.String.Single */
67 | .highlight .ss { color: #517918 } /* Literal.String.Symbol */
68 | .highlight .bp { color: #007020 } /* Name.Builtin.Pseudo */
69 | .highlight .fm { color: #06287e } /* Name.Function.Magic */
70 | .highlight .vc { color: #bb60d5 } /* Name.Variable.Class */
71 | .highlight .vg { color: #bb60d5 } /* Name.Variable.Global */
72 | .highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */
73 | .highlight .vm { color: #bb60d5 } /* Name.Variable.Magic */
74 | .highlight .il { color: #208050 } /* Literal.Number.Integer.Long */


--------------------------------------------------------------------------------
/docs/build/html/objects.inv:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/docs/build/html/objects.inv


--------------------------------------------------------------------------------
/docs/build/html/search.html:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | <!DOCTYPE html>
  4 | <html class="writer-html5" lang="en" >
  5 | <head>
  6 |   <meta charset="utf-8">
  7 |   
  8 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  9 |   
 10 |   <title>Search &mdash; poly-mpm 1.1 documentation</title>
 11 |   
 12 | 
 13 |   
 14 |   <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
 15 |   <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
 16 |   <link rel="stylesheet" href="_static/graphviz.css" type="text/css" />
 17 | 
 18 |   
 19 |   
 20 |   
 21 |   
 22 | 
 23 |   
 24 |     
 25 |   <!--[if lt IE 9]>
 26 |     <script src="_static/js/html5shiv.min.js"></script>
 27 |   <![endif]-->
 28 |   
 29 |     
 30 |       <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
 31 |         <script src="_static/jquery.js"></script>
 32 |         <script src="_static/underscore.js"></script>
 33 |         <script src="_static/doctools.js"></script>
 34 |         <script src="_static/language_data.js"></script>
 35 |         <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
 36 |     
 37 |     <script type="text/javascript" src="_static/js/theme.js"></script>
 38 | 
 39 |     
 40 |     <script type="text/javascript" src="_static/searchtools.js"></script>
 41 |     <link rel="index" title="Index" href="genindex.html" />
 42 |     <link rel="search" title="Search" href="#" /> 
 43 | </head>
 44 | 
 45 | <body class="wy-body-for-nav">
 46 | 
 47 |    
 48 |   <div class="wy-grid-for-nav">
 49 |     
 50 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
 51 |       <div class="wy-side-scroll">
 52 |         <div class="wy-side-nav-search" >
 53 |           
 54 | 
 55 |           
 56 |             <a href="index.html" class="icon icon-home" alt="Documentation Home"> poly-mpm
 57 |           
 58 | 
 59 |           
 60 |           </a>
 61 | 
 62 |           
 63 |             
 64 |             
 65 |               <div class="version">
 66 |                 1.1
 67 |               </div>
 68 |             
 69 |           
 70 | 
 71 |           
 72 | <div role="search">
 73 |   <form id="rtd-search-form" class="wy-form" action="#" method="get">
 74 |     <input type="text" name="q" placeholder="Search docs" />
 75 |     <input type="hidden" name="check_keywords" value="yes" />
 76 |     <input type="hidden" name="area" value="default" />
 77 |   </form>
 78 | </div>
 79 | 
 80 |           
 81 |         </div>
 82 | 
 83 |         
 84 |         <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
 85 |           
 86 |             
 87 |             
 88 |               
 89 |             
 90 |             
 91 |               <ul>
 92 | <li class="toctree-l1"><a class="reference internal" href="getting_started.html">Getting started</a></li>
 93 | <li class="toctree-l1"><a class="reference internal" href="tutorial.html">Tutorial</a></li>
 94 | <li class="toctree-l1"><a class="reference internal" href="code.html">Documentation</a></li>
 95 | </ul>
 96 | 
 97 |             
 98 |           
 99 |         </div>
100 |         
101 |       </div>
102 |     </nav>
103 | 
104 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
105 | 
106 |       
107 |       <nav class="wy-nav-top" aria-label="top navigation">
108 |         
109 |           <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
110 |           <a href="index.html">poly-mpm</a>
111 |         
112 |       </nav>
113 | 
114 | 
115 |       <div class="wy-nav-content">
116 |         
117 |         <div class="rst-content">
118 |         
119 |           
120 | 
121 | 
122 | 
123 | 
124 | 
125 | 
126 | 
127 | 
128 | 
129 | 
130 | 
131 | 
132 | 
133 | 
134 | 
135 | <div role="navigation" aria-label="breadcrumbs navigation">
136 | 
137 |   <ul class="wy-breadcrumbs">
138 |     
139 |       <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
140 |         
141 |       <li>Search</li>
142 |     
143 |     
144 |       <li class="wy-breadcrumbs-aside">
145 |         
146 |             
147 |         
148 |       </li>
149 |     
150 |   </ul>
151 | 
152 |   
153 |   <hr/>
154 | </div>
155 |           <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
156 |            <div itemprop="articleBody">
157 |             
158 |   <noscript>
159 |   <div id="fallback" class="admonition warning">
160 |     <p class="last">
161 |       Please activate JavaScript to enable the search functionality.
162 |     </p>
163 |   </div>
164 |   </noscript>
165 | 
166 |   
167 |   <div id="search-results">
168 |   
169 |   </div>
170 | 
171 |            </div>
172 |            
173 |           </div>
174 |           <footer>
175 |   
176 | 
177 |   <hr/>
178 | 
179 |   <div role="contentinfo">
180 |     <p>
181 |         
182 |         &copy; Copyright 2018, Benjy Marks
183 | 
184 |     </p>
185 |   </div>
186 |     
187 |     
188 |     
189 |     Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a
190 |     
191 |     <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a>
192 |     
193 |     provided by <a href="https://readthedocs.org">Read the Docs</a>. 
194 | 
195 | </footer>
196 | 
197 |         </div>
198 |       </div>
199 | 
200 |     </section>
201 | 
202 |   </div>
203 |   
204 | 
205 |   <script type="text/javascript">
206 |       jQuery(function () {
207 |           SphinxRtdTheme.Navigation.enable(true);
208 |       });
209 |   </script>
210 | 
211 |   
212 |   
213 |     
214 |   
215 |   <script type="text/javascript">
216 |     jQuery(function() { Search.loadIndex("searchindex.js"); });
217 |   </script>
218 |   
219 |   <script type="text/javascript" id="searchindexloader"></script>
220 |    
221 | 
222 | 
223 | </body>
224 | </html>


--------------------------------------------------------------------------------
/docs/code.rst:
--------------------------------------------------------------------------------
 1 | Documentation
 2 | **************************
 3 | 
 4 | The code is made up of the following modules:
 5 | 
 6 |     * `Main Module`_
 7 |     * `Material Points`_
 8 |     * `Material Point Lists`_
 9 |     * `Grid Operators`_
10 |     * `Constitutive Models`_
11 |     * `Integrators`_
12 |     * `Plotting`_
13 | 
14 | .. _main_module:
15 | 
16 | Main Module
17 | ==========================
18 | 
19 | .. automodule:: MPM
20 |    :members:
21 | 
22 | .. _material_points:
23 | 
24 | Material Points
25 | ==========================
26 | 
27 | .. autoclass:: particle.Particle
28 |    :members:
29 | 
30 | .. _material_point_lists:
31 | 
32 | Material Point Lists
33 | ==========================
34 | 
35 | .. automodule:: mplist
36 |    :members:
37 | 
38 | .. _grid_operators:
39 | 
40 | Grid Operators
41 | ==========================
42 | 
43 | .. automodule:: grid
44 |    :members:
45 | 
46 | .. _constitutive_models:
47 | 
48 | Constitutive Models
49 | ==========================
50 | 
51 | .. automodule:: constit
52 |    :members:
53 | 
54 | .. _pde_integrators:
55 | 
56 | Integrators
57 | ==========================
58 | 
59 | .. automodule:: integrators
60 |   :members:
61 | 
62 | 
63 | .. _custom_plotting:
64 | 
65 | Plotting
66 | ==========================
67 | 
68 | .. automodule:: plotting
69 |    :members:
70 | 


--------------------------------------------------------------------------------
/docs/getting_started.rst:
--------------------------------------------------------------------------------
 1 | .. _getting_started:
 2 | 
 3 | 
 4 | ***************
 5 | Getting started
 6 | ***************
 7 | 
 8 | .. _installation:
 9 | 
10 | Installation
11 | =============================
12 | 
13 | For this to run, you will need the following installed
14 | 
15 |     * Python 2.7+/3+
16 |     * NumPy
17 |     * Matplotlib
18 | 
19 | If running on Mac OS X, I recommend installing the Anaconda_ package. On Ubuntu, just type::
20 |     
21 |     sudo apt-get install python python-numpy python-matplotlib
22 | 
23 | .. _Anaconda: https://www.continuum.io/downloads
24 | 
25 | .. _example:
26 | 
27 | Running an example
28 | =============================
29 | 
30 | Parameters for each simulation are contained in separate files in the inputs directory. For example, to run the simulation described by :file:`inputs/ball.py`, run the following in the terminal::
31 | 
32 |   python MPM.py ball
33 | 
34 | By default, the output files should be contained in :file:`~/Documents/poly-mpm`.
35 | 
36 | 
37 | Loading example data
38 | =============================
39 | 
40 | This is a fairly convoluted process, but is kind of summarised here:
41 | 
42 | .. graphviz::
43 | 
44 |    digraph foo {
45 |       "input file" -> "inititalise" -> "params.Params instance";
46 |    }
47 |    
48 | Any data which is not provided in the input file will be created with a default value in :file:`initialise.py`. This complete data is then passed into the params.Params instance, which is used for the rest of the simulation.


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
1 | <meta http-equiv="refresh" content="0; url=./build/html/index.html" />
2 | 


--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
 1 | .. poly-mpm documentation master file, created by
 2 |    sphinx-quickstart on Tue May  3 11:30:20 2016.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | Welcome to poly-mpm's documentation!
 7 | ====================================
 8 | 
 9 | Contents:
10 | 
11 | .. toctree::
12 |    :maxdepth: 2
13 | 
14 |    getting_started.rst
15 |    tutorial.rst
16 |    code.rst
17 |    
18 | Indices and tables
19 | ==================
20 | 
21 | * :ref:`genindex`
22 | * :ref:`modindex`
23 | * :ref:`search`
24 | 
25 | 


--------------------------------------------------------------------------------
/docs/tutorial.rst:
--------------------------------------------------------------------------------
  1 | .. _tutorial:
  2 | 
  3 | 
  4 | ***************
  5 | Tutorial
  6 | ***************
  7 | 
  8 | 
  9 | Looking at the input file
 10 | =============================
 11 | 
 12 | Load up the file :file:`inputs/ball.py` in your favourite text editor. I like `atom <https://atom.io/>`_.
 13 | 
 14 | The Params class
 15 | =============================
 16 | 
 17 | This contains all of the parameters for controlling a single simulation. Some global information is stored here, such as timestepping and gravity values. Other information is stored in subclasses. A convenience method is also provided for updating gravity, or any other parameters, as many simulations require a slow ramp up in gravity, rather than applying a step function::
 18 | 
 19 |     class Params():
 20 |         def __init__(self,mode):
 21 |             self.dt = 1e-4 # timestep (s)
 22 |             self.savetime = 0.01
 23 |             self.t_f = 5.#100*self.dt # final time (s)
 24 |             self.nt = int(self.t_f/self.dt) # number of timesteps
 25 |             self.max_g = -10. # gravity (ms^-2)
 26 |             self.theta = 0.*pi/180. # slope angle (degrees)
 27 |             self.G = Grid_Params()
 28 |             self.B = Boundary_Params()
 29 |             self.O = Output_Params()
 30 |             self.S = Solid_Params()
 31 | 
 32 |         def update_forces(self):
 33 |             t_c = .5
 34 |             self.g=self.max_g
 35 | 
 36 | The Grid_Params class
 37 | =============================
 38 | 
 39 | This describes the :math:`x` and :math:`y` extents of the grid, as well as their resolution. This is pretty inflexible at the moment, and only allows for regular cartesian grids on a rectangular domain::
 40 | 
 41 |     class Grid_Params():
 42 |         def __init__(self):
 43 |             self.x_m = -1.0 # (m)
 44 |             self.x_M = 1.0 # (m)
 45 |             self.y_m = 0.0 # (m)
 46 |             self.y_M = 2.0 # (m)
 47 |             self.nx = 21 # number of grid edges in x direction
 48 |             self.ny = 21 # number of grid edges in y direction
 49 | 
 50 | The Boundary_Params class
 51 | =============================
 52 | 
 53 | Here all of the boundaries of the grid are defined. For this example, only the bottom of the grid has a boundary. It is also not rough (``self.roughness`` has not been set to  ``True``)::
 54 | 
 55 |     class Boundary_Params():
 56 |         def __init__(self):
 57 |             self.has_bottom = True
 58 | 
 59 | The Solid_Params class
 60 | =============================
 61 | 
 62 | This defines the properties of each material point. The lists ``self.X`` and ``self.Y`` define initial positions of each material point, up to ``self.n`` points in total. The constitutive model to use is defined by ``self.law`` --- this needs to be the same as the class in :file:`constit.py`. In this example, material points are placed onto a set of ``nr`` concentric circles with centre at ``c``, largest radius ``r`` and ``nphi`` material points around the largest circle.::
 63 | 
 64 |     class Solid_Params():
 65 |         def __init__(self):
 66 |             self.X = []
 67 |             self.Y = []
 68 |             self.n = 0
 69 | 
 70 |             self.rho = 1000. # density (kg/m^3)
 71 | 
 72 |     #         self.law = 'elastic'
 73 |             self.law = 'von_mises'
 74 |     #         self.law = 'dp'
 75 | 
 76 |             self.E = 1.e6 # elastic modulus (Pa)
 77 |             self.nu = 0.3 # poisson's ratio
 78 |             self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 79 |             self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 80 | 
 81 |             # for von_mises
 82 |             self.k = self.E/100.
 83 | 
 84 |             # for dp
 85 |             self.s = 5.
 86 |             self.beta = 10.
 87 |             self.mu = 0.5
 88 | 
 89 |             nr = 20 # particles in radial direction
 90 |             nphi = 50 # particles around circumference
 91 |             r = 0.3 # radius
 92 |             c = [0.,1.] # centre
 93 | 
 94 |             for i in linspace(0,r,nr):
 95 |                 dnphi = around(nphi*i/r) # number in this ring
 96 |                 for j in linspace(0,(1.-1./(dnphi))*2*pi,dnphi):
 97 |                     self.X.append(c[0]+i*sin(j))
 98 |                     self.Y.append(c[1]+i*cos(j))
 99 |                     self.n += 1
100 |             self.A = pi*0.2**2/self.n # area (m^2)
101 | 
102 | The Output_Params class
103 | =============================
104 | 
105 | This class defines what should be output from the simulation. Here, the continuum values and material point values are both show, using custom sizes for the respective figures.::
106 | 
107 |     class Output_Params():
108 |         def __init__(self):
109 |             self.continuum_fig_size = [10,6]
110 |             self.mp_fig_size = [10,10]
111 |             self.plot_continuum = True
112 |             self.plot_material_points = True
113 | 


--------------------------------------------------------------------------------
/inputs/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__init__.py


--------------------------------------------------------------------------------
/inputs/__pycache__/__init__.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/__init__.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/__init__.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/__init__.cpython-35.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/ball.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/ball.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/bi_conveyor.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/bi_conveyor.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/bi_dam_break.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/bi_dam_break.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/bi_dam_break.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/bi_dam_break.cpython-35.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/bi_seg_test.cpython-34 (vlan-2689-10-17-109-133.staff.wireless.sydney.edu.au's conflicted copy 2017-11-15).pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/bi_seg_test.cpython-34 (vlan-2689-10-17-109-133.staff.wireless.sydney.edu.au's conflicted copy 2017-11-15).pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/bi_seg_test.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/bi_seg_test.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/bi_seg_test.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/bi_seg_test.cpython-35.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/dam_break.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/dam_break.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/dam_break.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/dam_break.cpython-35.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/dp_rate_unit_test.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/dp_rate_unit_test.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/dp_unit_test.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/dp_unit_test.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/francois.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/francois.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/poly_avalanche.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/poly_avalanche.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/poly_avalanche.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/poly_avalanche.cpython-35.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/poly_seg_test.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/poly_seg_test.cpython-35.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/pouliquen_unit_test.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/pouliquen_unit_test.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/seg_unit_test.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/seg_unit_test.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/silo.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/silo.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/slope_stab.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/slope_stab.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/tri_seg_test.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/tri_seg_test.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/tunnel.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/tunnel.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/vicky.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/vicky.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/vicky.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/vicky.cpython-35.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/vicky_latest.cpython-35.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/vicky_latest.cpython-35.pyc


--------------------------------------------------------------------------------
/inputs/__pycache__/vm_unit_test.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/benjym/poly-mpm/fad5402f82494b17e74f9375a1e9269e29f02aab/inputs/__pycache__/vm_unit_test.cpython-34.pyc


--------------------------------------------------------------------------------
/inputs/anisotropy.py:
--------------------------------------------------------------------------------
  1 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp,linspace
  2 | from numpy import random, cos, sin, ceil, around, tile, repeat
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,mode):
  7 |         self.dt = 1e-3 # timestep (s)
  8 |         self.t = 0. # physical time (s)
  9 |         self.tstep = 0
 10 |         self.savetime = self.dt
 11 |         self.t_f = 0.5#100*self.dt # final time (s)
 12 |         self.nt = int(self.t_f/self.dt) # number of timesteps
 13 |         self.save = 0 # save counter
 14 |         self.M_tol = 1e-10 # very small mass (kg)
 15 |         self.max_g = 0. # gravity (ms^-2)
 16 |         self.max_q = 0.
 17 |         self.update_forces()
 18 |         self.theta = 0.*pi/180. # slope angle (degrees)
 19 |         self.thickness = 1. # (m) into page
 20 |         self.G = Grid_Params()
 21 |         self.B = Boundary_Params()
 22 |         self.O = Output_Params(self.nt)
 23 |         self.S = Solid_Params(self.G)
 24 |         self.F = Fluid_Params()
 25 |         self.R = Fluid_Params()
 26 |         self.has_yielded = False
 27 |         self.damping = False
 28 |         self.mode = mode
 29 | 
 30 |     def update_forces(self):
 31 |         t_c = .1
 32 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 33 | #        self.g=self.max_g
 34 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 35 | 
 36 | class Grid_Params():
 37 |     def __init__(self):
 38 |         self.scale = 20 # grid points per m
 39 |         self.x_m = 0.0 # (m)
 40 |         self.x_M = 2.0 # (m)
 41 |         self.y_m = 0.0 # (m)
 42 |         self.y_M = 2.0 # (m)
 43 |         self.nx = int(self.x_M-self.x_m)*self.scale+1
 44 |         self.ny = int(self.y_M-self.y_m)*self.scale/2+1
 45 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 46 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 47 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 48 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 49 |         
 50 | class Boundary_Params():
 51 |     def __init__(self):
 52 |         self.wall = False
 53 |         self.has_top = False
 54 |         self.has_bottom = False
 55 |         self.has_right = False
 56 |         self.has_left = False
 57 |         self.outlet_left = False
 58 |         self.force_boundaries = True
 59 |         self.vertical_force = False
 60 |         self.horizontal_force = False
 61 |         self.roughness = False
 62 | 
 63 | class Solid_Params():
 64 |     def __init__(self,G):
 65 |         self.x = (G.nx-1)*2 # particles in x direction
 66 |         self.y = (G.nx-1)*2 # particles in y direction
 67 |         self.X = []
 68 |         self.Y = []
 69 |         self.n = 0
 70 | 
 71 |         self.law = 'elastic'
 72 |         self.rho = 1000. # density (kg/m^3)
 73 |         
 74 |         self.E = 1.e7 # elastic modulus (Pa)
 75 |         self.nu = 0. # poisson's ratio
 76 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 77 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 78 | 
 79 |         gap = G.dx/4.
 80 |         xp = linspace(G.x_m+gap,G.x_M-gap,self.x)
 81 |         yp = linspace(G.y_m+gap,G.y_M-gap,self.y)
 82 |         X = tile(xp,self.y)
 83 |         Y = repeat(yp,self.x)
 84 |         for i in xrange(self.x*self.y):
 85 |             self.X.append(X[i])
 86 |             self.Y.append(Y[i])
 87 |             self.n += 1
 88 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 89 |         
 90 |         
 91 | class Output_Params():
 92 |     def __init__(self,nt):
 93 |         self.measure_energy = True
 94 |         self.plot_continuum = False
 95 |         self.plot_material_points = False
 96 |         self.measure_stiffness = False
 97 |         self.check_positions = False
 98 |         self.plot_fluid = False
 99 |         self.plot_gamma_dot = True
100 |         self.energy = zeros((nt+1,4)) # energy
101 |         
102 |     def measure_E(self,P,L):
103 |         print 'Measuring macro and micro stress/strain for each material point... '
104 |         for i in xrange(P.S.n):
105 |             original_position = array((P.S.X[i],P.S.Y[i],0))
106 |             macro_strain = (original_position-L.S[i].x)/array((P.S.L,P.S.W,1.)) #original_position
107 |             macro_stress = P.max_conf#/(P.S.L*P.S.W)
108 |             print 'From macroscopic stress/strain:'
109 |             print macro_stress/macro_strain/P.S.E
110 |             print 'From microscopic stress/strain:'
111 |             print L.S[i].dstress/L.S[i].dstrain/P.S.E
112 | 
113 |             
114 | class Fluid_Params():
115 |     def __init__(self):
116 |         self.n = 0
117 | 
118 |         
119 | class Rigid_Params():
120 |     def __init__(self):
121 |         self.n = 0
122 | 
123 | 


--------------------------------------------------------------------------------
/inputs/avalanche.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,mode):
  7 |         self.dt = 1e-4 # timestep (s)
  8 |         self.savetime = 0.1
  9 |         self.t_f = 1000.0 # 100*self.dt # final time (s)
 10 |         self.max_g = -10. # gravity (ms^-2)
 11 |         self.max_q = 0.
 12 |         self.theta = 45.*pi/180. # slope angle (degrees)
 13 |         self.G = Grid_Params()
 14 |         self.B = Boundary_Params()
 15 |         self.O = Output_Params()#self.nt)
 16 |         self.S = [Solid_Params(self.G)]
 17 | 
 18 |     def update_forces(self):
 19 |         t_c = 0.5
 20 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 21 | #         self.g = self.max_g
 22 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 23 | 
 24 | class Grid_Params():
 25 |     def __init__(self):
 26 |         self.x_m = 0.0 # (m)
 27 |         self.x_M = 4.0 # (m)
 28 |         self.y_m = 0.0 # (m)
 29 |         self.y_M = 1.0 # (m)
 30 |         self.nx = 21
 31 |         self.ny = 6
 32 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 33 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 34 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 35 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 36 |         self.thickness = 1. # (m)
 37 | 
 38 | class Boundary_Params():
 39 |     def __init__(self):
 40 |         self.wall = True
 41 |         self.has_bottom = True
 42 |         self.no_slip_bottom = True
 43 |         self.cyclic_lr = True
 44 | 
 45 | class Solid_Params():
 46 |     def __init__(self,G):
 47 |         self.X = []
 48 |         self.Y = []
 49 |         self.n = 0
 50 |         self.rho = 1000. # density (kg/m^3)
 51 | 
 52 | #         self.law = 'pouliquen'
 53 | #         self.mu_s = 0.32
 54 | #         self.mu_2 = 0.6
 55 | #         self.I_0 = 0.4
 56 | #         self.K = 1e6
 57 | #         self.mu_v = 0.
 58 | 
 59 |         self.law = 'viscous'
 60 |         self.mu_s = 1e3
 61 |         self.K = 1e6
 62 |         self.mu_v = 0
 63 | 
 64 | #         self.law = 'bingham'
 65 | #         self.mu_s = 1e2 # shear viscosity
 66 | #         self.tau_0 = 100. # yield stress
 67 | #         self.mu_0 = 1e3*self.mu_s # much steeper viscosity to mimic very rigid part
 68 | #         self.gamma_c = self.tau_0/(self.mu_0 - self.mu_s)
 69 | #         self.K = 1e7 # bulk modulus
 70 | #         self.mu_v = 0. #1e3
 71 | 
 72 |         self.inlet_rate = 0.1
 73 |         filling_fraction = 0.5
 74 |         self.pts_per_cell = 3
 75 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 76 |         self.y = int(round((G.ny-1)*self.pts_per_cell*filling_fraction)) # particles in y direction
 77 |         self.gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 78 |         self.xp = linspace(3.*(G.x_M-G.x_m)/4.,G.x_M-self.gap[0],self.x)
 79 |         self.yp = linspace(G.y_m+self.gap[1],self.gap[1]+filling_fraction*(G.y_M-2*self.gap[1]),self.y)
 80 |         X = tile(self.xp,self.y)
 81 |         Y = repeat(self.yp,self.x)
 82 |         for i in range(int(self.x*self.y)):
 83 |             self.X.append(X[i])
 84 |             self.Y.append(Y[i])
 85 |             self.n += 1
 86 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n*filling_fraction # area (m^2)
 87 | #         self.A = 0.002
 88 | #         self.initial_v = array([-0.0001,0,0])
 89 | 
 90 | class Output_Params():
 91 |     def __init__(self):
 92 |         self.continuum_fig_size = [18,6]
 93 |         self.mp_fig_size = [6,6]
 94 | 
 95 |         def after_every_nth_timestep(self,P,G,L,plot):
 96 |         plot.draw_continuum(G,P)
 97 |         plot.draw_material_points(L,P,G)
 98 |         # plot.draw_gsd_mp(L,P,G)
 99 |         # plot.draw_gsd_grid(L,P,G)
100 |         # plot.draw_continuum(G,P)
101 |         # plot.draw_material_points(L,P,G)
102 |         # plot.draw_gamma_dot(L,P,G)
103 |         # P.O.measure_E(L,P,G)
104 |         # plot.save_u(L,P,G)
105 |         # plot.save_s_bar(L,P,G)
106 |         # plot.save_density(L,P,G)
107 |         # plot.save_phi_MP(L,P,G)
108 | 
109 |     def final_graphs(self,P,G,L,plot):
110 |         plot.draw_continuum(G,P)
111 |         plot.draw_material_points(L,P,G,'final')
112 |         # P.O.measure_E(L,P,G)
113 |         # plot.draw_energy(P)
114 |         # plot.draw_gsd_mp(L,P,G)
115 |         # plot.draw_gsd_grid(L,P,G)
116 |         # plot.save_u(L,P,G)
117 |         # plot.save_s_bar(L,P,G)
118 |         # plot.save_density(L,P,G)
119 |         # plot.save_phi_MP(L,P,G)
120 |         # P.O.draw_p_q(P,G,L,plot,P.tstep)
121 |         # P.O.draw_mu(P,G,L,plot,P.tstep)
122 | 


--------------------------------------------------------------------------------
/inputs/ball.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp,linspace
  3 | from numpy import random, cos, sin, ceil, around
  4 | import matplotlib.pyplot as plt
  5 | 
  6 | class Params():
  7 |     def __init__(self,mode):
  8 |         self.dt = 1e-3 # timestep (s)
  9 |         self.savetime = 0.1
 10 |         self.t_f = 5.#100*self.dt # final time (s)
 11 |         self.nt = int(self.t_f/self.dt) # number of timesteps
 12 |         self.max_g = -10. # gravity (ms^-2)
 13 |         self.theta = 0.*pi/180. # slope angle (degrees)
 14 |         self.G = Grid_Params()
 15 |         self.B = Boundary_Params()
 16 |         self.O = Output_Params()
 17 |         self.S = [Solid_Params()]
 18 | 
 19 |     def update_forces(self):
 20 |         self.g=self.max_g
 21 | 
 22 | class Grid_Params():
 23 |     def __init__(self):
 24 |         self.x_m = -1.0 # (m)
 25 |         self.x_M = 1.0 # (m)
 26 |         self.y_m = 0.0 # (m)
 27 |         self.y_M = 2.0 # (m)
 28 |         self.nx = 6 # number of grid edges in x direction
 29 |         self.ny = 6 # number of grid edges in y direction
 30 | 
 31 | class Boundary_Params():
 32 |     def __init__(self):
 33 |         self.has_bottom = True
 34 | 
 35 | class Solid_Params():
 36 |     def __init__(self):
 37 |         self.X = []
 38 |         self.Y = []
 39 |         self.n = 0
 40 | 
 41 |         self.rho = 1000. # density (kg/m^3)
 42 | 
 43 |         self.law = 'elastic'
 44 |         # self.law = 'von_mises'
 45 | #         self.law = 'dp'
 46 | 
 47 |         self.E = 1.e6 # elastic modulus (Pa)
 48 |         self.nu = 0.3 # poisson's ratio
 49 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 50 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 51 | 
 52 |         # for von_mises
 53 |         self.k = self.E/100.
 54 | 
 55 |         # for dp
 56 |         self.s = 5.
 57 |         self.beta = 10.
 58 |         self.mu = 0.5
 59 | 
 60 |         nr = 20 # particles in radial direction
 61 |         nphi = 50 # particles around circumference
 62 |         r = 0.3 # radius
 63 |         c = [0.,1.0] # centre
 64 | 
 65 |         for i in linspace(0,r,nr):
 66 |             dnphi = int(around(nphi*i/r)) # number in this ring
 67 |             if dnphi > 0:
 68 |                 for j in linspace(0,(1.-1./(dnphi))*2*pi,dnphi):
 69 |                     self.X.append(c[0]+i*sin(j))
 70 |                     self.Y.append(c[1]+i*cos(j))
 71 |                     self.n += 1
 72 |         self.A = pi*r**2/self.n # area (m^2)
 73 | 
 74 | 
 75 | class Output_Params():
 76 |     def __init__(self):
 77 |         self.continuum_fig_size = [10,6]
 78 |         self.mp_fig_size = [10,10]
 79 | 
 80 |     def after_every_nth_timestep(self,P,G,L,plot):
 81 |         plot.draw_continuum(G,P)
 82 |         plot.draw_material_points(L,P,G)
 83 |         # plot.draw_gsd_mp(L,P,G)
 84 |         # plot.draw_gsd_grid(L,P,G)
 85 |         # plot.draw_continuum(G,P)
 86 |         # plot.draw_material_points(L,P,G)
 87 |         # plot.draw_gamma_dot(L,P,G)
 88 |         # P.O.measure_E(L,P,G)
 89 |         # plot.save_u(L,P,G)
 90 |         # plot.save_s_bar(L,P,G)
 91 |         # plot.save_density(L,P,G)
 92 |         # plot.save_phi_MP(L,P,G)
 93 | 
 94 |     def final_graphs(self,P,G,L,plot):
 95 |         plot.draw_continuum(G,P)
 96 |         plot.draw_material_points(L,P,G,'final')
 97 |         # P.O.measure_E(L,P,G)
 98 |         # plot.draw_energy(P)
 99 |         # plot.draw_gsd_mp(L,P,G)
100 |         # plot.draw_gsd_grid(L,P,G)
101 |         # plot.save_u(L,P,G)
102 |         # plot.save_s_bar(L,P,G)
103 |         # plot.save_density(L,P,G)
104 |         # plot.save_phi_MP(L,P,G)
105 |         # P.O.draw_p_q(P,G,L,plot,P.tstep)
106 |         # P.O.draw_mu(P,G,L,plot,P.tstep)
107 | 


--------------------------------------------------------------------------------
/inputs/bi_conveyor.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,mode):
  7 |         self.dt = 1e-5 # timestep (s)
  8 |         self.savetime = 1e2*self.dt
  9 |         self.t_f = 10.0 #100.0 # 3*self.dt # final time (s)
 10 |         self.max_g = -9.81 # gravity (ms^-2)
 11 |         self.max_q = 0.
 12 |         self.theta = 0.*pi/180. # slope angle (degrees)
 13 |         self.G = Grid_Params()
 14 |         self.B = Boundary_Params()
 15 |         self.O = Output_Params()#self.nt)
 16 |         self.S = [Solid_Params(self.G,self),]
 17 |         self.segregate_grid = True
 18 |         self.c = 1e-2 # inter-particle drag coefficient
 19 |         self.D = 0. # segregation diffusion coefficient
 20 |         self.supername = 'im/conveyor/'
 21 |         self.v_0 = 0.2 # m/s velocity at belt
 22 |         self.pressure = 'lithostatic'
 23 |         self.smooth_grad2 = True
 24 | 
 25 |     def update_forces(self):
 26 |         t_c = 0.05
 27 |         # self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 28 | #         self.g = self.max_g
 29 | 
 30 | class Grid_Params():
 31 |     def __init__(self):
 32 |         self.x_m = 0.0 # (m)
 33 |         self.x_M = 0.5 # (m)
 34 |         self.y_m = 0.0 # (m)
 35 |         self.y_M = 0.25 # (m)
 36 |         self.ny = 16
 37 |         self.nx = (self.ny-1)*2 + 1
 38 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 39 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 40 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 41 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 42 |         self.s = array([0.005,0.01]) # s coordinate
 43 |         self.ds = self.s[1]-self.s[0]
 44 |         self.ns = len(self.s)
 45 | 
 46 |         self.top_gap = 0.5*(self.y_M - self.y_m)
 47 | 
 48 | class Boundary_Params():
 49 |     def __init__(self):
 50 |         self.has_bottom = True
 51 |         self.has_right = True
 52 |         self.has_left = True
 53 |         self.conveyor = True
 54 | 
 55 | class Solid_Params():
 56 |     def __init__(self,G,P):
 57 |         self.X = []
 58 |         self.Y = []
 59 |         self.n = 0
 60 |         self.rho = 2700. # density (kg/m^3)
 61 |         self.packing = 0.6 # packing fraction
 62 |         self.rho_s = self.rho/self.packing # solid density
 63 |         self.phi = ones([G.ns])/float(G.ns)
 64 |         self.law = 'pouliquen'
 65 |         self.mu_0 = tan(deg2rad(20.9)) #0.3
 66 |         self.mu_1 = tan(deg2rad(32.76))
 67 |         self.delta_mu = self.mu_1 - self.mu_0
 68 |         self.I_0 = 0.279
 69 | 
 70 |         self.mu_v = 0
 71 |         self.E = 1e4
 72 |         self.nu = 0.4 # poissons ratio
 73 |         self.K = self.E/(3.*(1.-2.*self.nu))
 74 |         self.G = self.E/(2.*(1.+self.nu))
 75 |         self.eta_max = 100.*self.rho*sqrt(-P.max_g*(G.y_M-G.y_m)**3)
 76 | 
 77 |         self.pts_per_cell = 3
 78 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 79 |         self.y = (G.ny-1)//2*self.pts_per_cell # particles in y direction
 80 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 81 | 
 82 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 83 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1] - G.top_gap,self.y)
 84 |         X = tile(xp,self.y)
 85 |         Y = repeat(yp,self.x)
 86 |         for i in range(self.x*self.y):
 87 |             self.X.append(X[i])
 88 |             self.Y.append(Y[i])
 89 |             self.n += 1
 90 |         self.A = G.dx*G.dy/self.pts_per_cell**2 # (m^2)
 91 | 
 92 | #         elastic_wave_speed = sqrt(self.K/(self.A*self.rho*1.))
 93 |         elastic_wave_speed = sqrt(self.K/self.rho)
 94 |         distance = minimum(G.dx,G.dy)
 95 |         critical_time = distance/elastic_wave_speed
 96 |         critical_time /= 2. # safety
 97 |         if critical_time < P.dt:
 98 | #             P.dt = critical_time
 99 |             print('WARNING: timestep should be dt = ' + str(critical_time))
100 | 
101 | class Output_Params():
102 |     def __init__(self):
103 |         self.plot_continuum = True
104 |         # self.plot_material_points = True
105 |         # self.plot_gsd_grid = True
106 |         self.continuum_fig_size = [18,6]
107 |         self.mp_fig_size = [18,4]
108 | 


--------------------------------------------------------------------------------
/inputs/bi_double_insets.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,args):
  7 |         self.dt = 1e-4 # timestep (s)
  8 |         self.savetime = 1e-1 #1e1*self.dt#0.01
  9 |         self.t_f = 100.0 #100.0 # 3*self.dt # final time (s)
 10 |         self.max_g = -9.81 # gravity (ms^-2)
 11 |         self.max_q = 0.
 12 |         self.theta = 90.*pi/180. # slope angle (radians)
 13 |         self.G = Grid_Params(self,args)
 14 |         self.B = Boundary_Params()
 15 |         self.O = Output_Params(self.G)#self.nt)
 16 |         self.S = [Solid_Params(self.G,self,args),]
 17 |         self.segregate_grid = True
 18 |         self.c = 1e-3 # inter-particle drag coefficient
 19 |         # self.D = 1e-3 # segregation diffusion coefficient
 20 |         self.l = 10.
 21 |         # self.supername = 'im/drum/wall_mu_' + str(self.B.wall_mu) + '/ny_' + str(self.G.ny) + '/Fr_' + str(self.Fr) + '/'
 22 |         self.supername = 'im/double_inset/ny_' + str(self.G.ny) + '/c_' + str(self.c) + '/l_' + str(self.l) + '/'
 23 |         self.pressure = 'lithostatic'
 24 |         self.smooth_gamma_dot = False # smooth calculation of gamma_dot
 25 |         self.time_stepping = 'dynamic' # dynamic or static time steps
 26 |         self.normalise_phi = True
 27 |         self.CFL = 0.2 # stability criteria for determining timstep
 28 |         print(self.supername)
 29 | 
 30 |     def update_forces(self):
 31 |         self.g = self.max_g
 32 | 
 33 | class Grid_Params():
 34 |     def __init__(self,P,args):
 35 |         self.y_m = 0.0 # (m)
 36 |         self.y_M = 10.0 # (m)
 37 |         self.x_m = 0.0 # (m)
 38 |         self.x_M = 10.0 # (m)
 39 |         self.ny = int(args[1])
 40 |         self.nx = self.ny
 41 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 42 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 43 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 44 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 45 |         # self.s = array([0.5,1.0]) # s coordinate
 46 | 
 47 |         self.R = 10.#float(args[2])
 48 |         self.s_M = 0.003 # 3mm beads, following https://journals.aps.org/pre/pdf/10.1103/PhysRevE.62.961
 49 |         # self.s_m = 0.1
 50 |         self.s_m = self.s_M/self.R
 51 |         self.ns = 5
 52 |         # self.s = array([self.s_m,self.s_M])
 53 |         s_edges = linspace(self.s_m,self.s_M,self.ns+1)
 54 |         self.s = (s_edges[1:] + s_edges[:-1])/2.
 55 |         self.ds = self.s[1]-self.s[0]
 56 | 
 57 | class Boundary_Params():
 58 |     def __init__(self):
 59 |         self.has_bottom = True
 60 |         self.has_top = True
 61 |         self.cyclic_lr = True
 62 |         self.two_walls = True
 63 | 
 64 | class Solid_Params():
 65 |     def __init__(self,G,P,args):
 66 |         self.X = []
 67 |         self.Y = []
 68 |         self.n = 0
 69 |         self.rho = 2700. # density (kg/m^3)
 70 |         self.packing = 0.6 # packing fraction
 71 |         self.rho_s = self.rho/self.packing # solid density
 72 |         self.PHI = []
 73 | 
 74 |         self.law = 'pouliquen'
 75 |         # self.law = 'ken_simple'
 76 |         self.mu_0 = tan(deg2rad(20.9)) #0.3
 77 |         self.mu_1 = tan(deg2rad(32.76))
 78 |         self.delta_mu = self.mu_1 - self.mu_0
 79 |         self.I_0 = 0.279
 80 |         self.eta_max = 10.*self.rho*sqrt(-P.max_g*(G.y_M-G.y_m)**3)
 81 | 
 82 |         self.E = 1e7
 83 |         self.nu = 0.4 # poissons ratio
 84 |         self.K = self.E/(3*(1-2*self.nu))
 85 |         self.G = self.E/(2*(1+self.nu))
 86 | 
 87 |         self.pts_per_cell = 3
 88 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 89 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 90 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 91 | 
 92 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 93 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
 94 |         X = tile(xp,self.y)
 95 |         Y = repeat(yp,self.x)
 96 |         for i in range(self.x*self.y):
 97 |             self.X.append(X[i])
 98 |             self.Y.append(Y[i])
 99 |             self.n += 1
100 |         self.A = (G.y_M - G.y_m)*(G.x_M - G.x_m)/self.n # area (m^2)
101 | 
102 |     def critical_time(self,P):
103 |         distance = minimum(P.G.dx,P.G.dy)
104 |         t_ela = distance/sqrt(self.K/self.rho) # elasticity
105 |         t_diff = distance**2/self.eta_max*self.rho # momentum diffusivity/viscosity
106 |         return minimum(t_diff,t_ela)
107 | 
108 | class Output_Params():
109 |     def __init__(self,G):
110 |         self.plot_continuum = True
111 |         self.plot_material_points = True
112 |         self.plot_gsd_mp = True
113 |         # self.plot_gsd_grid = True
114 |         self.save_s_bar = True
115 |         self.save_u = True
116 |         self.save_density = True
117 |         self.save_phi_MP = True
118 |         self.continuum_fig_size = [24,8]
119 |         self.mp_fig_size = [18,4]
120 |         # self.save_fields = [[G.s_bar,'s_bar'],[G.m/G.V,'density'],[G.q[:,0]/G.m,'u'],[G.q[:,1]/G.m],'v']
121 | 


--------------------------------------------------------------------------------
/inputs/bi_drum.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,args):
  7 |         self.dt = 1e-4 # timestep (s)
  8 |         self.savetime = 1e-1 #1e1*self.dt#0.01
  9 |         self.t_f = 10.0 #100.0 # 3*self.dt # final time (s)
 10 |         self.max_g = -9.81 # gravity (ms^-2)
 11 |         self.max_q = 0.
 12 |         self.theta = 0*pi/180. # slope angle (radians)
 13 |         self.Fr = float(args[2]) # Froude number
 14 |         self.r = 0.1 # radius of drum
 15 |         self.G = Grid_Params(self,args)
 16 |         self.B = Boundary_Params()
 17 |         self.O = Output_Params()#self.nt)
 18 |         self.S = [Solid_Params(self.G,self,args),]
 19 |         self.S.append(Drum_Params(self.G,self))
 20 |         self.segregate_grid = True
 21 |         self.c = 1e-6 # inter-particle drag coefficient
 22 |         self.D = 0. # segregation diffusion coefficient
 23 |         self.supername = 'im/drum/ny_' + str(self.G.ny) + '/'
 24 |         self.pressure = 'lithostatic'
 25 |         self.smooth_gamma_dot = False # smooth calculation of gamma_dot
 26 |         self.smooth_grad2 = True # smooth the gradient of the shear strain rate
 27 |         self.intruder_v = array([0.,0.,0.])
 28 |         print(self.supername)
 29 | 
 30 |     def update_forces(self):
 31 |         t_c = sqrt(4*pi**2*self.r/(abs(self.max_g)*self.Fr)) # rotation period
 32 |         self.theta = (self.t/t_c)*2.*pi # slope angle (radians)
 33 |         self.g = self.max_g
 34 | 
 35 | class Grid_Params():
 36 |     def __init__(self,P,args):
 37 |         self.y_m = -P.r*1.1 # (m)
 38 |         self.y_M = P.r*1.1 # (m)
 39 |         self.x_m = -P.r*1.1 # (m)
 40 |         self.x_M = P.r*1.1 # (m)
 41 |         self.ny = int(args[1])
 42 |         self.nx = self.ny
 43 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 44 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 45 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 46 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 47 |         # self.s = array([0.5,1.0]) # s coordinate
 48 | 
 49 |         self.R = 10.#float(args[2])
 50 |         self.s_M = 0.003 # 3mm beads, following https://journals.aps.org/pre/pdf/10.1103/PhysRevE.62.961
 51 |         # self.s_m = 0.1
 52 |         self.s_m = self.s_M/self.R
 53 |         self.ns = 2
 54 |         self.s = array([self.s_m,self.s_M])
 55 |         # s_edges = linspace(self.s_m,self.s_M,self.ns+1)
 56 |         # self.s = (s_edges[1:] + s_edges[:-1])/2.
 57 |         self.ds = self.s[1]-self.s[0]
 58 | 
 59 | class Boundary_Params():
 60 |     def __init__(self):
 61 |         pass
 62 |         self.has_bottom = True
 63 |         self.has_top = True
 64 |         self.has_right = True
 65 |         self.has_left = True
 66 |         self.roughness = True
 67 | 
 68 | class Solid_Params():
 69 |     def __init__(self,G,P,args):
 70 |         self.X = []
 71 |         self.Y = []
 72 |         self.n = 0
 73 |         self.rho = 2700. # density (kg/m^3)
 74 |         self.packing = 0.6 # packing fraction
 75 |         self.rho_s = self.rho/self.packing # solid density
 76 |         self.PHI = []
 77 | 
 78 |         self.law = 'pouliquen'
 79 |         self.mu_0 = tan(deg2rad(20.9)) #0.3
 80 |         self.mu_1 = tan(deg2rad(32.76))
 81 |         self.delta_mu = self.mu_1 - self.mu_0
 82 |         self.I_0 = 0.279
 83 |         self.eta_max = 100.*self.rho*sqrt(-P.max_g*(G.y_M-G.y_m)**3)
 84 | 
 85 |         self.E = 1e6
 86 |         self.nu = 0.4 # poissons ratio
 87 |         self.K = self.E/(3*(1-2*self.nu))
 88 |         self.G = self.E/(2*(1+self.nu))
 89 | 
 90 |         c = [0.,0.] # centre
 91 |         fill = 0.5 # filling fraction
 92 | 
 93 |         self.pts_per_cell = 3
 94 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 95 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 96 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 97 | 
 98 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 99 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
100 |         X = tile(xp,self.y)
101 |         Y = repeat(yp,self.x)
102 |         for i in range(self.x*self.y):
103 |             if (X[i] - c[0])**2 + (Y[i] - c[1])**2 < P.r**2:
104 |                 if ((Y[i]-c[1])/P.r + 1.)/2. < fill:
105 |                     self.X.append(X[i])
106 |                     self.Y.append(Y[i])
107 |                     self.n += 1
108 | 
109 |         self.A = pi*P.r**2/self.n # area (m^2)
110 | 
111 | class Drum_Params():
112 |     def __init__(self,G,P):
113 |         self.X = []
114 |         self.Y = []
115 |         self.n = 0
116 |         self.rho = 2700.
117 | 
118 |         self.law = 'rigid'
119 |         self.E = 1e7 # young's modulus (Pa)
120 |         self.nu = 0.4 # poisson's ratio (-)
121 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
122 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
123 | 
124 |         c = [0.,0.] # centre
125 | 
126 |         self.pts_per_cell = 3
127 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
128 |         self.y = (G.ny-2)*self.pts_per_cell # particles in y direction
129 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
130 | 
131 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
132 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
133 |         X = tile(xp,self.y)
134 |         Y = repeat(yp,self.x)
135 | 
136 |         for i in range(self.x*self.y):
137 |             if (X[i]-c[0])**2 + (Y[i]-c[1])**2 >= P.r**2:
138 |                 self.X.append(X[i])
139 |                 self.Y.append(Y[i])
140 |                 self.n += 1
141 | 
142 |         self.A = G.dy*G.dx/self.pts_per_cell**2 # FIXME
143 | 
144 | 
145 | class Output_Params():
146 |     def __init__(self):
147 |         self.plot_continuum = True
148 |         self.plot_material_points = True
149 |         # self.plot_gsd_grid = True
150 |         self.save_s_bar = True
151 |         self.save_u = True
152 |         self.continuum_fig_size = [24,8]
153 |         self.mp_fig_size = [18,4]
154 | 


--------------------------------------------------------------------------------
/inputs/bi_vertical_chute.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,args):
  7 |         self.dt = 1e-8#5e-8 # timestep (s)
  8 |         self.savetime = 1e-3 # (s)
  9 |         self.t_f = 5.0 #100.0 # 3*self.dt # final time (s)
 10 |         self.max_g = -1#9.81 # gravity (ms^-2)
 11 |         self.theta = -deg2rad(90.) # slope angle (degrees)
 12 |         self.pressure = 'compression'
 13 |         self.initial_pressure = 7.0 # 7 Pa - same as Fan and Hill (ish)
 14 |         self.initial_flow = 'steady_poiseulle'
 15 | 
 16 |         self.segregate_grid = True
 17 |         self.c = 1e-3 # inter-particle drag coefficient
 18 |         # self.D = 0.#1e-2 # segregation diffusion coefficient
 19 |         self.l = 10. # number of particle diameters for seg diffusion coeff
 20 | 
 21 |         self.G = Grid_Params(args)
 22 |         self.B = Boundary_Params()
 23 |         self.O = Output_Params(self)#self.nt)
 24 |         self.S = [Solid_Params(self.G,self),]
 25 | 
 26 |         self.supername = 'im/vert_chute/lin/ny_' + str(self.G.ny) + '/ns_' + str(self.G.ns) + '/c_' + str(self.c) + '/l_' + str(self.l) + '/'
 27 |         self.smooth_gamma_dot = False
 28 |         self.time_stepping = 'dynamic' # dynamic or static time steps
 29 |         self.CFL = 0.2
 30 | 
 31 |         print('Saving to ' + self.supername)
 32 | 
 33 |     def update_forces(self):
 34 |         self.g = self.max_g
 35 | 
 36 | class Grid_Params():
 37 |     def __init__(self,args):
 38 |         self.ny = int(args[2])
 39 |         self.y_m = 0.0 # (m)
 40 |         self.y_M = 0.05 # (m)
 41 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 42 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 43 | 
 44 |         self.nx = 2
 45 |         self.x_m = 0.0 # (m)
 46 |         self.x_M = 1.0#self.dy*(self.nx-1) + self.x_m # (m)
 47 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 48 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 49 | 
 50 |         # self.R = 10.#float(args[3])
 51 |         self.s_M = 3e-3 # 3 mm
 52 |         self.s_m = 2e-3 #self.s_M/self.R
 53 |         self.ns = int(args[1])
 54 |         s_edges = linspace(self.s_m,self.s_M,self.ns+1)
 55 |         self.s = (s_edges[1:] + s_edges[:-1])/2.
 56 |         self.ds = self.s[1]-self.s[0]
 57 |         self.s_bar_0 = (self.s_m+self.s_M)/2.
 58 | 
 59 | class Boundary_Params():
 60 |     def __init__(self):
 61 |         self.has_bottom = True
 62 |         self.has_top = True
 63 |         self.cyclic_lr = True
 64 |         self.roughness = True
 65 | 
 66 | class Solid_Params():
 67 |     def __init__(self,G,P):
 68 |         self.X = []
 69 |         self.Y = []
 70 |         self.n = 0
 71 |         # NOTE: DEFINITION OF DENSITY DIFFERS FROM OTHER EXAMPLES
 72 |         # self.rho = 270.#0. # density (kg/m^3)
 73 |         self.packing = 0.6 # packing fraction
 74 |         self.rho_s = 270. # solid density - REDUCED BY FACTOR OF 10 AS IN FAN AND HILL PAPER!!!!!
 75 |         self.rho = self.rho_s*self.packing
 76 | 
 77 | 
 78 |         self.law = 'pouliquen'
 79 |         self.mu_0 = tan(deg2rad(20.9)) #0.3
 80 |         self.mu_1 = tan(deg2rad(32.76))
 81 |         self.delta_mu = self.mu_1 - self.mu_0
 82 |         self.I_0 = 0.279
 83 |         self.eta_max = 100.*self.rho*sqrt(-P.max_g*(G.y_M-G.y_m)**3)
 84 | 
 85 |         self.E = 1e7
 86 |         self.nu = 0.4 # poissons ratio
 87 |         self.K = self.E/(3*(1-2*self.nu))
 88 |         self.G = self.E/(2*(1+self.nu))
 89 | 
 90 | 
 91 | 
 92 |         # self.law = constit.pouliquen(E,nu,mu_0,mu_1,I_0,eta_max) # DO I WANT TO MAKE A GENERIC LAW CLASS AND HAVE EACH CONSTITUTIVE MODEL INHERIT THOSE PROPERTIES?!??
 93 |         # self.v_max = constit.pouliquen.get_analytical_vmax(P,G)
 94 |         # self.v_max = ( sqrt(abs(P.max_g)*G.s_bar_0)*(2./3.)*self.I_0*(tan(abs(P.theta))-self.mu_0)/(self.mu_1-tan(abs(P.theta)))*
 95 |                   # sqrt(self.packing*cos(abs(P.theta)))*G.y_M**1.5/G.s_bar_0**1.5 ) # Andreotti, Pouliquen and Forterre, page 233, equation (6.17)
 96 | 
 97 |         self.pts_per_cell = 3
 98 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 99 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
100 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
101 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
102 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
103 |         X = tile(xp,self.y)
104 |         Y = repeat(yp,self.x)
105 |         for i in range(self.x*self.y):
106 |             self.X.append(X[i])
107 |             self.Y.append(Y[i])
108 |             self.n += 1
109 | #         self.A = self.conc*(G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
110 |         # self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
111 |         self.A = G.dx*G.dy/self.pts_per_cell**2
112 | 
113 |     def critical_time(self,P):
114 |         distance = minimum(P.G.dx,P.G.dy)
115 |         t_ela = distance/sqrt(self.K/self.rho) # elasticity
116 |         t_diff = distance**2/self.eta_max*self.rho # momentum diffusivity/viscosity
117 |         return minimum(t_diff,t_ela)
118 | 
119 | 
120 | class Output_Params():
121 |     def __init__(self,P):
122 |         self.plot_continuum = True
123 |         # self.plot_material_points = True
124 |         # self.plot_gsd_grid = True
125 |         # self.plot_gsd_mp = True
126 |         # self.plot_gsd_grid = True
127 |         self.save_s_bar = True
128 |         self.save_u = True
129 |         self.save_density = True
130 |         self.save_phi_MP = True
131 |         self.continuum_fig_size = [12,8]
132 |         self.mp_fig_size = [6,6]
133 | 


--------------------------------------------------------------------------------
/inputs/bingham_unit_test.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,mode):
  7 |         self.supername = 'bingham_unit_test'
  8 |         self.dt = 2e-6 # timestep (s) --- TRY 0.1/mu_s
  9 |         self.t = 0. # physical time (s)
 10 |         self.tstep = 0
 11 |         self.savetime = 1000*self.dt # 0.1
 12 |         self.t_f = 10.0 # 100*self.dt # final time (s)
 13 |         self.nt = int(self.t_f/self.dt) # number of timesteps
 14 |         self.grid_save = 0 # save counter
 15 |         self.mp_save = 0 # save counter
 16 |         self.M_tol = 1e-10 # very small mass (kg)
 17 |         self.max_g = -1. # gravity (ms^-2)
 18 |         self.max_q = 0.
 19 |         self.update_forces()
 20 |         self.theta = 90.*pi/180. # slope angle (degrees)
 21 |         self.thickness = 1. # (m) into page
 22 |         self.G = Grid_Params()
 23 |         self.B = Boundary_Params()
 24 |         self.O = Output_Params(self.nt)
 25 |         self.S = [Solid_Params(self.G,self)]
 26 |         self.F = Fluid_Params()
 27 |         self.R = Fluid_Params()
 28 |         self.has_yielded = False
 29 |         self.damping = True
 30 |         self.mode = mode
 31 | 
 32 |     def update_forces(self):
 33 |         t_c = 100.*self.dt
 34 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 35 | #         self.g = self.max_g
 36 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 37 | 
 38 | class Grid_Params():
 39 |     def __init__(self):
 40 |         self.x_m = 0.0 # (m)
 41 |         self.x_M = 0.1 # (m)
 42 |         self.y_m = 0.0 # (m)
 43 |         self.y_M = 1.0 # (m)
 44 |         self.nx = 3
 45 |         self.ny = 21
 46 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 47 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 48 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 49 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 50 |         self.thickness = 1. # (m)
 51 |         
 52 | class Boundary_Params():
 53 |     def __init__(self):
 54 |         self.wall = False
 55 |         self.has_top = True
 56 |         self.has_bottom = True
 57 |         self.has_right = False
 58 |         self.has_left = False
 59 |         self.outlet_left = False
 60 |         self.cyclic_lr = True
 61 |         self.force_boundaries = False
 62 |         self.vertical_force = False
 63 |         self.horizontal_force = False
 64 |         self.roughness = True
 65 | 
 66 | class Solid_Params():
 67 |     def __init__(self,G,P):
 68 |         self.X = []
 69 |         self.Y = []
 70 |         self.n = 0
 71 | 
 72 |         self.law = 'bingham'
 73 |         self.rho = 1000. # density (kg/m^3)
 74 |         
 75 |         self.mu_s = 1e4 # shear viscosity
 76 |         self.tau_0 = 100. # yield stress
 77 |         self.mu_0 = 100.*self.mu_s # much steeper viscosity to mimic very rigid part
 78 |         self.gamma_c = self.tau_0/(self.mu_0 - self.mu_s)
 79 |         self.K = 0. # bulk modulus
 80 |         
 81 | #         self.initial_v = array([-10.,0.,0.])
 82 | #         self.pressure = 1e4
 83 |         
 84 |         self.pts_per_cell = 3
 85 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 86 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 87 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 88 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 89 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
 90 |         X = tile(xp,self.y)
 91 |         Y = repeat(yp,self.x)
 92 |         for i in xrange(self.x*self.y):
 93 |             self.X.append(X[i])
 94 |             self.Y.append(Y[i])
 95 |             self.n += 1
 96 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 97 |         P.supername += ('/' + str(self.mu_s) +
 98 |                         '/' + str(self.mu_0))
 99 | 
100 | class Output_Params():
101 |     def __init__(self,nt):
102 |         self.measure_energy = False
103 |         self.plot_continuum = True
104 |         self.plot_material_points = False
105 |         self.measure_stiffness = False
106 |         self.check_positions = False
107 |         self.plot_fluid = False
108 |         self.energy = zeros((nt+1,4)) # energy
109 |         
110 |     def measure_E(self,P,L):
111 |         print 'Measuring macro and micro stress/strain for each material point... '
112 |         for i in xrange(P.S.n):
113 |             original_position = array((P.S.X[i],P.S.Y[i],0))
114 |             macro_strain = (original_position-L.S[i].x)/array((P.S.L,P.S.W,1.)) #original_position
115 |             macro_stress = P.max_conf#/(P.S.L*P.S.W)
116 |             print 'From macroscopic stress/strain:'
117 |             print macro_stress/macro_strain/P.S.E
118 |             print 'From microscopic stress/strain:'
119 |             print L.S[i].dstress/L.S[i].dstrain/P.S.E
120 | 
121 |             
122 | class Fluid_Params():
123 |     def __init__(self):
124 |         self.n = 0
125 | 
126 |         
127 | class Rigid_Params():
128 |     def __init__(self):
129 |         self.n = 0
130 | 
131 | 


--------------------------------------------------------------------------------
/inputs/brazillian.py:
--------------------------------------------------------------------------------
  1 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp,linspace
  2 | from numpy import random, cos, sin, ceil, around
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,mode):
  7 |         self.dt = 1e-4 # timestep (s)
  8 |         self.t = 0. # physical time (s)
  9 |         self.tstep = 0
 10 |         self.savetime = .1
 11 |         self.t_f = 5.#100*self.dt # final time (s)
 12 |         self.nt = int(self.t_f/self.dt) # number of timesteps
 13 |         self.grid_save = 0 # save counter
 14 |         self.mp_save = 0 # save counter
 15 |         self.M_tol = 1e-10 # very small mass (kg)
 16 |         self.max_g = 0. # gravity (ms^-2)
 17 |         self.max_q = 600.
 18 |         self.update_forces()
 19 |         self.theta = 0.*pi/180. # slope angle (degrees)
 20 |         self.thickness = 1. # (m) into page
 21 |         self.G = Grid_Params()
 22 |         self.B = Boundary_Params()
 23 |         self.O = Output_Params(self.nt)
 24 |         self.S = [Solid_Params()]
 25 |         self.F = Fluid_Params()
 26 |         self.R = Fluid_Params()
 27 |         self.has_yielded = False
 28 |         self.damping = False
 29 |         self.mode = mode
 30 | 
 31 |     def update_forces(self):
 32 |         t_c = .1
 33 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 34 | #        self.g=self.max_g
 35 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 36 | 
 37 | class Grid_Params():
 38 |     def __init__(self):
 39 |         self.x_m = 0.0 # (m)
 40 |         self.x_M = 1.0 # (m)
 41 |         self.y_m = 0.0 # (m)
 42 |         self.y_M = 1.0 # (m)
 43 |         self.scale = 51
 44 |         self.nx = self.scale
 45 |         self.ny = self.scale
 46 |         self.thickness = 1.
 47 |         
 48 | class Boundary_Params():
 49 |     def __init__(self):
 50 |         self.wall = False
 51 |         self.has_top = False
 52 |         self.has_bottom = False
 53 |         self.has_right = False
 54 |         self.has_left = False
 55 |         self.outlet_left = False
 56 |         self.force_boundaries = True
 57 |         self.vertical_force = True
 58 |         self.horizontal_force = False
 59 |         self.roughness = False
 60 |         self.cyclic_lr = False
 61 |         self.inlet_right = False
 62 |         
 63 | class Solid_Params():
 64 |     def __init__(self):
 65 |         self.X = []
 66 |         self.Y = []
 67 |         self.n = 0
 68 | 
 69 |         self.law = 'elastic'
 70 | #        self.law = 'von_mises'
 71 |         self.rho = 1000. # density (kg/m^3)
 72 |         
 73 |         self.E = 1e7 # elastic modulus (Pa)
 74 |         self.nu = 0. # poisson's ratio
 75 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 76 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 77 | 
 78 |         self.s = 2.5
 79 |         self.k = 100.
 80 | 
 81 |         nr = 50 # particles in radial direction
 82 |         nphi = 6*nr #50 # particles around circumference
 83 |         r = 0.45 # radius
 84 |         c = [0.5,.5] # centre
 85 |         
 86 |         for i in linspace(0,r,nr):
 87 |             dnphi = around(nphi*i/r) # number in this ring
 88 |             for j in linspace(0,(1.-1./(dnphi))*2*pi,dnphi):
 89 |                 self.X.append(c[0]+i*sin(j))
 90 |                 self.Y.append(c[1]+i*cos(j))
 91 |                 self.n += 1
 92 |         self.A = pi*0.2**2/self.n # area (m^2)
 93 |         
 94 |         
 95 | class Output_Params():
 96 |     def __init__(self,nt):
 97 |         self.measure_energy = True
 98 |         self.plot_continuum = True
 99 |         self.plot_material_points = True
100 |         self.measure_stiffness = False
101 |         self.check_positions = True
102 |         self.plot_fluid = False
103 |         self.energy = zeros((10*nt+1,4)) # energy
104 |         
105 |     def measure_E(self,P,L):
106 |         print('Measuring macro and micro stress/strain for each material point... ')
107 |         for i in range(P.S.n):
108 |             original_position = array((P.S.X[i],P.S.Y[i],0))
109 |             macro_strain = (original_position-L.S[i].x)/array((P.S.L,P.S.W,1.)) #original_position
110 |             macro_stress = P.max_conf#/(P.S.L*P.S.W)
111 |             print('From macroscopic stress/strain:' +
112 |                   str(macro_stress/macro_strain/P.S.E) +
113 |                   'From microscopic stress/strain:' +
114 |                   str(L.S[i].dstress/L.S[i].dstrain/P.S.E)
115 |                   )
116 | 
117 |             
118 | class Fluid_Params():
119 |     def __init__(self):
120 |         self.n = 0
121 | 
122 |         
123 | class Rigid_Params():
124 |     def __init__(self):
125 |         self.n = 0
126 | 
127 | 


--------------------------------------------------------------------------------
/inputs/chuteflow.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,mode):
  7 |         self.dt = 1e-3 # timestep (s)
  8 |         self.t = 0. # physical time (s)
  9 |         self.tstep = 0
 10 |         self.savetime = 0.1
 11 |         self.t_f = 5.0 # 100*self.dt # final time (s)
 12 |         self.nt = int(self.t_f/self.dt) # number of timesteps
 13 |         self.grid_save = 0 # save counter
 14 |         self.mp_save = 0 # save counter
 15 |         self.M_tol = 1e-10 # very small mass (kg)
 16 |         self.max_g = -1. # gravity (ms^-2)
 17 |         self.max_q = 0.
 18 |         self.update_forces()
 19 |         self.theta = 45.*pi/180. # slope angle (degrees)
 20 |         self.thickness = 1. # (m) into page
 21 |         self.G = Grid_Params()
 22 |         self.B = Boundary_Params()
 23 |         self.O = Output_Params(self.nt)
 24 |         self.S = []
 25 |         self.S.append(Solid_Params(self.G))
 26 |         self.has_yielded = False
 27 |         self.damping = True
 28 |         self.mode = mode
 29 |         self.supername = 'chute_flow'
 30 | 
 31 |     def update_forces(self):
 32 |         t_c = 0.5
 33 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 34 | #         self.g = self.max_g
 35 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 36 | 
 37 | class Grid_Params():
 38 |     def __init__(self):
 39 |         self.x_m = 0.0 # (m)
 40 |         self.x_M = 0.1 # (m)
 41 |         self.y_m = 0.0 # (m)
 42 |         self.y_M = 1.0 # (m)
 43 |         self.nx = 3
 44 |         self.ny = 21
 45 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 46 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 47 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 48 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 49 |         self.thickness = 1. # (m)
 50 |         
 51 | class Boundary_Params():
 52 |     def __init__(self):
 53 |         self.wall = False
 54 |         self.has_top = False
 55 |         self.has_bottom = True
 56 |         self.has_right = False
 57 |         self.has_left = False
 58 |         self.outlet_left = False
 59 |         self.inlet_right = False
 60 |         self.cyclic_lr = True
 61 |         self.force_boundaries = False
 62 |         self.vertical_force = False
 63 |         self.horizontal_force = False
 64 |         self.roughness = True
 65 | 
 66 | class Solid_Params():
 67 |     def __init__(self,G):
 68 |         self.X = []
 69 |         self.Y = []
 70 |         self.n = 0
 71 | 
 72 |         self.law = 'viscous'
 73 | #         self.law = 'HB'
 74 |         self.rho = 1000. # density (kg/m^3)
 75 |         
 76 |         self.mu_s = 1e3 # shear viscosity
 77 |         self.mu_v = 0 # pressure viscosity
 78 |         self.K = 1e3
 79 | #         self.k = 1.
 80 | #         self.N = 2.
 81 | #         self.tau_0 = 1.
 82 | #         self.gamma_dot_0 = 0.1
 83 | #         self.mu_0 = self.k*self.gamma_dot_0**(self.N-1.) + self.tau_0/self.gamma_dot_0
 84 |         
 85 |         self.pts_per_cell = 3
 86 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 87 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 88 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 89 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 90 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
 91 |         X = tile(xp,self.y)
 92 |         Y = repeat(yp,self.x)
 93 |         for i in xrange(self.x*self.y):
 94 |             self.X.append(X[i])
 95 |             self.Y.append(Y[i])
 96 |             self.n += 1
 97 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/2./self.n # area (m^2)
 98 |         
 99 |         
100 | class Output_Params():
101 |     def __init__(self,nt):
102 |         self.measure_energy = False
103 |         self.plot_continuum = True
104 |         self.plot_material_points = True
105 |         self.measure_stiffness = False
106 |         self.check_positions = False
107 |         self.plot_fluid = False
108 |         self.energy = zeros((nt+1,4)) # energy
109 |         
110 |     def measure_E(self,P,L):
111 |         print 'Measuring macro and micro stress/strain for each material point... '
112 |         for i in xrange(P.S.n):
113 |             original_position = array((P.S.X[i],P.S.Y[i],0))
114 |             macro_strain = (original_position-L.S[i].x)/array((P.S.L,P.S.W,1.)) #original_position
115 |             macro_stress = P.max_conf#/(P.S.L*P.S.W)
116 |             print 'From macroscopic stress/strain:'
117 |             print macro_stress/macro_strain/P.S.E
118 |             print 'From microscopic stress/strain:'
119 |             print L.S[i].dstress/L.S[i].dstrain/P.S.E
120 | 


--------------------------------------------------------------------------------
/inputs/dam_break.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | from numpy import *
 3 | import matplotlib.pyplot as plt
 4 | 
 5 | class Params():
 6 |     def __init__(self,mode):
 7 |         self.dt = 1e-4 # timestep (s)
 8 |         self.savetime = 0.0001
 9 |         self.t_f = 10.0 #100.0 # 3*self.dt # final time (s)
10 |         self.max_g = -9.81 # gravity (ms^-2)
11 |         self.max_q = 0.
12 |         self.theta = 0.*pi/180. # slope angle (degrees)
13 | #         self.pressure = 'lithostatic'
14 |         self.pressure = 'non-zero'
15 |         self.G = Grid_Params()
16 |         self.B = Boundary_Params()
17 |         self.O = Output_Params()#self.nt)
18 | #         self.S = [Large_Params(self.G,self),Small_Params(self.G,self),]
19 |         self.S = [Solid_Params(self.G,self),]
20 |         self.supername = 'im/dam_break_no_seg/'
21 | 
22 |     def update_forces(self):
23 |         t_c = 0.05
24 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
25 | #         self.g = self.max_g
26 | 
27 | class Grid_Params():
28 |     def __init__(self):
29 |         self.x_m = 0.0 # (m)
30 |         self.x_M = 2.0 # (m)
31 |         self.y_m = 0.0 # (m)
32 |         self.y_M = 1.0 # (m)
33 |         self.ny = 21
34 |         self.nx = (self.ny-1)*4 + 1
35 |         self.x = linspace(self.x_m,self.x_M,self.nx)
36 |         self.y = linspace(self.y_m,self.y_M,self.ny)
37 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
38 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
39 |         self.s = array([0.5,1.0]) # s coordinate
40 |         self.ds = self.s[1]-self.s[0]
41 |         self.ns = len(self.s)
42 |         
43 | class Boundary_Params():
44 |     def __init__(self):
45 |         self.has_bottom = True
46 |         self.has_right = True
47 |         self.outlet_left = True
48 | #         self.roughness = True
49 |         
50 | class Solid_Params():
51 |     def __init__(self,G,P):
52 |         self.X = []
53 |         self.Y = []
54 |         self.n = 0
55 |         self.rho = 2650. # density (kg/m^3)
56 | 
57 |         self.law = 'dp_rate'
58 |         self.E = 1e4 # elastic modulus (Pa)
59 |         self.nu = 0.2 # poisson's ratio
60 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
61 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
62 |         self.mu = 1.
63 |         self.beta = 1.*self.mu
64 |         self.s = 1.
65 |         self.t_star = 0.01
66 |         
67 |         self.pts_per_cell = 3
68 |         self.x = (G.nx-1)//4*self.pts_per_cell # particles in x direction
69 |         self.y = (G.ny-2)*self.pts_per_cell # particles in y direction
70 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
71 | 
72 |         xp = linspace(G.x_M-(G.x_m+G.x_M)/4+gap[0],G.x_M-gap[0],self.x)
73 |         yp = linspace(G.y_m+gap[1],G.y_M-G.dy-gap[1],self.y)
74 |         X = tile(xp,self.y)
75 |         Y = repeat(yp,self.x)
76 |         for i in range(self.x*self.y):
77 |             self.X.append(X[i])
78 |             self.Y.append(Y[i])
79 |             self.n += 1
80 | #         self.A = self.conc*(G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
81 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m-G.dy)/4./self.n # area (m^2)
82 | 
83 |         elastic_wave_speed = sqrt(self.K/(self.A*self.rho*1.))
84 |         distance = minimum(G.dx,G.dy)
85 |         critical_time = distance/elastic_wave_speed
86 |         critical_time /= 2. # safety
87 |         if critical_time < P.dt:
88 | #             P.dt = critical_time
89 |             print('WARNING: timestep should be dt = ' + str(critical_time))
90 | 
91 | class Output_Params():
92 |     def __init__(self):
93 |         self.plot_continuum = True
94 |         self.plot_material_points = True
95 |         self.continuum_fig_size = [18,6]
96 |         self.mp_fig_size = [18,4]


--------------------------------------------------------------------------------
/inputs/dp_rate_unit_test.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp,linspace,minimum,amax,tile,repeat
  3 | from numpy import random,ones
  4 | import matplotlib.pyplot as plt
  5 | 
  6 | class Params():
  7 |     def __init__(self,mode):
  8 |         self.dt = 1e-3 # timestep (s)
  9 |         self.savetime = 0.1
 10 |         self.t_f = 5. # final time (s)
 11 |         self.nt = int(self.t_f/self.dt) # number of timesteps
 12 |         self.max_q = 10.
 13 |         self.max_g = 0.
 14 |         self.pressure = 'non-zero'
 15 |         self.theta = 0.*pi/180. # slope angle (degrees)
 16 |         self.G = Grid_Params()
 17 |         self.B = Boundary_Params()
 18 |         self.S = Solid_Params(self.G)
 19 |         self.O = Output_Params(self.nt,self.S.n)
 20 |         self.supername = 'im/dp_rate_unit_test'
 21 | #         self.damping = True
 22 | 
 23 |     def update_forces(self):
 24 |         self.g = 0
 25 |         t_c = self.t_f/2.
 26 |         if self.t < t_c:
 27 |             self.q_h = self.q_v = self.max_q*self.t/t_c
 28 |         else:
 29 |             self.q_h = self.t*self.max_q/t_c
 30 |             self.q_v = 2*self.max_q - self.t/t_c*self.max_q
 31 | #         self.q_h = self.t*self.max_q/t_c
 32 | #         self.q_v = minimum(self.q_h,self.max_q)
 33 |         
 34 | class Grid_Params():
 35 |     def __init__(self):
 36 |         self.x_m = 0.0 # (m)
 37 |         self.x_M = 1.0 # (m)
 38 |         self.y_m = 0.0 # (m)
 39 |         self.y_M = 1.0 # (m)
 40 |         self.nx = 2
 41 |         self.ny = 2
 42 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 43 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 44 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 45 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 46 | 
 47 | class Boundary_Params():
 48 |     def __init__(self):
 49 | #         self.has_right = True
 50 | #         self.has_left = True
 51 |         self.vertical_force = True
 52 |         self.horizontal_force = True
 53 | 
 54 | class Solid_Params():
 55 |     def __init__(self,G):
 56 |         self.X = []
 57 |         self.Y = []
 58 |         self.x = 3#(10*2-1)*2 # particles in x direction
 59 |         self.y = 3#(5*2-1)*2-4 # particles in y direction
 60 |         self.n = 0
 61 |         
 62 |         self.law = 'dp_rate'
 63 | #         self.law = 'rigid'
 64 |         self.rho = 2650. # density (kg/m^3)
 65 |         
 66 |         self.E = 1e5 # elastic modulus (Pa)
 67 |         self.nu = 0.2 # poisson's ratio
 68 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 69 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 70 | 
 71 |         self.mu = 1.
 72 |         self.beta = 1.*self.mu
 73 |         self.t_star = 1e-2
 74 | 
 75 |         self.pts_per_cell = 3
 76 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 77 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 78 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 79 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 80 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
 81 |         X = tile(xp,self.y)
 82 |         Y = repeat(yp,self.x)
 83 |         for i in range(self.x*self.y):
 84 |             self.X.append(X[i])
 85 |             self.Y.append(Y[i])
 86 |             self.n += 1
 87 | #         self.A = self.conc*(G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 88 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 89 | 
 90 | 
 91 | class Output_Params():
 92 |     def __init__(self,nt,n):
 93 | #         self.plot_continuum = True
 94 | #         self.plot_material_points = True
 95 |         self.energy = zeros((nt*10+1,4)) # energy
 96 |         self.p = zeros((nt*10+10,n))
 97 |         self.q = zeros((nt*10+10,n))
 98 | 
 99 |     def store_p_q(self,P,G,L,tstep):
100 |         for i in range(P.S[0].n):
101 |             self.p[tstep,i] = L.S[0][i].p
102 |             self.q[tstep,i] = L.S[0][i].q
103 |             
104 |     def draw_p_q(self,P,G,L,plot,tstep):
105 | #         x = zeros((P.S[0].n,3))
106 | #         v = zeros((P.S[0].n,3))
107 |         plt.figure()
108 |         for i in range(P.S[0].n):
109 |             plt.clf()
110 |             plt.xlabel(r"$p$")
111 |             plt.ylabel(r"$q$",rotation='horizontal')
112 |             plt.plot([0,amax(self.p)],[0,P.S[0].mu*amax(self.p)],'k--')
113 |             plt.plot(self.p[:tstep-1,i],self.q[:tstep-1,i],'b-')
114 |             plot.savefig(P,str(i))
115 |         #print (self.q[tstep-1,0]-self.q[1,0])/(self.p[tstep-1,0]-self.p[1,0])
116 | 


--------------------------------------------------------------------------------
/inputs/dp_unit_test.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp,linspace,minimum,amax,tile,repeat
  3 | from numpy import random,ones
  4 | import matplotlib.pyplot as plt
  5 | 
  6 | class Params():
  7 |     def __init__(self,mode):
  8 |         self.dt = 1e-4 # timestep (s)
  9 |         self.savetime = 1
 10 |         self.t_f = 1 # final time (s)
 11 |         self.nt = int(self.t_f/self.dt) # number of timesteps
 12 |         self.max_q = 1.
 13 |         self.max_g = 0.
 14 |         self.pressure = 'non-zero'
 15 |         self.theta = 0.*pi/180. # slope angle (degrees)
 16 |         self.G = Grid_Params()
 17 |         self.B = Boundary_Params()
 18 |         self.S = [Solid_Params(self.G),]
 19 |         self.O = Output_Params(self.nt,self.S[0].n)
 20 |         self.supername = 'im/dp_unit_test'
 21 | #         self.damping = True
 22 | 
 23 |     def update_forces(self):
 24 |         self.g = 0
 25 |         t_c = self.t_f/10.
 26 |         if self.t < t_c:
 27 |             self.q_h = self.q_v = self.max_q*self.t/t_c
 28 |         else:
 29 |             self.q_h = self.t*self.max_q/t_c
 30 |             self.q_v = 2*self.max_q - self.t/t_c*self.max_q
 31 | #         self.q_h = self.t*self.max_q/t_c
 32 | #         self.q_v = minimum(self.q_h,self.max_q)
 33 | 
 34 | class Grid_Params():
 35 |     def __init__(self):
 36 |         self.x_m = 0.0 # (m)
 37 |         self.x_M = 1.0 # (m)
 38 |         self.y_m = 0.0 # (m)
 39 |         self.y_M = 1.0 # (m)
 40 |         self.nx = 2
 41 |         self.ny = 2
 42 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 43 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 44 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 45 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 46 | 
 47 | class Boundary_Params():
 48 |     def __init__(self):
 49 | #         self.has_right = True
 50 | #         self.has_left = True
 51 |         self.vertical_force = True
 52 |         self.horizontal_force = True
 53 | 
 54 | class Solid_Params():
 55 |     def __init__(self,G):
 56 |         self.X = []
 57 |         self.Y = []
 58 |         self.x = 3#(10*2-1)*2 # particles in x direction
 59 |         self.y = 3#(5*2-1)*2-4 # particles in y direction
 60 |         self.n = 0
 61 | 
 62 |         self.law = 'dp'
 63 | #         self.law = 'rigid'
 64 |         self.rho = 2650. # density (kg/m^3)
 65 |         self.packing = 0.6 # packing fraction
 66 |         self.rho_s = self.rho/self.packing # solid density
 67 | 
 68 |         self.E = 1e7 # elastic modulus (Pa)
 69 |         self.nu = 0.4 # poisson's ratio
 70 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 71 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 72 | 
 73 |         # self.mu = 1.
 74 |         self.mu_0 = 0.5
 75 |         self.mu_1 = 1.
 76 |         self.delta_mu = self.mu_1 - self.mu_0
 77 |         self.I_0 = 1e-3
 78 |         self.beta = 0 #1.*self.mu
 79 |         self.s = 2.
 80 |         self.eta_max = 1e10
 81 | 
 82 |         self.pts_per_cell = 3
 83 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 84 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 85 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 86 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 87 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
 88 |         X = tile(xp,self.y)
 89 |         Y = repeat(yp,self.x)
 90 |         for i in range(self.x*self.y):
 91 |             self.X.append(X[i])
 92 |             self.Y.append(Y[i])
 93 |             self.n += 1
 94 | #         self.A = self.conc*(G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 95 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 96 | 
 97 | 
 98 | class Output_Params():
 99 |     def __init__(self,nt,n):
100 | #         self.plot_continuum = True
101 |         self.plot_material_points = True
102 |         self.energy = zeros((nt*10+1,4)) # energy
103 |         self.p = zeros((nt*10+10,n))
104 |         self.q = zeros((nt*10+10,n))
105 | 
106 |     def store_p_q(self,P,G,L,tstep):
107 |         for i in range(P.S[0].n):
108 |             self.p[tstep,i] = L.S[0][i].p
109 |             self.q[tstep,i] = L.S[0][i].q
110 | 
111 |     def draw_p_q(self,P,G,L,plot,tstep):
112 | #         x = zeros((P.S[0].n,3))
113 | #         v = zeros((P.S[0].n,3))
114 |         plt.figure()
115 |         for i in range(P.S[0].n):
116 |             plt.clf()
117 |             plt.xlabel(r"$p$")
118 |             plt.ylabel(r"$q$",rotation='horizontal')
119 |             plt.plot([0,amax(self.p)],[0,P.S[0].mu_0*amax(self.p)],'r--')
120 |             plt.plot([0,amax(self.p)],[0,P.S[0].mu_1*amax(self.p)],'g--')
121 |             plt.plot(self.p[:tstep-1,i],self.q[:tstep-1,i],'b-')
122 |             plot.savefig(P,str(i))
123 |         #print (self.q[tstep-1,0]-self.q[1,0])/(self.p[tstep-1,0]-self.p[1,0])
124 | 


--------------------------------------------------------------------------------
/inputs/fluid.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp
  3 | from numpy import linspace,tile,repeat
  4 | import matplotlib.pyplot as plt
  5 | 
  6 | class Params():
  7 |     def __init__(self,mode):
  8 |         self.dt = 1e-3 # timestep (s)
  9 |         self.t = 0. # physical time (s)
 10 |         self.tstep = 0 # current timestep
 11 |         self.t_f = 5.#100*self.dt # final time (s)
 12 |         self.savetime = .1
 13 |         self.nt = int(self.t_f/self.dt) # number of timesteps - WRONG!
 14 |         self.save = 0 # save counter
 15 |         self.M_tol = 1e-10 # very small mass (kg)
 16 |         self.max_g = -10. # gravity (ms^-2)
 17 |         self.max_q = 0.
 18 |         self.update_forces()
 19 |         self.theta = 0.*pi/180. # slope angle (degrees)
 20 |         self.thickness = 1. # (m) into page
 21 |         self.roughness = 1. # wall roughness (units?)
 22 |         self.G = Grid_Params()
 23 |         self.B = Boundary_Params()
 24 |         self.O = Output_Params(self.nt)
 25 |         self.S = Solid_Params(self.G)
 26 |         self.F = Fluid_Params(self.G)
 27 |         self.R = Rigid_Params()
 28 |         self.has_yielded = False
 29 |         self.damping = False # local non-viscous damping
 30 |         self.mode = mode
 31 |         
 32 |     def update_forces(self):
 33 |         t_c = .5
 34 |         if self.t < 4.*t_c:
 35 |             self.theta = 0.*pi/180. # slope angle (degrees)
 36 |         else:
 37 |             self.theta = 45.*pi/180. # slope angle (degrees)
 38 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 39 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 40 | 
 41 | class Grid_Params():
 42 |     def __init__(self):
 43 |         self.scale = 4 # grid points per m
 44 |         self.x_m = 0.0 # (m)
 45 |         self.x_M = 1.0 # (m)
 46 |         self.y_m = 0.0 # (m)
 47 |         self.y_M = 1.0 # (m)
 48 |         self.nx = int(self.x_M-self.x_m)*self.scale+1
 49 |         self.ny = int(self.y_M-self.y_m)*self.scale+1
 50 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 51 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 52 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 53 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 54 | 
 55 | class Boundary_Params():
 56 |     def __init__(self):
 57 |         self.wall = False
 58 |         self.has_top = False
 59 |         self.has_bottom = True
 60 |         self.has_right = True
 61 |         self.has_left = True
 62 |         self.outlet_left = False
 63 |         self.force_boundaries = False
 64 |         self.vertical_force = False
 65 |         self.horizontal_force = False
 66 |         self.roughness = False
 67 | 
 68 | class Solid_Params():
 69 |     def __init__(self,G):
 70 |         self.X = []
 71 |         self.Y = []
 72 |         self.x = G.scale # particles in x direction
 73 |         self.y = G.scale # particles in y direction
 74 |         self.n = 0
 75 | 
 76 | #        self.law = 'elastic'
 77 |         self.law = 'von_mises'
 78 |         self.rho = 2650. # density (kg/m^3)
 79 |         
 80 |         self.E = 1.e7 # elastic modulus (Pa)
 81 |         self.nu = 0.3 # poisson's ratio
 82 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 83 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 84 | 
 85 |         self.s = 100.
 86 |         self.k = self.E/100.
 87 | 
 88 | #        for i in linspace(G.x_M-2.*G.dx,G.x_M-G.dx,self.x):
 89 | #            for j in linspace(G.y_m+G.dy,G.y_m+2.*G.dy,self.y):
 90 | #                self.X.append(i)
 91 | #                self.Y.append(j)
 92 | #                self.n += 1
 93 |         self.A = 1. # area (m^2)
 94 | 
 95 | class Output_Params():
 96 |     def __init__(self,nt):
 97 |         self.measure_energy = True
 98 |         self.plot_continuum = False
 99 |         self.plot_material_points = False
100 |         self.plot_fluid = True
101 |         self.plot_gamma_dot = False
102 |         self.measure_stiffness = False
103 |         self.check_positions = True
104 |         self.energy = zeros((10*nt+1,4)) # DON'T KNOW NUMBER OF TIMESTEPS!
105 | 
106 | class Fluid_Params():
107 |     def __init__(self,G):
108 |         self.X = []
109 |         self.Y = []
110 |         self.x = G.scale # particles in x direction
111 |         self.y = G.scale # particles in y direction
112 |         self.n = 0
113 |         self.rho = 999.
114 |         self.P_0 = 200.
115 |         self.int_energy = 1.
116 |         self.gamma = 1.
117 |         self.mu = 1.
118 | #        for i in linspace(G.x_M-2.*G.dx,G.x_M-G.dx,self.x):
119 | #            for j in linspace(G.y_m,G.y_m+G.dy,self.y):
120 |         for i in linspace(G.x_m+0.01,G.x_M-0.01,G.scale*3):
121 |             for j in linspace(G.y_m+0.01,G.y_M-0.01,G.scale*3):
122 |                 self.X.append(i)
123 |                 self.Y.append(j)
124 |                 self.n += 1
125 |         self.A = 1. # area (m^2)
126 |         self.law = 'compressible'
127 |                 
128 | class Rigid_Params():
129 |     def __init__(self):
130 |         self.n = 0
131 | 
132 | 


--------------------------------------------------------------------------------
/inputs/francois.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,args):
  7 |         self.t = 0.
  8 |         self.dt = 1e-5 # timestep (s)
  9 |         self.savetime = 0.001 #1e1*self.dt#0.01
 10 |         self.t_f = 10.0 #100.0 # 3*self.dt # final time (s)
 11 |         self.max_g = -9.81 # gravity (ms^-2)
 12 |         self.max_v = array([0.1,0.,0.]) # maximum speed for intruder particle
 13 |         self.update_forces()
 14 |         self.G = Grid_Params(args)
 15 |         self.B = Boundary_Params()
 16 |         self.O = Output_Params()#self.nt)
 17 |         self.S = [Solid_Params(self.G,self)]
 18 |         self.S.append(Intruder_Params(self.G,self))
 19 |         self.supername = 'im/francois/ny_' + str(self.G.ny) + '/'
 20 |         self.pressure = 'lithostatic'
 21 |         print(self.supername)
 22 | 
 23 |     def update_forces(self):
 24 |         self.g = self.max_g
 25 |         t_c = 0.01
 26 |         self.intruder_v = self.max_v*(1.-exp(-3.*self.t**2/t_c**2))
 27 |         # self.intruder_v = self.max_v
 28 | 
 29 | class Grid_Params():
 30 |     def __init__(self,args):
 31 |         self.x_m = 0.0 # (m)
 32 |         self.x_M = 0.5 # (m)
 33 |         self.y_m = 0.0 # (m)
 34 |         self.y_M = 0.1 # (m)
 35 |         self.ny = int(args[1])
 36 |         self.nx = 5*(self.ny-1) + 1
 37 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 38 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 39 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 40 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 41 |         self.R = 0.01 # radius of intruder
 42 |         self.x_c = (self.x_m + self.x_M)/2. # initial x location of intruder
 43 |         self.y_c = (self.y_m + self.y_M - self.dy)/2. # initial y location of intruder
 44 | 
 45 |         self.top_gap = self.dy # no material at top - HACK - NEED TO UPDATE self.y IF THIS CHANGES!!!
 46 | 
 47 | class Boundary_Params():
 48 |     def __init__(self):
 49 |         self.has_bottom = True
 50 |         self.cyclic_lr = True
 51 | 
 52 | class Solid_Params():
 53 |     def __init__(self,G,P):
 54 |         self.X = []
 55 |         self.Y = []
 56 |         self.n = 0
 57 |         self.rho = 2700. # density (kg/m^3)
 58 |         self.packing = 0.6 # packing fraction
 59 |         self.rho_s = self.rho/self.packing # solid density
 60 | 
 61 |         self.law = 'pouliquen'
 62 |         self.mu_0 = tan(deg2rad(20.9)) #0.3
 63 |         self.mu_1 = tan(deg2rad(32.76))
 64 |         self.delta_mu = self.mu_1 - self.mu_0
 65 |         self.I_0 = 0.279
 66 | 
 67 |         self.E = 1e4
 68 |         self.nu = 0.4 # poissons ratio
 69 |         self.K = self.E/(3.*(1.-2.*self.nu))
 70 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 71 |         self.eta_max = 1.*self.rho*sqrt(-P.max_g*(G.y_M-G.y_m)**3)
 72 | 
 73 |         self.pts_per_cell = 3
 74 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 75 |         self.y = (G.ny-2)*self.pts_per_cell # particles in y direction
 76 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 77 | 
 78 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 79 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1]-G.top_gap,self.y)
 80 |         X = tile(xp,self.y)
 81 |         Y = repeat(yp,self.x)
 82 | 
 83 |         for i in range(self.x*self.y):
 84 |             if (X[i]-G.x_c)**2 + (Y[i]-G.y_c)**2 > G.R**2:
 85 |                 self.X.append(X[i])
 86 |                 self.Y.append(Y[i])
 87 |                 self.n += 1
 88 | 
 89 |         # self.A = ((G.x_M-G.x_m)*(G.y_M-G.y_m-G.top_gap) - pi*G.R**2)/self.n # area (m^2)
 90 |         self.A = G.dy*G.dx/self.pts_per_cell**2
 91 | 
 92 | class Intruder_Params():
 93 |     def __init__(self,G,P):
 94 |         self.X = []
 95 |         self.Y = []
 96 |         self.n = 0
 97 |         self.rho = 2700.
 98 | 
 99 |         self.law = 'elastic'
100 |         self.E = 1e4 # young's modulus (Pa)
101 |         self.nu = 0.4 # poisson's ratio (-)
102 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
103 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
104 | 
105 |         self.pts_per_cell = 3
106 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
107 |         self.y = (G.ny-2)*self.pts_per_cell # particles in y direction
108 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
109 | 
110 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
111 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1]-G.top_gap,self.y)
112 |         X = tile(xp,self.y)
113 |         Y = repeat(yp,self.x)
114 | 
115 |         self.initial_v = P.intruder_v
116 |         for i in range(self.x*self.y):
117 |             if (X[i]-G.x_c)**2 + (Y[i]-G.y_c)**2 <= G.R**2:
118 |                 self.X.append(X[i])
119 |                 self.Y.append(Y[i])
120 |                 self.n += 1
121 | 
122 |         # self.A = pi*G.R**2/self.n # area (m^2)
123 |         self.A = G.dy*G.dx/self.pts_per_cell**2
124 | 
125 |         # Advective terms
126 |         elastic_wave_speed = sqrt(self.K/self.rho)
127 |         max_speed = maximum(elastic_wave_speed,P.max_v[0])
128 |         distance = minimum(G.dx,G.dy)
129 |         critical_adv_time = distance/max_speed
130 |         # Diffusive terms
131 |         critical_diff_time = distance**2/P.S[0].eta_max
132 | 
133 |         critical_time = minimum(critical_adv_time,critical_diff_time)
134 |         CFL = critical_time/P.dt
135 | 
136 |         if CFL < 2:
137 |             print('WARNING: STABILITY IS GUARANTEED TO BE POOR')
138 |             print(critical_adv_time)
139 |             print(critical_diff_time)
140 |         print('Current CFL: ' + str(CFL))
141 | 
142 | class Output_Params():
143 |     def __init__(self):
144 |         self.plot_continuum = True
145 |         # self.plot_material_points = True
146 |         self.continuum_fig_size = [22,4]
147 |         self.mp_fig_size = [6,6]
148 | 


--------------------------------------------------------------------------------
/inputs/gsd.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp
  3 | from numpy import linspace,tile,repeat,random,ones
  4 | import matplotlib.pyplot as plt
  5 | 
  6 | class Params():
  7 |     def __init__(self,mode):
  8 |         self.dt = 1e-3 # timestep (s)
  9 |         self.t = 0. # physical time (s)
 10 |         self.tstep = 0 # current timestep
 11 |         self.t_f = 2.#100*self.dt # final time (s)
 12 |         self.savetime = .1
 13 |         self.nt = int(self.t_f/self.dt) # number of timesteps - WRONG!
 14 |         self.save = 0 # save counter
 15 |         self.M_tol = 1e-10 # very small mass (kg)
 16 |         self.max_g = -0. # gravity (ms^-2)
 17 |         self.max_q = 0.
 18 |         self.update_forces()
 19 |         self.theta = 0.*pi/180. # slope angle (degrees)
 20 |         self.G = Grid_Params()
 21 |         self.GSD = GSD_Params()
 22 |         self.B = Boundary_Params()
 23 |         self.O = Output_Params(self.nt)
 24 |         self.S = Solid_Params(self.G)
 25 |         self.F = Fluid_Params()
 26 |         self.R = Fluid_Params()
 27 |         self.check_positions = False
 28 |         self.has_yielded = False
 29 |         self.damping = True # local non-viscous damping
 30 |         self.mode = mode
 31 |         
 32 |     def update_forces(self):
 33 |         t_c = .1
 34 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 35 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 36 | 
 37 | class Grid_Params():
 38 |     def __init__(self):
 39 |         self.scale = 2 # grid points per m
 40 |         self.thickness = 1. # (m) into page
 41 |         self.x_m = 0.0 # (m)
 42 |         self.x_M = 4.0 # (m)
 43 |         self.y_m = 0.0 # (m)
 44 |         self.y_M = 2.0 # (m)
 45 |         self.nx = int(self.x_M-self.x_m)*self.scale+1
 46 |         self.ny = int(self.y_M-self.y_m)*self.scale+1
 47 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 48 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 49 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 50 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 51 | 
 52 | class Boundary_Params():
 53 |     def __init__(self):
 54 |         self.wall = False
 55 |         self.has_top = False
 56 |         self.has_bottom = True
 57 |         self.has_right = True
 58 |         self.has_left = True
 59 |         self.outlet_left = False
 60 |         self.force_boundaries = False
 61 |         self.vertical_force = False
 62 |         self.horizontal_force = False
 63 |         self.roughness = False
 64 | 
 65 | class GSD_Params():
 66 |     def __init__(self):
 67 |         self.s_min = 1.
 68 |         self.s_max = 1.
 69 |         self.ns = 1
 70 |         self.s = linspace(self.s_min,self.s_max,self.ns)
 71 |         self.ds = 1.#self.s[1]-self.s[0]
 72 | #        self.Phi = ones(self.ns)/self.ns
 73 |         self.phi = ones(self.ns)/(sum(ones(self.ns)*self.ds))
 74 | 
 75 | class Solid_Params():
 76 |     def __init__(self,G):
 77 |         self.X = []
 78 |         self.Y = []
 79 |         self.pts_per_cell = 3
 80 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 81 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 82 |         self.n = 0
 83 | 
 84 |         self.law = 'elastic'
 85 | #        self.law = 'von_mises'
 86 | #        self.law = 'dp'
 87 |         self.rho = 2650. # density (kg/m^3)
 88 |         
 89 |         self.E = 1.e6 # elastic modulus (Pa)
 90 |         self.nu = 0.3 # poisson's ratio
 91 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 92 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 93 | 
 94 |         self.s = 2.
 95 |         self.k = 1.
 96 |         
 97 |         self.mu = 1. # DP yield angle
 98 |         self.beta = 1. # DP flow angle or something
 99 |         
100 |         self.D = 0. #1e4 # diffusion co-eff
101 |         self.c = 1. # seg rate
102 | 
103 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
104 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
105 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
106 |         X = tile(xp,self.y)
107 |         Y = repeat(yp,self.x)
108 |         for i in range(self.x*self.y):
109 |              self.X.append(X[i])
110 |              self.Y.append(Y[i])
111 |              self.n += 1
112 |         total_area = (G.x_M-G.x_m)*(G.y_M-G.y_m)
113 |         self.A = (total_area)/self.n # area (m^2)
114 | 
115 | 
116 | class Output_Params():
117 |     def __init__(self,nt):
118 |         self.measure_energy = True
119 |         self.plot_continuum = True
120 |         self.plot_material_points = True
121 |         self.plot_gamma_dot = False
122 |         self.plot_fluid = False
123 |         self.measure_stiffness = False
124 |         self.check_positions = False
125 |         self.plot_fluid = False
126 |         self.plot_gsd = True
127 |         self.energy = zeros((10*nt+1,4)) # DON'T KNOW NUMBER OF TIMESTEPS!
128 | 
129 | class Fluid_Params():
130 |     def __init__(self):
131 |         self.n = 0
132 |         
133 | class Rigid_Params():
134 |     def __init__(self):
135 |         self.n = 0
136 | 
137 | 


--------------------------------------------------------------------------------
/inputs/incline.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,mode):
  7 |         self.dt = 1e-5 # timestep (s)
  8 |         self.savetime = 500*self.dt
  9 |         self.t_f = 5.0 # 3*self.dt # final time (s)
 10 |         self.max_g = -10. # gravity (ms^-2)
 11 |         self.max_q = 0.
 12 |         self.theta = 18.*pi/180. # slope angle (degrees)
 13 |         self.G = Grid_Params()
 14 |         self.B = Boundary_Params()
 15 |         self.O = Output_Params()#self.nt)
 16 |         self.S = [Solid_Params(self.G,self),]
 17 | 
 18 |     def update_forces(self):
 19 |         t_c = 0.05
 20 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 21 | #         self.g = self.max_g
 22 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 23 | 
 24 | class Grid_Params():
 25 |     def __init__(self):
 26 |         self.x_m = 0.0 # (m)
 27 |         self.x_M = 0.1 # (m)
 28 |         self.y_m = 0.0 # (m)
 29 |         self.y_M = 1.0 # (m)
 30 |         self.nx = 2
 31 |         self.ny = 21
 32 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 33 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 34 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 35 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 36 |         self.thickness = 1. # (m)
 37 |         
 38 | class Boundary_Params():
 39 |     def __init__(self):
 40 |         self.wall = False
 41 |         self.has_top = False
 42 |         self.has_bottom = True
 43 |         self.has_right = False
 44 |         self.has_left = False
 45 |         self.outlet_left = False
 46 |         self.cyclic_lr = True
 47 |         self.force_boundaries = False
 48 |         self.vertical_force = False
 49 |         self.horizontal_force = False
 50 |         self.roughness = True
 51 |         self.inlet_right = False
 52 |         
 53 | class Solid_Params():
 54 |     def __init__(self,G,P):
 55 |         self.X = []
 56 |         self.Y = []
 57 |         self.n = 0
 58 |         self.rho = 1000. # density (kg/m^3)
 59 |         
 60 |         self.law = 'viscous'
 61 |         self.mu_s = 1e4
 62 |         self.K = 1e6
 63 |         self.mu_v = 0 #1e4
 64 | 
 65 | #         self.law = 'bingham'
 66 | #         self.rho = 1000. # density (kg/m^3)
 67 | #         self.mu_s = 1e2 # shear viscosity
 68 | #         self.tau_0 = 100. # yield stress
 69 | #         self.mu_0 = 100.*self.mu_s # much steeper viscosity to mimic very rigid part
 70 | #         self.gamma_c = self.tau_0/(self.mu_0 - self.mu_s)
 71 | #         self.K = 1e6 # bulk modulus
 72 | #         self.mu_v = 0 #1e3
 73 | 
 74 | #         self.law = 'pouliquen'
 75 | #         self.K = 1e4
 76 | #         self.mu_s = tan(20.*pi/180.)
 77 | #         self.mu_2 = tan(30.*pi/180.)
 78 | #         self.mu_v = 1e4
 79 | #         self.I_0 = 0.279
 80 |         
 81 |         self.pts_per_cell = 3
 82 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 83 |         self.y = (G.ny-2)*self.pts_per_cell # particles in y direction
 84 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 85 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 86 |         yp = linspace(G.y_m+gap[1],G.y_M-G.dy-gap[1],self.y)
 87 |         X = tile(xp,self.y)
 88 |         Y = repeat(yp,self.x)
 89 |         for i in range(self.x*self.y):
 90 |             self.X.append(X[i])
 91 |             self.Y.append(Y[i])
 92 |             self.n += 1
 93 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 94 | 
 95 |         elastic_wave_speed = sqrt(self.K/(self.A*self.rho*G.thickness))
 96 |         distance = minimum(G.dx,G.dy)
 97 |         critical_time = distance/elastic_wave_speed
 98 |         critical_time /= 2. # safety
 99 |         if critical_time < P.dt:
100 |             P.dt = critical_time
101 |             print('Reducing timestep to dt = ' + str(P.dt))
102 |         
103 | class Output_Params():
104 |     def __init__(self):
105 |         self.measure_energy = False
106 |         self.plot_continuum = True
107 |         self.plot_material_points = True
108 |         self.measure_stiffness = False
109 |         self.check_positions = False
110 |         self.plot_fluid = False
111 |         self.continuum_fig_size = [10,4]
112 |             
113 | class Fluid_Params():
114 |     def __init__(self):
115 |         self.n = 0
116 | 
117 |         
118 | class Rigid_Params():
119 |     def __init__(self):
120 |         self.n = 0


--------------------------------------------------------------------------------
/inputs/macro.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp,linspace
  3 | from numpy import random
  4 | import matplotlib.pyplot as plt
  5 | 
  6 | class Params():
  7 |     def __init__(self):
  8 |         self.dt = 1e-3 # timestep (s)
  9 |         self.t = 0. # physical time (s)
 10 |         self.tstep = 0
 11 |         self.savetime = 1.
 12 |         self.t_f = 0.2#100*self.dt # final time (s)
 13 |         self.nt = int(self.t_f/self.dt) # number of timesteps
 14 |         self.save = 0 # save counter
 15 |         self.M_tol = 1e-10 # very small mass (kg)
 16 |         self.max_g = 0. # gravity (ms^-2)
 17 |         self.max_q = 1.
 18 |         self.update_forces()
 19 |         self.theta = 0.*pi/180. # slope angle (degrees)
 20 |         self.thickness = 1. # (m) into page
 21 |         self.G = Grid_Params()
 22 |         self.B = Boundary_Params()
 23 |         self.O = Output_Params(self.nt)
 24 |         self.S = Solid_Params(self.G)
 25 |         self.F = Fluid_Params()
 26 |         self.R = Fluid_Params()
 27 |         self.check_positions = False
 28 |         self.has_yielded = False
 29 |         self.damping = True
 30 | 
 31 |     def update_forces(self):
 32 |         t_c = .05
 33 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 34 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 35 | 
 36 | class Grid_Params():
 37 |     def __init__(self):
 38 |         self.x_m = 0.0 # (m)
 39 |         self.x_M = 1.0 # (m)
 40 |         self.y_m = 0.0 # (m)
 41 |         self.y_M = 1.0 # (m)
 42 |         self.nx = 2
 43 |         self.ny = 2
 44 |         
 45 | class Boundary_Params():
 46 |     def __init__(self):
 47 |         self.wall = False
 48 |         self.has_top = False
 49 |         self.has_bottom = False
 50 |         self.has_right = False
 51 |         self.has_left = False
 52 |         self.outlet_left = False
 53 |         self.outlet_bottom = False
 54 |         self.force_boundaries = True
 55 |         self.vertical_force = False
 56 |         self.horizontal_force = True
 57 | 
 58 | class Solid_Params():
 59 |     def __init__(self,G):
 60 |         self.X = []
 61 |         self.Y = []
 62 |         self.x = 2#(10*2-1)*2 # particles in x direction
 63 |         self.y = 2#(5*2-1)*2-4 # particles in y direction
 64 |         self.n = 0
 65 | 
 66 |         self.mode = 'blob' # ball, blob, slope, excavate
 67 |         self.law = 'elastic'
 68 | #        self.law = 'von_mises'
 69 |         self.rho = 2650. # density (kg/m^3)
 70 |         
 71 |         self.E = 1.e8 # elastic modulus (Pa)
 72 |         self.nu = 0. # poisson's ratio
 73 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 74 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 75 | 
 76 |         self.s = 2.5
 77 |         self.k = self.E/100.
 78 | 
 79 |         self.L = 0.9
 80 |         self.W = 0.9
 81 |         for x in linspace(0.5-self.L/2.,0.5+self.L/2.,self.x):
 82 |             for y in linspace(0.5-self.W/2.,0.5+self.W/2.,self.y):
 83 |                 self.X.append(x)
 84 |                 self.Y.append(y)
 85 |                 self.n += 1
 86 | 
 87 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 88 | 
 89 | class Output_Params():
 90 |     def __init__(self,nt):
 91 |         self.measure_energy = True
 92 |         self.plot_continuum = False
 93 |         self.plot_material_points = False
 94 |         self.measure_stiffness = True
 95 |         self.check_positions = False
 96 |         self.plot_fluid = False
 97 |         self.energy = zeros((nt+1,3)) # energy
 98 |         
 99 |     def measure_E(self,P,L):
100 |         print('Measuring macro and micro stress/strain for each material point... ')
101 |         for i in range(P.S.n):
102 |             original_position = array((P.S.X[i],P.S.Y[i],0))
103 |             macro_strain = (original_position-L.S[i].x)/array((P.S.L,P.S.W,1.)) #original_position
104 |             macro_stress = P.max_q/2.
105 |             print('From macroscopic stress/strain:' +
106 |                   str(macro_stress/macro_strain/P.S.E) +
107 |                   'From microscopic stress/strain:' +
108 |                   str(L.S[i].dstress/L.S[i].dstrain/P.S.E)
109 |                   )
110 |                   
111 | class Fluid_Params():
112 |     def __init__(self):
113 |         self.n = 0
114 |         
115 | class Rigid_Params():
116 |     def __init__(self):
117 |         self.n = 0
118 | 
119 | 


--------------------------------------------------------------------------------
/inputs/pierre.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp
  3 | from numpy import linspace,tile,repeat
  4 | import matplotlib.pyplot as plt
  5 | 
  6 | class Params():
  7 |     def __init__(self,mode):
  8 |         self.dt = 1e-2 # timestep (s)
  9 |         self.t = 0. # physical time (s)
 10 |         self.tstep = 0 # current timestep
 11 |         self.t_f = 100.#100*self.dt # final time (s)
 12 |         self.savetime = .1
 13 |         self.nt = int(self.t_f/self.dt) # number of timesteps - WRONG!
 14 |         self.grid_save = 0 # save counter
 15 |         self.mp_save = 0 # save counter
 16 |         self.M_tol = 1e-10 # very small mass (kg)
 17 |         self.max_g = -1. # gravity (ms^-2)
 18 |         self.max_q = 0 #2.
 19 |         self.update_forces()
 20 |         self.theta = 0.*pi/180. # slope angle (degrees)
 21 |         self.G = Grid_Params()
 22 |         self.B = Boundary_Params()
 23 |         self.O = Output_Params(self.nt)
 24 |         self.S = [Solid_Params(self.G)]
 25 |         self.F = Fluid_Params()
 26 |         self.R = Fluid_Params()
 27 |         self.check_positions = False
 28 |         self.has_yielded = False
 29 |         self.damping = False # local non-viscous damping
 30 |         self.mode = mode
 31 |         
 32 |     def update_forces(self):
 33 |         t_c = .5
 34 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 35 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 36 | 
 37 | class Grid_Params():
 38 |     def __init__(self):
 39 |         self.scale = 2 # grid points per m
 40 |         self.thickness = 1. # (m) into page
 41 |         self.x_m = 0.0 # (m)
 42 |         self.x_M = 12.0 # (m)
 43 |         self.y_m = 0.0 # (m)
 44 |         self.y_M = 6.0 # (m)
 45 |         self.nx = int(self.x_M-self.x_m)*self.scale+1
 46 |         self.ny = int(self.y_M-self.y_m)*self.scale+1
 47 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 48 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 49 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 50 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 51 | 
 52 | class Boundary_Params():
 53 |     def __init__(self):
 54 |         self.wall = False
 55 |         self.has_top = False
 56 |         self.has_bottom = True
 57 |         self.has_right = True
 58 |         self.has_left = True
 59 |         self.outlet_left = False
 60 |         self.force_boundaries = True
 61 |         self.vertical_force = True
 62 |         self.horizontal_force = False
 63 |         self.roughness = False
 64 |         self.cyclic_lr = False
 65 |         self.inlet_right = False
 66 |         
 67 | class Solid_Params():
 68 |     def __init__(self,G):
 69 |         self.X = []
 70 |         self.Y = []
 71 |         self.pts_per_cell = 3
 72 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 73 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 74 |         self.n = 0
 75 | 
 76 |         self.mode = 'slope' # ball, blob, slope, excavate
 77 |         self.rho = 2650. # density (kg/m^3)
 78 | 
 79 |         self.law = 'bingham'
 80 |         self.mu_s = 1e0 # shear viscosity
 81 |         self.tau_0 = 1e3 # yield stress
 82 |         self.mu_0 = 1e6*self.mu_s # much steeper viscosity to mimic very rigid part
 83 |         self.mu_v = self.mu_0 # volumetric viscosity
 84 |         self.gamma_c = self.tau_0/(self.mu_0 - self.mu_s)
 85 |         self.K = 1e6 # bulk modulus
 86 | 
 87 | #         self.law = 'dp'
 88 | #         self.G = 1e6
 89 | #         self.K = 1e6
 90 | #         self.mu = 1.
 91 | #         self.beta = 1.
 92 | #         self.s = 10
 93 |         
 94 |         self.slope_angle = 90.
 95 |         self.corner = array((6.,3.,0))    
 96 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 97 |         m = tan(self.slope_angle*pi/180.) # slope gradient
 98 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 99 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
100 |         X = tile(xp,self.y)
101 |         Y = repeat(yp,self.x)
102 |         for i in range(self.x*self.y):
103 |             if (X[i] > self.corner[0] or
104 |                 Y[i] < self.corner[1]):
105 |                 if not ((X[i]>self.corner[0]) and
106 |                        Y[i]>m*(X[i]-self.corner[0])+self.corner[1]):
107 |                     self.X.append(X[i])
108 |                     self.Y.append(Y[i])
109 |                     self.n += 1
110 |         total_area = (G.x_M-G.x_m)*(G.y_M-G.y_m)
111 |         missing_corner = (self.corner[0] - G.x_m)*(G.y_M-self.corner[1])
112 |         self.A = (total_area - missing_corner)/self.n # area (m^2)
113 | 
114 | 
115 | class Output_Params():
116 |     def __init__(self,nt):
117 |         self.measure_energy = False
118 |         self.plot_continuum = True
119 |         self.plot_material_points = True
120 |         self.plot_gamma_dot = False
121 |         self.plot_fluid = False
122 |         self.measure_stiffness = False
123 |         self.check_positions = False
124 |         self.plot_fluid = False
125 |         self.energy = zeros((10*nt+1,4)) # DON'T KNOW NUMBER OF TIMESTEPS!
126 | 
127 | class Fluid_Params():
128 |     def __init__(self):
129 |         self.n = 0
130 |         
131 | class Rigid_Params():
132 |     def __init__(self):
133 |         self.n = 0
134 | 
135 | 


--------------------------------------------------------------------------------
/inputs/poly_avalanche.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,mode):
  7 |         self.dt = 1e-4 # timestep (s)
  8 |         self.savetime = 0.1
  9 |         self.t_f = 1000.0 # 100*self.dt # final time (s)
 10 |         self.max_g = -10. # gravity (ms^-2)
 11 |         self.max_q = 0.
 12 |         self.theta = 45.*pi/180. # slope angle (degrees)
 13 |         self.G = Grid_Params()
 14 |         self.B = Boundary_Params()
 15 |         self.O = Output_Params()#self.nt)
 16 |         self.S = [Solid_Params(self.G)]
 17 |         self.segregate_grid = True
 18 |         self.c = 2.0 # inter-particle drag coefficient
 19 |         self.D = 1e-3 # segregation diffusion coefficient
 20 | 
 21 | 
 22 |     def update_forces(self):
 23 |         t_c = 0.5
 24 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 25 | #         self.g = self.max_g
 26 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 27 | 
 28 | class Grid_Params():
 29 |     def __init__(self):
 30 |         self.x_m = 0.0 # (m)
 31 |         self.x_M = 4.0 # (m)
 32 |         self.y_m = 0.0 # (m)
 33 |         self.y_M = 1.0 # (m)
 34 |         self.ny = 11
 35 |         self.nx = (self.ny-1)*4 + 1
 36 | 
 37 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 38 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 39 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 40 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 41 |         self.s = array([0.5,1.0]) # s coordinate
 42 |         self.ds = self.s[1]-self.s[0]
 43 |         self.ns = len(self.s)
 44 |         
 45 | class Boundary_Params():
 46 |     def __init__(self):
 47 |         self.wall = True
 48 |         self.has_bottom = True
 49 |         self.no_slip_bottom = True
 50 |         self.cyclic_lr = True
 51 | 
 52 | class Solid_Params():
 53 |     def __init__(self,G):
 54 |         self.X = []
 55 |         self.Y = []
 56 |         self.n = 0
 57 |         self.rho = 1000. # density (kg/m^3)
 58 |         self.phi = [0.5,0.5]
 59 | 
 60 | #         self.law = 'pouliquen'
 61 | #         self.mu_s = 0.32
 62 | #         self.mu_2 = 0.6
 63 | #         self.I_0 = 0.4
 64 | #         self.K = 1e6
 65 | #         self.mu_v = 0.
 66 | 
 67 |         self.law = 'viscous_size'
 68 |         self.mu = [1e3, 1e3]
 69 |         self.K = 1e6
 70 |         self.mu_v = 0
 71 |         
 72 | #         self.law = 'bingham'
 73 | #         self.mu_s = 1e2 # shear viscosity
 74 | #         self.tau_0 = 100. # yield stress
 75 | #         self.mu_0 = 1e3*self.mu_s # much steeper viscosity to mimic very rigid part
 76 | #         self.gamma_c = self.tau_0/(self.mu_0 - self.mu_s)
 77 | #         self.K = 1e7 # bulk modulus
 78 | #         self.mu_v = 0. #1e3
 79 |         
 80 |         self.inlet_rate = 0.1
 81 |         filling_fraction = 0.5
 82 |         self.pts_per_cell = 3
 83 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 84 |         self.y = int(round((G.ny-1)*self.pts_per_cell*filling_fraction)) # particles in y direction
 85 |         self.gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 86 |         self.xp = linspace(3.*(G.x_M-G.x_m)/4.,G.x_M-self.gap[0],self.x)
 87 |         self.yp = linspace(G.y_m+self.gap[1],self.gap[1]+filling_fraction*(G.y_M-2*self.gap[1]),self.y)
 88 |         X = tile(self.xp,self.y)
 89 |         Y = repeat(self.yp,self.x)
 90 |         for i in range(int(self.x*self.y)):
 91 |             self.X.append(X[i])
 92 |             self.Y.append(Y[i])
 93 |             self.n += 1
 94 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n*filling_fraction # area (m^2)
 95 | 
 96 | class Output_Params():
 97 |     def __init__(self):#self,nt):
 98 |         self.plot_continuum = True
 99 |         self.plot_gsd_grid = True
100 | #         self.continuum_fig_size = [18,6]
101 | #         self.mp_fig_size = [6,6]


--------------------------------------------------------------------------------
/inputs/poly_seg_test.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,args):
  7 |         self.dt = 1e-5 # timestep (s)
  8 |         self.savetime = 1e2*self.dt#0.0001
  9 |         self.t_f = 10.0 #100.0 # 3*self.dt # final time (s)
 10 |         self.max_g = -9.81 # gravity (ms^-2)
 11 |         self.theta = -float(args[1])*pi/180. # slope angle (degrees)
 12 |         self.pressure = 'lithostatic'
 13 |         
 14 |         self.segregate_grid = True
 15 | #         self.segregate_grid = False
 16 |         self.c = 1.0 # inter-particle drag coefficient
 17 |         self.D = 1e-2 # segregation diffusion coefficient
 18 |         
 19 |         self.G = Grid_Params()
 20 |         self.B = Boundary_Params()
 21 |         self.O = Output_Params(self)#self.nt)
 22 | #         self.S = [Large_Params(self.G,self),Small_Params(self.G,self),]
 23 |         self.S = [Solid_Params(self.G,self),]
 24 | 
 25 |         self.supername = 'im/seg/' + str(self.G.ns) + '/theta_' + args[1] + '/'
 26 |         print(self.supername)
 27 | 
 28 |     def update_forces(self):
 29 | #         t_c = 0.05
 30 | #         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 31 |         self.g = self.max_g
 32 | #         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 33 | #         if self.t > 0.01:
 34 | #             self.segregate_grid = True
 35 | #             self.plot_gsd_grid = True
 36 | 
 37 | class Grid_Params():
 38 |     def __init__(self):
 39 |         self.x_m = 0.0 # (m)
 40 |         self.x_M = 0.02 # (m)
 41 |         self.y_m = 0.0 # (m)
 42 |         self.y_M = 1.0 # (m)
 43 |         self.nx = 2
 44 |         self.ny = 201
 45 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 46 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 47 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 48 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 49 |         self.s = array([0.2,0.4,0.6,0.8,1.0]) # s coordinate
 50 |         self.ds = self.s[1]-self.s[0]
 51 |         self.ns = len(self.s)
 52 |         
 53 | class Boundary_Params():
 54 |     def __init__(self):
 55 |         self.has_bottom = True
 56 |         self.cyclic_lr = True
 57 |         self.roughness = True
 58 |         
 59 | class Solid_Params():
 60 |     def __init__(self,G,P):
 61 |         self.X = []
 62 |         self.Y = []
 63 |         self.n = 0
 64 |         self.rho = 2700. # density (kg/m^3)
 65 |         self.phi = [0.2,0.2,0.2,0.2,0.2]
 66 |         self.law = 'viscous'
 67 | #         mu_s = 1e3
 68 | #         self.mu = [mu_s*P.Mu, mu_s]
 69 | #         self.law = 'viscous_size'
 70 | #         self.law = 'shear_maxwell'
 71 | 
 72 |         self.mu_s = 1e3
 73 | #         self.mu_s = self.phi[0]*self.mu[0] + self.phi[1]*self.mu[1]
 74 |         self.mu_v = 0
 75 |         self.E = 1e6
 76 |         self.nu = 0.499 # poissons ratio
 77 |         self.K = self.E/(3*(1-2*self.nu))
 78 |         self.G = self.E/(2*(1+self.nu))
 79 |         
 80 |         self.pts_per_cell = 3
 81 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 82 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 83 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 84 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 85 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
 86 |         X = tile(xp,self.y)
 87 |         Y = repeat(yp,self.x)
 88 |         for i in range(self.x*self.y):
 89 |             self.X.append(X[i])
 90 |             self.Y.append(Y[i])
 91 |             self.n += 1
 92 | #         self.A = self.conc*(G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 93 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 94 | 
 95 | #         elastic_wave_speed = sqrt(self.K/(self.A*self.rho*1.))
 96 |         elastic_wave_speed = sqrt(self.K/self.rho)
 97 |         distance = minimum(G.dx,G.dy)
 98 |         critical_time = distance/elastic_wave_speed
 99 |         critical_time /= 2. # safety
100 |         if critical_time < P.dt:
101 | #             P.dt = critical_time
102 |             print('WARNING: timestep should be dt = ' + str(critical_time))
103 | 
104 | class Output_Params():
105 |     def __init__(self,P):
106 |         self.plot_continuum = True
107 | #         self.plot_material_points = True
108 |         self.plot_gsd_grid = True
109 |         self.continuum_fig_size = [10,4]


--------------------------------------------------------------------------------
/inputs/seg_unit_test.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | from numpy import *
 3 | import matplotlib.pyplot as plt
 4 | 
 5 | class Params():
 6 |     def __init__(self,mode):
 7 |         self.dt = 1e-8 # timestep (s)
 8 |         self.savetime = 10*self.dt # 0.1
 9 |         self.t_f = 100.0 # 100*self.dt # final time (s)
10 |         self.max_g = -9.81 # gravity (ms^-2)
11 | 
12 |         self.G = Grid_Params()
13 |         self.B = Boundary_Params()
14 |         self.O = Output_Params(self.nt)
15 |         self.S = [Solid_Params(self.G,self)]
16 | 
17 |         self.segregate_grid = True
18 |         self.c = 1e-3 #1. # inter-particle drag coefficient
19 |         self.D = 1e-3 #1e-6 # shear strain rate to kinetic stress constant
20 | 
21 |         self.supername = 'im/seg_unit_test/' + '/ny_' + str(self.G.ny) + '/ns_' + str(self.G.ns) + '/c_' + str(self.c) + '/D_' + str(self.D) + '/'
22 |         self.smooth_gamma_dot = False
23 |         self.time_stepping = 'dynamic' # dynamic or static time steps
24 |         self.CFL = 0.2
25 | 
26 |     def update_forces(self):
27 |         t_c = 0.1
28 | #         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
29 |         self.g = self.max_g
30 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
31 | 
32 | class Grid_Params():
33 |     def __init__(self):
34 |         self.x_m = 0.0 # (m)
35 |         self.x_M = 0.25 # (m)
36 |         self.y_m = 0.0 # (m)
37 |         self.y_M = 1.0 # (m)
38 |         self.nx = 6
39 |         self.ny = 21
40 |         self.x = linspace(self.x_m,self.x_M,self.nx)
41 |         self.y = linspace(self.y_m,self.y_M,self.ny)
42 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
43 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
44 |         self.thickness = 1. # (m)
45 | 
46 | class Boundary_Params():
47 |     def __init__(self):
48 |         self.has_top = True
49 |         self.has_bottom = True
50 |         self.cyclic_lr = True
51 |         self.roughness = True
52 | 
53 | class Solid_Params():
54 |     def __init__(self,G,P):
55 |         self.X = []
56 |         self.Y = []
57 |         self.n = 0
58 | 
59 |         self.law = 'viscous'
60 |         self.rho = 1000. # density (kg/m^3)
61 | 
62 |         self.mu_s = 1e5 # shear viscosity
63 |         self.mu_v = 1e5
64 |         self.K = 0. # pressure viscosity
65 | 
66 |         self.pts_per_cell = 3
67 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
68 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
69 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
70 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
71 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
72 |         X = tile(xp,self.y)
73 |         Y = repeat(yp,self.x)
74 |         for i in range(self.x*self.y):
75 |             self.X.append(X[i])
76 |             self.Y.append(Y[i])
77 |             self.n += 1
78 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
79 | #         P.supername += '/' + str(self.mu_s)
80 | 
81 | class Output_Params():
82 |     def __init__(self,nt):
83 |         self.plot_gsd = True
84 |         self.plot_continuum = True
85 |         self.continuum_fig_size = [10,6]
86 | 


--------------------------------------------------------------------------------
/inputs/silo.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,args):
  7 |         self.dt = 1e-6 # timestep (s)
  8 |         self.savetime = 0.01
  9 |         self.t_f = 10.0 #100.0 # 3*self.dt # final time (s)
 10 |         self.max_g = -9.81 # gravity (ms^-2)
 11 |         self.theta = 0.*pi/180. # slope angle (degrees)
 12 |         self.pressure = 'lithostatic'
 13 | 
 14 |         self.segregate_grid = True
 15 | #         self.segregate_grid = False
 16 |         self.c = 1e-3 # inter-particle drag coefficient
 17 |         self.l = 10. # number of particle diameters for seg diffusion coeff
 18 | 
 19 |         self.G = Grid_Params(args)
 20 |         self.B = Boundary_Params()
 21 |         self.O = Output_Params(self)
 22 |         self.S = [Solid_Params(self.G,self),]
 23 | 
 24 |         self.supername = 'im/silo/ny_' + str(self.G.ny) + '/ns_' + str(self.G.ns) + '/' + '/c_' + str(self.c) + '/l_' + str(self.l) + '/'
 25 |         print(self.supername)
 26 | 
 27 |     def update_forces(self): pass
 28 | 
 29 | class Grid_Params():
 30 |     def __init__(self,args):
 31 |         self.x_m = -0.5 # (m)
 32 |         self.x_M =  0.5 # (m)
 33 |         self.y_m = 0.0 # (m)
 34 |         self.y_M = 2. # (m)
 35 |         self.ny = int(args[1])
 36 |         self.nx = (self.ny-1)//2 + 1
 37 | 
 38 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 39 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 40 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 41 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 42 | 
 43 |         self.R = 10.
 44 |         self.s_M = 0.003 # 3mm
 45 |         self.s_m = self.s_M/self.R
 46 |         self.s = array([self.s_m,self.s_M]) # s coordinate
 47 |         self.ds = self.s[1]-self.s[0]
 48 |         self.ns = len(self.s)
 49 | 
 50 | class Boundary_Params():
 51 |     def __init__(self):
 52 |         self.has_right = True
 53 |         self.has_left = True
 54 |         self.silo_bottom = True
 55 |         self.outlet_bottom = True
 56 | #         self.roughness = True
 57 | 
 58 | class Solid_Params():
 59 |     def __init__(self,G,P):
 60 |         self.X = []
 61 |         self.Y = []
 62 |         self.n = 0
 63 |         self.rho = 2700. # density (kg/m^3)
 64 |         self.packing = 0.6 # packing fraction
 65 |         self.rho_s = self.rho/self.packing # solid density
 66 |         self.phi = ones([G.ns])/float(G.ns)
 67 |         self.law = 'pouliquen'
 68 |         self.mu_0 = tan(deg2rad(20.9)) #0.3
 69 |         self.mu_1 = tan(deg2rad(32.76))
 70 |         self.delta_mu = self.mu_1 - self.mu_0
 71 |         self.I_0 = 0.279
 72 | 
 73 |         self.mu_v = 0
 74 |         self.E = 1e6
 75 |         self.nu = 0.4 # poissons ratio
 76 |         self.K = self.E/(3.*(1.-2.*self.nu))
 77 |         self.G = self.E/(2.*(1.+self.nu))
 78 |         self.eta_max = 100.*self.rho*sqrt(-P.max_g*(G.y_M-G.y_m)**3)
 79 | 
 80 |         self.pts_per_cell = 3
 81 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 82 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 83 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 84 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 85 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
 86 |         X = tile(xp,self.y)
 87 |         Y = repeat(yp,self.x)
 88 |         for i in range(self.x*self.y):
 89 |             self.X.append(X[i])
 90 |             self.Y.append(Y[i])
 91 |             self.n += 1
 92 |         self.A = G.dx*G.dy/self.pts_per_cell**2 # area (m^2)
 93 | 
 94 |     def critical_time(self,P):
 95 |         distance = minimum(P.G.dx,P.G.dy)
 96 |         t_ela = distance/sqrt(self.K/self.rho) # elasticity
 97 |         t_diff = distance**2/self.eta_max*self.rho # momentum diffusivity/viscosity
 98 |         return minimum(t_diff,t_ela)
 99 | 
100 | class Output_Params():
101 |     def __init__(self,P):
102 |         self.plot_continuum = True
103 |         # self.plot_material_points = True
104 |         # self.plot_gsd_grid = True
105 |         self.save_s_bar = True
106 |         self.save_u = True
107 |         self.save_density = True
108 |         self.save_phi_MP = True
109 |         self.continuum_fig_size = [10,10]
110 |         self.mp_fig_size = [10,8]
111 | 


--------------------------------------------------------------------------------
/inputs/slope_stab.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp
  3 | from numpy import linspace,tile,repeat
  4 | import matplotlib.pyplot as plt
  5 | 
  6 | class Params():
  7 |     def __init__(self,mode):
  8 |         self.dt = 1e-4 # timestep (s)
  9 |         self.t_f = 5.#100*self.dt # final time (s)
 10 |         self.savetime = 0.05
 11 |         self.max_g = -9.81 # gravity (ms^-2)
 12 |         self.max_q = 1e3
 13 |         self.theta = 0.*pi/180. # slope angle (degrees)
 14 |         self.G = Grid_Params()
 15 |         self.B = Boundary_Params()
 16 |         self.O = Output_Params()
 17 |         self.S = [Solid_Params(self.G)]
 18 |         self.damping = True # local non-viscous damping
 19 |         self.mode = mode
 20 |         
 21 |     def update_forces(self):
 22 |         t_c = 0.5
 23 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 24 | #         if self.t > 3*t_c:
 25 | #             self.q = self.max_q*(1.-exp(-3.*(self.t-3*t_c)**2/t_c**2))
 26 | #         else:
 27 |         self.q = 0
 28 | 
 29 | class Grid_Params():
 30 |     def __init__(self):
 31 |         self.scale = 5 # grid points per m
 32 |         self.x_m = 0.0 # (m)
 33 |         self.x_M = 12.0 # (m)
 34 |         self.y_m = 0.0 # (m)
 35 |         self.y_M = 6.0 # (m)
 36 |         self.nx = int(self.x_M-self.x_m)*self.scale+1
 37 |         self.ny = int(self.y_M-self.y_m)*self.scale+1
 38 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 39 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 40 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 41 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 42 | 
 43 | class Boundary_Params():
 44 |     def __init__(self):
 45 |         self.has_bottom = True
 46 |         self.has_right = True
 47 |         self.has_left = True
 48 |         self.force_boundaries = True
 49 |         self.vertical_force = True
 50 |         self.horizontal_force = False
 51 |         
 52 | class Solid_Params():
 53 |     def __init__(self,G):
 54 |         self.X = []
 55 |         self.Y = []
 56 |         self.pts_per_cell = 3
 57 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 58 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 59 |         self.n = 0
 60 | 
 61 | #         self.mode = 'slope' # ball, blob, slope, excavate
 62 | # #        self.law = 'elastic'
 63 | 
 64 |         self.rho = 2650. # density (kg/m^3)
 65 | 
 66 | #         self.law = 'von_mises'#         
 67 | #         self.E = 1.e7 # elastic modulus (Pa)
 68 | #         self.nu = 0.3 # poisson's ratio
 69 | #         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 70 | #         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 71 | #         self.s = 2.
 72 | #         self.k = 1e3
 73 | 
 74 |         self.law = 'dp'
 75 |         self.E = 1e6 # elastic modulus (Pa)
 76 |         self.nu = 0.2 # poisson's ratio
 77 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 78 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 79 |         self.mu = 1.
 80 |         self.beta = 1.*self.mu
 81 |         self.s = 1.
 82 | 
 83 |         self.slope_angle = 90.
 84 |         self.corner = array((3.,3.,0))    
 85 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 86 |         m = tan(self.slope_angle*pi/180.) # slope gradient
 87 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 88 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
 89 |         X = tile(xp,self.y)
 90 |         Y = repeat(yp,self.x)
 91 |         for i in range(self.x*self.y):
 92 |             if (X[i] > self.corner[0] or
 93 |                 Y[i] < self.corner[1]):
 94 |                 if not ((X[i]>self.corner[0]) and
 95 |                        Y[i]>m*(X[i]-self.corner[0])+self.corner[1]):
 96 |                     self.X.append(X[i])
 97 |                     self.Y.append(Y[i])
 98 |                     self.n += 1
 99 |         total_area = (G.x_M-G.x_m)*(G.y_M-G.y_m)
100 |         missing_corner = (self.corner[0] - G.x_m)*(G.y_M-self.corner[1])
101 |         self.A = (total_area - missing_corner)/self.n # area (m^2)
102 | 
103 | 
104 | class Output_Params():
105 |     def __init__(self):
106 | #         self.measure_energy = True
107 |         self.plot_continuum = True
108 | #         self.plot_material_points = True
109 |         self.continuum_fig_size = [10,6]


--------------------------------------------------------------------------------
/inputs/tri_seg_test.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,mode):
  7 |         self.dt = 1e-4 # timestep (s)
  8 |         self.savetime = 0.01
  9 |         self.t_f = 10.0 #100.0 # 3*self.dt # final time (s)
 10 |         self.max_g = -9.81 # gravity (ms^-2)
 11 |         self.max_q = 0.
 12 |         self.theta = 18.*pi/180. # slope angle (degrees)
 13 |         self.G = Grid_Params()
 14 |         self.B = Boundary_Params()
 15 |         self.O = Output_Params()#self.nt)
 16 | #         self.S = [Large_Params(self.G,self),Small_Params(self.G,self),]
 17 |         self.S = [Solid_Params(self.G,self),]
 18 |         self.segregate_grid = False
 19 |         self.c = 10.0 # inter-particle drag coefficient
 20 |         if self.segregate_grid: self.supername = 'im/seg/'
 21 |         else: self.supername = 'im/no_seg/'
 22 | 
 23 |     def update_forces(self):
 24 |         t_c = 0.05
 25 | #         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 26 |         self.g = self.max_g
 27 | #         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 28 |         self.q = 0.
 29 | #         if self.t > 0.01:
 30 | #             self.segregate_grid = True
 31 | #             self.plot_gsd_grid = True
 32 | 
 33 | class Grid_Params():
 34 |     def __init__(self):
 35 |         self.x_m = 0.0 # (m)
 36 |         self.x_M = 0.02 # (m)
 37 |         self.y_m = 0.0 # (m)
 38 |         self.y_M = 1.0 # (m)
 39 |         self.nx = 2
 40 |         self.ny = 101
 41 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 42 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 43 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 44 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 45 |         self.s = array([0.5,1.0]) # s coordinate
 46 |         self.ds = self.s[1]-self.s[0]
 47 |         self.ns = len(self.s)
 48 |         
 49 | class Boundary_Params():
 50 |     def __init__(self):
 51 |         self.has_bottom = True
 52 |         self.cyclic_lr = True
 53 |         self.roughness = True
 54 |         
 55 | class Solid_Params():
 56 |     def __init__(self,G,P):
 57 |         self.X = []
 58 |         self.Y = []
 59 |         self.n = 0
 60 |         self.rho = 1000. # density (kg/m^3)
 61 | #         self.size = 1.0 # particle diameter (m)
 62 | #         self.conc = 0.5 # volumetric concentration
 63 |         self.phi = [0.333,0.334,0.333]
 64 |         self.mu = [1e3, 1e3]
 65 | #         self.pressure = 5e3
 66 |         self.law = 'viscous_size'
 67 | 
 68 |         self.mu_s = self.phi[0]*self.mu[0] + self.phi[1]*self.mu[1] + self.phi[2]*self.mu[2]
 69 |         self.K = 1e6
 70 |         self.mu_v = 0
 71 | #         self.mu_v = 1e4
 72 | 
 73 | #         self.law = 'bingham'
 74 | #         self.mu_s = 1e2 # shear viscosity
 75 | #         self.tau_0 = 100. # yield stress
 76 | #         self.mu_0 = 100.*self.mu_s # much steeper viscosity to mimic very rigid part
 77 | #         self.gamma_c = self.tau_0/(self.mu_0 - self.mu_s)
 78 | #         self.K = 1e5 # bulk modulus
 79 | #         self.mu_v = 0 #1e3
 80 | 
 81 | #         self.law = 'pouliquen'
 82 | #         self.K = 1e4
 83 | #         self.mu_s = tan(20.*pi/180.)
 84 | #         self.mu_2 = tan(30.*pi/180.)
 85 | #         self.mu_v = 1e4
 86 | #         self.I_0 = 0.279
 87 |         
 88 |         self.pts_per_cell = 3
 89 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 90 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 91 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 92 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 93 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
 94 |         X = tile(xp,self.y)
 95 |         Y = repeat(yp,self.x)
 96 |         for i in range(self.x*self.y):
 97 |             self.X.append(X[i])
 98 |             self.Y.append(Y[i])
 99 |             self.n += 1
100 | #         self.A = self.conc*(G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
101 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
102 | 
103 |         elastic_wave_speed = sqrt(self.K/(self.A*self.rho*1.))
104 |         distance = minimum(G.dx,G.dy)
105 |         critical_time = distance/elastic_wave_speed
106 |         critical_time /= 2. # safety
107 |         if critical_time < P.dt:
108 | #             P.dt = critical_time
109 |             print('WARNING: timestep should be dt = ' + str(critical_time))
110 | 
111 | class Output_Params():
112 |     def __init__(self):
113 |         self.plot_continuum = True
114 | #         self.plot_material_points = True
115 | #         self.plot_gsd_grid = True
116 |         self.continuum_fig_size = [10,4]


--------------------------------------------------------------------------------
/inputs/triaxial.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp,linspace
  3 | from numpy import random, tile, repeat
  4 | import matplotlib.pyplot as plt
  5 | 
  6 | class Params():
  7 |     def __init__(self,mode):
  8 |         self.dt = 1e-3 # timestep (s)
  9 |         self.tstep = 0
 10 |         self.savetime = 0.1
 11 |         self.t_f = 5.#100*self.dt # final time (s)
 12 |         self.nt = int(self.t_f/self.dt) # number of timesteps
 13 |         self.max_g = 0. # gravity (ms^-2)
 14 |         self.max_q = 200.
 15 |         self.theta = 0.*pi/180. # slope angle (degrees)
 16 |         self.G = Grid_Params()
 17 |         self.B = Boundary_Params()
 18 |         self.O = Output_Params(self.nt)
 19 |         self.S = Solid_Params(self.G)
 20 | 
 21 |     def update_forces(self):
 22 |         t_c = .5
 23 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 24 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 25 | 
 26 | 
 27 | class Grid_Params():
 28 |     def __init__(self):
 29 |         self.scale = 4
 30 |         self.x_m = 0.0 # (m)
 31 |         self.x_M = 1.0 # (m)
 32 |         self.y_m = 0.0 # (m)
 33 |         self.y_M = 2.0 # (m)
 34 |         self.nx = int(self.x_M-self.x_m)*self.scale+1
 35 |         self.ny = int(self.y_M-self.y_m)*self.scale+1
 36 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 37 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 38 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 39 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 40 | 
 41 | class Boundary_Params():
 42 |     def __init__(self):
 43 |         self.force_boundaries = True
 44 |         self.vertical_force = True
 45 |         self.horizontal_force = False
 46 |         self.roughness = True
 47 | 
 48 | class Solid_Params():
 49 |     def __init__(self,G):
 50 |         self.X = []
 51 |         self.Y = []
 52 |         self.x = (G.nx-1)*2 # particles in x direction
 53 |         self.y = (G.ny-1)*2 # particles in y direction
 54 |         self.n = 0
 55 |         self.mode = 'triaxial'
 56 | #        self.law = 'elastic'
 57 |         self.law = 'von_mises'
 58 | #        self.law = 'dp'
 59 |         self.rho = 2650. # density (kg/m^3)
 60 | 
 61 |         self.E = 1.e5 # elastic modulus (Pa)
 62 |         self.nu = 0.3 # poisson's ratio
 63 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
 64 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
 65 | 
 66 |         self.s = 20.
 67 |         self.k = 100.
 68 | 
 69 |         self.beta = .5 # dilatancy coefficient
 70 |         self.mu = 1. # ?
 71 | 
 72 |         gap = G.dx/4.
 73 |         xp = linspace(G.x_m+gap,G.x_M-gap,self.x)
 74 |         yp = linspace(G.y_m+gap,G.y_M-gap,self.y)
 75 |         X = tile(xp,self.y)
 76 |         Y = repeat(yp,self.x)
 77 |         for i in range(self.x*self.y):
 78 |             if i is not (G.scale)*self.x:
 79 |                 self.X.append(X[i])
 80 |                 self.Y.append(Y[i])
 81 |                 self.n += 1
 82 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 83 | 
 84 | 
 85 | class Output_Params():
 86 |     def __init__(self,nt):
 87 |         # self.measure_energy = True
 88 |         self.plot_material_points = True
 89 |         self.plot_continuum = True
 90 |         self.measure_stiffness = True
 91 |         # self.check_positions = True
 92 |         self.energy = zeros((10*nt+1,4)) # energy
 93 | 
 94 |     def measure_E(self,L,P,G):
 95 |         print('Measuring macro and micro stress/strain for each material point... ')
 96 |         for i in range(P.S[0].n):
 97 |             original_position = array((P.S[0].X[i],P.S[0].Y[i],0))
 98 |             macro_strain = (original_position-L.S[0][i].x)/array((P.G.x_M - P.G.x_m,P.G.y_M - P.G.y_m,1.)) #original_position
 99 |             macro_stress = P.max_q/2.
100 |             print('From macroscopic stress/strain:')
101 |             print(macro_stress/macro_strain/P.S[0].E)
102 |             print('From microscopic stress/strain:')
103 |             print(L.S[i].dstress/L.S[i].dstrain/P.S[0].E)
104 | 


--------------------------------------------------------------------------------
/inputs/tunnel.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | from numpy import *
 3 | import matplotlib.pyplot as plt
 4 | 
 5 | class Params():
 6 |     def __init__(self,args):
 7 |         self.dt = 1e-2 # timestep (s)
 8 |         self.savetime = 10*self.dt
 9 |         self.t_f = 10.0 #100.0 # 3*self.dt # final time (s)
10 |         self.max_g = -9.81 # gravity (ms^-2)
11 |         self.theta = 0*pi/180. # slope angle (degrees)
12 |         self.pressure = 'lithostatic'
13 |         self.supername = 'im/tunnel/'
14 |         self.damping = True
15 |         
16 |         self.G = Grid_Params()
17 |         self.B = Boundary_Params()
18 |         self.O = Output_Params(self)
19 |         self.S = [Solid_Params(self.G,self,'in'),Solid_Params(self.G,self,'out')] # in and out of tunnel
20 | 
21 |     def update_forces(self):
22 | #         t_c = 0.05
23 | #         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
24 |         self.g = self.max_g
25 | 
26 | class Grid_Params():
27 |     def __init__(self):
28 |         self.x_m = -100 # (m)
29 |         self.x_M = 100 # (m)
30 |         self.y_m = -100 # (m)
31 |         self.y_M = 0 # (m)
32 |         self.nx = 51
33 |         self.ny = 21
34 |         self.x = linspace(self.x_m,self.x_M,self.nx)
35 |         self.y = linspace(self.y_m,self.y_M,self.ny)
36 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
37 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
38 |         self.tunnel_centre = [0,-30] # m
39 |         self.tunnel_radius = 10 # m
40 | 
41 | class Boundary_Params():
42 |     def __init__(self):
43 |         self.has_bottom = True
44 |         self.cyclic_lr = True
45 |         
46 | class Solid_Params():
47 |     def __init__(self,G,P,portion):
48 |         self.X = []
49 |         self.Y = []
50 |         self.n = 0
51 |         self.rho = 2700. # density (kg/m^3)
52 | 
53 |         self.law = 'elastic_time'
54 |         self.E_0 = 1e7
55 |         self.E_f = self.E_0/1e4
56 |         self.rho_f = self.rho/1e2
57 |         self.nu = 0.3 # poissons ratio
58 |         self.t_0 = 1. # wait for consolidation before relaxation
59 |         self.t_c = 1. # s, relaxation time for elasticity in tunnel
60 | 
61 |         self.pts_per_cell = 3
62 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
63 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
64 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
65 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
66 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
67 |         X = tile(xp,self.y)
68 |         Y = repeat(yp,self.x)
69 |         n_tot = 0
70 |         for i in range(self.x*self.y):
71 |             if portion == 'out':
72 |                 if (X[i]-G.tunnel_centre[0])**2 + (Y[i]-G.tunnel_centre[1])**2 > G.tunnel_radius**2:
73 |                     self.X.append(X[i])
74 |                     self.Y.append(Y[i])
75 |                     self.n += 1
76 |             elif portion == 'in':
77 |                 if (X[i]-G.tunnel_centre[0])**2 + (Y[i]-G.tunnel_centre[1])**2 < G.tunnel_radius**2:
78 |                     self.X.append(X[i])
79 |                     self.Y.append(Y[i])
80 |                     self.n += 1
81 |             n_tot += 1
82 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/n_tot # area (m^2)
83 | 
84 | #         elastic_wave_speed = sqrt(self.K/(self.A*self.rho*1.))
85 |         elastic_wave_speed = sqrt(self.E_0/(3*(1-2*self.nu))/self.rho)
86 |         distance = minimum(G.dx,G.dy)
87 |         critical_time = distance/elastic_wave_speed
88 |         critical_time /= 2. # safety
89 |         if critical_time < P.dt:
90 | #             P.dt = critical_time
91 |             print('WARNING: timestep should be dt = ' + str(critical_time))
92 | 
93 | class Output_Params():
94 |     def __init__(self,P):
95 |         self.plot_continuum = True
96 |         self.continuum_fig_size = [10,4]
97 | #         self.plot_material_points = True
98 | #         self.mp_fig_size = [10,8]


--------------------------------------------------------------------------------
/inputs/vicky.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | from numpy import *
 3 | import matplotlib.pyplot as plt
 4 | 
 5 | class Params():
 6 |     def __init__(self,mode):
 7 |         self.dt = 1e-4 # timestep (s)
 8 |         self.savetime = 0.1
 9 |         self.t_f = 2.#100*self.dt # final time (s)
10 |         self.nt = int(self.t_f/self.dt) # number of timesteps
11 |         self.max_g = -10. # gravity (ms^-2)
12 |         self.theta = 0.*pi/180. # slope angle (degrees)
13 |         self.G = Grid_Params()
14 |         self.B = Boundary_Params()
15 |         self.O = Output_Params()
16 |         self.S = [Solid_Params(self,self.G)]
17 |         self.supername = 'im/pile/H_'+str(self.S[0].H)+'/L_'+str(self.S[0].L)+'/ny_' + str(self.G.ny)+'/'
18 |         self.damping = False
19 |         
20 |     def update_forces(self):
21 |         t_c = .5
22 |         self.g=self.max_g
23 | 
24 | class Grid_Params():
25 |     def __init__(self):
26 |         self.x_m = -1.0 # (m)
27 |         self.x_M = 1.0 # (m)
28 |         self.y_m = 0.0 # (m)
29 |         self.y_M = 1.0 # (m)
30 |         self.ny = 10 # number of grid edges in y direction
31 |         self.nx = 1+2*(self.ny-1) # number of grid edges in x direction
32 |         self.x = linspace(self.x_m,self.x_M,self.nx)
33 |         self.y = linspace(self.y_m,self.y_M,self.ny)
34 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
35 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
36 | 
37 | class Boundary_Params():
38 |     def __init__(self):
39 |         self.has_bottom = True
40 |         
41 | class Solid_Params():
42 |     def __init__(self,P,G):
43 |         self.X = [] # list of material point x coordinates
44 |         self.Y = [] # list of material point y coordinates
45 |         self.n = 0 # number of material points to add
46 |         self.rho = 1000. # density (kg/m^3)
47 |         
48 |         self.law = 'von_mises'
49 |         self.E = 1e6 # elastic modulus (Pa) - use dt = 5e-4
50 |         self.nu = 0.3 # poisson's ratio
51 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
52 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
53 |         self.yield_stress = 5e3   # Pa
54 |         self.k = self.yield_stress/sqrt(2)
55 |         self.s = 1.
56 | 
57 | #         self.law = 'dp'
58 | #         self.E = 1e6 # elastic modulus (Pa) - use dt = 5e-4
59 | #         self.nu = 0.3 # poisson's ratio
60 | #         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
61 | #         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
62 | #         self.mu = 1.
63 | #         self.beta = self.mu #0.5
64 | #         self.s = 1.
65 |         
66 |         self.L = 0.5
67 |         self.H = 1.
68 | 
69 |         self.pts_per_cell = 3
70 |         self.x = int(self.L/(G.x_M-G.x_m)*(G.nx-1))*self.pts_per_cell # particles in x direction
71 |         self.y = int(self.H/(G.y_M-G.y_m)*(G.ny-1))*self.pts_per_cell # particles in y direction
72 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
73 |         xp = linspace(-self.L/2.+gap[0],self.L/2.-gap[0],self.x)
74 |         yp = linspace(gap[1],self.H-gap[1],self.y)
75 |         X = tile(xp,self.y)
76 |         Y = repeat(yp,self.x)
77 |         for i in range(self.x*self.y):
78 |             self.X.append(X[i])
79 |             self.Y.append(Y[i])
80 |             self.n += 1
81 |         self.A = self.L*self.H/self.n # area (m^2)
82 | 
83 | #         elastic_wave_speed = sqrt(self.E/self.rho)
84 | #         distance = minimum(G.dx,G.dy)
85 | #         critical_time = distance/elastic_wave_speed
86 | #         critical_time /= 10. # safety
87 | #         if critical_time < P.dt:
88 | #             P.dt = critical_time
89 | #             P.nt = int(P.t_f/P.dt)
90 | #             print('Reducing timestep to dt = ' + str(P.dt))        
91 |         
92 | class Output_Params():
93 |     def __init__(self):
94 |         self.continuum_fig_size = [20,12]
95 |         self.mp_fig_size = [10,10]
96 |         self.plot_continuum = True
97 |         self.plot_material_points = False


--------------------------------------------------------------------------------
/inputs/vicky_latest.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp,linspace
 3 | from numpy import random, cos, sin, ceil, around, tile, repeat, sqrt
 4 | import matplotlib.pyplot as plt
 5 | 
 6 | class Params():
 7 |     def __init__(self,mode):
 8 |         self.dt = 1e-3 # timestep (s) 5e-4
 9 |         self.savetime = 0.1
10 |         self.t_f = 5.#100*self.dt # final time (s)
11 |         self.nt = int(self.t_f/self.dt) # number of timesteps
12 |         self.max_g = -10. # gravity (ms^-2)
13 |         self.theta = 0.*pi/180. # slope angle (degrees)
14 |         self.segregate = False
15 |         self.G = Grid_Params()
16 |         self.B = Boundary_Params()
17 |         self.O = Output_Params()
18 |         self.S = [Solid_Params(self.G)]
19 |         self.supername = 'slope/'+self.S[0].law+'/H_'+str(self.S[0].H)+'/L_'+str(self.S[0].L)+'/ny_'+str(self.G.ny)+'/'
20 |         self.damping = False
21 |         
22 |     def update_forces(self):
23 |         t_c = .5
24 |         if self.t < t_c:
25 |             self.theta = 30.*pi/180. # converted to radians
26 |         else:
27 |             self.theta = 0.
28 |         self.g=self.max_g
29 | 
30 | class Grid_Params():
31 |     def __init__(self):
32 |         self.x_m = -2.5 # (m)
33 |         self.x_M = 0.5 # (m)
34 |         self.y_m = 0.0 # (m)
35 |         self.y_M = 1.0 # (m)
36 |         self.ny = 20 # number of grid edges in y direction
37 |         self.nx = 2*(self.ny-1)+1 # number of grid edges in x direction
38 |         self.x = linspace(self.x_m,self.x_M,self.nx)
39 |         self.y = linspace(self.y_m,self.y_M,self.ny)
40 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
41 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
42 | 
43 | class Boundary_Params():
44 |     def __init__(self):
45 |         self.has_bottom = True
46 |         self.roughness = True
47 |         self.cyclic_lr = True
48 |         
49 | class Solid_Params():
50 |     def __init__(self,G):
51 |         self.X = [] # list of material point x coordinates
52 |         self.Y = [] # list of material point y coordinates
53 |         self.n = 0 # number of material points to add
54 | 
55 |         self.rho = 1000. # density (kg/m^3)
56 | 
57 | #         self.law = 'von_mises'
58 | #         self.E = 1e6 # elastic modulus (Pa) - use dt = 5e-4
59 | #         self.nu = 0.3 # poisson's ratio
60 | #         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
61 | #         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
62 | #         self.yield_stress = 5e3   # Pa
63 | #         self.k = self.yield_stress/sqrt(3)
64 | #         self.s = 1.
65 | 
66 |         self.law = 'bingham'
67 |         self.pressure = 1e3
68 |         self.mu_v = 0
69 |         self.mu_s = 1e3 # shear viscosity
70 |         self.tau_0 = 100. # yield stress
71 |         self.mu_0 = 100.*self.mu_s # much steeper viscosity to mimic very rigid part
72 |         self.gamma_c = self.tau_0/(self.mu_0 - self.mu_s)
73 |         self.K = 1e6 # bulk modulus
74 | 
75 |         self.L = 1.0
76 |         self.H = 1.0
77 | 
78 |         self.pts_per_cell = 3
79 |         self.x = int(self.L/(G.x_M-G.x_m)*(G.nx-1))*self.pts_per_cell # particles in x direction
80 |         self.y = int(self.H/(G.y_M-G.y_m)*(G.ny-1))*self.pts_per_cell # particles in y direction
81 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
82 |         xp = linspace(-self.L/2.+gap[0],self.L/2.-gap[0],self.x)
83 |         yp = linspace(gap[1],self.H-gap[1],self.y)
84 |         X = tile(xp,self.y)
85 |         Y = repeat(yp,self.x)
86 |         for i in range(self.x*self.y):
87 |             self.X.append(X[i])
88 |             self.Y.append(Y[i])
89 |             self.n += 1
90 |         self.A = self.L*self.H/self.n # area (m^2)
91 |         
92 |         
93 | class Output_Params():
94 |     def __init__(self):
95 |         self.continuum_fig_size = [10,6]
96 |         self.mp_fig_size = [10,10]
97 |         self.plot_continuum = True
98 |         self.plot_material_points = True
99 |         self.check_mesh_dependence = True


--------------------------------------------------------------------------------
/inputs/viscous_unit_test.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | from numpy import *
  3 | import matplotlib.pyplot as plt
  4 | 
  5 | class Params():
  6 |     def __init__(self,mode):
  7 | #         self.supername = 'viscous_unit_test'
  8 |         self.dt = 1e-5 # timestep (s) --- TRY 1./mu_s
  9 |         self.t = 0. # physical time (s)
 10 |         self.tstep = 0
 11 |         self.savetime = 10*self.dt # 0.1
 12 |         self.t_f = 100.0 # 100*self.dt # final time (s)
 13 |         self.nt = int(self.t_f/self.dt) # number of timesteps
 14 |         self.grid_save = 0 # save counter
 15 |         self.mp_save = 0 # save counter
 16 |         self.M_tol = 1e-10 # very small mass (kg)
 17 |         self.max_g = -1. # gravity (ms^-2)
 18 |         self.max_q = 0.
 19 |         self.update_forces()
 20 |         self.theta = 90.*pi/180. # slope angle (degrees)
 21 |         self.thickness = 1. # (m) into page
 22 |         self.G = Grid_Params()
 23 |         self.B = Boundary_Params()
 24 |         self.O = Output_Params(self.nt)
 25 |         self.S = [Solid_Params(self.G,self)]
 26 |         self.F = Fluid_Params()
 27 |         self.R = Fluid_Params()
 28 |         self.has_yielded = False
 29 |         self.damping = True
 30 |         self.mode = mode
 31 | 
 32 |     def update_forces(self):
 33 |         t_c = 0.1
 34 | #         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
 35 |         self.g = self.max_g
 36 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
 37 | 
 38 | class Grid_Params():
 39 |     def __init__(self):
 40 |         self.x_m = 0.0 # (m)
 41 |         self.x_M = 0.25 # (m)
 42 |         self.y_m = 0.0 # (m)
 43 |         self.y_M = 1.0 # (m)
 44 |         self.nx = 6
 45 |         self.ny = 21
 46 |         self.x = linspace(self.x_m,self.x_M,self.nx)
 47 |         self.y = linspace(self.y_m,self.y_M,self.ny)
 48 |         self.dx = self.x[1] - self.x[0] # grid spacing (m)
 49 |         self.dy = self.y[1] - self.y[0] # grid spacing (m)
 50 |         self.thickness = 1. # (m)
 51 |         
 52 | class Boundary_Params():
 53 |     def __init__(self):
 54 |         self.wall = False
 55 |         self.has_top = True
 56 |         self.has_bottom = True
 57 |         self.has_right = False
 58 |         self.has_left = False
 59 |         self.outlet_left = False
 60 |         self.cyclic_lr = True
 61 |         self.force_boundaries = False
 62 |         self.vertical_force = False
 63 |         self.horizontal_force = False
 64 |         self.roughness = True
 65 | 
 66 | class Solid_Params():
 67 |     def __init__(self,G,P):
 68 |         self.X = []
 69 |         self.Y = []
 70 |         self.n = 0
 71 | 
 72 |         self.law = 'viscous'
 73 |         self.rho = 1000. # density (kg/m^3)
 74 |         
 75 |         self.mu_s = 1e5 # shear viscosity
 76 |         self.mu_v = 1e5
 77 |         self.K = 0. # pressure viscosity
 78 |         
 79 |         self.pts_per_cell = 3
 80 |         self.x = (G.nx-1)*self.pts_per_cell # particles in x direction
 81 |         self.y = (G.ny-1)*self.pts_per_cell # particles in y direction
 82 |         gap = array((G.dx,G.dy))/(2*self.pts_per_cell)
 83 |         xp = linspace(G.x_m+gap[0],G.x_M-gap[0],self.x)
 84 |         yp = linspace(G.y_m+gap[1],G.y_M-gap[1],self.y)
 85 |         X = tile(xp,self.y)
 86 |         Y = repeat(yp,self.x)
 87 |         for i in range(self.x*self.y):
 88 |             self.X.append(X[i])
 89 |             self.Y.append(Y[i])
 90 |             self.n += 1
 91 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
 92 | #         P.supername += '/' + str(self.mu_s)
 93 | 
 94 | class Output_Params():
 95 |     def __init__(self,nt):
 96 |         self.measure_energy = False
 97 |         self.plot_continuum = True
 98 |         self.plot_material_points = False
 99 |         self.measure_stiffness = False
100 |         self.check_positions = False
101 |         self.plot_fluid = False
102 |         self.energy = zeros((nt+1,4)) # energy
103 |         self.continuum_fig_size = [10,6]
104 |             
105 | class Fluid_Params():
106 |     def __init__(self):
107 |         self.n = 0
108 | 
109 |         
110 | class Rigid_Params():
111 |     def __init__(self):
112 |         self.n = 0
113 | 
114 | 


--------------------------------------------------------------------------------
/inputs/vm_unit_test.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | from numpy import pi,array,dot,tan,zeros,eye,cumsum,outer,sum,trace,exp,linspace
 3 | from numpy import random
 4 | import matplotlib.pyplot as plt
 5 | 
 6 | class Params():
 7 |     def __init__(self,mode):
 8 |         self.dt = 1e-3 # timestep (s)
 9 |         self.t = 0. # physical time (s)
10 |         self.tstep = 0
11 |         self.savetime = 0.1
12 |         self.t_f = 1.#100*self.dt # final time (s)
13 |         self.nt = int(self.t_f/self.dt) # number of timesteps
14 |         self.save = 0 # save counter
15 |         self.M_tol = 1e-10 # very small mass (kg)
16 |         self.max_g = 0. # gravity (ms^-2)
17 |         self.max_q = 1.
18 |         self.update_forces()
19 |         self.theta = 0.*pi/180. # slope angle (degrees)
20 | 
21 |         self.G = Grid_Params()
22 |         self.B = Boundary_Params()
23 |         self.O = Output_Params(self.nt)
24 |         self.S = Solid_Params(self.G)
25 |         self.damping = True
26 |         self.mode = mode
27 | 
28 |     def update_forces(self):
29 |         t_c = .05
30 |         self.g = self.max_g*(1.-exp(-3.*self.t**2/t_c**2))
31 |         self.q = self.max_q*(1.-exp(-3.*self.t**2/t_c**2))
32 | 
33 | class Grid_Params():
34 |     def __init__(self):
35 |         self.x_m = 0.0 # (m)
36 |         self.x_M = 1.0 # (m)
37 |         self.y_m = 0.0 # (m)
38 |         self.y_M = 1.0 # (m)
39 |         self.nx = 2
40 |         self.ny = 2
41 |         
42 | class Boundary_Params():
43 |     def __init__(self):
44 |         self.force_boundaries = True
45 |         self.horizontal_force = True
46 | 
47 | class Solid_Params():
48 |     def __init__(self,G):
49 |         self.X = []
50 |         self.Y = []
51 |         self.x = 3#(10*2-1)*2 # particles in x direction
52 |         self.y = 3#(5*2-1)*2-4 # particles in y direction
53 |         self.n = 0
54 | 
55 | #        self.law = 'elastic'
56 |         self.law = 'von_mises'
57 |         self.rho = 2650. # density (kg/m^3)
58 |         
59 |         self.E = 1.e8 # elastic modulus (Pa)
60 |         self.nu = 0. # poisson's ratio
61 |         self.K = self.E/(3.*(1.-2.*self.nu)) # bulk modulus (Pa)
62 |         self.G = self.E/(2.*(1.+self.nu)) # shear modulus (Pa)
63 | 
64 |         self.s = 2.5
65 |         self.k = self.E/100
66 | 
67 |         self.L = 0.9
68 |         self.W = 0.9
69 |         for x in linspace(0.5-self.L/2.,0.5+self.L/2.,self.x):
70 |             for y in linspace(0.5-self.W/2.,0.5+self.W/2.,self.y):
71 |                 self.X.append(x)
72 |                 self.Y.append(y)
73 |                 self.n += 1
74 | 
75 |         self.A = (G.x_M-G.x_m)*(G.y_M-G.y_m)/self.n # area (m^2)
76 | 
77 | class Output_Params():
78 |     def __init__(self,nt):
79 |         self.plot_continuum = False
80 |         self.plot_material_points = True
81 |         self.measure_energy = True
82 |         self.measure_stiffness = True
83 | 
84 |     def measure_E(self,P,L):
85 |         print('Measuring macro and micro stress/strain for each material point... ')
86 |         for p in range(P.phases):
87 |             for i in range(P.S[p].n):
88 |                 original_position = array((P.S[p].X[i],P.S[p].Y[i],0))
89 |                 macro_stress = P.max_q/2.
90 |                 macro_strain = (original_position-L.S[p][i].x)/array((P.S[p].L,P.S[p].W,1.)) #original_position
91 |                 print('MP ' + str(i))
92 |                 print('Macro response:' + str(macro_stress/macro_strain/P.S[p].E) + '*E')
93 |                 print('Micro values:' + str(L.S[p][i].dstress/L.S[p][i].dstrain/P.S[p].E) + '*E')


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | astropy==5.3.3
 2 | cycler==0.10.0
 3 | kiwisolver==1.2.0
 4 | matplotlib==3.2.2
 5 | numpy==1.22.0
 6 | pyparsing==2.4.7
 7 | python-dateutil==2.8.1
 8 | scipy==1.10.0
 9 | six==1.15.0
10 | 


--------------------------------------------------------------------------------