├── .gitignore
├── .mailmap
├── .readthedocs.yaml
├── .travis.yml
├── AUTHORS
├── COPYING
├── COPYRIGHT
├── Makefile.am
├── NEWS.md
├── README.md
├── TODO
├── autogen.sh
├── codemeta.json
├── configure.ac
├── doc
    ├── README
    ├── docs
    │   ├── Acknowledgements.md
    │   ├── Data_Analysis_Tutorial.md
    │   ├── Developer_Information.md
    │   ├── Download.md
    │   ├── Guile_and_Scheme_Information.md
    │   ├── Installation.md
    │   ├── Introduction.md
    │   ├── License_and_Copyright.md
    │   ├── Python_Data_Analysis_Tutorial.md
    │   ├── Python_Tutorial.md
    │   ├── Python_User_Interface.md
    │   ├── Scheme_Tutorial.md
    │   ├── Scheme_User_Interface.md
    │   ├── The_Run_Function_Is_Not_A_Loop.md
    │   ├── images
    │   │   ├── Mpb-logo.jpg
    │   │   ├── diamond-b1-eps.gif
    │   │   ├── diamond-b1.gif
    │   │   ├── diamond-b3-eps.gif
    │   │   ├── diamond-b3.gif
    │   │   ├── diamond-bands.gif
    │   │   ├── diamond-eps.gif
    │   │   ├── tri-lattice.png
    │   │   ├── tri-rods-bands.png
    │   │   ├── tri-rods-eps-1.gif
    │   │   ├── tri-rods-eps-2.gif
    │   │   ├── tri-rods-ez1.gif
    │   │   ├── tri-rods-ez2.gif
    │   │   ├── tri-rods-ez3.gif
    │   │   ├── tri-rods-ez4.gif
    │   │   ├── tri-rods-ez5.gif
    │   │   ├── tri-rods-ez6.gif
    │   │   ├── tri-rods-ez7.gif
    │   │   └── tri-rods-ez8.gif
    │   └── index.md
    ├── mpb-mkdocs-theme
    │   ├── base.html
    │   ├── breadcrumbs.html
    │   ├── css
    │   │   ├── highlight.css
    │   │   ├── theme.css
    │   │   └── theme_extra.css
    │   ├── fonts
    │   │   ├── fontawesome-webfont.eot
    │   │   ├── fontawesome-webfont.svg
    │   │   ├── fontawesome-webfont.ttf
    │   │   └── fontawesome-webfont.woff
    │   ├── footer.html
    │   ├── img
    │   │   └── Mpb-logo.jpg
    │   ├── js
    │   │   ├── extra.js
    │   │   ├── highlight.pack.js
    │   │   ├── jquery-2.1.1.min.js
    │   │   ├── mathjaxhelper.js
    │   │   ├── modernizr-2.8.3.min.js
    │   │   └── theme.js
    │   ├── license
    │   │   └── highlight.js
    │   │   │   └── LICENSE
    │   ├── search.html
    │   ├── searchbox.html
    │   ├── toc.html
    │   └── versions.html
    └── requirements.txt
├── examples
    ├── Makefile.am
    ├── bragg-sine.ctl
    ├── bragg.ctl
    ├── check.ctl
    ├── diamond.ctl
    ├── dos.scm
    ├── hole-slab.ctl
    ├── honey-rods.ctl
    ├── line-defect.ctl
    ├── sq-rods.ctl
    ├── strip.ctl
    ├── tri-holes.ctl
    ├── tri-rods.ctl
    ├── tutorial.ctl
    ├── twodim-min-tetm.ctl
    └── wavevector.scm
├── m4
    ├── ax_blas.m4
    ├── ax_lapack.m4
    ├── ax_mpi.m4
    └── ax_openmp.m4
├── mkdocs.yml
├── mpb
    ├── Makefile.am
    ├── epsilon.c
    ├── epsilon_file.c
    ├── field-smob.c
    ├── field-smob.h
    ├── fields.c
    ├── material_grid.c
    ├── material_grid_opt.c
    ├── matrix-smob.c
    ├── matrix-smob.h
    ├── medium.c
    ├── mpb-split-preinstall.in
    ├── mpb-split.1
    ├── mpb.1
    ├── mpb.c
    ├── mpb.h
    ├── mpb.scm.in
    ├── my-smob.h
    └── transform.c
├── src
    ├── Makefile.am
    ├── matrices
    │   ├── Makefile.am
    │   ├── README
    │   ├── blasglue.c
    │   ├── blasglue.h
    │   ├── eigensolver.c
    │   ├── eigensolver.h
    │   ├── eigensolver_davidson.c
    │   ├── eigensolver_utils.c
    │   ├── evectmatrix.c
    │   ├── linmin.c
    │   ├── linmin.h
    │   ├── matrices.c
    │   ├── matrices.h
    │   ├── minpack2-linmin.c
    │   ├── scalar.h
    │   └── sqmatrix.c
    ├── matrixio
    │   ├── Makefile.am
    │   ├── evectmatrixio.c
    │   ├── fieldio.c
    │   ├── matrixio.c
    │   └── matrixio.h
    ├── maxwell
    │   ├── Makefile.am
    │   ├── README
    │   ├── imaxwell.h
    │   ├── maxwell.c
    │   ├── maxwell.h
    │   ├── maxwell_constraints.c
    │   ├── maxwell_eps.c
    │   ├── maxwell_op.c
    │   ├── maxwell_pre.c
    │   └── xyz_loop.h
    ├── mpbconf.h.in
    └── util
    │   ├── Makefile.am
    │   ├── check.h
    │   ├── debug_malloc.c
    │   ├── mpi_utils.c
    │   ├── mpi_utils.h
    │   ├── mpiglue.h
    │   ├── sphere-quad.c
    │   ├── verbosity.c
    │   └── verbosity.h
├── tests
    ├── Makefile.am
    ├── blastest.c
    ├── blastest.complex.out
    ├── blastest.real.out
    ├── eigs_test.c
    ├── malloctest.c
    ├── maxwell_test.c
    └── normal_vectors.c
└── utils
    ├── Makefile.am
    ├── mpb-data.1
    └── mpb-data.c


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.tar.gz
 2 | *.exe
 3 | *.dll
 4 | *.do
 5 | *.o
 6 | *.lo
 7 | *.a
 8 | *.la
 9 | *.dylib
10 | *.dSYM
11 | *.zip
12 | *.native
13 | _build
14 | 
15 | # autotools stuff
16 | Makefile
17 | Makefile.in
18 | .deps
19 | .libs
20 | stamp-h*
21 | install-sh
22 | libtool
23 | ltmain.sh
24 | m4/libtool.m4
25 | m4/ltoptions.m4
26 | m4/ltsugar.m4
27 | m4/ltversion.m4
28 | m4/lt~obsolete.m4
29 | configure
30 | config.*
31 | autom4te.cache
32 | INSTALL
33 | aclocal.m4
34 | depcomp
35 | missing
36 | py-compile
37 | compile
38 | 
39 | # other generated files
40 | mpb-split-preinstall
41 | mpb.scm
42 | mpbconf.h
43 | ctl.h
44 | gen-ctl-io
45 | ctl-io.c
46 | ctl-io.h
47 | mpb/geom.c
48 | mpb/main.c
49 | mpb/mpb
50 | mpb/mpb-split
51 | src/mpb.h
52 | src/util/sphere-quad.h
53 | src/util/sphere_quad
54 | tests/blastest
55 | tests/eigs_test
56 | tests/malloctest
57 | tests/maxwell_test
58 | tests/normal_vectors
59 | utils/mpb-data
60 | mpb/mpbi
61 | mpb/mpbi-split
62 | src/mpbi.h
63 | utils/mpbi-data
64 | mpb/mpb_mpi
65 | src/mpb_mpi.h
66 | mpb/mpbi_mpi
67 | src/mpbi_mpi.h
68 | mpb/mu.c
69 | doc/site
70 | 
71 | # local editor settings
72 | .vscode
73 | 
74 | # test output:
75 | check-epsilon.h5
76 | check-mu.h5
77 | tests/blastest.out
78 | tests/maxwell_test.out
79 | tests/maxwell_test_2.out
80 | 
81 | examples/*.h5
82 | examples/*.png
83 | 


--------------------------------------------------------------------------------
/.mailmap:
--------------------------------------------------------------------------------
1 | Steven G. Johnson <stevenj@alum.mit.edu> <stevenj@mit.edu>
2 | Steven G. Johnson <stevenj@alum.mit.edu> <stevenj@math.mit.edu>
3 | Steven G. Johnson <stevenj@alum.mit.edu> <stevenj@fftw.org>
4 | Steven G. Johnson <stevenj@alum.mit.edu> <stevenj.mit@gmail.com>
5 | Steven G. Johnson <stevenj@alum.mit.edu> <stevenj@ab-initio.mit.edu>
6 | Steven G. Johnson <stevenj@alum.mit.edu> <stevenj@fftw.org>
7 | Steven G. Johnson <stevenj@alum.mit.edu> <none>
8 | 


--------------------------------------------------------------------------------
/.readthedocs.yaml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | 
 3 | build:
 4 |   os: ubuntu-22.04
 5 |   tools:
 6 |     python: "3.10"
 7 | 
 8 | mkdocs:
 9 |   configuration: mkdocs.yml
10 | 
11 | python:
12 |    install:
13 |    - requirements: doc/requirements.txt
14 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: c
 2 | sudo: false
 3 | dist: trusty
 4 | 
 5 | addons:
 6 |   apt:
 7 |     packages: &common_pkgs
 8 |       - autoconf
 9 |       - automake
10 |       - libtool
11 |       - guile-2.0-dev
12 |       - liblapack-dev
13 |       - libblas-dev
14 |       - gfortran
15 |       - git
16 |       - libfftw3-dev
17 | 
18 | before_script:
19 |   - git clone https://github.com/stevengj/libctl
20 |   - (cd libctl && git checkout master && sh autogen.sh --prefix=$HOME/local && make && make install)
21 | 
22 | script:
23 |   - |
24 |     sh autogen.sh \
25 |     --enable-maintainer-mode \
26 |     --prefix=$HOME/local \
27 |     --with-libctl=$HOME/local/share/libctl \
28 |     ${MPI_FLAG} \
29 |     ${HERM_EPS} \
30 |     ${INV_SYM} \
31 |     GEN_CTL_IO=$HOME/local/bin/gen-ctl-io \
32 |     CPPFLAGS="-I$HOME/local/include ${CPPFLAGS}" \
33 |     LDFLAGS="-L$HOME/local/lib ${LDFLAGS}"
34 |   - make && make check && make install
35 | 
36 | matrix:
37 |   include:
38 |     - os: linux
39 |       env:
40 |         - MPI_FLAG=
41 |         - HERM_EPS=
42 |         - INV_SYM=
43 |       addons:
44 |         apt:
45 |           packages:
46 |             - *common_pkgs
47 |             - libhdf5-serial-dev
48 |     - os: linux
49 |       env:
50 |         - MPI_FLAG="--with-mpi CC=mpicc"
51 |         - HERM_EPS=--with-hermitian-eps
52 |         - INV_SYM=
53 |       addons:
54 |         apt:
55 |           packages:
56 |             - *common_pkgs
57 |             - libopenmpi-dev
58 |             - mpi-default-bin
59 |             - openmpi-bin
60 |             - libfftw3-mpi-dev
61 |             - libhdf5-openmpi-dev
62 |     - os: osx
63 |       env:
64 |         - MPI_FLAG=
65 |         - HERM_EPS=
66 |         - INV_SYM=--with-inv-symmetry
67 |       install:
68 |         - brew update
69 |         - brew install guile fftw lapack
70 | 


--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
1 | MPB was written by Steven G. Johnson (stevenj@alum.mit.edu) with contributions by:
2 | 
3 | M.T. Homer Reid
4 | Christopher Hogan
5 | Ardavan Oskooi
6 | Thomas Christensen
7 | 
8 | and others listed in the git logs (https://github.com/NanoComp/mpb/graphs/contributors).
9 | 


--------------------------------------------------------------------------------
/COPYRIGHT:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | 


--------------------------------------------------------------------------------
/Makefile.am:
--------------------------------------------------------------------------------
 1 | ACLOCAL_AMFLAGS=-I m4
 2 | 
 3 | SUBDIRS = src tests
 4 | 
 5 | if WITH_LIBCTL
 6 | SUBDIRS += mpb examples
 7 | endif
 8 | if WITH_LIBCTLGEOM
 9 | SUBDIRS += utils
10 | endif
11 | 
12 | EXTRA_DIST = COPYRIGHT TODO m4 README.md NEWS.md
13 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Latest Docs](https://readthedocs.org/projects/pip/badge/?version=latest)](http://mpb.readthedocs.io/en/latest/)
 2 | [![Build Status](https://travis-ci.org/NanoComp/mpb.svg?branch=master)](https://travis-ci.org/NanoComp/mpb)
 3 | 
 4 | MPB is a free and open-source software package for computing electromagnetic band structures and modes.
 5 | 
 6 | ## Features
 7 | 
 8 | -   **Free and open-source software** under the [GNU GPL](https://en.wikipedia.org/wiki/GNU_General_Public_License).
 9 | -   Complete **scriptability** via [Python](Python_Tutorial) or [Scheme](Scheme_User_Interface) APIs.
10 | -   Portable to any Unix-like system such as [Linux](https://en.wikipedia.org/wiki/Linux), [macOS](https://en.wikipedia.org/wiki/MacOS), and [FreeBSD](https://en.wikipedia.org/wiki/FreeBSD).
11 | -   Distributed memory **parallelism** on any system supporting the [MPI](https://en.wikipedia.org/wiki/Message_Passing_Interface) standard.
12 | -   Fully-vectorial **1d, 2d, 3d** calculations. Iterative eigensolver techniques are employed to make large calculations possible.
13 | -   **Direct, frequency-domain eigensolver** as opposed to indirect methods, e.g. time-domain. This means that you get both eigenvalues (frequencies) and eigenstates (electromagnetic modes) at the same time. See [comparison of time-domain and frequency-domain techniques](Introduction.md#frequency-domain-vs-time-domain).
14 | -   **Targeted eigensolver**. Iterative eigensolvers normally compute states (harmonic modes) with the lowest few frequencies. MPB can alternatively compute the modes whose frequencies are closest to a specified target frequency. This greatly reduces the number of bands that must be computed in guided or resonant mode calculations.
15 | -   Support for arbitrary, **anisotropic** dielectrics including **gyrotropic/magneto-optic** materials and **non-orthogonal** unit cells. Lossy and wavelength-dependent $\varepsilon$ and $\mu$ are not supported.
16 | -   Field output in the [HDF5](https://support.hdfgroup.org/HDF5/) data format.
17 | 
18 | ## Citing MPB
19 | 
20 | We kindly request that you cite the following reference in any publication for which you use MPB:
21 | 
22 | * Steven G. Johnson and J. D. Joannopoulos, [Block-iterative frequency-domain methods for Maxwell's equations in a planewave basis](http://www.opticsinfobase.org/abstract.cfm?URI=oe-8-3-173), *Optics Express* vol. **8**, no. 3, pp. 173–190 (2001).
23 | 
24 | ## Documentation
25 | 
26 | See the [manual on readthedocs](https://mpb.readthedocs.io/en/latest) for the latest documentation.
27 | 


--------------------------------------------------------------------------------
/TODO:
--------------------------------------------------------------------------------
 1 | Add more example files: more 3d crystals, strip waveguide, ...
 2 | 
 3 | Export/import DXF, VRML, POV, ...?  Import full epsilon tensor from a file.
 4 | 
 5 | Make mpb-data pick default -n when -r is used.
 6 | 
 7 | More eigensolver improvements...adaptive selection of an iteration technique?
 8 | 
 9 | Try Jacobi-Davidson method with harmonic eigenvalues for targeted solver.
10 | 
11 | World domination.
12 | 


--------------------------------------------------------------------------------
/autogen.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | # paranoia: sometimes autoconf doesn't get things right the first time
4 | autoreconf --verbose --install --symlink --force
5 | autoreconf --verbose --install --symlink --force
6 | autoreconf --verbose --install --symlink --force
7 | 
8 | ./configure --enable-maintainer-mode "$@"
9 | 


--------------------------------------------------------------------------------
/codemeta.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
 3 |   "@type": "SoftwareSourceCode",
 4 |   "name": "MPB",
 5 |   "description": "MPB is a free software package for computing photonic band structures and modes.",
 6 |   "url": "https://github.com/stevengj/mpb",
 7 |   "codeRepository": "https://github.com/stevengj/mpb",
 8 |   "issueTracker": "https://github.com/stevengj/mpb/issues",
 9 |   "license": "https://spdx.org/licenses/GPL-2.0-or-later.html",
10 |   "citation": "http://dx.doi.org/10.1364/OE.8.000173",
11 |   "author": [
12 |     {
13 |       "@type": "Person",
14 |       "givenName": "Steven G.",
15 |       "familyName": "Johnson",
16 |       "email": "stevenj@alum.mit.edu",
17 |       "@id": "http://orcid.org/0000-0001-7327-4967"
18 |     }
19 |   ],
20 |   "developmentStatus": "active",
21 |   "downloadUrl": "https://github.com/stevengj/mpb/releases",
22 |   "version":"1.7.0",
23 |   "dateCreated":"1998-05-20",
24 |   "datePublished":"1999-11-19",
25 |   "programmingLanguage": ["C", "Scheme"]
26 | }
27 | 


--------------------------------------------------------------------------------
/doc/README:
--------------------------------------------------------------------------------
 1 | This is the documentation tree for MPB.
 2 | 
 3 | Markdown (.md) files for MPB documentation are in the doc/docs.
 4 | 
 5 | To build and visualize the HTML documentation locally using the
 6 | mkdocs package (useful for verifying on your local machine before
 7 | committing), install the `mkdocs` package, then run the 
 8 | following command from the top-level mpb repository tree:
 9 | 
10 | % mkdocs serve
11 | 
12 | and then open the following URL in a browser window:
13 | 
14 | http://127.0.0.1:8000
15 | 
16 | This launches a little web server on your local machine
17 | plus a filesystem hook for rebuilding the documentation
18 | tree automatically whenever any .md file is modified, so
19 | you can see what the actual HTML documentation looks
20 | like in real time as you edit the source.
21 | 


--------------------------------------------------------------------------------
/doc/docs/Acknowledgements.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | Acknowledgements
 3 | ---
 4 | 
 5 | MPB originated as part of graduate research at MIT with initial contributions by [Steven G. Johnson](http://math.mit.edu/~stevenj/).  We are also grateful to R. D. Meade *et al.* for developing a Fortran band-structure program that helped to inspire MPB and provided early numerical validation results, along with an [algorithm for anisotropic sub-pixel averaging](http://link.aps.org/abstract/PRB/v48/p8434) that MPB still uses in a [modified form](http://doi.org/10.1103/PhysRevE.77.036611) today (via an independent software implementation).  Significant contributions to MPB have been made by [Simpetus](http://www.simpetus.com) (which funded the Python API and several other major developments) and by the developer community on [GitHub](https://github.com/NanoComp/mpb).
 6 | 
 7 | Referencing
 8 | -----------
 9 | 
10 | We kindly request that you cite the following reference in any publication for which you use MPB:
11 | 
12 | - Steven G. Johnson and J. D. Joannopoulos, [Block-iterative frequency-domain methods for Maxwell's equations in a planewave basis](http://www.opticsinfobase.org/abstract.cfm?URI=oe-8-3-173), *Optics Express* **8**, no. 3, 173-190 (2001). ([pdf](http://math.mit.edu/~stevenj/papers/JohnsonJo01.pdf))
13 | 
14 | Financial Support
15 | -----------------
16 | 
17 | MPB's development has been supported in part by Small Business Innovation Research (SBIR) Phase 1 and 2 awards from the National Science Foundation (NSF) under award numbers [1647206](https://www.nsf.gov/awardsearch/showAward?AWD_ID=1647206) and [1758596](https://www.nsf.gov/awardsearch/showAward?AWD_ID=1758596). Initial development was supported in part by the Materials Research Science and Engineering Center program of the National Science Foundation under Grant No. DMR-9400334, the U.S. Army Research Office under contract/grant DAAG55-97-1-0366, a National Defense Science and Engineering Fellowship, and an MIT Karl Taylor Compton Fellowship.
18 | 


--------------------------------------------------------------------------------
/doc/docs/Download.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | # Download
 3 | ---
 4 | 
 5 | The latest development source is on [GitHub](https://github.com/NanoComp/mpb).
 6 | 
 7 | The current stable release can be downloaded from:
 8 | 
 9 | - <https://github.com/NanoComp/mpb/releases>
10 | 
11 | Refer to [NEWS](https://github.com/NanoComp/mpb/blob/master/NEWS.md) to see what's new in this version, and be sure to read the [Installation](Installation.md) for how to compile and install it.
12 | 
13 | Please subscribe to the **mpb-announce** mailing list to receive notifications when new versions are released:
14 | 
15 | -   [mpb-announce mailing list](http://ab-initio.mit.edu/cgi-bin/mailman/listinfo/mpb-announce)
16 | 
17 | MPB on Amazon Web Services (AWS)
18 | ---------------------------------
19 | 
20 | The most recent, stable version of MPB preinstalled on [Ubuntu](https://en.wikipedia.org/wiki/Ubuntu) can be accessed for free on Amazon Web Services (AWS) Elastic Compute Cloud (EC2) as an [Amazon Machine Image (AMI)](https://aws.amazon.com/marketplace/pp/B01KHWH0AS) provided by [Simpetus](http://www.simpetus.com/launchsims.html).
21 | 
22 | Precompiled MPB Packages for and Ubuntu
23 | ---------------------------------------
24 | 
25 | Precompiled packages of MPB are available for [Ubuntu](https://en.wikipedia.org/wiki/Ubuntu) as **mpb**. The Ubuntu 16.10 package is available in the [science](https://packages.ubuntu.com/yakkety/mpb) repository. We highly recommend using Ubuntu as MPB and all of its dependencies can be installed using just one line:
26 | 
27 | ```
28 | sudo apt-get install mpb h5utils
29 | ```
30 | 
31 | You can also install the [parallel version of MPB](https://packages.ubuntu.com/trusty/science/mpb-mpi) which is based on [MPICH](https://www.mpich.org/) using:
32 | 
33 | ```
34 | sudo apt-get install mpb-mpi
35 | ```


--------------------------------------------------------------------------------
/doc/docs/Guile_and_Scheme_Information.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | # Guile and Scheme Information
 3 | ---
 4 | 
 5 | There are many places you can go to find out more regarding Guile and the Scheme programming language. We list a few of them here.
 6 | 
 7 | [TOC]
 8 | 
 9 | Scheme
10 | -------
11 | 
12 | Scheme is a simplified derivative of [Lisp](https://en.wikipedia.org/wiki/Lisp), and is a small and beautiful dynamically typed, [lexically scoped](https://en.wikipedia.org/wiki/Lexical_variable_scoping), [functional](https://en.wikipedia.org/wiki/Functional_programming_language) language.
13 | 
14 | -   A [history and introduction to Scheme](https://en.wikipedia.org/wiki/Scheme_programming_language)
15 | -   [R5RS](http://www.swiss.ai.mit.edu/ftpdir/scheme-reports/r5rs-html/r5rs_toc.html) is the official Scheme language definition and reference.
16 | -   A classic [introduction](ftp://ftp.cs.indiana.edu/pub/scheme-repository/doc/pubs/intro.txt) to Scheme by Ken Dickey.
17 | -   [Structure and Interpretation of Computer Programs](http://mitpress.mit.edu/sicp/sicp.html) by Abelson, Sussman, and Sussman (full text online).
18 | -   [Introduction to Scheme and its Implementation](ftp://ftp.cs.utexas.edu/pub/garbage/cs345/schintro-v14/schintro_toc.html) (the complete book on-line) by Prof. Paul R. Wilson ([Univ. of Texas](http://www.cs.utexas.edu/)).
19 | -   [Teach Yourself Scheme](http://ds26gte.github.io/tyscheme/index.html) is a nice tutorial-style introduction to Scheme programming.
20 | -   The [MIT Scheme Home Page](http://www.swiss.ai.mit.edu/projects/scheme/index.html) (where do you think Scheme was invented?)
21 |     -   also check out the MIT [Scheme Underground](http://www.ai.mit.edu/projects/su/su.html)
22 | -   There is the [comp.lang.scheme](news:comp.lang.scheme) newsgroup, and its [FAQ](http://www.faqs.org/faqs/by-newsgroup/comp/comp.lang.scheme.html).
23 | -   The [Internet Scheme Repository](http://www.cs.indiana.edu/scheme-repository/) has a lot of code and documentation.
24 | -   [schemers.org](http://www.schemers.org/) is another Scheme site and collection of resources.
25 | 
26 | Guile
27 | ------
28 | 
29 | Guile is a free implementation of Scheme, designed to be plugged in to other programs as a scripting language.
30 | 
31 | -   The [homepage](http://www.gnu.org/software/guile/) for the GNU Guile project.
32 | -   See parts IV and V of the [Guile Reference Manual](http://www.gnu.org/software/guile/manual/html_node/index.html) for additional Scheme functions and types defined within the Guile environment.
33 | 
34 | How to Write a Loop in Scheme
35 | -----------------------------
36 | 
37 | The most frequently asked question seems to be: **how do I write a loop in Scheme?** We give a few answers to that here, supposing that we want to vary a parameter *x* from *a* to *b* in steps of *dx*, and do something for each value of *x*.
38 | 
39 | The classic way, in Scheme, is to write a [tail-recursive](https://en.wikipedia.org/wiki/Tail_call) function:
40 | 
41 | `(define (doit x x-max dx)`
42 | `   (if (<= x x-max)`
43 | `      (begin`
44 | `         `*`...perform` `loop` `body` `with` `x...`*
45 | `         (doit (+ x dx) x-max dx))))`
46 | `(doit a b dx) ; execute loop from a to b in steps of dx`
47 | 
48 | There is also a [do-loop construct](http://www.swiss.ai.mit.edu/ftpdir/scheme-reports/r5rs-html/r5rs_6.html#SEC36) in Scheme that you can use
49 | 
50 | `(do ((x a (+ x dx))) ((> x b)) `*`...perform` `loop` `body` `with` `x...`*`)`
51 | 
52 | If you have a list of values of *x* that you want to loop over, then you can use `map`:
53 | 
54 | `(map (lambda (x) `*`...do` `stuff` `with` `x...`*`) `*`list-of-x-values`*`)`
55 | 
56 | How to Read In Values from a Text File in Scheme
57 | ------------------------------------------------
58 | 
59 | A simple command to read a text file and store its values within a variable in Scheme is `read`. As an example, suppose a file *foo.dat* contains the following text, including parentheses:
60 | 
61 | `(1 3 12.2 14.5 16 18)`
62 | 
63 | In Scheme, we would then use
64 | 
65 | `(define port (open-input-file "foo.dat"))`
66 | `(define foo (read port))`
67 | `(close-input-port port)`
68 | 
69 | The variable *foo* would then be a list of numbers '(1 3 12.2 14.5 16 18).
70 | 
71 | ### Tricks Specific to Libctl-Using Programs such as [MPB](index.md) or [Meep](https://meep.readthedocs.io)
72 | 
73 | [libctl](https://libctl.readthedocs.io) has a couple of built-in functions `arith-sequence` and `interpolate` (see the [user reference](https://libctl.readthedocs.io/en/latest/Libctl_User_Reference/)) to construct lists of a regular sequence of values, which you can use in conjunction with `map` as above:
74 | 
75 | `(map (lambda (x) `*`...do` `stuff` `with` `x...`*`) (arith-sequence x-min dx num-x))`
76 | 
77 | or
78 | 
79 | `(map (lambda (x) `*`...do` `stuff` `with` `x...`*`) (interpolate num-x (list a b)))`
80 | 
81 | Finally, if you have an entire libctl input file *myfile.ctl* that you want to loop, varying over some parameter *x*, you can do so by writing a loop on the Unix command-line. Using the [bash](https://en.wikipedia.org/wiki/bash) shell, you could do:
82 | 
83 | ``for x in `seq a dx b`; do meep x=$x myfile.ctl; done``


--------------------------------------------------------------------------------
/doc/docs/License_and_Copyright.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | # License and Copyright
 3 | ---
 4 | 
 5 | *Omnis enim res, quae dando non deficit, dum habetur et non datur, nondum habetur, quomodo habenda est.*
 6 | 
 7 | "For if a thing is not diminished by being shared with others, it is not rightly owned if it is only owned and not shared."
 8 | 
 9 | &mdash; Saint Augustine, [*De Doctrina Christiana*](http://www.ccel.org/a/augustine/doctrine/doctrine.html), *c.* 396 AD.
10 | 
11 | MIT Photonic-Bands is copyright © 1999–2019, Massachusetts Institute of Technology.
12 | 
13 | MPB is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
14 | 
15 | This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16 | 
17 | You should have received a copy of the GNU General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. You can also find it on the GNU web site:
18 | 
19 | 
20 | [http://www.gnu.org/copyleft/gpl.html](http://www.gnu.org/copyleft/gpl.html)
21 | 
22 | The file `minpack2-linmin.c` was derived from the [MINPACK-2](ftp://info.mcs.anl.gov/pub/MINPACK-2/) package. It is copyright © 1996 by [Jorge J. Moré](http://www-unix.mcs.anl.gov/~more/), who has graciously granted us permission to distribute it along with MPB under the GNU General Public License.
23 | 
24 | As a clarification, we should note that Scheme control (`ctl`) files, written by the user (i.e. not containing code distributed with MPB) and loaded at runtime by MPB, are *not* considered derived works of MPB and do *not* fall thereby under the restrictions of the GNU General Public License.
25 | 
26 | In addition, all of the example Scheme code in this manual, as well as the example ctl files in the `mpb/examples/` directory, may be freely used, modified, and redistributed, without any restrictions. The warranty disclaimer still applies, of course.


--------------------------------------------------------------------------------
/doc/docs/The_Run_Function_Is_Not_A_Loop.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | The Run Function Is Not A Loop
 3 | ---
 4 | 
 5 | In Meep, there are functions `run-until` and similar that run the simulation, and take arguments allowing custom actions to be performed on every time step, or on some subset of the time steps.  Many users misunderstand this, however, and make the same mistake: they think the `run` function is a "looping" construct of some kind, and that you can just put any code you want into it and it will get executed for every time step.  This mistake and how to correct it are described in this article.
 6 | 
 7 | Hello World
 8 | -----------
 9 | 
10 | Let's consider a "Hello World" example.  Suppose we start with a control file that runs for 200 time units and outputs <math>E_z</math> on each time step:
11 | 
12 | ```
13 |  (run-until 200 output-efield-z)
14 | ```
15 | 
16 | and now we want to modify it to also print "Hello World!" for every time step, as it is running.
17 | 
18 | The Wrong Way
19 | -------------
20 | 
21 | Many users will naively write:
22 | 
23 | ```
24 |  (run-until 200
25 |      output-efield-z
26 |      (print "Hello World!\n"))
27 | ```
28 | 
29 | **This is wrong.**  It will output "Hello World!" *once*, then give an error.  What is going on? The problem is that you are thinking of `run-until` in the wrong way, as if it were a loop:
30 | 
31 | ```
32 |   for time < 200 do
33 |       output-efield-z
34 |       (print "Hello World!\n")
35 | ```
36 | 
37 | This is **not** what is happening. Instead, `run-until` is just a *function* that runs the simulation, and its arguments should be *functions* that are called for each time step.  That is, it is really doing something like:
38 | 
39 | ```
40 |   evaluate the arguments: 200: a number
41 |            output-efield-z: a function
42 |            (print "Hello World!\n"): prints output and returns #<unspecified>;
43 |   call run-until:
44 |      time-step until t=200
45 |      at each time step, call the arguments:
46 |         call (output-efield-z)
47 |         call (#<unspecified>)
48 | ```
49 | 
50 | Two things went wrong.  First, the arguments are evaluated **before** calling the function, which means that the `print` statement is executed before `run-until` even starts!  Second, `run-until` then tries to call the **result** of `(print ...)` as if it were a function, which causes an error because `(print ...)` does not return a function. The `print` returns a special Scheme code `#<unspecified>` that means it doesn't really return anything at all.
51 | 
52 | The Right Way
53 | -------------
54 | 
55 | What we should have passed to `run-until`, instead of the *result* of calling `(print ...)`, is a *function* that calls `(print ...)`.  There are two ways to do it.
56 | 
57 | First, we could explicitly define a function, call it `my-hello`, that does what we want:
58 | 
59 | ```
60 |  (define (my-hello) (print "Hello World!\n"))
61 |  (run-until 200 output-efield-z my-hello)
62 | ```
63 | 
64 | Notice two things. First, `my-hello` is a function of no arguments, which means that it is just called at every time step. Another, more complicated, possibility is described in the [User Interface](Scheme_User_Interface.md#writing-your-own-step-functions). Second, when we call `run-until`, we just pass the *name* of the function `my-hello`, and not the *result* of calling the function `(my-hello)`.
65 | 
66 | A second possibility is that we could use Scheme's `lambda` construct to define our function in-line. The `lambda` syntax in Scheme allows you to define *anonymous* functions without assigning them a name via `define`, and to stick the function definition right into another expression. It works like this:
67 | 
68 | ```
69 |  (run-until 200 output-efield-z (lambda () (print "Hello World!\n")))
70 | ```
71 | 
72 | Here, the `(lambda () ...)` defines a function of no arguments `()` that, when called, executes the `...` statements.


--------------------------------------------------------------------------------
/doc/docs/images/Mpb-logo.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/Mpb-logo.jpg


--------------------------------------------------------------------------------
/doc/docs/images/diamond-b1-eps.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/diamond-b1-eps.gif


--------------------------------------------------------------------------------
/doc/docs/images/diamond-b1.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/diamond-b1.gif


--------------------------------------------------------------------------------
/doc/docs/images/diamond-b3-eps.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/diamond-b3-eps.gif


--------------------------------------------------------------------------------
/doc/docs/images/diamond-b3.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/diamond-b3.gif


--------------------------------------------------------------------------------
/doc/docs/images/diamond-bands.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/diamond-bands.gif


--------------------------------------------------------------------------------
/doc/docs/images/diamond-eps.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/diamond-eps.gif


--------------------------------------------------------------------------------
/doc/docs/images/tri-lattice.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-lattice.png


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-bands.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-bands.png


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-eps-1.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-eps-1.gif


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-eps-2.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-eps-2.gif


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-ez1.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-ez1.gif


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-ez2.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-ez2.gif


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-ez3.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-ez3.gif


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-ez4.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-ez4.gif


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-ez5.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-ez5.gif


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-ez6.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-ez6.gif


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-ez7.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-ez7.gif


--------------------------------------------------------------------------------
/doc/docs/images/tri-rods-ez8.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/docs/images/tri-rods-ez8.gif


--------------------------------------------------------------------------------
/doc/docs/index.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | # MPB
 3 | ---
 4 | 
 5 | **MPB** is a free and open-source software package for computing the band structures, or dispersion relations, and electromagnetic modes of periodic dielectric structures, on both serial and parallel computers. MPB is an acronym for *MIT Photonic Bands*. MPB computes definite-frequency eigenstates, or harmonic modes, of [Maxwell's equations](https://en.wikipedia.org/wiki/Maxwell%27s_equations) for periodic dielectric structures of lossless, wavelength-independent, anisotropic $\varepsilon$ and $\mu$ for arbitrary wavevectors, using fully-vectorial and three-dimensional methods. It is applicable to many problems in optics, such as waveguides and resonator systems, and [photonic crystals](http://ab-initio.mit.edu/book).
 6 | 
 7 | See also the complementary [Meep](https://meep.readthedocs.io/) package for time-domain simulations, reflection/transmission spectra, etc.
 8 | 
 9 | Features
10 | --------
11 | 
12 | -   **Free and open-source software** under the [GNU GPL](https://en.wikipedia.org/wiki/GNU_General_Public_License).
13 | -   Complete **scriptability** via [Python](Python_Tutorial) or [Scheme](Scheme_User_Interface) APIs.
14 | -   Portable to any Unix-like system such as [Linux](https://en.wikipedia.org/wiki/Linux), [macOS](https://en.wikipedia.org/wiki/MacOS), and [FreeBSD](https://en.wikipedia.org/wiki/FreeBSD).
15 | -   Distributed memory **parallelism** on any system supporting the [MPI](https://en.wikipedia.org/wiki/Message_Passing_Interface) standard.
16 | -   Fully-vectorial **1d, 2d, 3d** calculations. Iterative eigensolver techniques are employed to make large calculations possible.
17 | -   **Direct, frequency-domain eigensolver** as opposed to indirect methods, e.g. time-domain. This means that you get both eigenvalues (frequencies) and eigenstates (electromagnetic modes) at the same time. See [comparison of time-domain and frequency-domain techniques](Introduction.md#frequency-domain-vs-time-domain).
18 | -   **Targeted eigensolver**. Iterative eigensolvers normally compute states (harmonic modes) with the lowest few frequencies. MPB can alternatively compute the modes whose frequencies are closest to a specified target frequency. This greatly reduces the number of bands that must be computed in guided or resonant mode calculations.
19 | -   Support for arbitrary, **anisotropic** dielectrics including **gyrotropic/magneto-optic** materials and **non-orthogonal** unit cells. Lossy and wavelength-dependent $\varepsilon$ and $\mu$ are not supported.
20 | -   Field output in the [HDF5](https://support.hdfgroup.org/HDF5/) data format.
21 | 
22 | To give you some feel for how long these calculations take, let us consider one typical data point. For the 3d band-structure of a [diamond lattice of dielectric spheres in air](Data_Analysis_Tutorial.md#diamond-lattice-of-spheres), computing the lowest 10 bands on a 16×16×16 grid at 31 k-points, MPB took 8 seconds on a 2.8 GHz AMD Opteron under Debian with the [ATLAS](http://www.netlib.org/atlas/) optimized BLAS library. Thus, at each k-point, MPB was minimizing a function with 81920 degrees of freedom in 0.26 seconds on average.
23 | 
24 | Download
25 | ------------
26 | 
27 | The development repository is on on [GitHub](https://github.com/NanoComp/mpb). Gzipped tarballs of stable versions are available in [Download](Download.md). The release history is described in [NEWS](https://github.com/NanoComp/mpb/blob/master/NEWS.md). Installation instructions are in [Installation](Installation.md).
28 | 
29 | Documentation
30 | -------------
31 | 
32 | See the navigation sidebar at left. In particular, the [Introduction](Introduction) and [Tutorial](Scheme_Tutorial.md) are the most important things to review.
33 | 
34 | Please [cite the reference publication](Acknowledgements.md#referencing) in any publication for which you found MPB useful.
35 | 
36 | ### Mailing Lists
37 | 
38 | Subscribe to the read-only [mpb-announce mailing list](http://ab-initio.mit.edu/cgi-bin/mailman/listinfo/mpb-announce) to receive notifications of updates and releases. Subscribe to the [mpb-discuss mailing list](http://ab-initio.mit.edu/cgi-bin/mailman/listinfo/mpb-discuss) for discussions regarding MPB. The [mpb-discuss archives](http://www.mail-archive.com/mpb-discuss@ab-initio.mit.edu/) includes all postings since 2006 spanning a large number and variety of discussion topics related to installation, setting up simulations, post-processing output, etc.
39 | 
40 | ### Bug Reports and Feature Requests
41 | 
42 | For bug reports and feature requests, please file a [GitHub issue](https://github.com/NanoComp/mpb/issues).
43 | 
44 | Acknowledgements
45 | ----------------
46 | 
47 | The MPB project is maintained by [Simpetus](http://www.simpetus.com) and the developer community on [GitHub](https://github.com/NanoComp/mpb). [Acknowledgements](Acknowledgements.md) provides a complete listing of the project contributors.
48 | 
49 | Contacts and Feedback
50 | ---------------------
51 | 
52 | If you have questions or problems regarding MPB, you are encouraged to query the [mailing list](https://www.mail-archive.com/mpb-discuss@ab-initio.mit.edu/).
53 | 
54 | Professional consulting services for photonic design and modeling including development of custom, turn-key simulation modules, training, technical support, and access to MPB in the public cloud via Amazon Web Services (AWS) are provided by [Simpetus](http://www.simpetus.com).
55 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/base.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
  3 | <!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
  4 | <head>
  5 |   <meta charset="utf-8">
  6 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7 |   {% block htmltitle %}
  8 |   <title>{% if page_title %}{{ page_title }} - {% endif %}{{ site_name }}</title>
  9 |   {% endblock %}
 10 | 
 11 |   {% if favicon %}<link rel="shortcut icon" href="{{ favicon }}">
 12 |   {% else %}<link rel="shortcut icon" href="{{ base_url }}/img/favicon.ico">{% endif %}
 13 | 
 14 |   {# CSS #}
 15 |   <link href='https://fonts.googleapis.com/css?family=Lato:400,700|Roboto+Slab:400,700|Inconsolata:400,700' rel='stylesheet' type='text/css'>
 16 | 
 17 |   <link rel="stylesheet" href="{{ base_url }}/css/theme.css" type="text/css" />
 18 |   <link rel="stylesheet" href="{{ base_url }}/css/theme_extra.css" type="text/css" />
 19 |   <link rel="stylesheet" href="{{ base_url }}/css/highlight.css">
 20 |   {%- for path in extra_css %}
 21 |   <link href="{{ path }}" rel="stylesheet">
 22 |   {%- endfor %}
 23 | 
 24 |   {% if current_page %}
 25 |   <script>
 26 |     // Current page data
 27 |     var mkdocs_page_name = "{{ current_page.input_path.replace('.md', '') }}"
 28 |   </script>
 29 |   {% endif %}
 30 |   <script src="{{ base_url }}/js/jquery-2.1.1.min.js"></script>
 31 |   <script src="{{ base_url }}/js/modernizr-2.8.3.min.js"></script>
 32 |   <script type="text/javascript" src="{{ base_url }}/js/highlight.pack.js"></script>
 33 |   <script src="{{ base_url }}/js/theme.js"></script>
 34 | 
 35 |   {%- block extrahead %} {% endblock %}
 36 | 
 37 |   {%- for path in extra_javascript %}
 38 |   <script src="{{ path }}"></script>
 39 |   {%- endfor %}
 40 | 
 41 |   {% if google_analytics %}
 42 |   <script>
 43 |       (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
 44 |       (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
 45 |       m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 46 |       })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
 47 | 
 48 |       ga('create', '{{ google_analytics[0] }}', '{{ google_analytics[1] }}');
 49 |       ga('send', 'pageview');
 50 |   </script>
 51 |   {% endif %}
 52 | </head>
 53 | 
 54 | <body class="wy-body-for-nav" role="document">
 55 | 
 56 |   <div class="wy-grid-for-nav">
 57 | 
 58 |     {# SIDE NAV, TOGGLES ON MOBILE #}
 59 |     <nav data-toggle="wy-nav-shift" class="wy-nav-side stickynav">
 60 | 
 61 |       <p align="center"
 62 |       <a href="{{ homepage_url }}">
 63 |          <img align="center" height="auto" width="100%"
 64 |               src="{{ base_url }}/img/Mpb-logo.jpg"
 65 |       </a>
 66 | 
 67 |       <div class="wy-side-nav-search">
 68 |         <a href="{{ homepage_url }}" class="icon icon-home"> {{ site_name }}</a>
 69 |         {% include "searchbox.html" %}
 70 |       </div>
 71 | 
 72 |       <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
 73 |         <ul class="current">
 74 |           {% for nav_item in nav %}
 75 |             <li>{% include "toc.html" %}<li>
 76 |           {% endfor %}
 77 |         </ul>
 78 |       </div>
 79 |       &nbsp;
 80 |     </nav>
 81 | 
 82 |     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
 83 | 
 84 |       {# MOBILE NAV, TRIGGLES SIDE NAV ON TOGGLE #}
 85 |       <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
 86 |         <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
 87 |         <a href="{{ homepage_url }}">{{ site_name }}</a>
 88 |       </nav>
 89 | 
 90 |       {# PAGE CONTENT #}
 91 |       <div class="wy-nav-content">
 92 |         <div class="rst-content">
 93 |           {% include "breadcrumbs.html" %}
 94 |           <div role="main">
 95 |             <div class="section">
 96 |               {% block content %}
 97 |                 {{ content }}
 98 |               {% endblock %}
 99 |             </div>
100 |           </div>
101 | 	  {%- block footer %}
102 |           {% include "footer.html" %}
103 | 	  {% endblock %}
104 |         </div>
105 |       </div>
106 | 
107 |     </section>
108 | 
109 |   </div>
110 | 
111 | {% include "versions.html" %}
112 | 
113 | </body>
114 | </html>
115 | {% if current_page and current_page.is_homepage %}
116 | <!--
117 | MkDocs version : {{ mkdocs_version }}
118 | Build Date UTC : {{ build_date_utc }}
119 | -->
120 | {% endif %}
121 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/breadcrumbs.html:
--------------------------------------------------------------------------------
 1 | <div role="navigation" aria-label="breadcrumbs navigation">
 2 |   <ul class="wy-breadcrumbs">
 3 |     <li><a href="{{ homepage_url }}"><span class="SmallCaps">mpb</span> documentation</a> &raquo;</li>
 4 |     {% if current_page %}
 5 |       {% for doc in current_page.ancestors %}
 6 |         {% if doc.link %}
 7 |           <li><a href="{{ doc.link|e }}">{{ doc.title }}</a> &raquo;</li>
 8 |         {% else %}
 9 |           <li>{{ doc.title }} &raquo;</li>
10 |         {% endif %}
11 |       {% endfor %}
12 |     {% endif %}
13 |     {% if current_page %}<li>{{ current_page.title }}</li>{% endif %}
14 |     <li class="wy-breadcrumbs-aside">
15 |       {% if repo_url %}
16 |         {% if repo_name == 'GitHub' %}
17 |           <a href="{{ repo_url }}" class="icon icon-github"> Edit on GitHub</a>
18 |         {% elif repo_name == 'Bitbucket' %}
19 |           <a href="{{ repo_url }}" class="icon icon-bitbucket"> Edit on BitBucket</a>
20 |         {% endif %}
21 |       {% endif %}
22 |     </li>
23 |   </ul>
24 |   <hr/>
25 | </div>
26 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/css/highlight.css:
--------------------------------------------------------------------------------
  1 | /*
  2 | This is the GitHub theme for highlight.js
  3 | 
  4 | github.com style (c) Vasily Polovnyov <vast@whiteants.net>
  5 | 
  6 | */
  7 | 
  8 | .hljs {
  9 |   display: block; 
 10 |   overflow-x: auto;
 11 |   padding: 0.5em;
 12 |   color: #333;
 13 |   -webkit-text-size-adjust: none;
 14 | }
 15 | 
 16 | .hljs-comment,
 17 | .diff .hljs-header,
 18 | .hljs-javadoc {
 19 |   color: #998;
 20 |   font-style: italic;
 21 | }
 22 | 
 23 | .hljs-keyword,
 24 | .css .rule .hljs-keyword,
 25 | .hljs-winutils,
 26 | .nginx .hljs-title,
 27 | .hljs-subst,
 28 | .hljs-request,
 29 | .hljs-status {
 30 |   color: #333;
 31 |   font-weight: bold;
 32 | }
 33 | 
 34 | .hljs-number,
 35 | .hljs-hexcolor,
 36 | .ruby .hljs-constant {
 37 |   color: #008080;
 38 | }
 39 | 
 40 | .hljs-string,
 41 | .hljs-tag .hljs-value,
 42 | .hljs-phpdoc,
 43 | .hljs-dartdoc,
 44 | .tex .hljs-formula {
 45 |   color: #d14;
 46 | }
 47 | 
 48 | .hljs-title,
 49 | .hljs-id,
 50 | .scss .hljs-preprocessor {
 51 |   color: #900;
 52 |   font-weight: bold;
 53 | }
 54 | 
 55 | .hljs-list .hljs-keyword,
 56 | .hljs-subst {
 57 |   font-weight: normal;
 58 | }
 59 | 
 60 | .hljs-class .hljs-title,
 61 | .hljs-type,
 62 | .vhdl .hljs-literal,
 63 | .tex .hljs-command {
 64 |   color: #458;
 65 |   font-weight: bold;
 66 | }
 67 | 
 68 | .hljs-tag,
 69 | .hljs-tag .hljs-title,
 70 | .hljs-rule .hljs-property,
 71 | .django .hljs-tag .hljs-keyword {
 72 |   color: #000080;
 73 |   font-weight: normal;
 74 | }
 75 | 
 76 | .hljs-attribute,
 77 | .hljs-variable,
 78 | .lisp .hljs-body,
 79 | .hljs-name {
 80 |   color: #008080;
 81 | }
 82 | 
 83 | .hljs-regexp {
 84 |   color: #009926;
 85 | }
 86 | 
 87 | .hljs-symbol,
 88 | .ruby .hljs-symbol .hljs-string,
 89 | .lisp .hljs-keyword,
 90 | .clojure .hljs-keyword,
 91 | .scheme .hljs-keyword,
 92 | .tex .hljs-special,
 93 | .hljs-prompt {
 94 |   color: #990073;
 95 | }
 96 | 
 97 | .hljs-built_in {
 98 |   color: #0086b3;
 99 | }
100 | 
101 | .hljs-preprocessor,
102 | .hljs-pragma,
103 | .hljs-pi,
104 | .hljs-doctype,
105 | .hljs-shebang,
106 | .hljs-cdata {
107 |   color: #999;
108 |   font-weight: bold;
109 | }
110 | 
111 | .hljs-deletion {
112 |   background: #fdd;
113 | }
114 | 
115 | .hljs-addition {
116 |   background: #dfd;
117 | }
118 | 
119 | .diff .hljs-change {
120 |   background: #0086b3;
121 | }
122 | 
123 | .hljs-chunk {
124 |   color: #aaa;
125 | }
126 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/css/theme_extra.css:
--------------------------------------------------------------------------------
  1 |  }* Tweak the overal size to better match RTD.
  2 |  */
  3 | body {
  4 |     font-size: 90%;
  5 | }
  6 | 
  7 | h3, h4, h5, h6 {
  8 |     color: #000000;
  9 |     font-weight: 300
 10 | }
 11 | 
 12 | /*
 13 |  * Sphinx doesn't have support for section dividers like we do in
 14 |  * MkDocs, this styles the section titles in the nav
 15 |  *
 16 |  * https://github.com/mkdocs/mkdocs/issues/175
 17 |  */
 18 | .wy-menu-vertical span {
 19 |     line-height: 18px;
 20 |     padding: 0.4045em 1.618em;
 21 |     display: block;
 22 |     position: relative;
 23 |     font-size: 90%;
 24 |     color: #838383;
 25 | }
 26 | 
 27 | .wy-menu-vertical .subnav a {
 28 |     padding: 0.4045em 2.427em;
 29 | }
 30 | 
 31 | /*
 32 |  * Long navigations run off the bottom of the screen as the nav
 33 |  * area doesn't scroll.
 34 |  *
 35 |  * https://github.com/mkdocs/mkdocs/pull/202
 36 |  */
 37 | .wy-nav-side {
 38 |     height: 100%;
 39 |     overflow-y: auto;
 40 | }
 41 | 
 42 | /*
 43 |  * readthedocs theme hides nav items when the window height is
 44 |  * too small to contain them.
 45 |  *
 46 |  * https://github.com/mkdocs/mkdocs/issues/#348
 47 |  */
 48 | .wy-menu-vertical ul {
 49 |   margin-bottom: 2em;
 50 | }
 51 | 
 52 | /*
 53 |  * Wrap inline code samples otherwise they shoot of the side and
 54 |  * can't be read at all.
 55 |  *
 56 |  * https://github.com/mkdocs/mkdocs/issues/313
 57 |  */
 58 | /*
 59 | p code {
 60 |     word-wrap: break-word;
 61 | }
 62 | */
 63 | 
 64 | /*
 65 |  * The CSS classes from highlight.js seem to clash with the
 66 |  * ReadTheDocs theme causing some code to be incorrectly made
 67 |  * bold and italic.
 68 |  *
 69 |  * https://github.com/mkdocs/mkdocs/issues/411
 70 |  */
 71 | 
 72 | code.cs, code.c {
 73 |     font-weight: inherit;
 74 |     font-style: inherit;
 75 | }
 76 | 
 77 | /*
 78 |  * Fix some issues with the theme and non-highlighted code
 79 |  * samples. Without and highlighting styles attached the
 80 |  * formatting is broken.
 81 |  *
 82 |  * https://github.com/mkdocs/mkdocs/issues/319
 83 |  */
 84 | .no-highlight {
 85 |   display: block;
 86 |   padding: 0.5em;
 87 |   color: #333;
 88 | }
 89 | 
 90 | 
 91 | /*
 92 |  * Additions specific to the search functionality provided by MkDocs
 93 |  */
 94 | 
 95 | #mkdocs-search-results article h3
 96 | {
 97 |     margin-top: 23px;
 98 |     border-top: 1px solid #E1E4E5;
 99 |     padding-top: 24px;
100 | }
101 | 
102 | #mkdocs-search-results article:first-child h3 {
103 |     border-top: none;
104 | }
105 | 
106 | #mkdocs-search-query{
107 |     width: 100%;
108 |     border-radius: 50px;
109 |     padding: 6px 12px;
110 |     border-color: #D1D4D5;
111 | }
112 | 
113 | .wy-menu-vertical li ul {
114 |     display: inherit;
115 | }
116 | 
117 | .wy-menu-vertical li ul.subnav ul.subnav{
118 |     padding-left: 1em;
119 | }
120 | 
121 | /*
122 |  * Fix wrapping in the code highlighting
123 |  *
124 |  * https://github.com/mkdocs/mkdocs/issues/233
125 |  */
126 | code {
127 |     white-space: pre;
128 |     border: none;
129 |     /*background-color: lightgray;*/
130 |     background-color: inherit;
131 |     color: black;
132 |     color: inherit;
133 | }
134 | 
135 | pre {
136 |   padding: 5px 5px 5px 5px;
137 |   font-size: 125%;
138 |   /*border-style: dashed dashed dashed dashed;*/
139 |   border-width: 0pt black;
140 |   background: lightgray;
141 |   background-color: lightgray;
142 |   color: black;
143 | }
144 | 
145 | .hljs {
146 |   background: lightgray;
147 |   background-color: lightgray;
148 |   color: black;
149 | }
150 | 
151 | /*
152 |  * HR 20150603 I can't figure out any way to get
153 |  * small caps text other than via the following kluge:
154 |  *
155 |  * 1. Enable the 'wikilinks' markdown extension in the 
156 |  *    mkdocs.yml file     
157 |  *
158 |  * 2. Include the following style specification to ensure
159 |  *    that wikilinks are rendered in small caps but otherwise
160 |  *    like ordinary text (i.e. in ordinary black text and 
161 |  *    with the usual underline-on-hover feature turned off)
162 |  *
163 |  * 3. Then text delineated by double brackets (as in: [[scuff-em]])
164 |  *    be rendered in small caps.
165 |  */
166 | a.wikilink {
167 |    font-variant: small-caps;
168 |    color: #000000;
169 | }
170 | a.wikilink:hover
171 |  {text-decoration:none }
172 | 
173 | .SmallCaps{
174 |    font-variant: small-caps;
175 |    font-variant-numeric: oldstyle-nums;
176 | }
177 | 
178 | .SC{
179 |    font-variant: small-caps;
180 |    font-variant-numeric: oldstyle-nums;
181 | }
182 | 
183 | ol.TOC { 
184 |   margin: 20px 0;
185 |   padding:5px;
186 |   border: 1px solid #aaaaaa;
187 |   background-color: #f9f9f9;
188 | }
189 | 
190 | .toc { 
191 |   margin: 20px 0;
192 |   padding:5px;
193 |   border: 1px solid #aaaaaa;
194 |   background-color: #f9f9f9;
195 | }
196 | 
197 | .toctitle 
198 |  { font-variant: small-caps; 
199 |    font-weight:  bold;
200 |    padding: 5px;
201 |    margin: 5px 5px;
202 |    text-align: center;
203 |  }
204 | 
205 | .shaded
206 |  { background-color: #EEEEEE;
207 |  }
208 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/mpb-mkdocs-theme/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/mpb-mkdocs-theme/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/mpb-mkdocs-theme/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/footer.html:
--------------------------------------------------------------------------------
 1 | <footer>
 2 |   {% if next_page or previous_page %}
 3 |     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
 4 |       {% if next_page %}
 5 |         <a href="{{ next_page.url }}" class="btn btn-neutral float-right" title="{{ next_page.title }}"/>Next <span class="icon icon-circle-arrow-right"></span></a>
 6 |       {% endif %}
 7 |       {% if previous_page %}
 8 |         <a href="{{ previous_page.url }}" class="btn btn-neutral" title="{{ previous_page.title }}"><span class="icon icon-circle-arrow-left"></span> Previous</a>
 9 |       {% endif %}
10 |     </div>
11 |   {% endif %}
12 | 
13 |   <hr/>
14 | 
15 |   <div role="contentinfo">
16 |     <p>
17 |     <!-- Copyright etc -->
18 |     </p>
19 |   </div>
20 | 
21 |   <a href="http://https://github.com/stevengj/mpb">
22 |     <span class="SmallCaps">mpb</span> </a> documentation
23 | 
24 |   <p>
25 |   <font size=-1>
26 |   Built with <a href="http://www.mkdocs.org">MkDocs</a> 
27 |   using a customized theme modeled 
28 |   after the 
29 |   <a href="https://github.com/snide/sphinx_rtd_theme">theme</a>
30 |   provided by <a href="https://readthedocs.org">Read the Docs</a>.
31 |   </font>
32 | 
33 | </footer>
34 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/img/Mpb-logo.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoComp/mpb/16991f378a646c3ec181fe1e7be71b2c38be7b74/doc/mpb-mkdocs-theme/img/Mpb-logo.jpg


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/js/extra.js:
--------------------------------------------------------------------------------
 1 | //HR 20170807 startup javascript code to fix broken search box on readthedocs
 2 | //inspired by similar code in the nodecmu project:
 3 | //https://github.com/nodemcu/nodemcu-firmware/blob/master/docs/js/extra.js
 4 | 
 5 |   /**
 6 |    * Analyzes the URL of the current page to find out what the selected GitHub branch is. It's usually
 7 |    * part of the location path. The code needs to distinguish between running MkDocs standalone
 8 |    * and docs served from RTD. If no valid branch could be determined 'dev' returned.
 9 |    *
10 |    * @returns GitHub branch name
11 |    */
12 |   function determineSelectedBranch() {
13 |     var branch = 'dev', path = window.location.pathname;
14 |     if (window.location.origin.indexOf('readthedocs') > -1) {
15 |       // path is like /en/<branch>/<lang>/build/ -> extract 'lang'
16 |       // split[0] is an '' because the path starts with the separator
17 |       var thirdPathSegment = path.split('/')[2];
18 |       // 'latest' is an alias on RTD for the 'dev' branch - which is the default for 'branch' here
19 |       if (thirdPathSegment != 'latest') {
20 |         branch = thirdPathSegment;
21 |       }
22 |     }
23 |     return branch;
24 |   }
25 | 
26 |  function fixSearch() {
27 |     var target = document.getElementById('rtd-search-form');
28 |     var config = {attributes: true, childList: true};
29 | 
30 |     var observer = new MutationObserver(function(mutations) {
31 |       // if it isn't disconnected it'll loop infinitely because the observed element is modified
32 |       observer.disconnect();
33 |       var form = $('#rtd-search-form');
34 |       form.empty();
35 | 
36 |  // HR 20170807 the following fancier code attempts to determine the appropriate github branch/readthedocs version on the fly; for now I'm hard-coding it to 'latest'
37 |  //     form.attr('action', 'https://' + window.location.hostname + '/en/' + determineSelectedBranch() + '/search.html');
38 |         form.attr('action', 'https://' + window.location.hostname + '/en/latest/search.html');
39 | 
40 |       $('<input>').attr({
41 |         type: "text",
42 |         name: "q",
43 |         placeholder: "Search docs"
44 |       }).appendTo(form);
45 |     });
46 |     // don't run this outside RTD hosting
47 |     if (window.location.origin.indexOf('readthedocs') > -1) {
48 |       observer.observe(target, config);
49 |     }
50 |   }
51 | 
52 | $( document ).ready(function() {
53 |     fixSearch();
54 | });
55 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/js/mathjaxhelper.js:
--------------------------------------------------------------------------------
1 | MathJax.Hub.Config({
2 |   config: ["MMLorHTML.js"],
3 |   jax: ["input/TeX", "output/HTML-CSS", "output/NativeMML"],
4 |   extensions: ["MathMenu.js", "MathZoom.js"]
5 | });
6 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/js/theme.js:
--------------------------------------------------------------------------------
 1 | $( document ).ready(function() {
 2 | 
 3 |     // Shift nav in mobile when clicking the menu.
 4 |     $(document).on('click', "[data-toggle='wy-nav-top']", function() {
 5 |       $("[data-toggle='wy-nav-shift']").toggleClass("shift");
 6 |       $("[data-toggle='rst-versions']").toggleClass("shift");
 7 |     });
 8 | 
 9 |     // Close menu when you click a link.
10 |     $(document).on('click', ".wy-menu-vertical .current ul li a", function() {
11 |       $("[data-toggle='wy-nav-shift']").removeClass("shift");
12 |       $("[data-toggle='rst-versions']").toggleClass("shift");
13 |     });
14 | 
15 |     $(document).on('click', "[data-toggle='rst-current-version']", function() {
16 |       $("[data-toggle='rst-versions']").toggleClass("shift-up");
17 |     });
18 | 
19 |     // Make tables responsive
20 |     $("table.docutils:not(.field-list)").wrap("<div class='wy-table-responsive'></div>");
21 | 
22 |     hljs.initHighlightingOnLoad();
23 | 
24 |     $('table').addClass('docutils');
25 | });
26 | 
27 | window.SphinxRtdTheme = (function (jquery) {
28 |     var stickyNav = (function () {
29 |         var navBar,
30 |             win,
31 |             stickyNavCssClass = 'stickynav',
32 |             applyStickNav = function () {
33 |                 if (navBar.height() <= win.height()) {
34 |                     navBar.addClass(stickyNavCssClass);
35 |                 } else {
36 |                     navBar.removeClass(stickyNavCssClass);
37 |                 }
38 |             },
39 |             enable = function () {
40 |                 applyStickNav();
41 |                 win.on('resize', applyStickNav);
42 |             },
43 |             init = function () {
44 |                 navBar = jquery('nav.wy-nav-side:first');
45 |                 win    = jquery(window);
46 |             };
47 |         jquery(init);
48 |         return {
49 |             enable : enable
50 |         };
51 |     }());
52 |     return {
53 |         StickyNav : stickyNav
54 |     };
55 | }($));
56 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/license/highlight.js/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2006, Ivan Sagalaev
 2 | All rights reserved.
 3 | Redistribution and use in source and binary forms, with or without
 4 | modification, are permitted provided that the following conditions are met:
 5 | 
 6 |     * Redistributions of source code must retain the above copyright
 7 |       notice, this list of conditions and the following disclaimer.
 8 |     * Redistributions in binary form must reproduce the above copyright
 9 |       notice, this list of conditions and the following disclaimer in the
10 |       documentation and/or other materials provided with the distribution.
11 |     * Neither the name of highlight.js nor the names of its contributors 
12 |       may be used to endorse or promote products derived from this software 
13 |       without specific prior written permission.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 | DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
19 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/search.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block extrahead %}
 4 |   <script>var base_url = '{{ base_url }}';</script>
 5 |   <script data-main="{{ base_url }}/mkdocs/js/search.js" src="{{ base_url }}/mkdocs/js/require.js"></script>
 6 | {% endblock %}
 7 | 
 8 | {% block content %}
 9 | 
10 |   <h1 id="search">Search Results</h1>
11 | 
12 |   <form id="content_search" action="search.html">
13 |     <span role="status" aria-live="polite" class="ui-helper-hidden-accessible"></span>
14 |     <input name="q" id="mkdocs-search-query" type="text" class="search_input search-query ui-autocomplete-input" placeholder="Search the Docs" autocomplete="off" autofocus>
15 |   </form>
16 | 
17 |   <div id="mkdocs-search-results">
18 |     Sorry, page not found.
19 |   </div>
20 | 
21 | {% endblock %}
22 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/searchbox.html:
--------------------------------------------------------------------------------
1 | <div role="search">
2 |   <form id ="rtd-search-form" class="wy-form" action="{{ base_url }}/search.html" method="get">
3 |     <input type="text" name="q" placeholder="Search docs" />
4 |   </form>
5 | </div>
6 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/toc.html:
--------------------------------------------------------------------------------
 1 | {% if nav_item.children %}
 2 |     <ul class="subnav">
 3 |     <li><span>{{ nav_item.title }}</span></li>
 4 | 
 5 |         {% for nav_item in nav_item.children %}
 6 |             {% include 'toc.html' %}
 7 |         {% endfor %}
 8 |     </ul>
 9 | {% else %}
10 |     <li class="toctree-l1 {% if nav_item.active%}current{%endif%}">
11 |         <a class="{% if nav_item.active%}current{%endif%}" href="{{ nav_item.url }}">{{ nav_item.title }}</a>
12 |         {% if nav_item == current_page %}
13 |             <ul>
14 |             {% for toc_item in toc %}
15 |                 <li class="toctree-l3"><a href="{{ toc_item.url }}">{{ toc_item.title }}</a></li>
16 |                 {% for toc_item in toc_item.children %}
17 |                     <li><a class="toctree-l4" href="{{ toc_item.url }}">{{ toc_item.title }}</a></li>
18 |                 {% endfor %}
19 |             {% endfor %}
20 |             </ul>
21 |         {% endif %}
22 |     </li>
23 | {% endif %}
24 | 


--------------------------------------------------------------------------------
/doc/mpb-mkdocs-theme/versions.html:
--------------------------------------------------------------------------------
 1 | <div class="rst-versions" role="note" style="cursor: pointer">
 2 |     <span class="rst-current-version" data-toggle="rst-current-version">
 3 |       {% if repo_name == 'GitHub' %}
 4 |           <a class="icon icon-github" style="float: left; color: #fcfcfc"> GitHub</a>
 5 |       {% elif repo_name == 'Bitbucket' %}
 6 |           <a class="icon icon-bitbucket" style="float: left; color: #fcfcfc"> BitBucket</a>
 7 |       {% endif %}
 8 |       {% if previous_page %}
 9 |         <span><a href="{{ previous_page.url }}" style="color: #fcfcfc;">&laquo; Previous</a></span>
10 |       {% endif %}
11 |       {% if next_page %}
12 |         <span style="margin-left: 15px"><a href="{{ next_page.url }}" style="color: #fcfcfc">Next &raquo;</a></span>
13 |       {% endif %}
14 |     </span>
15 | </div>
16 | 


--------------------------------------------------------------------------------
/doc/requirements.txt:
--------------------------------------------------------------------------------
1 | python-markdown-math
2 | 


--------------------------------------------------------------------------------
/examples/Makefile.am:
--------------------------------------------------------------------------------
1 | EXTRA_DIST = bragg.ctl bragg-sine.ctl check.ctl diamond.ctl dos.scm	\
2 | hole-slab.ctl honey-rods.ctl line-defect.ctl sq-rods.ctl strip.ctl	\
3 | tri-holes.ctl tri-rods.ctl tutorial.ctl wavevector.scm
4 | 


--------------------------------------------------------------------------------
/examples/bragg-sine.ctl:
--------------------------------------------------------------------------------
 1 | ; Compute the band structure for a Bragg mirror consisting of a
 2 | ; sinusoidally-varying dielectric index.
 3 | 
 4 | ; The index will vary sinusoidally between index-min and index-max:
 5 | (define-param index-min 1)
 6 | (define-param index-max 3)
 7 | 
 8 | (define pi (* 4 (atan 1))) ; 3.14159...
 9 | 
10 | ; Define a function of position p (in the lattice basis) that returns
11 | ; the material at that position.  In this case, we use the function:
12 | ;        index-min + 0.5 * (index-max - index-min)
13 | ;                        * (1 + cos(2*pi*x))
14 | ; This is periodic, and also has inversion symmetry.
15 | (define (eps-func p)
16 |   (make dielectric
17 |     (index (+ index-min (* 0.5 (- index-max index-min)
18 | 			   (+ 1 (cos (* 2 pi (vector3-x p)))))))))
19 | 
20 | (set! geometry-lattice (make lattice (size 1 no-size no-size))) ; 1d cell
21 | 
22 | ; We'll just make it the default material, so that it goes everywhere.
23 | (set! default-material (make material-function (material-func eps-func)))
24 | 
25 | (set! k-points (interpolate 9 (list (vector3 0 0 0) (vector3 0.5 0 0))))
26 | 
27 | (set-param! resolution 32)
28 | (set-param! num-bands 8)
29 | 
30 | ; the TM and TE bands are degenerate, so we only need TM:
31 | (run-tm)
32 | 


--------------------------------------------------------------------------------
/examples/bragg.ctl:
--------------------------------------------------------------------------------
 1 | ; Compute the bands at the X point for a quarter-wave stack Bragg
 2 | ; mirror (this is the point that defines the band gap edges).
 3 | 
 4 | ; the high and low indices:
 5 | (define-param n-lo 1.0)
 6 | (define-param n-hi 3.0)
 7 | 
 8 | (define-param w-hi (/ n-lo (+ n-hi n-lo))) ; a quarter-wave stack
 9 | 
10 | (set! geometry-lattice (make lattice (size 1 no-size no-size))) ; 1d cell
11 | (set! default-material (make dielectric (index n-lo)))
12 | (set! geometry 
13 |       (list
14 |        (make cylinder 
15 | 	 (material (make dielectric (index n-hi)))
16 | 	 (center 0 0 0) (axis 1 0 0) 
17 | 	 (radius infinity) (height w-hi))))
18 | 
19 | (define-param kx 0.5)
20 | (set! k-points (list (vector3 kx 0 0)))
21 | 
22 | (set-param! resolution 32)
23 | (set-param! num-bands 8)
24 | 
25 | (run-tm output-hfield-y) ; note that TM and TE bands are degenerate, so we only need TM
26 | 


--------------------------------------------------------------------------------
/examples/diamond.ctl:
--------------------------------------------------------------------------------
 1 | ; Dielectric spheres in a diamond (fcc) lattice.  This file is used in
 2 | ; the "Data Analysis Tutorial" section of the MPB manual.
 3 | 
 4 | (set! geometry-lattice (make lattice 
 5 | 			 (basis-size (sqrt 0.5) (sqrt 0.5) (sqrt 0.5))
 6 | 			 (basis1 0 1 1)
 7 | 			 (basis2 1 0 1)
 8 | 			 (basis3 1 1 0)))
 9 | 
10 | ; Corners of the irreducible Brillouin zone for the fcc lattice,
11 | ; in a canonical order:
12 | (set! k-points (interpolate 4 (list
13 | 			       (vector3 0 0.5 0.5)            ; X
14 | 			       (vector3 0 0.625 0.375)        ; U
15 | 			       (vector3 0 0.5 0)              ; L
16 | 			       (vector3 0 0 0)                ; Gamma
17 | 			       (vector3 0 0.5 0.5)            ; X
18 | 			       (vector3 0.25 0.75 0.5)        ; W
19 | 			       (vector3 0.375 0.75 0.375))))  ; K
20 | 
21 | ; define a couple of parameters (which we can set from the command-line)
22 | (define-param eps 11.56) ; the dielectric constant of the spheres
23 | (define-param r 0.25)    ; the radius of the spheres
24 | 
25 | (define diel (make dielectric (epsilon eps)))
26 | 
27 | ; A diamond lattice has two "atoms" per unit cell:
28 | (set! geometry (list (make sphere (center 0.125 0.125 0.125) (radius r) 
29 | 			   (material diel))
30 | 		     (make sphere (center -0.125 -0.125 -0.125) (radius r) 
31 | 			   (material diel))))
32 | 
33 | ; (A simple fcc lattice would have only one sphere/object at the origin.)
34 | 
35 | (set-param! resolution 16) ; use a 16x16x16 grid
36 | (set-param! mesh-size 5)
37 | (set-param! num-bands 5)
38 | 
39 | ; run calculation, outputting electric-field energy density at the U point:
40 | (run (output-at-kpoint (vector3 0 0.625 0.375) output-dpwr))
41 | 


--------------------------------------------------------------------------------
/examples/dos.scm:
--------------------------------------------------------------------------------
 1 | ; A simple function to compute the density of states (DOS) by summing
 2 | ; Gaussian smoothing functions around each computed frequency point.
 3 | ; This scheme was suggested by Xavier Gonze and implemented in ABINIT
 4 | ; (http://www.mapr.ucl.ac.be/Fr/PCPM/ABINIT/), with further
 5 | ; suggestions by Doug Allan of Corning.  (There are also more
 6 | ; sophisticated algorithms employing the group velocity, but we have
 7 | ; not implemented them yet.)
 8 | 
 9 | ; To apply it to output, say, the density of states at 100 points
10 | ; points in the frequency range 0 to 1 you would do the following
11 | ; (*after* using (run) to compute the frequencies at a bunch of
12 | ; k-points filling the irreducible Brillouin zone):
13 | ;
14 | ; (include "dos.scm")
15 | ; (print-dos 0 1 100)
16 | 
17 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
18 | 
19 | ; Given a list of frequencies, freqs, and a broadening width df,
20 | ; return a function (dos f) that returns the density of states at a
21 | ; frequency f.  The integral of dos equals the number of elements of
22 | ; freqs.  See also broaden, below, to compute a default df.
23 | (define ((broaden-df freqs df) f)
24 |   (/ (fold-left
25 |       + 0 (map (lambda (f0) (exp (- (sqr (/ (- f f0) df))))) freqs))
26 |      (* 2 df (sqrt (atan 1)))))
27 | 
28 | ; Return the median difference between consecutive numbers in the list nums.
29 | (define (median-diff nums)
30 |   (let ((snums (sort nums <)) (n (- (length nums) 1)))
31 |     (let ((sdiff (sort (map (lambda (x y) (- y x))
32 | 			    (reverse (cdr (reverse snums)))
33 | 			    (cdr snums)) <)))
34 |       (* 0.5 (+ (list-ref sdiff (quotient n 2))
35 | 		(list-ref sdiff (- (quotient (+ n 1) 2) 1)))))))
36 | 
37 | ; Like broaden-df, above, but use a default df given by (median-diff freqs).
38 | (define (broaden freqs)
39 |   (broaden-df freqs (median-diff freqs)))
40 | 
41 | ; Return the broaden (dos) function applied to all-freqs, the list of
42 | ; all frequencies computed from the last run.  (Actually, all-freqs
43 | ; is the list of lists of frequencies at each k-point.)
44 | (define (all-freqs-broaden)
45 |   (broaden (fold-left append '() all-freqs)))
46 | 
47 | ; Output the DOS from all-freqs, at num-freq points from freq-min to freq-max.
48 | (define (print-dos freq-min freq-max num-freq)
49 |   (let ((dos (all-freqs-broaden)))
50 |     (map (lambda (f) (print "dos:, " f ", " (dos f) "\n"))
51 | 	 (interpolate (max 0 (- num-freq 2)) (list freq-min freq-max)))))
52 | 


--------------------------------------------------------------------------------
/examples/hole-slab.ctl:
--------------------------------------------------------------------------------
 1 | ; Photonic crystal slab consisting of a triangular lattice of air
 2 | ; holes in a finite-thickness dielectric slab, optionally with a
 3 | ; substrate on one side of the slab.  See the paper: S. G. Johnson,
 4 | ; S. Fan, P. R. Villeneuve, J. D. Joannopoulos, L. A. Kolodziejski,
 5 | ; "Guided modes in photonic crystal slabs," PRB 60, 5751 (August
 6 | ; 1999).
 7 | 
 8 | ; Note that this structure has mirror symmetry throught the z=0 plane,
 9 | ; and we are looking at k-vectors in the xy plane only.  Thus, we can
10 | ; break up the modes into even and odd (analogous to TE and TM), using
11 | ; the run-zeven and run-zodd functions.
12 | 
13 | (define-param h 0.5) ; the thickness of the slab
14 | (define-param eps 12.0) ; the dielectric constant of the slab
15 | (define-param loweps 1.0) ; the dielectric constant of the substrate
16 | (define-param r 0.3) ; the radius of the holes
17 | (define-param supercell-h 4) ; height of the supercell
18 | 
19 | ; triangular lattice with vertical supercell:
20 | (set! geometry-lattice (make lattice (size 1 1 supercell-h)
21 |                          (basis1 (/ (sqrt 3) 2) 0.5)
22 |                          (basis2 (/ (sqrt 3) 2) -0.5)))
23 | 
24 | (set! geometry
25 |       (list (make block (material (make dielectric (epsilon loweps)))
26 | 		  (center 0 0 (* 0.25 supercell-h))
27 | 		  (size infinity infinity (* 0.5 supercell-h)))
28 | 	    (make block (material (make dielectric (epsilon eps)))
29 | 		  (center 0) (size infinity infinity h))
30 | 	    (make cylinder (material air)
31 | 		  (center 0) (radius r) (height supercell-h))))
32 | 
33 | ; 1st Brillouin zone of a triangular lattice:
34 | (define Gamma (vector3 0 0 0))
35 | (define M (vector3 0 0.5 0))
36 | (define K (vector3 (/ -3) (/ 3) 0))
37 | 
38 | (define-param only-K false) ; run with only-K=true to only do this k-point
39 | (define-param k-interp 4)   ; the number of k points to interpolate
40 | (if only-K
41 |     (set! k-points (list K))
42 |     (set! k-points (interpolate k-interp (list Gamma M K Gamma))))
43 | 
44 | (set-param! resolution (vector3 32 32 16))
45 | (set-param! num-bands 9)
46 | 
47 | ; Run even and odd bands, outputting fields only at the K point:
48 | (if (= loweps 1.0)
49 |     (begin ; we only have even/odd classification for symmetric structure
50 |       (run-zeven (output-at-kpoint K output-hfield-z))
51 |       (run-zodd (output-at-kpoint K output-dfield-z)))
52 |     (run (output-at-kpoint K output-hfield-z) display-zparities))
53 | 
54 | (display-eigensolver-stats)
55 | 


--------------------------------------------------------------------------------
/examples/honey-rods.ctl:
--------------------------------------------------------------------------------
 1 | ; A honeycomb lattice of dielectric rods in air.  (This structure has
 2 | ; a complete (overlapping TE/TM) band gap.)  A honeycomb lattice is really
 3 | ; just a triangular lattice with two rods per unit cell, so we just
 4 | ; take the lattice, k-points, etcetera from tri-rods.ctl.
 5 | 
 6 | (define-param r 0.14) ; the rod radius
 7 | (define-param eps 12) ; the rod dielectric constant
 8 | 
 9 | ; triangular lattice:
10 | (set! geometry-lattice (make lattice (size 1 1 no-size)
11 |                          (basis1 (/ (sqrt 3) 2) 0.5)
12 |                          (basis2 (/ (sqrt 3) 2) -0.5)))
13 | 
14 | ; Two rods per unit cell, at the correct positions to form a honeycomb
15 | ; lattice, and arranged to have inversion symmetry:
16 | (set! geometry
17 |       (list (make cylinder
18 | 	      (center (/ 6) (/ 6) 0) (radius r) (height infinity)
19 | 	      (material (make dielectric (epsilon eps))))
20 | 	    (make cylinder
21 | 	      (center (/ -6) (/ -6) 0) (radius r) (height infinity)
22 | 	      (material (make dielectric (epsilon eps))))))
23 | 
24 | ; The k-points list, for the Brillouin zone of a triangular lattice:
25 | (set! k-points (list (vector3 0 0 0)          ; Gamma
26 |                      (vector3 0 0.5 0)        ; M
27 |                      (vector3 (/ -3) (/ 3) 0) ; K
28 |                      (vector3 0 0 0)))        ; Gamma
29 | (define-param k-interp 4) ; number of k-points to interpolate
30 | (set! k-points (interpolate k-interp k-points))
31 | 
32 | (set-param! resolution 32)
33 | (set-param! num-bands 8)
34 | 
35 | (run-tm)
36 | (run-te)
37 | 
38 | ; Since there is a complete gap, we could instead see it just by using:
39 | ; (run)
40 | ; The gap is between bands 12 and 13 in this case.  (Note that there is
41 | ; a false gap between bands 2 and 3, which disappears as you increase the
42 | ; k-point resolution.)
43 | 


--------------------------------------------------------------------------------
/examples/line-defect.ctl:
--------------------------------------------------------------------------------
 1 | ; A line-defect waveguide in a 2d triangular lattice of dielectric
 2 | ; rods (c.f. tri-rods.ctl), formed by a row of missing rods along the
 3 | ; "x" direction.  (Here, "x" and "y" refer to the first and second
 4 | ; basis directions.)  This structure supports a single guided band
 5 | ; within the band gap, much like the analogous waveguide in a square
 6 | ; lattice of rods (see "Photonic Crystals" by Joannopoulos et al.).
 7 | 
 8 | (define-param supercell-y 7) ; the (odd) number of lateral supercell periods
 9 | 
10 | (set! geometry-lattice (make lattice 
11 | 			 (basis1 (/ (sqrt 3) 2) 0.5)
12 | 			 (basis2 (/ (sqrt 3) 2) -0.5)
13 | 			 (size 1 supercell-y no-size)))
14 | 
15 | (define-param eps 12) ; the dielectric constant of the rods
16 | (define-param r 0.2) ; the rod radius in the bulk crystal
17 | 
18 | (set! geometry (list (make cylinder
19 | 		       (center 0 0 0) (radius r) (height infinity)
20 | 		       (material (make dielectric (epsilon eps))))))
21 | 
22 | (set! geometry 
23 |       (append
24 |        ; duplicate the bulk crystal rods over the supercell:
25 |        (geometric-objects-lattice-duplicates geometry)
26 | 
27 |        ; add a rod of air, to erase a row of rods and form a waveguide:
28 |        (list 
29 | 	(make cylinder (center 0) (radius r) (height infinity)
30 | 	      (material air)))))
31 | 
32 | (define Gamma (vector3 0 0 0))
33 | (define K' (lattice->reciprocal (vector3 0.5 0 0))) ; edge of Brillouin zone.
34 | (set! k-points (interpolate 4 (list Gamma K')))
35 | 
36 | ; the bigger the supercell, the more bands you need to compute to get
37 | ; to the defect modes (the lowest band is "folded" supercell-y times):
38 | (define-param extra-bands 5) ; number of extra bands to compute above the gap
39 | (set! num-bands (+ supercell-y extra-bands))
40 | 
41 | (set-param! resolution 32)
42 | 
43 | ; Compute the TM modes, outputting the Ez field in the *middle* of the
44 | ; band.  (In general, the guided mode in such an air defect may have
45 | ; exited the gap by the time it reaches the edge of the Brillouin
46 | ; zone at K'.)
47 | (run-tm 
48 |  (output-at-kpoint (list-ref k-points (quotient (length k-points) 2))
49 | 		   fix-efield-phase output-efield-z))
50 | 


--------------------------------------------------------------------------------
/examples/sq-rods.ctl:
--------------------------------------------------------------------------------
 1 | ; Compute band structure for a square lattice of dielectric rods
 2 | ; in air.
 3 | 
 4 | ; Define various parameters with define-param so that they are
 5 | ; settable from the command-line (with mpb <param>=<value>):
 6 | (define-param r 0.2) ; radius of the rods
 7 | (define-param eps 11.56) ; dielectric constant
 8 | (define-param k-interp 4) ; number of k points to interpolate
 9 | 
10 | (define GaAs (make dielectric (epsilon eps)))
11 | 
12 | (set! geometry-lattice (make lattice (size 1 1 no-size))) ; 2d cell
13 | 
14 | (set! geometry 
15 |       (list
16 |        (make cylinder 
17 | 	 (material GaAs) 
18 | 	 (center 0 0) (radius r) (height infinity))))
19 |       
20 | (define Gamma (vector3 0 0 0))
21 | (define X (vector3 0.5 0 0))
22 | (define M (vector3 0.5 0.5 0))
23 | (set! k-points (interpolate k-interp (list Gamma X M Gamma)))
24 | 
25 | (set-param! resolution 32)
26 | (set-param! num-bands 8)
27 | 
28 | ; Compute the TE and TM bands.  Wrap in the (begin-time message ...)
29 | ; construct from libctl so that we report the total elapsed time:
30 | (begin-time
31 |  "total time for both TE and TM bands: "
32 |  (run-te)
33 |  (run-tm))
34 | 
35 | (display-eigensolver-stats)
36 | 


--------------------------------------------------------------------------------
/examples/strip.ctl:
--------------------------------------------------------------------------------
 1 | ; Compute modes of a rectangular Si strip waveguide on top of oxide. 
 2 | ; Note that you should only pay attention, here, to the guided modes,
 3 | ; which are the modes whose frequency falls under the light line --
 4 | ; that is, frequency < beta / 1.45, where 1.45 is the SiO2 index.
 5 | 
 6 | ; Since there's no special lengthscale here, I'll just
 7 | ; use microns.  In general, if you use units of x, the frequencies
 8 | ; output are equivalent to x/lambda; so here, the freqeuncies will be
 9 | ; output as um/lambda, e.g. 1.5um would correspond to the frequency
10 | ; 1/1.5 = 0.6667.
11 | 
12 | ; define parameters which can easily be changed on the command-line
13 | ; (e.g.: mpb w=0.5 buried-strip.ctl)
14 | (define-param w 0.3) ; Si width (um)
15 | (define-param h 0.25) ; Si height (um)
16 | 
17 | (define Si (make dielectric (index 3.45)))
18 | (define SiO2 (make dielectric (index 1.45)))
19 | 
20 | ; Define the computational cell.  We'll make x the propagation direction.
21 | ; the other cell sizes should be big enough so that the boundaries are
22 | ; far away from the mode field.
23 | (define-param sc-y 2) ; supercell width (um)
24 | (define-param sc-z 2) ; supercell height (um)
25 | (set! geometry-lattice (make lattice (size no-size sc-y sc-z)))
26 | 
27 | ; define the 2d blocks for the strip and substrate
28 | (set! geometry
29 |       (list
30 |        (make block (size infinity infinity (* 0.5 (- sc-z h)))
31 | 	     (center 0 0 (* 0.25 (+ sc-z h))) (material SiO2))
32 |        (make block (size infinity w h) (center 0 0 0) (material Si))))
33 | 
34 | 
35 | ; The k (i.e. beta, i.e. propagation constant) points to look at, in
36 | ; units of 2*pi/um.  We'll look at num-k points from k-min to k-max.
37 | (define-param num-k 9)
38 | (define-param k-min 0.1)
39 | (define-param k-max 3.0)
40 | (set! k-points (interpolate num-k (list (vector3 k-min) (vector3 k-max))))
41 | 
42 | (set-param! resolution 32) ; pixels/um
43 | 
44 | ; Increase this to see more modes.  (The guided ones are the ones below the
45 | ; light line, i.e. those with frequencies < kmag / 1.45, where kmag
46 | ; is the corresponding column in the output if you grep for "freqs:".)
47 | (set-param! num-bands 4)
48 | 
49 | (set-param! filename-prefix "strip-") ; use this prefix for output files
50 | 
51 | ; compute num-bands lowest frequencies as a function of k. Also display
52 | ; "parities", i.e. whether the mode is symmetric or anti-symmetric
53 | ; through the y=0 and z=0 planes.
54 | (run display-yparities display-zparities)
55 | 
56 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
57 | 
58 | ; Above, we outputted the dispersion relation: frequency (omega) as a
59 | ; function of wavevector kx (beta).  Alternatively, you can compute
60 | ; beta for a given omega -- for example, you might want to find the
61 | ; modes and wavevectors at a fixed wavelength of 1.55 microns.  You
62 | ; can do that using the find-k function:
63 | 
64 | (define-param omega (/ 1 1.55)) ; frequency corresponding to 1.55um
65 | 
66 | ; Output the x component of the Poynting vector for num-bands bands at omega
67 | (find-k NO-PARITY omega 1 num-bands (vector3 1) 1e-3
68 | 	(* omega 3.45) (* omega 0.1) (* omega 4) output-poynting-x
69 | 	display-yparities display-group-velocities)
70 | 
71 | 


--------------------------------------------------------------------------------
/examples/tri-holes.ctl:
--------------------------------------------------------------------------------
 1 | ; 2d system: triangular lattice of air holes in dielectric
 2 | ; This structure has a complete band gap (i.e. a gap in both TE and TM
 3 | ; simultaneously) for a hole radius of 0.45a and a dielectric constant of
 4 | ; 12.   (See, e.g., the book "Photonic Crystals" by Joannopoulos et al.)
 5 | 
 6 | ; first, define the lattice vectors and k-points for a triangular lattice:
 7 | 
 8 | (set! geometry-lattice (make lattice (size 1 1 no-size)
 9 |                          (basis1 (/ (sqrt 3) 2) 0.5)
10 |                          (basis2 (/ (sqrt 3) 2) -0.5)))
11 | 
12 | (define-param kz 0) ; use non-zero kz to consider vertical propagation
13 | 
14 | (set! k-points (list (vector3 0 0 kz)          ; Gamma
15 |                      (vector3 0 0.5 kz)        ; M
16 |                      (vector3 (/ -3) (/ 3) kz) ; K
17 |                      (vector3 0 0 kz)))        ; Gamma
18 | (define-param k-interp 4)
19 | (set! k-points (interpolate k-interp k-points))
20 | 
21 | ; Now, define the geometry, etcetera:
22 | 
23 | (define-param eps 12) ; the dielectric constant of the background
24 | (define-param r 0.45) ; the hole radius
25 | 
26 | (set! default-material (make dielectric (epsilon eps)))
27 | (set! geometry (list (make cylinder (center 0) (material air)
28 | 			   (radius r) (height infinity))))
29 | 
30 | (set-param! resolution 32)
31 | (set-param! num-bands 8)
32 | 
33 | (if (= kz 0)
34 |     (begin
35 |       (run-te)
36 |       (run-tm))
37 |     (run)) ; if kz != 0 there are no purely te and tm bands
38 | 


--------------------------------------------------------------------------------
/examples/tri-rods.ctl:
--------------------------------------------------------------------------------
 1 | ; A triangular lattice of dielectric rods in air.  (This structure has
 2 | ; a band-gap for TM fields.)  This file is used in the "Data Analysis
 3 | ; Tutorial" section of the MPB manual.
 4 | 
 5 | (set! num-bands 8)
 6 | 
 7 | (set! geometry-lattice (make lattice (size 1 1 no-size)
 8 |                          (basis1 (/ (sqrt 3) 2) 0.5)
 9 |                          (basis2 (/ (sqrt 3) 2) -0.5)))
10 | (set! geometry (list (make cylinder
11 |                        (center 0 0 0) (radius 0.2) (height infinity)
12 |                        (material (make dielectric (epsilon 12))))))
13 | 
14 | (set! k-points (list (vector3 0 0 0)          ; Gamma
15 |                      (vector3 0 0.5 0)        ; M
16 |                      (vector3 (/ -3) (/ 3) 0) ; K
17 |                      (vector3 0 0 0)))        ; Gamma
18 | (set! k-points (interpolate 4 k-points))
19 | 
20 | (set! resolution 32)
21 | 
22 | (run-tm (output-at-kpoint (vector3 (/ -3) (/ 3) 0) 
23 | 			  fix-efield-phase output-efield-z))
24 | (run-te)
25 | 
26 | 


--------------------------------------------------------------------------------
/examples/tutorial.ctl:
--------------------------------------------------------------------------------
  1 | ; This file contains the Scheme commands from the user tutorial section
  2 | ; of the manual.  It is meant to be run interactively by the user.
  3 | 
  4 | ; *** Our First Band Structure ***
  5 | 
  6 | (print "********** Square lattice of rods in air **********\n")
  7 | 
  8 | (set! num-bands 8)
  9 | (set! k-points (list (vector3 0 0 0)     ; Gamma
 10 |                      (vector3 0.5 0 0)   ; X
 11 |                      (vector3 0.5 0.5 0) ; M
 12 |                      (vector3 0 0 0)))   ; Gamma
 13 | (set! k-points (interpolate 4 k-points))
 14 | (set! geometry (list (make cylinder 
 15 |                        (center 0 0 0) (radius 0.2) (height infinity)
 16 |                        (material (make dielectric (epsilon 12))))))
 17 | (set! geometry-lattice (make lattice (size 1 1 no-size)))
 18 | (set! resolution 32)
 19 | 
 20 | (print "********** Square lattice of rods: TE bands**********\n")
 21 | (run-te)
 22 | 
 23 | (print "********** Square lattice of rods: TM bands **********\n")
 24 | (run-tm)
 25 | 
 26 | (print "********** Square lattice of rods: TM, w/efield **********\n")
 27 | (run-tm output-efield-z)
 28 | 
 29 | (print "********** Square lattice of rods: TE, w/hfield & dpwr **********\n")
 30 | (run-te (output-at-kpoint (vector3 0.5 0 0) output-hfield-z output-dpwr))
 31 | 
 32 | ; *** Bands of a Triangular Lattice ***
 33 | 
 34 | (print "********** Triangular lattice of rods in air **********\n")
 35 | 
 36 | (set! geometry-lattice (make lattice (size 1 1 no-size)
 37 |                          (basis1 (/ (sqrt 3) 2) 0.5)
 38 |                          (basis2 (/ (sqrt 3) 2) -0.5)))
 39 | 
 40 | (set! k-points (list (vector3 0 0 0)          ; Gamma
 41 |                      (vector3 0 0.5 0)        ; M
 42 |                      (vector3 (/ -3) (/ 3) 0) ; K
 43 |                      (vector3 0 0 0)))        ; Gamma
 44 | (set! k-points (interpolate 4 k-points))
 45 | 
 46 | (run-tm)
 47 | 
 48 | ; *** Maximizing the First TM Gap ***
 49 | 
 50 | (print "********** Maximizing the first TM gap **********\n")
 51 | 
 52 | (define (first-tm-gap r)
 53 |   (set! geometry (list (make cylinder
 54 |                          (center 0 0 0) (radius r) (height infinity)
 55 |                          (material (make dielectric (epsilon 12))))))
 56 |   (run-tm)
 57 |   (retrieve-gap 1)) ; return the gap from TM band 1 to TM band 2
 58 | 
 59 | (set! num-bands 2)
 60 | (set! mesh-size 7) ; increase from default value of 3
 61 | 
 62 | (define result (maximize first-tm-gap 0.1 0.1 0.5))
 63 | (print "radius at maximum: " (max-arg result) "\n")
 64 | (print "gap size at maximum: " (max-val result) "\n")
 65 | 
 66 | (set! mesh-size 3) ; reset to default value of 3
 67 | 
 68 | ; *** A Complete 2D Gap with an Anisotropic Dielectric ***
 69 | 
 70 | (print "********** Anisotropic complete 2d gap **********\n")
 71 | 
 72 | (set! geometry (list (make cylinder
 73 |                        (center 0 0 0) (radius 0.3) (height infinity)
 74 |                        (material (make dielectric-anisotropic
 75 |                                    (epsilon-diag 1 1 12))))))
 76 | (set! default-material (make dielectric-anisotropic (epsilon-diag 12 12 1)))
 77 | (set! num-bands 8)
 78 | (run) ; just use run, instead of run-te or run-tm, to find the complete gap
 79 | 
 80 | ; *** Finding a Point-defect State ***
 81 | 
 82 | (print "********** 5x5 point defect **********\n")
 83 | 
 84 | (set! geometry-lattice (make lattice (size 5 5 no-size)))
 85 | (set! geometry (list (make cylinder
 86 |                        (center 0 0 0) (radius 0.2) (height infinity)
 87 |                        (material (make dielectric (epsilon 12))))))
 88 | (set! geometry (geometric-objects-lattice-duplicates geometry))
 89 | (set! geometry (append geometry 
 90 |                        (list (make cylinder (center 0 0 0) 
 91 |                                    (radius 0.2) (height infinity)
 92 |                                    (material air)))))
 93 | (set! resolution 16)
 94 | (set! k-points (list (vector3 0.5 0.5 0)))
 95 | 
 96 | (set! num-bands 50)
 97 | (run-tm)
 98 | 
 99 | (output-efield-z 25)
100 | (get-dfield 25)  ; compute the D field for band 25
101 | (compute-field-energy)  ; compute the energy density from D
102 | (print
103 |  "energy in cylinder: "
104 |  (compute-energy-in-objects (make cylinder (center 0 0 0)
105 |                                   (radius 1.0) (height infinity)
106 |                                   (material air)))
107 |  "\n")
108 | 
109 | (print "********** 5x5 point defect, targeted solver **********\n")
110 | (set! num-bands 1)  ; only need to compute a single band, now!
111 | (set! target-freq (/ (+ 0.2812 0.4174) 2))
112 | (set! tolerance 1e-8)
113 | (run-tm)
114 | 
115 | ; *** Tuning the Point-defect Mode ***
116 | 
117 | (print "********** Tuning the 5x5 point defect **********\n")
118 | 
119 | (define old-geometry geometry) ; save the 5x5 grid with a missing rod
120 | (define (rootfun eps)
121 |   ; add the cylinder of epsilon = eps to the old geometry:
122 |   (set! geometry (append old-geometry
123 |                          (list (make cylinder (center 0 0 0)
124 |                                      (radius 0.2) (height infinity)
125 |                                      (material (make dielectric
126 |                                                  (epsilon eps)))))))
127 |   (run-tm)  ; solve for the mode (using the targeted solver)
128 |   (print "epsilon = " eps " gives freq. = " (list-ref freqs 0) "\n")
129 |   (- (list-ref freqs 0) 0.314159))  ; return 1st band freq. - 0.314159
130 | 
131 | (define rooteps (find-root rootfun 0.01 1 12))
132 | (print "root (value of epsilon) is at: " rooteps "\n")
133 | 
134 | (define rootval (rootfun rooteps))
135 | (print "root function at " rooteps " = " rootval "\n")
136 | 


--------------------------------------------------------------------------------
/examples/twodim-min-tetm.ctl:
--------------------------------------------------------------------------------
 1 | (define-param tri? false)
 2 | (set-param! mesh-size 1)
 3 | (define-param mg-res 32)
 4 | (set-param! resolution 64)
 5 | (define-param eps 12)
 6 | (set-param! tolerance 1e-13)
 7 | 
 8 | (if (not deterministic?)
 9 |     (let ((time (gettimeofday)))
10 |       (set! *random-state*
11 | 	    (seed->random-state (+ (car time)
12 | 				   (cdr time))))))
13 | (define-param r 0.1)
14 | (define-param rand-init? true)
15 | (define-param kind U-SUM)
16 | (define mg (make material-grid
17 | 	     (epsilon-min 1)
18 | 	     (epsilon-max eps)
19 | 	     (material-grid-kind kind)
20 | 	     (size mg-res mg-res 1)
21 | 	     (matgrid-init
22 | 	      (if rand-init?
23 | 		  (lambda (x y z) (random:uniform))
24 | 		  (lambda (x y z) 
25 | 		    (if (< (+ (* x x) (* y y)) (* r r))
26 | 			0.0 1.0))))))
27 | 
28 | (if tri?
29 |     (set! geometry-lattice (make lattice (size 1 1 no-size)
30 | 				 (basis1 (/ (sqrt 3) 2) 0.5)
31 | 				 (basis2 (/ (sqrt 3) 2) -0.5)))
32 |     (set! geometry-lattice (make lattice (size 1 1 no-size))))
33 | 
34 | (set! geometry 
35 |       (list 
36 |        (make block (e1 1 0) (e2 0 1) 
37 | 	     (center 0) (size 1 1) ( material mg))))
38 | 
39 | (define-param band 1)
40 | (set! num-bands 1)
41 | (define-param gridfile false)
42 | (if gridfile
43 |     (load-material-grid! mg gridfile (vector3 supercell supercell 1)))
44 | (define-param noise 0)
45 | (if (> noise 0)
46 |     (randomize-material-grid! mg noise))
47 | 
48 | (init-params NO-PARITY true)
49 | (set! interactive? false)
50 | 
51 | (define-param epsfile false)
52 | (if epsfile
53 |     (material-grids-match-epsilon-file! epsfile 1e-4))
54 | 
55 | (define-param gaptol 0)
56 | (define-param epstol 0)
57 | (define-param maxeval 40)
58 | 
59 | (define-param kx 0.1234)
60 | (define-param ky 0.3456)
61 | 
62 | (material-grids-min-tetm-gap
63 |  (vector3 kx ky) band
64 |  gaptol epstol maxeval 0)
65 | 
66 | (save-material-grid mg (string-append (get-filename-prefix) "grid"))
67 | 
68 | (set! k-points (list (vector3 kx ky)))
69 | (set! num-bands 2)
70 | (run)
71 | 


--------------------------------------------------------------------------------
/examples/wavevector.scm:
--------------------------------------------------------------------------------
 1 | ; Code to output the data needed for a wavevector diagram at a grid of
 2 | ; k points, suitable for plotting with a contour-plot program.
 3 | 
 4 | (define (kgrid kx-min kx-max ky-min ky-max nkx nky)
 5 |   (map (lambda (kx)
 6 | 	 (interpolate nky (list (vector3 kx ky-min) (vector3 kx ky-max))))
 7 |        (interpolate nkx (list kx-min kx-max))))
 8 | 
 9 | ; output a bunch of lines of the form:
10 | ; kgrid:, band#, kx, frequencies at kys...
11 | ; Frequencies above the light cone omega > c |k| / n-lightcone are
12 | ; excluded (multiplied by -1); set n-lightcone = 0 to disable this.
13 | (define (wavevector-diagram kgrid parity n-lightcone)
14 |   (map (lambda (kylist)
15 | 	 (set! k-points kylist)
16 | 	 (run-parity parity true)
17 | 	 (map
18 | 	  (lambda (band)
19 | 	    (print "kgrid:, " band ", " (vector3-x (car kylist)))
20 | 	    (map (lambda (freqs k) 
21 | 		   (print ", " 
22 | 			  (* (if (and (positive? n-lightcone)
23 | 				      (> (list-ref freqs (- band 1))
24 | 					 (* n-lightcone
25 | 					    (vector3-norm 
26 | 					     (reciprocal->cartesian k)))))
27 | 				 -1
28 | 				 1)
29 | 			     (list-ref freqs (- band 1)))))
30 | 		 all-freqs k-points)
31 | 	    (print "\n"))
32 | 	  (arith-sequence 1 1 num-bands)))
33 | 	 kgrid))
34 | 
35 |   


--------------------------------------------------------------------------------
/m4/ax_lapack.m4:
--------------------------------------------------------------------------------
  1 | # ===========================================================================
  2 | #        https://www.gnu.org/software/autoconf-archive/ax_lapack.html
  3 | # ===========================================================================
  4 | #
  5 | # SYNOPSIS
  6 | #
  7 | #   AX_LAPACK([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
  8 | #
  9 | # DESCRIPTION
 10 | #
 11 | #   This macro looks for a library that implements the LAPACK linear-algebra
 12 | #   interface (see http://www.netlib.org/lapack/). On success, it sets the
 13 | #   LAPACK_LIBS output variable to hold the requisite library linkages.
 14 | #
 15 | #   To link with LAPACK, you should link with:
 16 | #
 17 | #     $LAPACK_LIBS $BLAS_LIBS $LIBS $FLIBS
 18 | #
 19 | #   in that order. BLAS_LIBS is the output variable of the AX_BLAS macro,
 20 | #   called automatically. FLIBS is the output variable of the
 21 | #   AC_F77_LIBRARY_LDFLAGS macro (called if necessary by AX_BLAS), and is
 22 | #   sometimes necessary in order to link with F77 libraries. Users will also
 23 | #   need to use AC_F77_DUMMY_MAIN (see the autoconf manual), for the same
 24 | #   reason.
 25 | #
 26 | #   The user may also use --with-lapack=<lib> in order to use some specific
 27 | #   LAPACK library <lib>. In order to link successfully, however, be aware
 28 | #   that you will probably need to use the same Fortran compiler (which can
 29 | #   be set via the F77 env. var.) as was used to compile the LAPACK and BLAS
 30 | #   libraries.
 31 | #
 32 | #   ACTION-IF-FOUND is a list of shell commands to run if a LAPACK library
 33 | #   is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
 34 | #   is not found. If ACTION-IF-FOUND is not specified, the default action
 35 | #   will define HAVE_LAPACK.
 36 | #
 37 | # LICENSE
 38 | #
 39 | #   Copyright (c) 2009 Steven G. Johnson <stevenj@alum.mit.edu>
 40 | #   Copyright (c) 2019 Geoffrey M. Oxberry <goxberry@gmail.com>
 41 | #
 42 | #   This program is free software: you can redistribute it and/or modify it
 43 | #   under the terms of the GNU General Public License as published by the
 44 | #   Free Software Foundation, either version 3 of the License, or (at your
 45 | #   option) any later version.
 46 | #
 47 | #   This program is distributed in the hope that it will be useful, but
 48 | #   WITHOUT ANY WARRANTY; without even the implied warranty of
 49 | #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 50 | #   Public License for more details.
 51 | #
 52 | #   You should have received a copy of the GNU General Public License along
 53 | #   with this program. If not, see <https://www.gnu.org/licenses/>.
 54 | #
 55 | #   As a special exception, the respective Autoconf Macro's copyright owner
 56 | #   gives unlimited permission to copy, distribute and modify the configure
 57 | #   scripts that are the output of Autoconf when processing the Macro. You
 58 | #   need not follow the terms of the GNU General Public License when using
 59 | #   or distributing such scripts, even though portions of the text of the
 60 | #   Macro appear in them. The GNU General Public License (GPL) does govern
 61 | #   all other use of the material that constitutes the Autoconf Macro.
 62 | #
 63 | #   This special exception to the GPL applies to versions of the Autoconf
 64 | #   Macro released by the Autoconf Archive. When you make and distribute a
 65 | #   modified version of the Autoconf Macro, you may extend this special
 66 | #   exception to the GPL to apply to your modified version as well.
 67 | 
 68 | #serial 10
 69 | 
 70 | AU_ALIAS([ACX_LAPACK], [AX_LAPACK])
 71 | AC_DEFUN([AX_LAPACK], [
 72 | AC_REQUIRE([AX_BLAS])
 73 | ax_lapack_ok=no
 74 | 
 75 | AC_ARG_WITH(lapack,
 76 |         [AS_HELP_STRING([--with-lapack=<lib>], [use LAPACK library <lib>])])
 77 | case $with_lapack in
 78 |         yes | "") ;;
 79 |         no) ax_lapack_ok=disable ;;
 80 |         -* | */* | *.a | *.so | *.so.* | *.dylib | *.dylib.* | *.o)
 81 |                  LAPACK_LIBS="$with_lapack"
 82 |         ;;
 83 |         *) LAPACK_LIBS="-l$with_lapack" ;;
 84 | esac
 85 | 
 86 | # Get fortran linker name of LAPACK function to check for.
 87 | AC_F77_FUNC(cheev)
 88 | 
 89 | # We cannot use LAPACK if BLAS is not found
 90 | if test "x$ax_blas_ok" != xyes; then
 91 |         ax_lapack_ok=noblas
 92 |         LAPACK_LIBS=""
 93 | fi
 94 | 
 95 | # First, check LAPACK_LIBS environment variable
 96 | if test "x$LAPACK_LIBS" != x; then
 97 |         save_LIBS="$LIBS"; LIBS="$LAPACK_LIBS $BLAS_LIBS $LIBS $FLIBS"
 98 |         AC_MSG_CHECKING([for $cheev in $LAPACK_LIBS])
 99 |         AC_LINK_IFELSE([AC_LANG_CALL([], [$cheev])], [ax_lapack_ok=yes], [LAPACK_LIBS=""])
100 |         AC_MSG_RESULT($ax_lapack_ok)
101 |         LIBS="$save_LIBS"
102 |         if test $ax_lapack_ok = no; then
103 |                 LAPACK_LIBS=""
104 |         fi
105 | fi
106 | 
107 | # LAPACK linked to by default?  (is sometimes included in BLAS lib)
108 | if test $ax_lapack_ok = no; then
109 |         save_LIBS="$LIBS"; LIBS="$LIBS $BLAS_LIBS $FLIBS"
110 |         AC_CHECK_FUNC($cheev, [ax_lapack_ok=yes])
111 |         LIBS="$save_LIBS"
112 | fi
113 | 
114 | # Generic LAPACK library?
115 | for lapack in lapack lapack_rs6k; do
116 |         if test $ax_lapack_ok = no; then
117 |                 save_LIBS="$LIBS"; LIBS="$BLAS_LIBS $LIBS"
118 |                 AC_CHECK_LIB($lapack, $cheev,
119 |                     [ax_lapack_ok=yes; LAPACK_LIBS="-l$lapack"], [], [$FLIBS])
120 |                 LIBS="$save_LIBS"
121 |         fi
122 | done
123 | 
124 | AC_SUBST(LAPACK_LIBS)
125 | 
126 | # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
127 | if test x"$ax_lapack_ok" = xyes; then
128 |         ifelse([$1],,AC_DEFINE(HAVE_LAPACK,1,[Define if you have LAPACK library.]),[$1])
129 |         :
130 | else
131 |         ax_lapack_ok=no
132 |         $2
133 | fi
134 | ])dnl AX_LAPACK
135 | 


--------------------------------------------------------------------------------
/m4/ax_openmp.m4:
--------------------------------------------------------------------------------
  1 | # ===========================================================================
  2 | #        https://www.gnu.org/software/autoconf-archive/ax_openmp.html
  3 | # ===========================================================================
  4 | #
  5 | # SYNOPSIS
  6 | #
  7 | #   AX_OPENMP([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
  8 | #
  9 | # DESCRIPTION
 10 | #
 11 | #   This macro tries to find out how to compile programs that use OpenMP a
 12 | #   standard API and set of compiler directives for parallel programming
 13 | #   (see http://www-unix.mcs/)
 14 | #
 15 | #   On success, it sets the OPENMP_CFLAGS/OPENMP_CXXFLAGS/OPENMP_F77FLAGS
 16 | #   output variable to the flag (e.g. -omp) used both to compile *and* link
 17 | #   OpenMP programs in the current language.
 18 | #
 19 | #   NOTE: You are assumed to not only compile your program with these flags,
 20 | #   but also link it with them as well.
 21 | #
 22 | #   If you want to compile everything with OpenMP, you should set:
 23 | #
 24 | #     CFLAGS="$CFLAGS $OPENMP_CFLAGS"
 25 | #     #OR#  CXXFLAGS="$CXXFLAGS $OPENMP_CXXFLAGS"
 26 | #     #OR#  FFLAGS="$FFLAGS $OPENMP_FFLAGS"
 27 | #
 28 | #   (depending on the selected language).
 29 | #
 30 | #   The user can override the default choice by setting the corresponding
 31 | #   environment variable (e.g. OPENMP_CFLAGS).
 32 | #
 33 | #   ACTION-IF-FOUND is a list of shell commands to run if an OpenMP flag is
 34 | #   found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it is
 35 | #   not found. If ACTION-IF-FOUND is not specified, the default action will
 36 | #   define HAVE_OPENMP.
 37 | #
 38 | # LICENSE
 39 | #
 40 | #   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
 41 | #   Copyright (c) 2015 John W. Peterson <jwpeterson@gmail.com>
 42 | #   Copyright (c) 2016 Nick R. Papior <nickpapior@gmail.com>
 43 | #
 44 | #   This program is free software: you can redistribute it and/or modify it
 45 | #   under the terms of the GNU General Public License as published by the
 46 | #   Free Software Foundation, either version 3 of the License, or (at your
 47 | #   option) any later version.
 48 | #
 49 | #   This program is distributed in the hope that it will be useful, but
 50 | #   WITHOUT ANY WARRANTY; without even the implied warranty of
 51 | #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 52 | #   Public License for more details.
 53 | #
 54 | #   You should have received a copy of the GNU General Public License along
 55 | #   with this program. If not, see <https://www.gnu.org/licenses/>.
 56 | #
 57 | #   As a special exception, the respective Autoconf Macro's copyright owner
 58 | #   gives unlimited permission to copy, distribute and modify the configure
 59 | #   scripts that are the output of Autoconf when processing the Macro. You
 60 | #   need not follow the terms of the GNU General Public License when using
 61 | #   or distributing such scripts, even though portions of the text of the
 62 | #   Macro appear in them. The GNU General Public License (GPL) does govern
 63 | #   all other use of the material that constitutes the Autoconf Macro.
 64 | #
 65 | #   This special exception to the GPL applies to versions of the Autoconf
 66 | #   Macro released by the Autoconf Archive. When you make and distribute a
 67 | #   modified version of the Autoconf Macro, you may extend this special
 68 | #   exception to the GPL to apply to your modified version as well.
 69 | 
 70 | #serial 13
 71 | 
 72 | AC_DEFUN([AX_OPENMP], [
 73 | AC_PREREQ([2.69]) dnl for _AC_LANG_PREFIX
 74 | 
 75 | AC_CACHE_CHECK([for OpenMP flag of _AC_LANG compiler], ax_cv_[]_AC_LANG_ABBREV[]_openmp, [save[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS
 76 | ax_cv_[]_AC_LANG_ABBREV[]_openmp=unknown
 77 | # Flags to try:  -fopenmp (gcc), -mp (SGI & PGI),
 78 | #                -qopenmp (icc>=15), -openmp (icc),
 79 | #                -xopenmp (Sun), -omp (Tru64),
 80 | #                -qsmp=omp (AIX),
 81 | #                none
 82 | ax_openmp_flags="-fopenmp -openmp -qopenmp -mp -xopenmp -omp -qsmp=omp none"
 83 | if test "x$OPENMP_[]_AC_LANG_PREFIX[]FLAGS" != x; then
 84 |   ax_openmp_flags="$OPENMP_[]_AC_LANG_PREFIX[]FLAGS $ax_openmp_flags"
 85 | fi
 86 | for ax_openmp_flag in $ax_openmp_flags; do
 87 |   case $ax_openmp_flag in
 88 |     none) []_AC_LANG_PREFIX[]FLAGS=$save[]_AC_LANG_PREFIX[] ;;
 89 |     *) []_AC_LANG_PREFIX[]FLAGS="$save[]_AC_LANG_PREFIX[]FLAGS $ax_openmp_flag" ;;
 90 |   esac
 91 |   AC_LINK_IFELSE([AC_LANG_SOURCE([[
 92 | @%:@include <omp.h>
 93 | 
 94 | static void
 95 | parallel_fill(int * data, int n)
 96 | {
 97 |   int i;
 98 | @%:@pragma omp parallel for
 99 |   for (i = 0; i < n; ++i)
100 |     data[i] = i;
101 | }
102 | 
103 | int
104 | main()
105 | {
106 |   int arr[100000];
107 |   omp_set_num_threads(2);
108 |   parallel_fill(arr, 100000);
109 |   return 0;
110 | }
111 | ]])],[ax_cv_[]_AC_LANG_ABBREV[]_openmp=$ax_openmp_flag; break],[])
112 | done
113 | []_AC_LANG_PREFIX[]FLAGS=$save[]_AC_LANG_PREFIX[]FLAGS
114 | ])
115 | if test "x$ax_cv_[]_AC_LANG_ABBREV[]_openmp" = "xunknown"; then
116 |   m4_default([$2],:)
117 | else
118 |   if test "x$ax_cv_[]_AC_LANG_ABBREV[]_openmp" != "xnone"; then
119 |     OPENMP_[]_AC_LANG_PREFIX[]FLAGS=$ax_cv_[]_AC_LANG_ABBREV[]_openmp
120 |   fi
121 |   m4_default([$1], [AC_DEFINE(HAVE_OPENMP,1,[Define if OpenMP is enabled])])
122 | fi
123 | ])dnl AX_OPENMP
124 | 


--------------------------------------------------------------------------------
/mkdocs.yml:
--------------------------------------------------------------------------------
 1 | site_name: MPB Documentation
 2 | site_author: MPB Developers
 3 | repo_url: https://github.com/NanoComp/mpb/
 4 | edit_uri: edit/master/doc/docs
 5 | 
 6 | use_directory_urls: True
 7 | 
 8 | docs_dir: 'doc/docs'
 9 | site_dir: 'doc/site'
10 | 
11 | theme:
12 |   name: readthedocs
13 | 
14 | markdown_extensions:
15 |     - wikilinks
16 |     - toc:
17 |         title: Table of Contents
18 |         permalink: "#"
19 |     - attr_list
20 |     - fenced_code
21 |     - md_in_html
22 |     - mdx_math:
23 |         enable_dollar_delimiter: True
24 | 
25 | extra_javascript:
26 |  - 'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS_HTML'
27 |  - 'js/mathjaxhelper.js'
28 |  - 'js/extra.js'
29 | 
30 | nav:
31 | - Manual: 'index.md'
32 | - Introduction: 'Introduction.md'
33 | - Download: 'Download.md'
34 | - Installation: 'Installation.md'
35 | - Developer Information: 'Developer_Information.md'
36 | - Acknowledgements: 'Acknowledgements.md'
37 | - License and Copyright: 'License_and_Copyright.md'
38 | - Python Interface:
39 |    - User Interface: 'Python_User_Interface.md'
40 |    - Tutorial: 'Python_Tutorial.md'
41 |    - Data Analysis: 'Python_Data_Analysis_Tutorial.md'
42 | - Scheme Interface:
43 |    - User Interface: 'Scheme_User_Interface.md'
44 |    - Tutorial: 'Scheme_Tutorial.md'
45 |    - Data Analysis: 'Data_Analysis_Tutorial.md'
46 |    - Guile and Scheme Information: 'Guile_and_Scheme_Information.md'
47 | 


--------------------------------------------------------------------------------
/mpb/Makefile.am:
--------------------------------------------------------------------------------
 1 | # libctl: flexible Guile-based control files for scientific software
 2 | # Copyright (C) 1998, 1999-2012, Steven G. Johnson
 3 | #
 4 | # This file may be used without restriction.  It is in the public
 5 | # domain, and is NOT restricted by the terms of any GNU license.
 6 | #
 7 | # This library is distributed in the hope that it will be useful,
 8 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
 9 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10 | # Lesser General Public License for more details.
11 | #
12 | # Steven G. Johnson can be contacted at stevenj@alum.mit.edu.
13 | 
14 | ##############################################################################
15 | 
16 | bin_PROGRAMS = mpb@MPB_SUFFIX@
17 | 
18 | SPECIFICATION_FILE = mpb.scm
19 | EXTRA_DIST = mpb.scm.in epsilon.c mu.c
20 | 
21 | nodist_pkgdata_DATA = $(SPECIFICATION_FILE)
22 | 
23 | MY_SOURCES = transform.c medium.c epsilon_file.c field-smob.c fields.c	\
24 | material_grid.c material_grid_opt.c matrix-smob.c mpb.c field-smob.h matrix-smob.h mpb.h my-smob.h
25 | 
26 | MY_LIBS = $(top_builddir)/src/matrixio/libmatrixio.a $(top_builddir)/src/libmpb@MPB_SUFFIX@.la $(NLOPT_LIB) -lctl $(GUILE_LIBS)
27 | MY_CPPFLAGS = $(GUILE_CPPFLAGS) -I$(top_srcdir)/src/util -I$(top_srcdir)/src/matrices -I$(top_srcdir)/src/matrixio -I$(top_srcdir)/src/maxwell
28 | MY_DEFS = -DHAVE_CTL_HOOKS=1 -DHAVE_CTL_EXPORT_HOOK=1
29 | 
30 | # what is printed out when invoking your program with --version:
31 | VERSION_STRING = "mpb@MPB_SUFFIX@ @VERSION@, Copyright (C) 1999-2012, MIT"
32 | 
33 | check-local: mpb@MPB_SUFFIX@
34 | 	$(RUNCODE) ./mpb@MPB_SUFFIX@ $(top_srcdir)/examples/check.ctl
35 | 	$(RUNCODE) ./mpb@MPB_SUFFIX@ force-mu?=true $(top_srcdir)/examples/check.ctl
36 | 
37 | dist_man_MANS = mpb-split.1 mpb.1
38 | 
39 | if !MPI
40 | bin_SCRIPTS = mpb@MPB_SUFFIX@-split
41 | endif
42 | 
43 | mpb@MPB_SUFFIX@-split: mpb-split-preinstall
44 | 	sed "s%\./mpb%"$(prefix)/bin/"mpb@MPB_SUFFIX@%g" \
45 |             mpb-split-preinstall > $@
46 | 	chmod u+x $@
47 | 
48 | # The following variables should be detected and set by autoconf:
49 | 
50 | # libctl install. dir., e.g. /usr/local/share/libctl
51 | LIBCTL_DIR = @LIBCTL_DIR@
52 | 
53 | # gen-ctl-io program
54 | GEN_CTL_IO = @GEN_CTL_IO@
55 | 
56 | ##############################################################################
57 | #   don't (normally) edit below except to replace "mpb" with your name   #
58 | ##############################################################################
59 | 
60 | CTL_DEFS = -DCTL_SCM='"'$(LIBCTL_DIR)/base/ctl.scm'"' \
61 |        -DINCLUDE_SCM='"'$(LIBCTL_DIR)/base/include.scm'"' \
62 |           -DSPEC_SCM='"'$(pkgdatadir)/$(SPECIFICATION_FILE)'"' \
63 |     -DVERSION_STRING='"'$(VERSION_STRING)'"'
64 | 
65 | mpb@MPB_SUFFIX@_SOURCES = $(MY_SOURCES)
66 | nodist_mpb@MPB_SUFFIX@_SOURCES = main.c geom.c ctl-io.h ctl-io.c
67 | BUILT_SOURCES = $(nodist_mpb@MPB_SUFFIX@_SOURCES) mu.c
68 | mpb@MPB_SUFFIX@_LDADD = $(MY_LIBS)
69 | mpb@MPB_SUFFIX@_LDFLAGS = $(MY_LDFLAGS)
70 | mpb@MPB_SUFFIX@_CPPFLAGS = $(CTL_H_CPPFLAG) $(MY_CPPFLAGS) $(MY_DEFS) $(CTL_DEFS)
71 | 
72 | if MAINTAINER_MODE
73 | 
74 | mu.c: epsilon.c
75 | 	$(PERL) -pe 's/epsilon/mu/g;s/eps_inv/mu_inv/g' $< > $@
76 | 
77 | endif
78 | 
79 | main.c: $(LIBCTL_DIR)/base/main.c
80 | 	cp -f $(LIBCTL_DIR)/base/main.c $@
81 | 
82 | geom.c: $(LIBCTL_DIR)/utils/geom.c
83 | 	cp -f $(LIBCTL_DIR)/utils/geom.c $@
84 | 
85 | ctl-io.c: $(SPECIFICATION_FILE) $(LIBCTL_DIR)/utils/geom.scm
86 | 	$(GEN_CTL_IO) --code -o $@ $(SPECIFICATION_FILE) $(LIBCTL_DIR)
87 | 
88 | ctl-io.h: $(SPECIFICATION_FILE) $(LIBCTL_DIR)/utils/geom.scm
89 | 	$(GEN_CTL_IO) --header -o $@ $(SPECIFICATION_FILE) $(LIBCTL_DIR)
90 | 
91 | clean-local:
92 | 	rm -f ctl-io.* main.* geom.*
93 | 


--------------------------------------------------------------------------------
/mpb/epsilon_file.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2014 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | /**************************************************************************/
 19 | 
 20 | /* This file defines functions to initialize the dielectric function
 21 |    by reading epsilon values from a file, rather than using the
 22 |    geometry.  Actually, we would like to use the geometry in addition
 23 |    to the epsilon file, for added flexibility.  So, we return an epsilon
 24 |    function that can be used when no geometric objects are found. */
 25 | 
 26 | /**************************************************************************/
 27 | 
 28 | #include <stdio.h>
 29 | #include <stdlib.h>
 30 | #include <math.h>
 31 | 
 32 | #include "config.h"
 33 | #include <check.h>
 34 | #include <mpi_utils.h>
 35 | #include <matrices.h>
 36 | #include <matrixio.h>
 37 | #include <maxwell.h>
 38 | 
 39 | #include <ctl.h>
 40 | 
 41 | #include "mpb.h"
 42 | 
 43 | typedef struct {
 44 |      int nx, ny, nz;
 45 |      real *data;
 46 | } epsilon_file_data;
 47 | 
 48 | /* Linearly interpolate a given point in a 3d grid of data.  The point
 49 |    coordinates should be in the range [0,1], or at the very least [-1,2]
 50 |    ... anything outside [0,1] is *mirror* reflected into [0,1] */
 51 | real linear_interpolate(real rx, real ry, real rz,
 52 | 			real *data, int nx, int ny, int nz, int stride)
 53 | {
 54 |      int x, y, z, x2, y2, z2;
 55 |      real dx, dy, dz;
 56 | 
 57 |      /* mirror boundary conditions for r just beyond the boundary */
 58 |      if (rx < 0.0) rx = -rx; else if (rx > 1.0) rx = 1.0 - rx;
 59 |      if (ry < 0.0) ry = -ry; else if (ry > 1.0) ry = 1.0 - ry;
 60 |      if (rz < 0.0) rz = -rz; else if (rz > 1.0) rz = 1.0 - rz;
 61 | 
 62 |      /* get the point corresponding to r in the epsilon array grid: */
 63 |      x = rx * nx; if (x == nx) --x;
 64 |      y = ry * ny; if (y == ny) --y;
 65 |      z = rz * nz; if (z == nz) --z;
 66 | 
 67 |      /* get the difference between (x,y,z) and the actual point
 68 |         ... we shift by 0.5 to center the data points in the pixels */
 69 |      dx = rx * nx - x - 0.5;
 70 |      dy = ry * ny - y - 0.5;
 71 |      dz = rz * nz - z - 0.5;
 72 | 
 73 |      /* get the other closest point in the grid, with mirror boundaries: */
 74 |      x2 = (dx >= 0.0 ? x + 1 : x - 1);
 75 |      if (x2 < 0) x2++; else if (x2 == nx) x2--;
 76 |      y2 = (dy >= 0.0 ? y + 1 : y - 1);
 77 |      if (y2 < 0) y2++; else if (y2 == ny) y2--;
 78 |      z2 = (dz >= 0.0 ? z + 1 : z - 1);
 79 |      if (z2 < 0) z2++; else if (z2 == nz) z2--;
 80 | 
 81 |      /* take abs(d{xyz}) to get weights for {xyz} and {xyz}2: */
 82 |      dx = fabs(dx);
 83 |      dy = fabs(dy);
 84 |      dz = fabs(dz);
 85 | 
 86 |      /* define a macro to give us data(x,y,z) on the grid,
 87 | 	in row-major order (the order used by HDF5): */
 88 | #define D(x,y,z) (data[(((x)*ny + (y))*nz + (z)) * stride])
 89 | 
 90 |      return(((D(x,y,z)*(1.0-dx) + D(x2,y,z)*dx) * (1.0-dy) +
 91 | 	     (D(x,y2,z)*(1.0-dx) + D(x2,y2,z)*dx) * dy) * (1.0-dz) +
 92 | 	    ((D(x,y,z2)*(1.0-dx) + D(x2,y,z2)*dx) * (1.0-dy) +
 93 | 	     (D(x,y2,z2)*(1.0-dx) + D(x2,y2,z2)*dx) * dy) * dz);
 94 | 
 95 | #undef D
 96 | }
 97 | 
 98 | static void epsilon_file_func(symmetric_matrix *eps, symmetric_matrix *eps_inv,
 99 | 			      const real r[3], void *edata)
100 | {
101 |      epsilon_file_data *d = (epsilon_file_data *) edata;
102 |      real rx, ry, rz;
103 |      real eps_val;
104 | 
105 |      /* make sure r is positive: */
106 |      rx = r[0] >= 0.0 ? r[0] : (r[0] + (1 + (int) (-r[0])));
107 |      ry = r[1] >= 0.0 ? r[1] : (r[1] + (1 + (int) (-r[1])));
108 |      rz = r[2] >= 0.0 ? r[2] : (r[2] + (1 + (int) (-r[2])));
109 | 
110 |      /* make sure r is in [0,1) */
111 |      rx = rx < 1.0 ? rx : rx - ((int) rx);
112 |      ry = ry < 1.0 ? ry : ry - ((int) ry);
113 |      rz = rz < 1.0 ? rz : rz - ((int) rz);
114 | 
115 |      eps_val = linear_interpolate(rx,ry,rz, d->data, d->nx,d->ny,d->nz, 1);
116 |      eps->m00 = eps->m11 = eps->m22 = eps_val;
117 |      eps_inv->m00 = eps_inv->m11 = eps_inv->m22 = 1.0 / eps_val;
118 | #ifdef WITH_HERMITIAN_EPSILON
119 |      CASSIGN_ZERO(eps->m01);
120 |      CASSIGN_ZERO(eps->m02);
121 |      CASSIGN_ZERO(eps->m12);
122 |      CASSIGN_ZERO(eps_inv->m01);
123 |      CASSIGN_ZERO(eps_inv->m02);
124 |      CASSIGN_ZERO(eps_inv->m12);
125 | #else
126 |      eps->m01 = eps->m02 = eps->m12 = 0.0;
127 |      eps_inv->m01 = eps_inv->m02 = eps_inv->m12 = 0.0;
128 | #endif
129 | }
130 | 
131 | void get_epsilon_file_func(const char *fname,
132 | 			   maxwell_dielectric_function *func,
133 | 			   void **func_data)
134 | {
135 |      if (fname && fname[0]) {
136 | 	  char *eps_fname;
137 | 	  matrixio_id file_id;
138 | 	  epsilon_file_data *d;
139 | 	  int rank = 3, dims[3];
140 | 
141 | 	  CHK_MALLOC(d, epsilon_file_data, 1);
142 | 	  
143 | 	  eps_fname = ctl_fix_path(fname);
144 | 	  mpi_one_printf("Using background dielectric from file \"%s\"...\n",
145 | 			 eps_fname);
146 | 	  file_id = matrixio_open(eps_fname, 1);
147 | 	  free(eps_fname);
148 | 
149 | 	  d->data = matrixio_read_real_data(file_id, NULL, &rank, dims,
150 | 					    0,0,0, NULL);
151 | 	  CHECK(d->data, "couldn't find dataset in dielectric file");
152 | 	  matrixio_close(file_id);
153 | 	  
154 | 	  d->nx = rank >= 1 ? dims[0] : 1;
155 | 	  d->ny = rank >= 2 ? dims[1] : 1;
156 | 	  d->nz = rank >= 3 ? dims[2] : 1;
157 | 
158 | 	  mpi_one_printf("    ...read %dx%dx%d dielectric function\n",
159 | 			 d->nx, d->ny, d->nz);
160 | 
161 | 	  *func = epsilon_file_func;
162 | 	  *func_data = (void*) d;
163 |      }
164 |      else {
165 | 	  *func = NULL;
166 | 	  *func_data = NULL;
167 |      }
168 | }
169 | 
170 | void destroy_epsilon_file_func_data(void *func_data)
171 | {
172 |      epsilon_file_data *d = (epsilon_file_data *) func_data;
173 |      if (d) {
174 | 	  free(d->data);
175 | 	  free(d);
176 |      }
177 | }
178 | 


--------------------------------------------------------------------------------
/mpb/field-smob.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2014 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #ifndef FIELD_SMOB_H
19 | #define FIELD_SMOB_H
20 | 
21 | #include "ctl-io.h"
22 | #include "my-smob.h"
23 | 
24 | #include <matrices.h>
25 | 
26 | extern long scm_tc16_smob_field_smob;
27 | 
28 | typedef enum { 
29 |      RSCALAR_FIELD_SMOB, CVECTOR_FIELD_SMOB, CSCALAR_FIELD_SMOB
30 | } field_smob_type;
31 | 
32 | typedef struct {
33 |      field_smob_type type;
34 |      char type_char;
35 |      union {
36 | 	  real *rs;
37 | 	  scalar_complex *cv;
38 | 	  scalar_complex *cs;
39 |      } f;
40 |      int nx, ny, nz, N;
41 |      int local_ny, local_y_start;
42 |      int last_dim, last_dim_size, other_dims;
43 | } field_smob;
44 | 
45 | #define FIELD_P(X) T_SMOB_P(field_smob, X)
46 | #define FIELD(X) T_SMOB(field_smob, X)
47 | #define SAFE_FIELD(X) (cur_fieldp(X) ? update_curfield_smob() : SAFE_T_SMOB(field_smob, X))
48 | 
49 | #define RSCALAR_FIELD_P(X) (FIELD_P(X) && ((FIELD(X))->type == RSCALAR_FIELD_SMOB))
50 | #define CSCALAR_FIELD_P(X) (FIELD_P(X) && ((FIELD(X))->type == CSCALAR_FIELD_SMOB))
51 | #define CVECTOR_FIELD_P(X) (FIELD_P(X) && ((FIELD(X))->type == CVECTOR_FIELD_SMOB))
52 | 
53 | extern field_smob *update_curfield_smob(void);
54 | extern void register_field_smobs(void);
55 | extern field_smob *assert_field_smob(SCM fo);
56 | 
57 | #endif /* FIELD_SMOB_H */
58 | 


--------------------------------------------------------------------------------
/mpb/matrix-smob.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2014 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #ifndef MATRIX_SMOB_H
19 | #define MATRIX_SMOB_H
20 | 
21 | #include "ctl-io.h"
22 | #include "my-smob.h"
23 | 
24 | #include <matrices.h>
25 | 
26 | extern long scm_tc16_smob_evectmatrix;
27 | extern long scm_tc16_smob_sqmatrix;
28 | 
29 | #define EVECTMATRIX_P(X) T_SMOB_P(evectmatrix, X)
30 | #define EVECTMATRIX(X) T_SMOB(evectmatrix, X)
31 | #define SAFE_EVECTMATRIX(X) SAFE_T_SMOB(evectmatrix, X)
32 | 
33 | #define SQMATRIX_P(X) T_SMOB_P(sqmatrix, X)
34 | #define SQMATRIX(X) T_SMOB(sqmatrix, X)
35 | #define SAFE_SQMATRIX(X) SAFE_T_SMOB(sqmatrix, X)
36 | 
37 | extern SCM evectmatrix2scm(evectmatrix m);
38 | extern SCM evectmatrix_sub2scm(evectmatrix m, int p_start, int p_end);
39 | extern SCM sqmatrix2scm(sqmatrix m);
40 | 
41 | extern integer sqmatrix_size(object mo);
42 | extern cnumber sqmatrix_ref(object mo, integer i, integer j);
43 | 
44 | extern void register_matrix_smobs(void);
45 | extern sqmatrix *assert_sqmatrix_smob(SCM mo);
46 | extern evectmatrix *assert_evectmatrix_smob(SCM mo);
47 | 
48 | #endif /* MATRIX_SMOB_H */
49 | 


--------------------------------------------------------------------------------
/mpb/mpb-split-preinstall.in:
--------------------------------------------------------------------------------
 1 | #! @SH_JOB@
 2 | if test x"`echo $1 | egrep '^[0-9]*$'`" = x; then
 3 |     echo "Syntax: $0 <num-split> [mpb arguments...]" 1>&2
 4 |     exit 1
 5 | fi
 6 | 
 7 | tmpname=/tmp/mpb-split.$$.tmp # unique temporary filename
 8 | subprocesses="" # keep a list of the subprocess ids launched
 9 | 
10 | # If a SIGINT or SIGHUP is received, kill subprocesses and delete temp. files:
11 | trap 'echo "killing subprocesses: $subprocesses"; kill -9 $subprocesses; rm -f $tmpname.*; exit 1' 1 2
12 | 
13 | # Run num-split instances of mpb, each with a chunk of k-points, with
14 | # the first chunk going to stdout and the rest going to temporary files
15 | # to be output later.
16 | ./mpb interactive?=false k-split-index=0 k-split-num=$* &
17 | subprocesses="$subprocesses $!"
18 | i=0
19 | while test `expr $i \< $1` = 1; do
20 |     ./mpb interactive?=false k-split-index=$i k-split-num=$* > $tmpname.$i &
21 |     subprocesses="$subprocesses $!"
22 |     i=`expr $i + 1`
23 | done
24 | 
25 | # After all mpb processes have finished, concatenate their outputs in order.
26 | wait
27 | i=0
28 | while test `expr $i \< $1` = 1; do
29 |     cat $tmpname.$i
30 |     rm -f $tmpname.$i
31 |     i=`expr $i + 1`
32 | done
33 | 


--------------------------------------------------------------------------------
/mpb/mpb-split.1:
--------------------------------------------------------------------------------
 1 | .\" Copyright (C) 1999-2014 Massachusetts Institute of Technology.
 2 | .\"
 3 | .\" This program is free software; you can redistribute it and/or modify
 4 | .\" it under the terms of the GNU General Public License as published by
 5 | .\" the Free Software Foundation; either version 2 of the License, or
 6 | .\" (at your option) any later version.
 7 | .\"
 8 | .\" This program is distributed in the hope that it will be useful,
 9 | .\" but WITHOUT ANY WARRANTY; without even the implied warranty of
10 | .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 | .\" GNU General Public License for more details.
12 | .\"
13 | .\" You should have received a copy of the GNU General Public License
14 | .\" along with this program; if not, write to the Free Software
15 | .\" Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 | .\"
17 | .TH MPB 1 "March 13, 2002" "MPB" "MIT Photonic-Bands Package"
18 | .SH NAME
19 | mpb-split \- compute eigenmodes with MPB using multiple processes
20 | .SH SYNOPSIS
21 | .B mpb-split
22 | \fINUM-SPLIT\fR [\fIDEFINITION\fR]... [\fICTLFILE\fR]...
23 | .SH DESCRIPTION
24 | .PP
25 | ." Add any additional description here
26 | mpb-split is a parallelizing front-end to MIT Photonic Bands (MPB).
27 | For a computation with several k points, it splits the list of k
28 | points over multiple processes.  Of course, this will only benefit you
29 | on a system where different processes will run on different
30 | processors, such as an SMP or a cluster with automatic process
31 | migration (e.g. MOSIX). mpb-split is actually a trivial shell script,
32 | though, so you can easily modify it if you need to use a special
33 | command to launch processes on other processors/machines.
34 | 
35 | MIT Photonic Bands (MPB) is a free program to compute the band
36 | structures (dispersion relations) and electromagnetic modes of
37 | periodic dielectric structures, and is applicable both to photonic
38 | crystals (photonic band-gap materials) and a wide range of other
39 | optical problems.
40 | .PP
41 | More information on MPB, including a detailed manual, can be found
42 | online at the MPB home page:
43 | .I http://ab-initio.mit.edu/mpb/
44 | .PP
45 | A typical invocation of
46 | .I mpb-split
47 | looks like:
48 | .PP
49 | .Vb 1
50 | \&    mpb-split num-split foo.ctl >& foo.out
51 | .Ve
52 | .PP
53 | This causes
54 | .I mpb-split
55 | to process the control file foo.ctl, divide the k points into
56 | . B num-split
57 | equal chunks, run each list in a separate process with MPB, and
58 | redirect the output (in order) to foo.out.  (One typically redirects
59 | output to a file, as the output is verbose and contains a number of
60 | comma-delimited datasets that one can extract by grepping.)
61 | .PP
62 | Overall, the behavior and arguments are the same as for
63 | .I mpb
64 | except that the first argument must be the integer \fBnum-split\fR.
65 | .PP
66 | What 
67 | .I mpb-split
68 | technically does is to set the MPB variable k-split-num to 
69 | .B num-split
70 | and k-split-index to the index (starting with 0) of the chunk for each
71 | process. If you want, you can use these variables to divide the
72 | problem in some other way and then reset them to 1 and 0,
73 | respectively.
74 | .SH BUGS
75 | Send bug reports to S. G. Johnson, stevenj@alum.mit.edu.
76 | .SH AUTHORS
77 | Written by Steven G. Johnson.  Copyright (c) 1999-2012 by
78 | the Massachusetts Institute of Technology.
79 | .SH "SEE ALSO"
80 | mpb(1), mpb-data(1)
81 | 


--------------------------------------------------------------------------------
/mpb/mpb.1:
--------------------------------------------------------------------------------
 1 | .\" Copyright (C) 1999-2014 Massachusetts Institute of Technology.
 2 | .\"
 3 | .\" This program is free software; you can redistribute it and/or modify
 4 | .\" it under the terms of the GNU General Public License as published by
 5 | .\" the Free Software Foundation; either version 2 of the License, or
 6 | .\" (at your option) any later version.
 7 | .\"
 8 | .\" This program is distributed in the hope that it will be useful,
 9 | .\" but WITHOUT ANY WARRANTY; without even the implied warranty of
10 | .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 | .\" GNU General Public License for more details.
12 | .\"
13 | .\" You should have received a copy of the GNU General Public License
14 | .\" along with this program; if not, write to the Free Software
15 | .\" Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 | .\"
17 | .TH MPB 1 "January 27, 2000" "MPB" "MIT Photonic-Bands Package"
18 | .SH NAME
19 | mpb \- compute eigenmodes of periodic dielectric structures
20 | .SH SYNOPSIS
21 | .B mpb
22 | [\fIOPTION\fR]... [\fIDEFINITION\fR]... [\fICTLFILE\fR]...
23 | .SH DESCRIPTION
24 | .PP
25 | ." Add any additional description here
26 | MIT Photonic Bands (MPB) is a free program to compute the band
27 | structures (dispersion relations) and electromagnetic modes of
28 | periodic dielectric structures, and is applicable both to photonic
29 | crystals (photonic band-gap materials) and a wide range of other
30 | optical problems. Its features include: fully-vectorial, 3D
31 | computations; a flexible user-interface based upon the GNU Guile
32 | scripting language; output in HDF format; and iterative, targeted
33 | eigensolver methods to address very large problems by solving for only
34 | a few states near a specified frequency.
35 | .PP
36 | More information on MPB, including a detailed manual, can be found
37 | online at the MPB home page:
38 | .I http://ab-initio.mit.edu/mpb/
39 | .PP
40 | A typical invocation of MPB looks like:
41 | .PP
42 | .Vb 1
43 | \&    mpb foo.ctl >& foo.out
44 | .Ve
45 | .PP
46 | This causes MPB to process the control file foo.ctl and redirect its output
47 | to foo.out.  (One typically redirects output to a file, as the output is
48 | verbose and contains a number of comma-delimited datasets that one can
49 | extract by grepping.)
50 | .PP
51 | You can also use MPB in an interactive mode, in which you can type in
52 | MPB commands (in Scheme/Guile) and immediately see their results.
53 | Interactive mode is entered when you invoke
54 | .I mpb
55 | with no control files, or if your control files don't contain any
56 | .I run
57 | statements (which disable interactive mode), or if the last control file ends
58 | by setting
59 | .I (set! interactive? true)
60 | in which case interactive mode is entered after the control files
61 | execute.
62 | .PP
63 | Another useful feature is that you can alter parameters in your control files
64 | from the command line, by including definitions of the form
65 | \fIvariable\fR=\fIvalue\fR as arguments to
66 | .I mpb
67 | (before the control files).  This overrides the values of variables
68 | defined with
69 | .I define-param
70 | in the control file (including all of the predefined MPB input variables).
71 | .PP
72 | Multiple control files and definitions are executed in sequence, in
73 | the order they are specified on the command line.
74 | .SH OPTIONS
75 | .TP
76 | \fB\-h\fR, \fB\--help\fR
77 | Display help on the command-line options and usage.
78 | .TP
79 | \fB\-V\fR, \fB\--version\fR
80 | Print the version number and copyright info for mpb.
81 | .TP
82 | \fB\-v\fR, \fB\--verbose\fR
83 | Verbose output.
84 | .SH BUGS
85 | Send bug reports to S. G. Johnson, stevenj@alum.mit.edu.
86 | .SH AUTHORS
87 | Written by Steven G. Johnson.  Copyright (c) 1999-2012 by
88 | the Massachusetts Institute of Technology.
89 | .SH "SEE ALSO"
90 | mpb-split(1), mpb-data(1)
91 | 


--------------------------------------------------------------------------------
/mpb/mpb.h:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2014 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | #ifndef MPB_H
 19 | #define MPB_H
 20 | 
 21 | #include <maxwell.h>
 22 | #include <ctl-io.h>
 23 | #include <ctlgeom.h>
 24 | 
 25 | /* this integer flag is defined by main.c from libctl, and is
 26 |    set when the user runs the program with --verbose */
 27 | extern int verbose;
 28 | 
 29 | #define MAX2(a,b) ((a) > (b) ? (a) : (b))
 30 | #define MIN2(a,b) ((a) < (b) ? (a) : (b))
 31 | 
 32 | #define TWOPI 6.2831853071795864769252867665590057683943388
 33 | 
 34 | /**************************************************************************/
 35 | 
 36 | extern void get_epsilon_file_func(const char *fname,
 37 | 				  maxwell_dielectric_function *func,
 38 | 				  void **func_data);
 39 | extern void destroy_epsilon_file_func_data(void *func_data);
 40 | 
 41 | extern real linear_interpolate(real rx, real ry, real rz,
 42 | 			       real *data, int nx, int ny, int nz, int stride);
 43 | 
 44 | /**************************************************************************/
 45 | 
 46 | /* global variables for retaining data about the eigenvectors between
 47 |    calls from Guile: */
 48 | 
 49 | #define MAX_NWORK 10
 50 | extern int nwork_alloc;
 51 | 
 52 | #define NUM_FFT_BANDS 20 /* max number of bands to FFT at a time */
 53 | 
 54 | extern maxwell_data *mdata;
 55 | extern maxwell_target_data *mtdata;
 56 | extern evectmatrix H, W[MAX_NWORK], Hblock;
 57 | 
 58 | extern vector3 cur_kvector;
 59 | extern scalar_complex *curfield;
 60 | extern int curfield_band;
 61 | extern char curfield_type;
 62 | 
 63 | extern void curfield_reset(void);
 64 | 
 65 | /* R[i]/G[i] are lattice/reciprocal-lattice vectors */
 66 | extern real R[3][3], G[3][3];
 67 | extern matrix3x3 Rm, Gm; /* same thing, but matrix3x3 */
 68 | extern real Vol; /* computational cell volume = |det Rm| */
 69 | 
 70 | /* index of current kpoint, for labeling output */
 71 | extern int kpoint_index;
 72 | 
 73 | /* in fields.c */
 74 | extern void compute_field_squared(void);
 75 | void get_efield(integer which_band);
 76 | real mean_medium_from_matrix(const symmetric_matrix *eps_inv);
 77 | void get_bloch_field_point_(scalar_complex *field, vector3 p);
 78 | 
 79 | /**************************************************************************/
 80 | 
 81 | extern void vector3_to_arr(real arr[3], vector3 v);
 82 | extern void matrix3x3_to_arr(real arr[3][3], matrix3x3 m);
 83 | extern scalar_complex cnumber2cscalar(cnumber c);
 84 | extern cnumber cscalar2cnumber(scalar_complex cs);
 85 | extern cvector3 cscalar32cvector3(const scalar_complex *cs);
 86 | extern void cvector32cscalar3(scalar_complex *cs, cvector3 v);
 87 | 
 88 | /**************************************************************************/
 89 | /* in epsilon.c */
 90 | 
 91 | extern int no_size_x, no_size_y, no_size_z;
 92 | extern geom_box_tree geometry_tree;
 93 | extern void reset_epsilon(void);
 94 | extern void init_epsilon(void);
 95 | 
 96 | /**************************************************************************/
 97 | /* material_grid.c */
 98 | 
 99 | typedef enum { U_MIN = 0, U_PROD = 1, U_SUM = 2 } material_grid_kinds;
100 | extern real material_grid_val(vector3 p, const material_grid *g);
101 | extern double matgrid_val(vector3 p, geom_box_tree tp, int oi,
102 | 			  const material_grid *mg);
103 | material_grid *get_material_grids(geometric_object_list g, int *ngrids);
104 | int material_grids_ntot(const material_grid *grids, int ngrids);
105 | void material_grids_set(const double *u, material_grid *grids, int ngrids);
106 | void material_grids_get(double *u, const material_grid *grids, int ngrids);
107 | void material_grids_addgradient(double *v,
108 | 				double scalegrad, int band,
109 | 				const material_grid *grids, int ngrids);
110 | 
111 | /**************************************************************************/
112 | 
113 | extern const char *parity_string(maxwell_data *d);
114 | 
115 | #endif /* MPB_H */
116 | 


--------------------------------------------------------------------------------
/mpb/my-smob.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2014 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #ifndef SMOB_H
19 | #define SMOB_H 1
20 | 
21 | /* use new smob functions from Guile 1.4+ */
22 | #include <libguile/smob.h>
23 | 
24 | #ifndef HAVE_SCM_MAKE_SMOB_TYPE
25 | /* Thanks to Greg Badros for posting a Guile smob tutorial; see
26 |    http://sources.redhat.com/ml/guile/1999-04/msg00107.html
27 |    However, this way of creating smobs no longer works as of Guile 1.4. */
28 | #define REGISTER_SMOBFUNS(T) \
29 |   do { scm_tc16_smob_ ## T = scm_newsmob(& T ## _smobfuns); } while (0)
30 | #define MAKE_SMOBFUNS(T) \
31 |   static scm_smobfuns T ## _smobfuns = { \
32 |     &mark_ ## T, \
33 |     &free_ ## T, \
34 |     &print_ ## T,  0 }
35 | #endif /* ! HAVE_SCM_MAKE_SMOB_TYPE */
36 | 
37 | #if defined(HAVE_SCM_NEW_SMOB)
38 | #  define NEWCELL_SMOB(ANSWER,T,PSMOB) \
39 |        ANSWER = scm_new_smob(scm_tc16_smob_ ## T, (scm_t_bits) PSMOB)
40 | #elif defined(HAVE_SCM_NEWSMOB)
41 | #  define NEWCELL_SMOB(ANSWER,T,PSMOB) \
42 |        SCM_NEWSMOB(ANSWER, scm_tc16_smob_ ## T, PSMOB)
43 | #else
44 | #  define NEWCELL_SMOB(ANSWER,T,PSMOB) do { \
45 |      SCM_NEWCELL((ANSWER)); \
46 |      SCM_SETCAR((ANSWER),scm_tc16_smob_ ## T); \
47 |      SCM_SETCDR((ANSWER),(SCM) (PSMOB)); \
48 |    } while (0)
49 | #endif
50 | 
51 | /* T_SMOB_P(T, X) is true iff X is an instance of the T SMOB type */
52 | #ifdef HAVE_SCM_SMOB_PREDICATE
53 | #  define T_SMOB_P(T, X) SCM_SMOB_PREDICATE(scm_tc16_smob_ ## T, X)
54 | #else
55 | #  define T_SMOB_P(T, X) (SCM_NIMP (X) \
56 |                           && SCM_TYP16 (X) == (scm_tc16_smob_ ## T))
57 | #endif
58 | 
59 | /* T_SMOB(T, X) returns the T * with the guts of the X instance; it
60 |    assumes X is a T SMOB instance, and could crash if it is not */
61 | #ifdef HAVE_SCM_SMOB_DATA
62 | #  define T_SMOB(T, X)  ((T *) SCM_SMOB_DATA(X))
63 | #else
64 | #  define T_SMOB(T, X)  ((T *)SCM2PTR(SCM_CDR(X)))
65 | #endif
66 | 
67 | /* Since T_SMOB(X) can be dangerous if X is not a T
68 |    object, we also have a SAFE_T_SMOB macro: */
69 | #define SAFE_T_SMOB(T, X) (T_SMOB_P(T,X) ? T_SMOB(T,X) : NULL)
70 | 
71 | #endif /* SMOB_H */
72 | 


--------------------------------------------------------------------------------
/src/Makefile.am:
--------------------------------------------------------------------------------
 1 | SUBDIRS = util matrices matrixio maxwell
 2 | 
 3 | lib_LTLIBRARIES = libmpb@MPB_SUFFIX@.la
 4 | 
 5 | libmpb@MPB_SUFFIX@_la_SOURCES =
 6 | libmpb@MPB_SUFFIX@_la_LIBADD = util/libutil.la matrices/libmatrices.la maxwell/libmaxwell.la
 7 | libmpb@MPB_SUFFIX@_la_LDFLAGS = -no-undefined -version-info @SHARED_VERSION_INFO@
 8 | 
 9 | BUILT_SOURCES = mpb@MPB_SUFFIX@.h
10 | include_HEADERS = mpb@MPB_SUFFIX@.h
11 | pkginclude_HEADERS = matrices/eigensolver.h matrices/matrices.h	\
12 | matrices/scalar.h maxwell/maxwell.h util/verbosity.h
13 | 
14 | mpb@MPB_SUFFIX@.h: mpbconf.h
15 | 	cp -f mpbconf.h $@
16 | 
17 | EXTRA_DIST = mpbconf.h.in
18 | 


--------------------------------------------------------------------------------
/src/matrices/Makefile.am:
--------------------------------------------------------------------------------
1 | noinst_LTLIBRARIES = libmatrices.la
2 | EXTRA_DIST = README
3 | 
4 | libmatrices_la_SOURCES = blasglue.c blasglue.h eigensolver.c		\
5 | eigensolver.h eigensolver_davidson.c eigensolver_utils.c evectmatrix.c	\
6 | linmin.c linmin.h matrices.c matrices.h minpack2-linmin.c scalar.h	\
7 | sqmatrix.c
8 | libmatrices_la_CPPFLAGS = -I$(srcdir)/../util
9 | 


--------------------------------------------------------------------------------
/src/matrices/README:
--------------------------------------------------------------------------------
 1 | In this directory are datatypes and subroutines to handle matrix types
 2 | and operations common to iterative block eigensolver algorithms.  The
 3 | block eigensolver algorithm itself is implemented in eigensolver.c.
 4 | 
 5 | Such algorithms solve for the first p eigenstates of an n x n (sparse)
 6 | matrix A.  This corresponds to minimizing Yt*A*Y under the constraint
 7 | Yt*Y==1, where Y is an n x p matrix whose columns are the eigenvectors
 8 | and Yt is its adjoint.  The components of Y are, in general, complex
 9 | vectors of length c.
10 | 
11 | We define two datatypes:
12 | 
13 | evectmatrix -- An (N x c) x p matrix (row-major) whose columns are
14 |                the eigenvects.  n = localN*c rows are stored local
15 |                to the current process.
16 | 
17 | sqmatrix -- a p x p matrix.  These are typically used to hold things
18 |             like Yt*Y.
19 | 
20 | The main reason for having two separate datatypes is that, on a
21 | parallel machine, evectmatrix's are distributed while sqmatrix's
22 | are not.  (In particular, evectmatrix's are distributed across
23 | their rows.)
24 | 
25 | Various operations are defined on these matrices (multiplication, a X
26 | + Y, etcetera, typically using BLAS routines internally).  The
27 | sqmatrix type also has operations like (dense) inversion and
28 | diagonalization (based on LAPACK).  Together, these operations can be
29 | used to easily implement most eigensolver algorithms.
30 | 


--------------------------------------------------------------------------------
/src/matrices/blasglue.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #ifndef BLASGLUE_H
19 | #define BLASGLUE_H
20 | 
21 | #include "scalar.h"
22 | 
23 | extern void blasglue_axpy(int n, real a, scalar *x, int incx,
24 | 			  scalar *y, int incy);
25 | extern void blasglue_scal(int n, scalar a, scalar *x, int incx);
26 | extern void blasglue_rscal(int n, real a, scalar *x, int incx);
27 | extern void blasglue_copy(int n, scalar *x, int incx, scalar *y, int incy);
28 | extern scalar blasglue_dotc(int n, scalar *x, int incx, scalar *y, int incy);
29 | void blasglue_gemm(char transa, char transb, int m, int n, int k,
30 |                    real a, scalar *A, int fdA, scalar *B, int fdB,
31 |                    real b, scalar *C, int fdC);
32 | extern void blasglue_herk(char uplo, char trans, int n, int k,
33 | 			  real a, scalar *A, int fdA,
34 | 			  real b, scalar *C, int fdC);
35 | extern int lapackglue_potrf(char uplo, int n, scalar *A, int fdA);
36 | extern int lapackglue_potri(char uplo, int n, scalar *A, int fdA);
37 | extern int lapackglue_hetrf(char uplo, int n, scalar *A, int fdA,
38 | 			     int *ipiv, scalar *work, int lwork);
39 | extern int lapackglue_hetri(char uplo, int n, scalar *A, int fdA,
40 | 			     int *ipiv, scalar *work);
41 | extern void lapackglue_heev(char jobz, char uplo, int n, scalar *A, int fdA,
42 | 			    real *w, scalar *work, int lwork, real *rwork);
43 | extern void lapackglue_geev(char jobvl, char jobvr, int n,
44 |                             scalar *A, int fdA, scalar_complex *w,
45 |                             scalar *VL, int fdVL, scalar *VR, int fdVR,
46 |                             scalar *work, int lwork, real *rwork);
47 | extern void lapackglue_hegv(int itype, char jobz, char uplo, int n,
48 |                             scalar *A, int fdA, scalar *B, int fdB, 
49 |                             real *w, scalar *work, int lwork, real *rwork);
50 | extern void lapackglue_syev(char jobz, char uplo, int n, real *A, int fdA,
51 | 			    real *w, real *work, int lwork);
52 | 
53 | #endif /* BLASGLUE_H */
54 | 


--------------------------------------------------------------------------------
/src/matrices/eigensolver.h:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | #ifndef EIGENSOLVER_H
 19 | #define EIGENSOLVER_H
 20 | 
 21 | #ifdef MPB_REAL
 22 | #  define real mpb_real
 23 | #endif
 24 | 
 25 | #include "matrices.h"
 26 | 
 27 | #ifdef __cplusplus
 28 | extern "C" {
 29 | #endif /* __cplusplus */
 30 | 
 31 | typedef void (*evectoperator) (evectmatrix Xin, evectmatrix Xout,
 32 | 			       void *data, int is_current_eigenvector,
 33 | 			       evectmatrix Work);
 34 | 
 35 | typedef void (*evectpreconditioner) (evectmatrix Xin, evectmatrix Xout,
 36 | 				     void *data,
 37 | 				     evectmatrix Y, real *eigenvals,
 38 | 				     sqmatrix YtY);
 39 | 
 40 | typedef void (*evectconstraint) (evectmatrix X, void *data);
 41 | 
 42 | extern void eigensolver(evectmatrix Y, real *eigenvals,
 43 | 			evectoperator A, void *Adata,
 44 | 			evectoperator B, void *Bdata,
 45 | 			evectpreconditioner K, void *Kdata,
 46 | 			evectconstraint constraint, void *constraint_data,
 47 | 			evectmatrix Work[], int nWork,
 48 | 			real tolerance, int *num_iterations,
 49 | 			int flags);
 50 | 
 51 | extern void eigensolver_lagrange(evectmatrix Y, real *eigenvals,
 52 | 			evectoperator A, void *Adata,
 53 | 			evectoperator B, void *Bdata,
 54 | 			evectpreconditioner K, void *Kdata,
 55 | 			evectconstraint constraint, void *constraint_data,
 56 | 			evectoperator L, void *Ldata, real *lag,
 57 | 			evectmatrix Work[], int nWork,
 58 | 			real tolerance, int *num_iterations,
 59 | 			int flags);
 60 | 
 61 | extern void eigensolver_davidson(evectmatrix Y, real *eigenvals,
 62 | 				 evectoperator A, void *Adata,
 63 | 				 evectpreconditioner K, void *Kdata,
 64 | 				 evectconstraint constraint,
 65 | 				 void *constraint_data,
 66 | 				 evectmatrix Work[], int nWork,
 67 | 				 real tolerance, int *num_iterations,
 68 | 				 int flags,
 69 | 				 real target);
 70 | 
 71 | extern void eigensolver_get_eigenvals(evectmatrix Y, real *eigenvals,
 72 | 				      evectoperator A, void *Adata,
 73 | 				      evectmatrix Work1, evectmatrix Work2);
 74 | 
 75 | /* eigensolver option flags, designed to be combined with a bitwise or ('|');
 76 |    each flag should set exactly one bit. */
 77 | #define EIGS_VERBOSE (1<<0)
 78 | #define EIGS_PROJECT_PRECONDITIONING (1<<1)
 79 | #define EIGS_RESET_CG (1<<2)
 80 | #define EIGS_FORCE_EXACT_LINMIN (1<<3)
 81 | #define EIGS_FORCE_APPROX_LINMIN (1<<4)
 82 | #define EIGS_ORTHONORMALIZE_FIRST_STEP (1<<5)
 83 | #define EIGS_REORTHOGONALIZE (1<<6)
 84 | #define EIGS_DYNAMIC_RESET_CG (1<<7)
 85 | #define EIGS_ORTHOGONAL_PRECONDITIONER (1<<8)
 86 | 
 87 | /* default flags: what we think works best most of the time: */
 88 | #define EIGS_DEFAULT_FLAGS (EIGS_RESET_CG | EIGS_REORTHOGONALIZE)
 89 | 
 90 | typedef struct evectconstraint_chain_struct {
 91 |      evectconstraint C;
 92 |      void *constraint_data;
 93 |      struct evectconstraint_chain_struct *next;
 94 | } evectconstraint_chain;
 95 | 
 96 | extern evectconstraint_chain *evect_add_constraint(evectconstraint_chain 
 97 | 						   *constraints,
 98 | 						   evectconstraint C,
 99 | 						   void *constraint_data);
100 | extern void evect_destroy_constraints(evectconstraint_chain *constraints);
101 | extern void evectconstraint_chain_func(evectmatrix X, void *data);
102 | 
103 | #ifdef __cplusplus
104 | }  /* extern "C" */
105 | #endif /* __cplusplus */
106 | 
107 | #ifdef MPB_REAL
108 | #  undef real
109 | #endif
110 | 
111 | #endif /* EIGENSOLVER_H */
112 | 


--------------------------------------------------------------------------------
/src/matrices/eigensolver_utils.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | #include <stdlib.h>
 19 | #include <stdio.h>
 20 | #include <math.h>
 21 | 
 22 | #include "config.h"
 23 | #include <mpiglue.h>
 24 | #include <check.h>
 25 | #include <scalar.h>
 26 | #include <matrices.h>
 27 | 
 28 | #include "eigensolver.h"
 29 | 
 30 | /**************************************************************************/
 31 | 
 32 | void eigensolver_get_eigenvals_aux(evectmatrix Y, real *eigenvals,
 33 | 				   evectoperator A, void *Adata,
 34 | 				   evectmatrix Work1, evectmatrix Work2,
 35 | 				   sqmatrix U, sqmatrix Usqrt,
 36 | 				   sqmatrix Uwork)
 37 | {
 38 |      sqmatrix_sqrt(Usqrt, U, Uwork); /* Usqrt = 1/sqrt(Yt*Y) */
 39 |      evectmatrix_XeYS(Work1, Y, Usqrt, 1);  /* Work1 = orthonormalize(Y) */
 40 | 
 41 |      A(Work1, Work2, Adata, 1, Y); /* Work2 = A Work1; Y is scratch */
 42 |      evectmatrix_XtY(U, Work1, Work2, Uwork);  /* U = Work1 * A * Work1 */
 43 | 
 44 |      sqmatrix_eigensolve(U, eigenvals, Uwork);
 45 |      evectmatrix_XeYS(Y, Work1, U, 1);
 46 | }
 47 | 
 48 | void eigensolver_get_eigenvals(evectmatrix Y, real *eigenvals,
 49 | 			       evectoperator A, void *Adata,
 50 | 			       evectmatrix Work1, evectmatrix Work2)
 51 | {
 52 |      sqmatrix U, Usqrt, Uwork;
 53 |  
 54 |      U = create_sqmatrix(Y.p);
 55 |      Usqrt = create_sqmatrix(Y.p);
 56 |      Uwork = create_sqmatrix(Y.p);
 57 | 
 58 |      evectmatrix_XtX(U, Y, Uwork);
 59 |      sqmatrix_invert(U, 1, Uwork);
 60 | 
 61 |      eigensolver_get_eigenvals_aux(Y, eigenvals, A, Adata, Work1, Work2,
 62 | 				   U, Usqrt, Uwork);
 63 | 
 64 |      destroy_sqmatrix(U);
 65 |      destroy_sqmatrix(Usqrt);
 66 |      destroy_sqmatrix(Uwork);
 67 | }
 68 | 
 69 | /**************************************************************************/
 70 | 
 71 | /* Subroutines for chaining constraints, to make it easy to pass
 72 |    multiple constraint functions to the eigensolver: */
 73 | 
 74 | evectconstraint_chain *evect_add_constraint(evectconstraint_chain *constraints,
 75 | 					    evectconstraint C,
 76 | 					    void *constraint_data)
 77 | {
 78 |      evectconstraint_chain *new_constraints;
 79 | 
 80 |      CHK_MALLOC(new_constraints, evectconstraint_chain, 1);
 81 | 
 82 |      new_constraints->C = C;
 83 |      new_constraints->constraint_data = constraint_data;
 84 |      new_constraints->next = constraints;
 85 |      return new_constraints;
 86 | }
 87 | 
 88 | void evect_destroy_constraints(evectconstraint_chain *constraints)
 89 | {
 90 |      while (constraints) {
 91 | 	  evectconstraint_chain *cur_constraint = constraints;
 92 | 	  constraints = constraints->next;
 93 | 	  free(cur_constraint);
 94 |      }
 95 | }
 96 | 
 97 | void evectconstraint_chain_func(evectmatrix X, void *data)
 98 | {
 99 |      evectconstraint_chain *constraints = (evectconstraint_chain *) data;
100 | 
101 |      while (constraints) {
102 | 	  if (constraints->C)
103 | 	       constraints->C(X, constraints->constraint_data);
104 |           constraints = constraints->next;
105 |      }
106 | }
107 | 
108 | 	       
109 | 


--------------------------------------------------------------------------------
/src/matrices/linmin.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | /* Nice C wrappers around minpack2-linmin.c functions. */
 19 | 
 20 | #include <stdlib.h>
 21 | #include <stdio.h>
 22 | 
 23 | #include "config.h"
 24 | #include <mpi_utils.h>
 25 | #include <check.h>
 26 | 
 27 | #include "linmin.h"
 28 | #include "verbosity.h"
 29 | 
 30 | #define double linmin_real
 31 | 
 32 | extern int dcsrch(double *stp, double *f, double *g,
 33 | 		   double *ftol, double *gtol, double *xtol,
 34 | 		   char *task,
 35 | 		   double *stpmin, double *stpmax, int *isave,
 36 | 		   double *dsave);
 37 | 
 38 | /* Our line minimization algorithm is designed only for f(x) for x >= 0.
 39 |    If the minimum lies for negative x, we use reverse_func below to
 40 |    transform f(x) into f(-x). */
 41 | typedef struct {
 42 |      linmin_func f;
 43 |      void *f_data;
 44 | } linmin_func_data;
 45 | double reverse_func(double x, double *deriv, void *data)
 46 | {
 47 |      linmin_func_data *d = (linmin_func_data *) data;
 48 |      double val;
 49 |      val = d->f(-x, deriv, d->f_data);
 50 |      *deriv = -*deriv;
 51 |      return val;
 52 | }
 53 | 
 54 | double linmin(double *converged_f, double *converged_df,
 55 | 	      double x_guess, double f_0, double df_0,
 56 | 	      double f_tol, double df_tol, double x_tol,
 57 | 	      double x_min, double x_max,
 58 | 	      linmin_func f, void *f_data, int verbose)
 59 | {
 60 |      if (df_0 > 0) {  /* minimum lies for negative x; transform to f(-x) */
 61 | 	  linmin_func_data d;
 62 | 	  double x;
 63 | 	  d.f = f;
 64 | 	  d.f_data = f_data;
 65 | 	  x = linmin(converged_f, converged_df,
 66 | 		     -x_guess, f_0, -df_0, f_tol, df_tol, x_tol,
 67 | 		     -x_min, -x_max, reverse_func, &d, verbose);
 68 | 	  *converged_df = -*converged_df;
 69 | 	  return(-x);
 70 |      }
 71 |      else if (df_0 == 0) { /* already at minimum! */
 72 | 	  *converged_f = f_0;
 73 |           *converged_df = df_0;
 74 |           return 0;
 75 |      }
 76 |      else {
 77 | 	  char task[300] = "START";
 78 | 	  int isave[2];
 79 | 	  double dsave[13], x, f_x, df_x;
 80 | 	  int iters = 0;
 81 | 
 82 | 	  x = x_guess;
 83 | 	  f_x = f_0; df_x = df_0; /* initially, pass in f and df at x=0 */
 84 | 	  dcsrch(&x, &f_x, &df_x, &f_tol, &df_tol, &x_tol,
 85 | 		 task, &x_min, &x_max, isave, dsave);
 86 | 
 87 | 	  while (*task == 'F') {
 88 | 	       f_x = f(x, &df_x, f_data);
 89 | 	       mpi_assert_equal(x);
 90 | 	       mpi_assert_equal(f_x);
 91 | 	       ++iters;
 92 | 	       dcsrch(&x, &f_x, &df_x, &f_tol, &df_tol, &x_tol,
 93 | 		      task, &x_min, &x_max, isave, dsave);
 94 | 	  }
 95 | 
 96 | 	  if (*task != 'C') {  /* not converged; warning or error */
 97 | 	       if (*task == 'E'  && mpb_verbosity >= 2)
 98 | 		    mpi_one_fprintf(stderr, "linmin: %s\n", task);
 99 | 	       CHECK(*task != 'E', "linmin failure");
100 | 	  }
101 | 
102 | 	  if (mpb_verbosity >= 2)
103 | 	       mpi_one_printf("    linmin: converged after %d iterations.\n", iters);
104 | 
105 | 	  *converged_f = f_x;
106 | 	  *converged_df = df_x;
107 | 	  return x;
108 |      }
109 | }
110 | 


--------------------------------------------------------------------------------
/src/matrices/linmin.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #ifndef LINMIN_H
19 | #define LINMIN_H
20 | 
21 | #if defined(SCALAR_LONG_DOUBLE_PREC)
22 | typedef long double linmin_real;
23 | #else
24 | typedef double linmin_real;
25 | #endif
26 | 
27 | typedef linmin_real (*linmin_func) (linmin_real x, linmin_real *deriv, void *data);
28 | 
29 | extern linmin_real linmin(linmin_real *converged_f, linmin_real *converged_df,
30 | 		     linmin_real x_guess, linmin_real f_0, linmin_real df_0,
31 | 		     linmin_real f_tol, linmin_real df_tol, linmin_real x_tol,
32 | 		     linmin_real x_min, linmin_real x_max,
33 | 		     linmin_func f, void *f_data, int verbose);
34 | 
35 | #endif /* LINMIN_H */
36 | 


--------------------------------------------------------------------------------
/src/matrices/matrices.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | #include <stdlib.h>
 19 | #include <stdio.h>
 20 | 
 21 | #include "config.h"
 22 | #include <check.h>
 23 | 
 24 | #include "matrices.h"
 25 | 
 26 | /* Basic operations: allocation, deallocation, etcetera. */
 27 | 
 28 | evectmatrix create_evectmatrix(int N, int c, int p,
 29 | 			       int localN, int Nstart, int allocN)
 30 | {
 31 |      evectmatrix X;
 32 |  
 33 |      CHECK(localN <= N && allocN >= localN && Nstart < N,
 34 | 	   "invalid N arguments");
 35 |     
 36 |      X.N = N;
 37 |      X.localN = localN;
 38 |      X.Nstart = Nstart;
 39 |      X.allocN = allocN;
 40 |      X.c = c;
 41 |      
 42 |      X.n = localN * c;
 43 |      X.alloc_p = X.p = p;
 44 |      
 45 |      if (allocN > 0) {
 46 | 	  CHK_MALLOC(X.data, scalar, allocN * c * p);
 47 |      }
 48 |      else
 49 | 	  X.data = NULL;
 50 | 
 51 |      return X;
 52 | }
 53 | 
 54 | void destroy_evectmatrix(evectmatrix X)
 55 | {
 56 |      free(X.data);
 57 | }
 58 | 
 59 | sqmatrix create_sqmatrix(int p)
 60 | {
 61 |      sqmatrix X;
 62 | 
 63 |      X.alloc_p = X.p = p;
 64 |      if (p > 0) {
 65 | 	  CHK_MALLOC(X.data, scalar, p * p);
 66 |      }
 67 |      else
 68 | 	  X.data = (scalar*) NULL;
 69 |      return X;
 70 | }
 71 | 
 72 | void destroy_sqmatrix(sqmatrix X)
 73 | {
 74 |      free(X.data);
 75 | }
 76 | 
 77 | /***********************************************************************/
 78 | 
 79 | /* a few general matrix operations for diagonal matrices; these
 80 |    will be used both by evectmatrix and sqmatrix routines: */
 81 | 
 82 | /* compute diag = diagonal elements of Xt * Y, where X and Y are n x p. */
 83 | void matrix_XtY_diag(scalar *X, scalar *Y, int n, int p, scalar *diag)
 84 | {
 85 |      int i, j;
 86 | 
 87 |      for (j = 0; j < p; ++j) {
 88 | 	  ASSIGN_ZERO(diag[j]);
 89 |      }
 90 |      
 91 |      for (i = 0; i < n; ++i)
 92 | 	  for (j = 0; j < p; ++j) {
 93 | 	       ACCUMULATE_SUM_CONJ_MULT(diag[j], X[i*p+j], Y[i*p+j]);
 94 | 	  }
 95 | }
 96 | 
 97 | /* compute diag = diagonal elements of Re[Xt * Y], where X and Y are n x p. */
 98 | void matrix_XtY_diag_real(scalar *X, scalar *Y, int n, int p, real *diag)
 99 | {
100 |      int i, j;
101 | 
102 |      for (j = 0; j < p; ++j) {
103 | 	  diag[j] = 0;
104 |      }
105 |      
106 |      for (i = 0; i < n; ++i)
107 | 	  for (j = 0; j < p; ++j) {
108 | 	       diag[j] += (SCALAR_RE(X[i*p+j]) * SCALAR_RE(Y[i*p+j]) + 
109 | 			   SCALAR_IM(X[i*p+j]) * SCALAR_IM(Y[i*p+j]));
110 | 	  }
111 | }
112 | 
113 | /* compute diag = diagonal elements of Xt * X, where X is n x p. */
114 | void matrix_XtX_diag_real(scalar *X, int n, int p, real *diag)
115 | {
116 |      int i, j;
117 | 
118 |      for (j = 0; j < p; ++j) {
119 | 	  diag[j] = 0;
120 |      }
121 |      
122 |      for (i = 0; i < n; ++i)
123 | 	  for (j = 0; j < p; ++j) {
124 | 	       ACCUMULATE_SUM_SQ(diag[j], X[i*p+j]);
125 | 	  }
126 | }
127 | 
128 | /* compute X += a * Y * diag(diag), where X and Y are n x p */
129 | void matrix_XpaY_diag(scalar *X, real a, scalar *Y, 
130 | 		      scalar *diag, int n, int p)
131 | {
132 |      int i, j;
133 | 
134 |      for (i = 0; i < n; ++i) {
135 | 	  for (j = 0; j < p; ++j) {
136 | 	       scalar c;
137 | 	       ASSIGN_MULT(c, Y[i*p+j], diag[j]);
138 | 	       ASSIGN_SCALAR(X[i*p+j],
139 | 			     SCALAR_RE(X[i*p+j]) + a * SCALAR_RE(c),
140 | 			     SCALAR_IM(X[i*p+j]) + a * SCALAR_IM(c));
141 | 	  }
142 |      }
143 | }
144 | 
145 | /* compute X += a * Y * diag(diag), where X and Y are n x p and diag is real */
146 | void matrix_XpaY_diag_real(scalar *X, real a, scalar *Y, 
147 | 			   real *diag, int n, int p)
148 | {
149 |      int i, j;
150 | 
151 |      for (i = 0; i < n; ++i) {
152 | 	  for (j = 0; j < p; ++j) {
153 | 	       real d = a * diag[j];
154 | 	       ASSIGN_SCALAR(X[i*p+j],
155 | 			     SCALAR_RE(X[i*p+j]) + d * SCALAR_RE(Y[i*p+j]),
156 | 			     SCALAR_IM(X[i*p+j]) + d * SCALAR_IM(Y[i*p+j]));
157 | 	  }
158 |      }
159 | }
160 | 
161 | /* compute X = X * diag1 + Y * diag2, where X and Y are n x p and 
162 |    diag1 and diag2 are real diagonal matrices */
163 | void matrix_X_diag_real_pY_diag_real(scalar *X, real *diag1,
164 | 				     scalar *Y, real *diag2, int n, int p)
165 | {
166 |           int i, j;
167 | 
168 | 	  for (i = 0; i < n; ++i) {
169 | 	       for (j = 0; j < p; ++j) {
170 | 		    real d1 = diag1[j], d2 = diag2[j];
171 | 		    ASSIGN_SCALAR(X[i*p+j],
172 | 				  d1 * SCALAR_RE(X[i*p+j]) + 
173 | 				  d2 * SCALAR_RE(Y[i*p+j]),
174 | 				  d1 * SCALAR_IM(X[i*p+j]) +
175 | 				  d2 * SCALAR_IM(Y[i*p+j]));
176 | 	       }
177 | 	  }
178 | }
179 | 
180 | /* compute Re [ trace A * diag(diag) ], where A is p by p. */
181 | real matrix_re_trace_A_diag_real(scalar *A, real *diag, int p)
182 | {
183 |      real trace = 0.0;
184 |      int i;
185 |      for (i = 0; i < p; ++i)
186 | 	  trace += SCALAR_RE(A[i*(p+1)]) * diag[i];
187 |      return trace;
188 | }
189 | 
190 | scalar matrix_diag_trace(scalar *diag, int p)
191 | {
192 |      scalar trace = SCALAR_INIT_ZERO;
193 |      int i;
194 |      for (i = 0; i < p; ++i) {
195 | 	  ACCUMULATE_SUM(trace, diag[i]);
196 |      }
197 |      return trace;
198 | }
199 | 
200 | real matrix_diag_real_trace(real *diag, int p)
201 | {
202 |      real trace = 0.0;
203 |      int i;
204 |      for (i = 0; i < p; ++i)
205 | 	  trace += diag[i];
206 |      return trace;
207 | }
208 | 


--------------------------------------------------------------------------------
/src/matrices/matrices.h:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | #ifndef MATRICES_H
 19 | #define MATRICES_H
 20 | 
 21 | #include "scalar.h"
 22 | 
 23 | #ifdef __cplusplus
 24 | extern "C" {
 25 | #endif /* __cplusplus */
 26 | 
 27 | typedef struct {
 28 |      int N, localN, Nstart, allocN;
 29 |      int c;
 30 |      int n, p, alloc_p;
 31 |      scalar *data;
 32 | } evectmatrix;
 33 | 
 34 | typedef struct {
 35 |      int p, alloc_p;
 36 |      scalar *data;
 37 | } sqmatrix;
 38 | 
 39 | /* try to keep track of flops, at least from evectmatrix multiplications */
 40 | extern double evectmatrix_flops;
 41 | 
 42 | /* general creation/destruction operations: */
 43 | 
 44 | extern evectmatrix create_evectmatrix(int N, int c, int p,
 45 | 				      int localN, int Nstart, int allocN);
 46 | extern void destroy_evectmatrix(evectmatrix X);
 47 | extern sqmatrix create_sqmatrix(int p);
 48 | extern void destroy_sqmatrix(sqmatrix X);
 49 | 
 50 | /* diagonal matrix utils: */
 51 | 
 52 | extern void matrix_XtY_diag(scalar *X, scalar *Y, int n, int p, scalar *diag);
 53 | extern void matrix_XtY_diag_real(scalar *X, scalar *Y, int n, int p, 
 54 | 				 real *diag);
 55 | extern void matrix_XtX_diag_real(scalar *X, int n, int p, real *diag);
 56 | extern void matrix_XpaY_diag(scalar *X, real a, scalar *Y,
 57 | 			     scalar *diag, int n, int p);
 58 | extern void matrix_XpaY_diag_real(scalar *X, real a, scalar *Y,
 59 | 				  real *diag, int n, int p);
 60 | extern void matrix_X_diag_real_pY_diag_real(scalar *X, real *diag1,
 61 | 					    scalar *Y, real *diag2,
 62 | 					    int n, int p);
 63 | extern real matrix_re_trace_A_diag_real(scalar *A, real *diag, int p);
 64 | extern scalar matrix_diag_trace(scalar *diag, int p);
 65 | extern real matrix_diag_real_trace(real *diag, int p);
 66 | 
 67 | /* evectmatrix operations, defined in evectmatrix.c: */
 68 | 
 69 | extern void evectmatrix_resize(evectmatrix *A, int p, short preserve_data);
 70 | extern void evectmatrix_copy(evectmatrix X, evectmatrix Y);
 71 | extern void evectmatrix_copy_slice(evectmatrix X, evectmatrix Y,
 72 | 				   int ix, int iy, int p);
 73 | extern void evectmatrix_aXpbY(real a, evectmatrix X, real b, evectmatrix Y);
 74 | extern void evectmatrix_aXpbYS_sub(real a, evectmatrix X, 
 75 | 				   real b, evectmatrix Y,
 76 | 				   sqmatrix S, int Soffset, short sdagger);
 77 | extern void evectmatrix_XeYS(evectmatrix X, evectmatrix Y,
 78 | 			     sqmatrix S, short sherm);
 79 | extern void evectmatrix_XpaYS(evectmatrix X, real a, evectmatrix Y,
 80 | 			      sqmatrix S, short sdagger);
 81 | extern void evectmatrix_XtX(sqmatrix U, evectmatrix X, sqmatrix S);
 82 | extern void evectmatrix_XtY(sqmatrix U, evectmatrix X, evectmatrix Y,
 83 | 			    sqmatrix S);
 84 | extern void evectmatrix_XtY_slice(sqmatrix U, evectmatrix X, evectmatrix Y,
 85 | 				  int ix, int iy, int p, sqmatrix S);
 86 | extern void evectmatrix_XtY_slice2(sqmatrix U, evectmatrix X, evectmatrix Y,
 87 |                                    int ix, int iy, int p, int q, int iu,
 88 |                                    sqmatrix S1, sqmatrix S2);
 89 | extern void evectmatrixXtY_sub(sqmatrix U, int Uoffset,
 90 | 			       evectmatrix X, evectmatrix Y, sqmatrix S);
 91 | extern void evectmatrix_XtY_diag(evectmatrix X, evectmatrix Y, scalar *diag,
 92 | 				 scalar *scratch_diag);
 93 | extern void evectmatrix_XtY_diag_real(evectmatrix X, evectmatrix Y,
 94 | 				      real *diag, real *scratch_diag);
 95 | extern void evectmatrix_XtX_diag_real(evectmatrix X, real *diag,
 96 | 				      real *scratch_diag);
 97 | extern scalar evectmatrix_traceXtY(evectmatrix X, evectmatrix Y);
 98 | 
 99 | /* sqmatrix operations, defined in sqmatrix.c: */
100 | 
101 | extern void sqmatrix_assert_hermitian(sqmatrix A);
102 | extern void sqmatrix_copy(sqmatrix A, sqmatrix B);
103 | extern void sqmatrix_resize(sqmatrix *A, int p, short preserve_data);
104 | extern void sqmatrix_copy_upper2full(sqmatrix F, sqmatrix U);
105 | extern void sqmatrix_symmetrize(sqmatrix Asym, sqmatrix A);
106 | extern scalar sqmatrix_trace(sqmatrix U);
107 | extern scalar sqmatrix_traceAtB(sqmatrix A, sqmatrix B);
108 | extern void sqmatrix_AeBC(sqmatrix A, sqmatrix B, short bdagger,
109 | 			  sqmatrix C, short cdagger);
110 | extern void sqmatrix_ApaBC(sqmatrix A, real a, sqmatrix B, short bdagger,
111 | 			   sqmatrix C, short cdagger);
112 | extern void sqmatrix_ApaB(sqmatrix A, real a, sqmatrix B);
113 | extern void sqmatrix_aApbB(real a, sqmatrix A, real b, sqmatrix B);
114 | extern int sqmatrix_invert(sqmatrix U, short positive_definite,
115 | 			    sqmatrix Work);
116 | extern void sqmatrix_eigensolve(sqmatrix U, real *eigenvals, sqmatrix W);
117 | extern void sqmatrix_gen_eigensolve(sqmatrix U, sqmatrix B, real *eigenvals, sqmatrix W);
118 | extern void sqmatrix_eigenvalues(sqmatrix A, scalar_complex *eigenvals);
119 | extern void sqmatrix_sqrt(sqmatrix Usqrt, sqmatrix U, sqmatrix W);
120 | 
121 | #ifdef __cplusplus
122 | }  /* extern "C" */
123 | #endif /* __cplusplus */
124 | 
125 | #endif /* MATRICES_H */
126 | 


--------------------------------------------------------------------------------
/src/matrixio/Makefile.am:
--------------------------------------------------------------------------------
1 | noinst_LIBRARIES = libmatrixio.a
2 | 
3 | libmatrixio_a_SOURCES = evectmatrixio.c fieldio.c matrixio.c matrixio.h
4 | libmatrixio_a_CPPFLAGS = -I$(srcdir)/../util -I$(srcdir)/../matrices
5 | 


--------------------------------------------------------------------------------
/src/matrixio/evectmatrixio.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #include <stdlib.h>
19 | #include <stdio.h>
20 | #include <string.h>
21 | 
22 | #include "config.h"
23 | 
24 | #include <check.h>
25 | #include <matrices.h>
26 | 
27 | #include "matrixio.h"
28 | 
29 | void evectmatrixio_writeall_raw(const char *filename, evectmatrix a)
30 | {
31 |      int dims[4], start[4] = {0, 0, 0, 0};
32 |      const int rank = 4;
33 |      matrixio_id file_id, data_id;
34 |      
35 |      dims[0] = a.N;
36 |      dims[1] = a.c;
37 |      dims[2] = a.p;
38 |      dims[3] = SCALAR_NUMVALS;
39 | 
40 |      start[0] = a.Nstart;
41 | 
42 |      file_id = matrixio_create(filename);     
43 |      data_id = matrixio_create_dataset(file_id, "rawdata", NULL, rank, dims);
44 |      
45 |      dims[0] = a.localN;
46 |      matrixio_write_real_data(data_id, dims, start, 1, (real *) a.data);
47 | 
48 |      matrixio_close_dataset(data_id);
49 |      matrixio_close(file_id);
50 | }
51 | 
52 | void evectmatrixio_readall_raw(const char *filename, evectmatrix a)
53 | {
54 |      int rank = 4, dims[4];
55 |      matrixio_id file_id;
56 | 
57 |      dims[0] = a.N;
58 |      dims[1] = a.c;
59 |      dims[2] = a.p;
60 |      dims[3] = SCALAR_NUMVALS;
61 | 
62 |      file_id = matrixio_open(filename, 1);
63 |      
64 |      CHECK(matrixio_read_real_data(file_id, "rawdata", &rank, dims, 
65 | 				   a.localN, a.Nstart, 1, (real *) a.data),
66 | 	   "error reading data set in file");
67 | 
68 |      matrixio_close(file_id);
69 | }
70 | 


--------------------------------------------------------------------------------
/src/matrixio/fieldio.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | #include <stdlib.h>
 19 | #include <stdio.h>
 20 | #include <string.h>
 21 | #include <math.h>
 22 | 
 23 | #include "config.h"
 24 | 
 25 | #include <check.h>
 26 | #include <matrices.h>
 27 | 
 28 | #include "matrixio.h"
 29 | 
 30 | #define TWOPI 6.2831853071795864769252867665590057683943388
 31 | #define MAX2(a,b) ((a) > (b) ? (a) : (b))
 32 | 
 33 | /* note that kvector here is given in the reciprocal basis 
 34 |    ...data_id should be of length at 2*num_components */
 35 | void fieldio_write_complex_field(scalar_complex *field,
 36 | 				 int rank,
 37 | 				 const int dims[3],
 38 | 				 const int local_dims[3],
 39 | 				 const int start[3],
 40 | 				 int which_component, int num_components,
 41 | 				 const real *kvector,
 42 | 				 matrixio_id file_id,
 43 | 				 int append,
 44 | 				 matrixio_id data_id[])
 45 | {
 46 |      int i, j, k, component, ri_part;
 47 | 
 48 |      rank = dims[2] == 1 ? (dims[1] == 1 ? 1 : 2) : 3;
 49 | 
 50 |      if (kvector) {
 51 | 	  real s[3]; /* the step size between grid points dotted with k */
 52 | 	  scalar_complex *phasex, *phasey, *phasez;
 53 | 
 54 | 	  for (i = 0; i < 3; ++i)
 55 | 	       s[i] = TWOPI * kvector[i] / dims[i];
 56 | 	  
 57 | 	  /* cache exp(ikx) along each of the directions, for speed */
 58 | 	  CHK_MALLOC(phasex, scalar_complex, local_dims[0]);
 59 | 	  CHK_MALLOC(phasey, scalar_complex, local_dims[1]);
 60 | 	  CHK_MALLOC(phasez, scalar_complex, local_dims[2]);
 61 | 	  for (i = 0; i < local_dims[0]; ++i) {
 62 | 	       real phase = s[0] * (i + start[0]);
 63 | 	       phasex[i].re = cos(phase);
 64 | 	       phasex[i].im = sin(phase);
 65 | 	  }
 66 | 	  for (j = 0; j < local_dims[1]; ++j) {
 67 | 	       real phase = s[1] * (j + start[1]);
 68 | 	       phasey[j].re = cos(phase);
 69 | 	       phasey[j].im = sin(phase);
 70 | 	  }
 71 | 	  for (k = 0; k < local_dims[2]; ++k) {
 72 | 	       real phase = s[2] * (k + start[2]);
 73 | 	       phasez[k].re = cos(phase);
 74 | 	       phasez[k].im = sin(phase);
 75 | 	  }
 76 | 
 77 | 	  /* Now, multiply field by exp(i k*r): */
 78 | 	  for (i = 0; i < local_dims[0]; ++i) {
 79 | 	       scalar_complex px = phasex[i];
 80 | 	       
 81 | 	       for (j = 0; j < local_dims[1]; ++j) {
 82 | 		    scalar_complex py;
 83 | 		    real re = phasey[j].re, im = phasey[j].im;
 84 | 		    py.re = px.re * re - px.im * im;
 85 | 		    py.im = px.re * im + px.im * re;
 86 | 		    
 87 | 		    for (k = 0; k < local_dims[2]; ++k) {
 88 | 			 int ijk = ((i*local_dims[1] + j)*local_dims[2] + k)*3;
 89 | 			 real p_re, p_im;
 90 | 			 real re = phasez[k].re, im = phasez[k].im;
 91 | 			 
 92 | 			 p_re = py.re * re - py.im * im;
 93 | 			 p_im = py.re * im + py.im * re;
 94 | 			 
 95 | 			 for (component = 0; component < 3; ++component) {
 96 | 			      int ijkc = ijk + component;
 97 | 			      re = field[ijkc].re; im = field[ijkc].im;
 98 | 			      field[ijkc].re = re * p_re - im * p_im;
 99 | 			      field[ijkc].im = im * p_re + re * p_im;
100 | 			 }
101 | 		    }
102 | 	       }
103 | 	  }
104 | 	  
105 | 	  free(phasez);
106 | 	  free(phasey);
107 | 	  free(phasex);
108 |      }
109 | 
110 |      /* write hyperslabs for each field component: */
111 |      for (component = 0; component < num_components; ++component)
112 | 	  if (component == which_component ||
113 | 	      which_component < 0)
114 | 	       for (ri_part = 0; ri_part < 2; ++ri_part) {
115 | 		    char name[] = "x.i";
116 | 		    name[0] = (num_components == 1 ? 'c' : 'x') + component;
117 | 		    name[2] = ri_part ? 'i' : 'r';
118 | 
119 | 		    if (!append)
120 | 			 data_id[component*2 + ri_part] =
121 | 			      matrixio_create_dataset(file_id, name, NULL,
122 | 						      rank, dims);
123 | 		    
124 | 		    matrixio_write_real_data(
125 | 			 data_id[component*2 + ri_part], local_dims, start, 
126 | 			 2 * num_components,
127 | 			 ri_part ? &field[component].im
128 | 			 : &field[component].re);
129 | 	       }
130 | }
131 | 
132 | void fieldio_write_real_vals(real *vals,
133 | 			     int rank,
134 | 			     const int dims[3],
135 | 			     const int local_dims[3],
136 | 			     const int start[3],
137 | 			     matrixio_id file_id,
138 | 			     int append,
139 | 			     const char *dataname,
140 | 			     matrixio_id *data_id)
141 | {
142 |      rank = dims[2] == 1 ? (dims[1] == 1 ? 1 : 2) : 3;
143 | 
144 |      if (!append || data_id->id < 0)
145 | 	  *data_id = matrixio_create_dataset(file_id, dataname, 
146 | 					     NULL, rank,dims);
147 |      
148 |      matrixio_write_real_data(*data_id,local_dims,start,1,vals);
149 | }
150 | 


--------------------------------------------------------------------------------
/src/matrixio/matrixio.h:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | #ifndef MATRIXIO_H
 19 | #define MATRIXIO_H
 20 | 
 21 | #include <matrices.h>
 22 | 
 23 | #if defined(HAVE_HDF5)
 24 | /* don't use new HDF5 1.8 API (which isn't even fully documented yet, grrr) */
 25 | #  define H5_USE_16_API 1
 26 | #  include <hdf5.h>
 27 | typedef hid_t matrixio_id_;
 28 | /* HDF5 changed this datatype in their interfaces starting in version 1.6.4 */
 29 | #  if H5_VERS_MAJOR > 1 \
 30 |      || (H5_VERS_MAJOR == 1 && H5_VERS_MINOR > 6) \
 31 |      || (H5_VERS_MAJOR == 1 && H5_VERS_MINOR == 6 && H5_VERS_RELEASE > 3)
 32 | typedef hsize_t start_t;
 33 | #  else
 34 | typedef hssize_t start_t;
 35 | #  endif
 36 | #else /* no HDF */
 37 | typedef int matrixio_id_; /* dummy */
 38 | #endif
 39 | 
 40 | typedef struct {
 41 |      matrixio_id_ id;
 42 |      int parallel;
 43 | } matrixio_id;
 44 | 
 45 | extern matrixio_id matrixio_create(const char *fname);
 46 | matrixio_id matrixio_create_serial(const char *fname);
 47 | extern matrixio_id matrixio_open(const char *fname, int read_only);
 48 | matrixio_id matrixio_open_serial(const char *fname, int read_only);
 49 | extern void matrixio_close(matrixio_id id);
 50 | 
 51 | extern matrixio_id matrixio_create_sub(matrixio_id id,
 52 |                                 const char *name, const char *description);
 53 | extern void matrixio_close_sub(matrixio_id id);
 54 | 
 55 | extern matrixio_id matrixio_open_dataset(matrixio_id id,
 56 | 					 const char *name,
 57 | 					 int rank, const int *dims);
 58 | extern matrixio_id matrixio_create_dataset(matrixio_id id,
 59 |                                     const char *name, const char *description,
 60 |                                     int rank, const int *dims);
 61 | extern void matrixio_close_dataset(matrixio_id data_id);
 62 | extern int matrixio_dataset_exists(matrixio_id id, const char *name);
 63 | extern void matrixio_dataset_delete(matrixio_id id, const char *name);
 64 | 
 65 | extern void matrixio_write_real_data(matrixio_id data_id,
 66 |                               const int *local_dims, const int *local_start,
 67 |                               int stride,
 68 |                               real *data);
 69 | extern real *matrixio_read_real_data(matrixio_id id,
 70 | 				     const char *name,
 71 | 				     int *rank, int *dims,
 72 | 				     int local_dim0, int local_dim0_start,
 73 | 				     int stride,
 74 | 				     real *data);
 75 | 
 76 | extern void matrixio_write_string_attr(matrixio_id id, const char *name,
 77 | 				       const char *val);
 78 | extern void matrixio_write_data_attr(matrixio_id id, const char *name,
 79 | 				     const real *val, int rank, 
 80 | 				     const int *dims);
 81 | extern char *matrixio_read_string_attr(matrixio_id id, const char *name);
 82 | extern real *matrixio_read_data_attr(matrixio_id id, const char *name,
 83 | 				     int *rank, int max_rank, int *dims);
 84 | 
 85 | extern void evectmatrixio_writeall_raw(const char *filename, evectmatrix a);
 86 | extern void evectmatrixio_readall_raw(const char *filename, evectmatrix a);
 87 | 
 88 | extern void fieldio_write_complex_field(scalar_complex *field,
 89 | 					int rank,
 90 | 					const int dims[3],
 91 | 					const int local_dims[3],
 92 | 					const int start[3],
 93 | 					int which_component,
 94 | 					int num_components,
 95 | 					const real kvector[3],
 96 | 					matrixio_id file_id,
 97 | 					int append,
 98 | 					matrixio_id data_id[]);
 99 | extern void fieldio_write_real_vals(real *vals,
100 | 				    int rank,
101 | 				    const int dims[3],
102 | 				    const int local_dims[3],
103 | 				    const int start[3],
104 | 				    matrixio_id file_id,
105 | 				    int append,
106 | 				    const char *dataname,
107 | 				    matrixio_id *data_id);
108 | 
109 | #endif /* MATRIXIO_H */
110 | 


--------------------------------------------------------------------------------
/src/maxwell/Makefile.am:
--------------------------------------------------------------------------------
1 | noinst_LTLIBRARIES = libmaxwell.la
2 | EXTRA_DIST = README
3 | 
4 | libmaxwell_la_SOURCES = imaxwell.h maxwell.c maxwell.h xyz_loop.h		\
5 | maxwell_constraints.c maxwell_eps.c maxwell_op.c maxwell_pre.c
6 | libmaxwell_la_CPPFLAGS = -I$(srcdir)/../util -I$(srcdir)/../matrices
7 | 


--------------------------------------------------------------------------------
/src/maxwell/README:
--------------------------------------------------------------------------------
 1 | This directory contains code for operating the Maxwell operator on
 2 | a vector field:
 3 | 
 4 | 	MaxwellOp(V) = curl(1/eps * curl(V))
 5 | 
 6 | We store V in a Fourier basis, so that the curl operation is diagonal.
 7 | To multiply by epsilon-inverse, we use a pair of FFTs to transform to
 8 | and from position space.
 9 | 
10 | Also included are initialization routines for the auxiliary data and
11 | storage required by MaxwellOp, as well as subsidiary routines to
12 | compute things like the curl and the energy density.
13 | 


--------------------------------------------------------------------------------
/src/maxwell/imaxwell.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | /* internal header for maxwell.h, depends on config.h */
19 | 
20 | #ifndef IMAXWELL_H
21 | #define IMAXWELL_H
22 | 
23 | #include "config.h"
24 | 
25 | #include "maxwell.h"
26 | 
27 | #if defined(HAVE_LIBFFTW3) || defined(HAVE_LIBFFTW3F) || defined(HAVE_LIBFFTW3L)
28 | #  include <fftw3.h>
29 | #  ifdef HAVE_MPI
30 | #    include <fftw3-mpi.h>
31 | #  endif
32 | #  define HAVE_FFTW3 1
33 | #elif defined(HAVE_LIBFFTW)
34 | #  include <fftw.h>
35 | #  include <rfftw.h>
36 | #  ifdef HAVE_MPI
37 | #    include <fftw_mpi.h>
38 | #    include <rfftw_mpi.h>
39 | #  endif
40 | #elif defined(HAVE_LIBDFFTW)
41 | #  include <dfftw.h>
42 | #  include <drfftw.h>
43 | #  ifdef HAVE_MPI
44 | #    include <dfftw_mpi.h>
45 | #    include <drfftw_mpi.h>
46 | #  endif
47 | #elif defined(HAVE_LIBSFFTW)
48 | #  include <sfftw.h>
49 | #  include <srfftw.h>
50 | #  ifdef HAVE_MPI
51 | #    include <sfftw_mpi.h>
52 | #    include <srfftw_mpi.h>
53 | #  endif
54 | #elif defined(HAVE_LIBXFFTW)
55 | #  include <xfftw.h>
56 | #  include <xrfftw.h>
57 | #  ifdef HAVE_MPI
58 | #    include <xfftw_mpi.h>
59 | #    include <xrfftw_mpi.h>
60 | #  endif
61 | #endif
62 | 
63 | #if defined(HAVE_LIBFFTW) || defined(HAVE_LIBDFFTW) || defined(HAVE_LIBSFFTW) || defined(HAVE_LIBXFFTW)
64 | #  define HAVE_FFTW 1
65 | #endif
66 | 
67 | #include "scalar.h"
68 | 
69 | #if defined(HAVE_FFTW3)
70 | #  if defined(SCALAR_SINGLE_PREC)
71 | #    define FFTW(x) fftwf_ ## x
72 | #  elif defined(SCALAR_LONG_DOUBLE_PREC)
73 | #    define FFTW(x) fftwl_ ## x
74 | #  else
75 | #    define FFTW(x) fftw_ ## x
76 | #  endif
77 |   typedef FFTW(plan) fftplan;
78 | #elif defined(HAVE_FFTW)
79 | #  ifdef HAVE_MPI
80 | #    ifdef SCALAR_COMPLEX
81 |      typedef fftwnd_mpi_plan fftplan;
82 | #    else
83 |      typedef rfftwnd_mpi_plan fftplan;
84 | #    endif
85 | #  else
86 | #    ifdef SCALAR_COMPLEX
87 |      typedef fftwnd_plan fftplan;
88 | #    else
89 |      typedef rfftwnd_plan fftplan;
90 | #    endif
91 | #  endif
92 | #endif
93 | 
94 | #endif /* IMAXWELL_H */
95 | 


--------------------------------------------------------------------------------
/src/maxwell/xyz_loop.h:
--------------------------------------------------------------------------------
 1 |      /* This is a semi-horrifying macro to perform we have different loops over
 2 |         the coordinates, depending upon whether we are using complex or real and serial or
 3 |         parallel transforms.  Each loop will define, in its body,
 4 |         variables (i1,i2,i3) describing the global coordinate of the current
 5 |         point, and xyz_index describing the corresponding index in
 6 | 	   the array md->eps_inv[] or similar.
 7 | 
 8 |      We use it like this:
 9 | 
10 |      LOOP_XYZ(md) { // {{ implied open braces (yuck!)
11 |           body...
12 |      }}}
13 | 
14 |      where md is the maxwell_data pointer.
15 |       */
16 | 
17 | #ifdef SCALAR_COMPLEX
18 | #  ifndef HAVE_MPI
19 |      #define LOOP_XYZ(md) { \
20 |           int n1 = md->nx, n2 = md->ny, n3 = md->nz, i1, i2, i3; \
21 |           for (i1 = 0; i1 < n1; ++i1) \
22 |      	  for (i2 = 0; i2 < n2; ++i2) \
23 |      	       for (i3 = 0; i3 < n3; ++i3) { \
24 |                       int xyz_index = ((i1 * n2 + i2) * n3 + i3);
25 | #  else /* HAVE_MPI */
26 |      /* first two dimensions are transposed in MPI output: */
27 |      #define LOOP_XYZ(md) { \
28 |           int n1 = md->nx, n2 = md->ny, n3 = md->nz, i1, i2_, i3; \
29 |           int local_n2 = md->local_ny, local_y_start = md->local_y_start; \
30 |           for (i2_ = 0; i2_ < local_n2; ++i2_) \
31 |                for (i1 = 0; i1 < n1; ++i1) \
32 |      	       for (i3 = 0; i3 < n3; ++i3) { \
33 |                       int i2 = i2_ + local_y_start; \
34 |                       int xyz_index = ((i2_ * n1 + i1) * n3 + i3);
35 | #  endif /* HAVE_MPI */
36 | #else /* not SCALAR_COMPLEX */
37 | #  ifndef HAVE_MPI
38 |      #define LOOP_XYZ(md) { \
39 |           int n1 = md->nx, n2 = md->ny, n3 = md->nz, i1_, i2_, i1, i2, i3; \
40 |           int n_other = md->other_dims; \
41 |           int n_last = md->last_dim_size / 2; \
42 |           int rank = (n3 == 1) ? (n2 == 1 ? 1 : 2) : 3; \
43 |           for (i1_ = 0; i1_ < n_other; ++i1_) \
44 |      	  for (i2_ = 0; i2_ < n_last; ++i2_) { \
45 |                  int xyz_index = i1_ * n_last + i2_; \
46 |           	 switch (rank) { \
47 |           	      case 2: i1 = i1_; i2 = i2_; i3 = 0; break; \
48 |           	      case 3: i1 = i1_ / n2; i2 = i1_ % n2; i3 = i2_; break; \
49 |           	      default: i1 = i2_; i2 = i3 = 0;  break; \
50 |                  }
51 | 
52 | #  else /* HAVE_MPI */
53 |      #define LOOP_XYZ(md) { \
54 |           int n1 = md->nx, n2 = md->ny, n3 = md->nz, i1, i2_, i3; \
55 |           int local_n2 = md->local_ny, local_y_start = md->local_y_start; \
56 |           int local_n3 = n3 > 1 ? md->last_dim_size / 2 : 1; \
57 |           for (i2_ = 0; i2_ < local_n2; ++i2_)               \
58 |                for (i1 = 0; i1 < n1; ++i1) \
59 |      	       for (i3 = 0; i3 < local_n3; ++i3) { \
60 |                   int i2 = i2_ + local_y_start; \
61 |                	  int xyz_index = ((i2_ * n1 + i1) * local_n3 + i3);
62 | #  endif  /* HAVE_MPI */
63 | 
64 | #endif /* not SCALAR_COMPLEX */
65 | 


--------------------------------------------------------------------------------
/src/mpbconf.h.in:
--------------------------------------------------------------------------------
 1 | #ifndef MPB_H
 2 | #define MPB_H 1
 3 | 
 4 | #undef SCALAR_COMPLEX
 5 | #undef SCALAR_LONG_DOUBLE_PREC
 6 | #undef SCALAR_SINGLE_PREC
 7 | #undef WITH_HERMITIAN_EPSILON
 8 | #undef MPB_VERSION_MAJOR
 9 | #undef MPB_VERSION_MINOR
10 | #undef MPB_VERSION_PATCH
11 | 
12 | #define MPB_REAL 1 /* avoid C++ conflict with MPB's "real" type */
13 | #include "mpb/eigensolver.h"
14 | #include "mpb/maxwell.h"
15 | #include "mpb/verbosity.h"
16 | 
17 | extern void (*mpb_printf_callback)(const char *s);
18 | #endif /* MPB_H */
19 | 


--------------------------------------------------------------------------------
/src/util/Makefile.am:
--------------------------------------------------------------------------------
 1 | noinst_LTLIBRARIES = libutil.la
 2 | 
 3 | libutil_la_SOURCES = check.h debug_malloc.c mpi_utils.c mpi_utils.h mpiglue.h \
 4 | 	sphere-quad.h verbosity.h verbosity.c
 5 | 
 6 | BUILT_SOURCES = sphere-quad.h
 7 | 
 8 | noinst_PROGRAMS = sphere_quad
 9 | sphere_quad_SOURCES = sphere-quad.c
10 | 
11 | if MAINTAINER_MODE
12 | 
13 | PRELUDE = "/* This file was automatically generated --- DO NOT EDIT */"
14 | SPHERE_QUAD = $(top_builddir)/src/util/sphere_quad
15 | sphere-quad.h: sphere_quad$(EXEEXT)
16 | 	(echo $(PRELUDE); echo; $(SPHERE_QUAD)) > $@
17 | 
18 | endif
19 | 


--------------------------------------------------------------------------------
/src/util/check.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #ifndef CHECK_H
19 | #define CHECK_H
20 | 
21 | #ifdef CHECK_DISABLE
22 | 
23 | #define CHECK(condition, message) /* do nothing */
24 | 
25 | #else /* not CHECK_DISABLE */
26 | 
27 | #include <mpi_utils.h>
28 | 
29 | #ifdef DEBUG
30 | extern void check_breakpoint(void);
31 | #define CHECK_BREAKPOINT check_breakpoint() /* defined in debug_malloc.c */
32 | #else
33 | #define CHECK_BREAKPOINT /* nothing */
34 | #endif
35 | 
36 | #define CHECK(condition, message) do { \
37 |      if (!(condition))  { \
38 |           CHECK_BREAKPOINT; \
39 |           mpi_die("CHECK failure on line %d of " __FILE__ ": " \
40 | 		  message "\n", __LINE__); \
41 |      } \
42 | } while (0)
43 | 
44 | #endif /* not CHECK_DISABLE */
45 | 
46 | #ifdef DEBUG_MALLOC
47 | extern void *debug_malloc(size_t n);
48 | extern void debug_free(void *p);
49 | #  define malloc debug_malloc
50 | #  define free debug_free
51 | #endif
52 | 
53 | /* Macro to check whether a floating-point number contains a ridiculous
54 |    value.  Note that x != x if and only if x is a NaN. */
55 | #define BADNUM(x) ((x) != (x) || (x) > 1e50 || (x) < -1e50)
56 | 
57 | extern void debug_output_malloc_count(void);
58 | extern void debug_check_memory_leaks(void);
59 | 
60 | #define CHK_MALLOC(p, t, n) {                                         \
61 |      size_t CHK_MALLOC_n_tmp = (n);                                   \
62 |      (p) = (t *) malloc(sizeof(t) * CHK_MALLOC_n_tmp);                \
63 |      CHECK((p) || CHK_MALLOC_n_tmp == 0, "out of memory!");           \
64 | }
65 | 
66 | #endif /* CHECK_H */
67 | 


--------------------------------------------------------------------------------
/src/util/debug_malloc.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | /* Debugging versions of malloc & free, to help catch common errors.
 19 |    The routines in this file were adapted from similar routines in the
 20 |    FFTW library (www.fftw.org), written by Matteo Frigo and Steven
 21 |    G. Johnson.  FFTW is also GPLed and is also copyrighted by MIT.  */
 22 | 
 23 | #include <stdio.h>
 24 | #include <stdlib.h>
 25 | 
 26 | #include "config.h"
 27 | 
 28 | #ifdef HAVE_MALLOC_H
 29 | #include <malloc.h>
 30 | #endif
 31 | 
 32 | #include "mpi_utils.h"
 33 | #include "check.h"
 34 | 
 35 | void* (*my_malloc_hook) (size_t) = 0;
 36 | 
 37 | /**********************************************************
 38 |  *   DEBUGGING CODE
 39 |  **********************************************************/
 40 | 
 41 | #ifdef DEBUG
 42 | 
 43 | void check_breakpoint(void)
 44 | {
 45 |      /* this function is only here so that we can drop into a breakpoint
 46 | 	in a debugger when a CHECK macro fails... */
 47 | }
 48 | 
 49 | #endif
 50 | 
 51 | #ifdef DEBUG_MALLOC
 52 | 
 53 | #  undef malloc
 54 | #  undef free
 55 | 
 56 | /*
 57 |  * debugging malloc/free.  Initialize every malloced and freed area to
 58 |  * random values, just to make sure we are not using uninitialized
 59 |  * pointers.  Also check for writes past the ends of allocated blocks,
 60 |  * and a couple of other things.
 61 |  *
 62 |  */
 63 | 
 64 | static int debug_malloc_cnt = 0;
 65 | static int debug_malloc_total = 0;
 66 | 
 67 | #define MAGIC 0xABadCafe
 68 | #define MMAGIC (((int) MAGIC) < 0 ? ((int) MAGIC) : -((int) MAGIC))
 69 | #define PAD_FACTOR 2
 70 | #define TWOINTS (2 * sizeof(int))
 71 | 
 72 | #define VERBOSE_ALLOCATION 0
 73 | 
 74 | #if VERBOSE_ALLOCATION
 75 | #define WHEN_VERBOSE(a) a
 76 | #else
 77 | #define WHEN_VERBOSE(a)
 78 | #endif
 79 | 
 80 | void *debug_malloc(size_t n)
 81 | {
 82 |      char *p;
 83 |      int i;
 84 | 
 85 |      WHEN_VERBOSE(mpi_one_fprintf(stderr,"DEBUG_MALLOC %d\n", n));
 86 | 
 87 |      if (n == 0)
 88 | 	  mpi_one_fprintf(stderr, "(Allocating a block of zero size.)\n");
 89 | 
 90 |      debug_malloc_total += n;
 91 | 
 92 |      p = (char *) malloc(PAD_FACTOR * n + TWOINTS);
 93 |      CHECK(p, "debug_malloc: out of memory\n");
 94 | 
 95 |      /* store the size in a known position */
 96 |      ((int *) p)[0] = n;
 97 |      ((int *) p)[1] = MAGIC;
 98 |      for (i = 0; i < PAD_FACTOR * n; ++i)
 99 | 	  p[i + TWOINTS] = (char) (i ^ 0xDEADBEEF);
100 | 
101 |      ++debug_malloc_cnt;
102 | 
103 |      /* skip the size we stored previously */
104 |      return (void *) (p + TWOINTS);
105 | }
106 | 
107 | void debug_free(void *p)
108 | {
109 |      char *q = ((char *) p) - TWOINTS;
110 | 
111 |      CHECK(p, "debug_free: tried to free NULL pointer!\n");
112 |      CHECK(q, "debug_free: tried to free NULL+TWOINTS pointer!\n");
113 | 
114 |      {
115 | 	  int n = ((int *) q)[0];
116 | 	  int magic = ((int *) q)[1];
117 | 	  int i;
118 | 
119 | 	  WHEN_VERBOSE(mpi_one_fprintf(stderr,"DEBUG_FREE %d\n", n));
120 | 	  CHECK(n != MMAGIC, "Tried to free a freed pointer!\n");
121 | 	  *((int *) q) = MMAGIC; /* to detect duplicate free's */
122 | 
123 | 	  CHECK(magic == MAGIC, "Wrong magic in debug_free()!\n");
124 | 	  ((int *) q)[1] = ~MAGIC;
125 | 
126 | 	  CHECK(n >= 0, "Tried to free block with corrupt size descriptor!\n");
127 | 
128 | 	  debug_malloc_total -= n;
129 | 
130 | 	  CHECK(debug_malloc_total >= 0, 
131 | 		"debug_malloc_total went negative!\n");
132 | 
133 | 	  /* check for writing past end of array: */
134 | 	  for (i = n; i < PAD_FACTOR * n; ++i)
135 | 	       if (q[i + TWOINTS] != (char) (i ^ 0xDEADBEEF))
136 | 		    mpi_die("Byte %d past end of array has changed!\n"
137 | 			    "Array bounds overwritten!\n",
138 | 			    i - n + 1);
139 | 	  for (i = 0; i < PAD_FACTOR * n; ++i)
140 | 	       q[i + TWOINTS] = (char) (i ^ 0xBEEFDEAD);
141 | 
142 | 	  --debug_malloc_cnt;
143 | 	  free(q);
144 |      }
145 | }
146 | 
147 | #endif /* DEBUG */
148 | 
149 | /* output current memory usage: */
150 | void debug_output_malloc_count(void)
151 | {
152 | #ifdef DEBUG_MALLOC
153 |      mpi_one_fprintf(stderr, "malloc: %d blocks, %g kB\n", 
154 | 		     debug_malloc_cnt, debug_malloc_total / 1024.0);
155 | #endif
156 | }
157 | 
158 | /* check for memory leaks when debugging */
159 | void debug_check_memory_leaks(void)
160 | {
161 | #ifdef DEBUG_MALLOC
162 |      if (debug_malloc_cnt || debug_malloc_total)
163 | 	  mpi_die("MEMORY LEAK!!!\n"
164 | 		  "number of unbalanced malloc calls = %d\n"
165 | 		  "total leaked bytes = %d\n",
166 | 		  debug_malloc_cnt,
167 | 		  debug_malloc_total);
168 | #endif
169 | }
170 | 


--------------------------------------------------------------------------------
/src/util/mpi_utils.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #ifndef MPI_UTILS_H
19 | #define MPI_UTILS_H
20 | 
21 | #include <stdio.h>
22 | 
23 | #ifdef HAVE_MPI
24 | #  include <mpi.h>
25 | extern MPI_Comm mpb_comm;
26 | #else
27 | extern int mpb_comm;
28 | #endif
29 | 
30 | extern void end_divide_parallel(void);
31 | extern int divide_parallel_processes(int numgroups);
32 | extern void begin_global_communications(void);
33 | extern void end_global_communications(void);
34 | extern int my_global_rank(void);
35 | 
36 | extern void mpi_die(const char *template, ...)
37 | #ifdef __GNUC__
38 |      __attribute__ ((format (printf, 1, 2)))
39 | #endif
40 | ;
41 | 
42 | extern void mpi_one_fprintf(FILE *f, const char *template, ...)
43 | #ifdef __GNUC__
44 |      __attribute__ ((format (printf, 2, 3)))
45 | #endif
46 | ;
47 | 
48 | extern void mpi_one_printf(const char *template, ...)
49 | #ifdef __GNUC__
50 |      __attribute__ ((format (printf, 1, 2)))
51 | #endif
52 | ;
53 | 
54 | extern int mpi_is_master(void);
55 | 
56 | extern void mpi_assert_equal(double x);
57 | 
58 | extern void mpi_begin_critical_section(int tag);
59 | extern void mpi_end_critical_section(int tag);
60 | 
61 | /* "in-place" Allreduce wrapper for reducing a single value */
62 | #define mpi_allreduce_1(b, ctype, t, op, comm) { \
63 |      ctype bbbb = *(b); \
64 |      mpi_allreduce(&bbbb, (b), 1, ctype, t, op, comm); \
65 | }
66 | 
67 | #endif /* MPI_UTILS_H */
68 | 


--------------------------------------------------------------------------------
/src/util/mpiglue.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #ifndef MPIGLUE_H
19 | #define MPIGLUE_H
20 | 
21 | /* This header file stands between our code and MPI.  If MPI is present,
22 |    we just #include <mpi.h>.  Otherwise, we use no-op stubs for 
23 |    MPI routines. */
24 | 
25 | #ifdef HAVE_MPI
26 | 
27 | #include <mpi.h>
28 | 
29 | typedef double mpiglue_clock_t;
30 | #define MPIGLUE_CLOCK MPI_Wtime()
31 | #define MPIGLUE_CLOCK_DIFF(t2, t1) ((t2) - (t1))
32 | 
33 | #define mpi_allreduce(sb, rb, n, ctype, t, op, comm) \
34 |      MPI_Allreduce(sb,rb,n,t,op,comm)
35 | 
36 | #else /* don't have MPI */
37 | 
38 | #include <string.h>
39 | #include <time.h>
40 | #include <check.h>
41 | 
42 | #define MPI_Init(argc,argv) 0
43 | #define MPI_Finalize() 0
44 | 
45 | /* Stub for the MPI_Allreduce function, differing only by the addition
46 |    of a "ctype" parameter that is the C type for the buffers.  This
47 |    routine just loops over the buffers and assigns sb to rb, since
48 |    all of the MPI reduce operations become simple assignments on a
49 |    single processor.   (Our original implementation required rb == sb,
50 |    but it seems that MPI implementations do not allow this.  The MPI 2.0
51 |    specification supports an MPI_IN_PLACE constant that you can pass
52 |    for sb in order to be in-place, but I don't want to require that. */
53 | #define mpi_allreduce(sb, rb, n, ctype, t, op, comm) { \
54 |      CHECK((sb) != (rb), "MPI_Allreduce doesn't work for sendbuf == recvbuf");\
55 |      memcpy((rb), (sb), (n) * sizeof(ctype)); \
56 | }
57 | 
58 | #define MPI_Bcast(b, n, t, root, comm) 0
59 | 
60 | #define MPI_Abort(comm, errcode) exit(errcode)
61 | 
62 | #define MPI_Barrier(comm) 0
63 | 
64 | #define MPI_Comm_rank(comm, rankp) *(rankp) = 0
65 | #define MPI_Comm_size(comm, sizep) *(sizep) = 1
66 | 
67 | #define MPI_Send(sb,n,t, r,tag, comm) \
68 | CHECK(0, "MPI_Send stub is non-functional");
69 | 
70 | #define MPI_Recv(sb,n,t, r,tag, comm,statp) \
71 | CHECK(0, "MPI_Recv stub is non-functional");
72 | 
73 | typedef int mpiglue_status_t;
74 | #define MPI_Status mpiglue_status_t
75 | 
76 | typedef clock_t mpiglue_clock_t;
77 | #define MPIGLUE_CLOCK clock()
78 | #define MPIGLUE_CLOCK_DIFF(t2, t1) (((t2) - (t1)) * 1.0 / CLOCKS_PER_SEC)
79 | 
80 | #endif /* HAVE_MPI */
81 | 
82 | #endif /* MPIGLUE_H */
83 | 


--------------------------------------------------------------------------------
/src/util/verbosity.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 3 |  *
 4 |  * This program is free software; you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation; either version 2 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * This program is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with this program; if not, write to the Free Software
16 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 |  */
18 | 
19 | #include "verbosity.h"
20 | 
21 | /* The global verbosity flag. See verbosity.h */
22 | int mpb_verbosity = 1;
23 | 


--------------------------------------------------------------------------------
/src/util/verbosity.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #ifndef _MPB_VERBOSITY_H
19 | 
20 | #ifdef __cplusplus
21 | extern "C" {
22 | #endif /* __cplusplus */
23 | 
24 | /*
25 | A global "verbosity" level.
26 |    0: minimal output
27 |    1: a little
28 |    2: a lot (default)
29 |    3: debugging
30 | */
31 | extern int mpb_verbosity;
32 | 
33 | #ifdef __cplusplus
34 | }
35 | #endif /* __cplusplus */
36 | 
37 | #endif /* _MPB_VERBOSITY_H */
38 | 


--------------------------------------------------------------------------------
/tests/Makefile.am:
--------------------------------------------------------------------------------
 1 | noinst_PROGRAMS = malloctest blastest eigs_test maxwell_test
 2 | if WITH_LIBCTLGEOM
 3 | noinst_PROGRAMS += normal_vectors
 4 | endif
 5 | EXTRA_DIST = blastest.real.out blastest.complex.out
 6 | 
 7 | LIBMPB = $(top_builddir)/src/libmpb@MPB_SUFFIX@.la
 8 | AM_CPPFLAGS = -I$(top_srcdir)/src/util -I$(top_srcdir)/src/matrices -I$(top_srcdir)/src/maxwell
 9 | 
10 | malloctest_SOURCES = malloctest.c
11 | malloctest_LDADD = $(LIBMPB)
12 | 
13 | blastest_SOURCES = blastest.c
14 | blastest_LDADD = $(LIBMPB)
15 | 
16 | eigs_test_SOURCES = eigs_test.c
17 | eigs_test_LDADD = $(LIBMPB)
18 | 
19 | maxwell_test_SOURCES = maxwell_test.c
20 | maxwell_test_LDADD = $(LIBMPB)
21 | 
22 | normal_vectors_SOURCES = normal_vectors.c
23 | normal_vectors_LDADD = -lctlgeom $(LIBMPB)
24 | normal_vectors_CPPFLAGS = $(CTLGEOM_H_CPPFLAG) $(AM_CPPFLAGS)
25 | 
26 | blastest.out: blastest
27 | 	./blastest | sed 's/\-0\.000\([ ,)]\)/ 0.000\1/g' | sed 's/\-0\.000$$/ 0.000/g' > $@
28 | 	diff $(srcdir)/blastest.@SCALAR_TYPE@.out $@
29 | 
30 | maxwell_test.out: maxwell_test
31 | 	./maxwell_test -1 -c 1e-9 -x 256 -E 1e-3 > $@
32 | 
33 | maxwell_test_2.out: maxwell_test
34 | 	./maxwell_test -1 -c 1e-9 -x 256 -E 1e-3 -e -k 0.4 -n 1 > $@
35 | 
36 | if !MPI
37 | MAXWELL_TEST_OUT=maxwell_test.out maxwell_test_2.out
38 | endif
39 | 
40 | check-local: blastest.out $(MAXWELL_TEST_OUT)
41 | 	@echo "**********************************************************"
42 | 	@echo "                       PASSED tests."
43 | 	@echo "**********************************************************"
44 | 
45 | clean-local:
46 | 	rm -f blastest.out $(MAXWELL_TEST_OUT)
47 | 


--------------------------------------------------------------------------------
/tests/blastest.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
  2 |  *
  3 |  * This program is free software; you can redistribute it and/or modify
  4 |  * it under the terms of the GNU General Public License as published by
  5 |  * the Free Software Foundation; either version 2 of the License, or
  6 |  * (at your option) any later version.
  7 |  *
  8 |  * This program is distributed in the hope that it will be useful,
  9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 |  * GNU General Public License for more details.
 12 |  *
 13 |  * You should have received a copy of the GNU General Public License
 14 |  * along with this program; if not, write to the Free Software
 15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 |  */
 17 | 
 18 | #include <stdio.h>
 19 | #include <stdlib.h>
 20 | #include <math.h>
 21 | 
 22 | #include "config.h"
 23 | #include <blasglue.h>
 24 | #include <check.h>
 25 | 
 26 | extern void debug_check_memory_leaks(void);  
 27 | 
 28 | void printmat(scalar *A, int m, int n)
 29 | {
 30 |   int i, j;
 31 | 
 32 |   for (i = 0; i < m; ++i) {
 33 |     for (j = 0; j < n; ++j) {
 34 | #ifdef SCALAR_COMPLEX
 35 |       printf("  (%6.3f,%6.3f)", (double)A[i*n + j].re, (double)A[i*n + j].im);
 36 | #else
 37 |       printf("  %6.3f", (double)A[i*n + j]);
 38 | #endif
 39 |     }
 40 |     printf("\n");
 41 |   }
 42 | }
 43 | 
 44 | void printmat_matlab(scalar *A, int m, int n)
 45 | {
 46 |   int i, j;
 47 | 
 48 |   printf("[");
 49 |   for (i = 0; i < m; ++i) {
 50 |     for (j = 0; j < n; ++j) {
 51 | #ifdef SCALAR_COMPLEX
 52 |          printf("  %g+%gi", (double)A[i*n + j].re, (double)A[i*n + j].im);
 53 | #else
 54 |          printf("  %g", (double)A[i*n + j]);
 55 | #endif
 56 |     }
 57 |     printf(";\n");
 58 |   }
 59 |   printf("]\n");
 60 | }
 61 | 
 62 | int main(void)
 63 | {
 64 |   const int N = 4;
 65 |   int i,j;
 66 | #ifndef SCALAR_COMPLEX
 67 |   scalar A[] = { 3.3, 6.2, 7.1, 9.1,
 68 |                  -2.3, 3.6, 0.3, 9.7,
 69 |                  6.7, -0.1, 1.1, 4.8,
 70 |                  8.4, 7.7, 5.9, -1.8 };
 71 |   scalar B[] = { 1.1, 2.2, 3.3, 4.4,
 72 | 		 8.8, 7.7, 6.6, 5.5,
 73 | 		 6.1, 8.2, 9.7, 3.6,
 74 | 		 6.3, 2.9, 5.5, 8.1 };
 75 | #else
 76 |   scalar A[] = { {3.3, 6.2} , {7.1, 9.1}, {2.3, 8.2}, {-3.2, 6.6},
 77 | 		 {-2.3, 3.6}, {0.3, 9.7}, {1.9,-4.9}, {7.1, 7.1},
 78 | 		 {6.7, -0.1}, {1.1, 4.8}, {-9.7, 3.7}, {-0.01, -0.2},
 79 | 		 {8.4, 7.7}, {5.9, -1.8}, {8.8, 9.9}, {0.0, 0.1} };
 80 |   scalar B[] = { {1.1, 2.2}, {3.3, 4.4}, {1.2, 2.3}, {3.4, 4.5},
 81 | 		 {8.8, 7.7}, {6.6, 5.5}, {3.5, 7.2}, {-0.3, 6.1},
 82 | 		 {6.1, 8.2}, {9.7, 3.6}, {-5.1, 6.1}, {2.3, 8.1},
 83 | 		 {6.3, 2.9}, {5.5, 8.1}, {8.5, 6.7}, {9.0, 2.4} };
 84 | #endif
 85 |   scalar C[16], D[16], E[16];
 86 |   real eigvals[4], wrk[20];
 87 | 
 88 |   printf("A = "); printmat_matlab(A,N,N);
 89 |   printf("B = "); printmat_matlab(B,N,N);
 90 | 
 91 |   blasglue_gemm('N', 'N', N, N, N, 1.0, A, N, B, N, 0.0, C, N);
 92 |   printf("\nC = A * B\n");
 93 |   printmat(C,N,N);
 94 | 
 95 |   blasglue_gemm('N', 'N', N, N, N, 1.0, C, N, B, N, 0.0, D, N);
 96 |   printf("\nC * B\n");
 97 |   printmat(D,N,N);
 98 | 
 99 |   blasglue_herk('U', 'C', N, N, 1.0, A, N, 0.0, D, N);
100 |   /* Now, copy the conjugate of the upper half
101 |      onto the lower half of D */
102 |   for (i = 0; i < N; ++i)
103 |     for (j = i + 1; j < N; ++j) {
104 |       ASSIGN_CONJ(D[j * N + i], D[i * N + j]);
105 |     }
106 |   printf("\nD = A' * A\n");
107 |   printmat(D,N,N);
108 | 
109 |   lapackglue_potrf('U', N, D, N);
110 |   lapackglue_potri('U', N, D, N);
111 |   /* Now, copy the conjugate of the upper half
112 |      onto the lower half of D */
113 |   for (i = 0; i < N; ++i)
114 |     for (j = i + 1; j < N; ++j) {
115 |       ASSIGN_CONJ(D[j * N + i], D[i * N + j]);
116 |     }
117 |   printf("\ninverse(D)\n");
118 |   printmat(D,N,N);
119 | 
120 |   /* D = At * A, again */
121 |   blasglue_herk('U', 'C', N, N, 1.0, A, N, 0.0, D, N);
122 | 
123 |   /* Compute eigenvectors and eigenvalues: */
124 |   lapackglue_heev('V', 'U', N, D, N, eigvals, E, 16, wrk);
125 |   /* Choose a deterministic phase for each row/eigenvector: */
126 |   for (i = 0; i < N; ++i) {
127 |        scalar phase;
128 |        real len;
129 |        for (j = 0; (len = sqrt(SCALAR_NORMSQR(D[i*N + j]))) < 1e-6; ++j)
130 | 	    ;
131 |        /* phase to make D[i*N+j] purely real: */
132 |        ASSIGN_SCALAR(phase, SCALAR_RE(D[i*N+j])/len, -SCALAR_IM(D[i*N+j])/len);
133 |        ASSIGN_MULT(D[i*N+j], D[i*N+j], phase);
134 |        if (SCALAR_RE(D[i*N+j]) < 0) { /* pick deterministic (positive) sign */
135 | 	    ASSIGN_SCALAR(phase, -SCALAR_RE(phase), -SCALAR_IM(phase));
136 | 	    ASSIGN_SCALAR(D[i*N+j], -SCALAR_RE(D[i*N+j]),-SCALAR_IM(D[i*N+j]));
137 |        }
138 |        for (j = j + 1; j < N; ++j)
139 | 	    ASSIGN_MULT(D[i*N + j], D[i*N + j], phase);
140 |   }
141 |   printf("\n[v,d] = eig(D);\n");
142 |   printf("\ndiag(d)\n  ");
143 |   for (i = 0; i < 4; ++i) printf("  %6.3f", (double)eigvals[i]);
144 |   printf("\nv'\n");
145 |   printmat(D,N,N);
146 |   blasglue_gemm('C', 'N', N, N, N, 1.0, D, N, D, N, 0.0, C, N);
147 |   printf("\nv * v'\n");
148 |   printmat(C,N,N);
149 | 
150 |   /* Compute E = diag(sqrt(eigenvals)) * D; i.e. the rows of E
151 |      become the rows of D times sqrt(corresponding eigenvalue) */
152 |   for (i = 0; i < N; ++i) {
153 |     CHECK(eigvals[i] > 0, "non-positive eigenvalue");
154 |     
155 |     blasglue_copy(N, D + i*N, 1, E + i*N, 1);
156 |     blasglue_rscal(N, sqrt(eigvals[i]), E + i*N, 1);
157 |   }
158 | 
159 |   /* compute C = adjoint(D) * E == sqrt (At * A) */
160 |   blasglue_gemm('C', 'N', N, N, N, 1.0, D, N, E, N, 0.0, C, N);
161 |   printf("\nsqrtm(D)\n");
162 |   printmat(C,N,N);
163 | 
164 |   blasglue_gemm('C', 'N', N, N, N, 1.0, E, N, E, N, 0.0, C, N);
165 |   printf("\nsqrtm(D) * sqrtm(D)\n");
166 |   printmat(C,N,N);
167 | 
168 |   debug_check_memory_leaks();
169 | 
170 |   return EXIT_SUCCESS;
171 | }
172 | 


--------------------------------------------------------------------------------
/tests/blastest.complex.out:
--------------------------------------------------------------------------------
 1 | A = [  3.3+6.2i  7.1+9.1i  2.3+8.2i  -3.2+6.6i;
 2 |   -2.3+3.6i  0.3+9.7i  1.9+-4.9i  7.1+7.1i;
 3 |   6.7+-0.1i  1.1+4.8i  -9.7+3.7i  -0.01+-0.2i;
 4 |   8.4+7.7i  5.9+-1.8i  8.8+9.9i  0+0.1i;
 5 | ]
 6 | B = [  1.1+2.2i  3.3+4.4i  1.2+2.3i  3.4+4.5i;
 7 |   8.8+7.7i  6.6+5.5i  3.5+7.2i  -0.3+6.1i;
 8 |   6.1+8.2i  9.7+3.6i  -5.1+6.1i  2.3+8.1i;
 9 |   6.3+2.9i  5.5+8.1i  8.5+6.7i  9+2.4i;
10 | ]
11 | 
12 | C = A * B
13 |   (-110.110,250.010)  (-97.850,232.290)  (-184.140,104.870)  (-180.090,165.720)
14 |   (-6.590,137.580)  (-57.190,123.300)  (-46.850,179.640)  ( 7.640,85.870)
15 |   (-108.683, 7.081)  (-102.435,66.669)  ( 5.715,-39.797)  (-58.270,-36.804)
16 |   (30.290,189.720)  (91.590,211.200)  (-79.960,68.780)  (-57.070,195.460)
17 | 
18 | C * B
19 |   (-6919.199,975.010)  (-7883.329,1142.554)  (-5063.800,-1300.820)  (-6178.540,-503.102)
20 |   (-3722.331,2056.288)  (-3437.379,3032.270)  (-2779.525,-251.145)  (-3076.656,877.121)
21 |   (-1449.081,-1030.123)  (-1256.229,-1618.081)  (-1020.338,-1211.081)  (-877.937,-1626.178)
22 |   (-3182.440,3668.914)  (-4212.248,3649.090)  (-3406.522,2136.486)  (-3790.311,2409.382)
23 | 
24 | D = A' * A
25 |   (242.330, 0.000)  (156.670,-65.660)  (121.210,56.450)  (40.313,-0.771)
26 |   (156.670,65.660)  (289.700, 0.000)  (85.180,142.270)  (107.189, 9.658)
27 |   (121.210,-56.450)  (85.180,-142.270)  (383.380, 0.000)  (25.807,92.557)
28 |   (40.313, 0.771)  (107.189,-9.658)  (25.807,-92.557)  (154.670, 0.000)
29 | 
30 | inverse(D)
31 |   ( 0.008, 0.000)  (-0.006, 0.001)  (-0.001, 0.002)  ( 0.003, 0.001)
32 |   (-0.006,-0.001)  ( 0.018, 0.000)  (-0.001,-0.010)  (-0.017, 0.002)
33 |   (-0.001,-0.002)  (-0.001, 0.010)  ( 0.010, 0.000)  ( 0.000,-0.012)
34 |   ( 0.003,-0.001)  (-0.017,-0.002)  ( 0.000, 0.012)  ( 0.024, 0.000)
35 | 
36 | [v,d] = eig(D);
37 | 
38 | diag(d)
39 |     21.695  114.964  297.042  636.378
40 | v'
41 |   ( 0.167, 0.000)  (-0.581,-0.074)  (-0.005, 0.394)  ( 0.688, 0.029)
42 |   ( 0.829, 0.000)  (-0.302, 0.197)  (-0.172,-0.198)  (-0.327, 0.086)
43 |   ( 0.236, 0.000)  ( 0.420,-0.151)  (-0.582,-0.143)  ( 0.381,-0.491)
44 |   ( 0.479, 0.000)  ( 0.518,-0.241)  ( 0.584, 0.275)  ( 0.139, 0.083)
45 | 
46 | v * v'
47 |   ( 1.000, 0.000)  ( 0.000, 0.000)  ( 0.000, 0.000)  ( 0.000, 0.000)
48 |   ( 0.000, 0.000)  ( 1.000, 0.000)  ( 0.000, 0.000)  ( 0.000, 0.000)
49 |   ( 0.000, 0.000)  ( 0.000, 0.000)  ( 1.000, 0.000)  ( 0.000, 0.000)
50 |   ( 0.000, 0.000)  ( 0.000, 0.000)  ( 0.000, 0.000)  ( 1.000, 0.000)
51 | 
52 | sqrtm(D)
53 |   (14.249, 0.000)  ( 4.839,-1.835)  ( 3.176, 1.293)  ( 0.852,-0.206)
54 |   ( 4.839, 1.835)  (14.680, 0.000)  ( 2.138, 4.539)  ( 4.715,-0.063)
55 |   ( 3.176,-1.293)  ( 2.138,-4.539)  (18.171, 0.000)  ( 0.469, 4.007)
56 |   ( 0.852, 0.206)  ( 4.715, 0.063)  ( 0.469,-4.007)  (10.742, 0.000)
57 | 
58 | sqrtm(D) * sqrtm(D)
59 |   (242.330, 0.000)  (156.670,-65.660)  (121.210,56.450)  (40.313,-0.771)
60 |   (156.670,65.660)  (289.700, 0.000)  (85.180,142.270)  (107.189, 9.658)
61 |   (121.210,-56.450)  (85.180,-142.270)  (383.380, 0.000)  (25.807,92.557)
62 |   (40.313, 0.771)  (107.189,-9.658)  (25.807,-92.557)  (154.670, 0.000)
63 | 


--------------------------------------------------------------------------------
/tests/blastest.real.out:
--------------------------------------------------------------------------------
 1 | A = [  3.3  6.2  7.1  9.1;
 2 |   -2.3  3.6  0.3  9.7;
 3 |   6.7  -0.1  1.1  4.8;
 4 |   8.4  7.7  5.9  -1.8;
 5 | ]
 6 | B = [  1.1  2.2  3.3  4.4;
 7 |   8.8  7.7  6.6  5.5;
 8 |   6.1  8.2  9.7  3.6;
 9 |   6.3  2.9  5.5  8.1;
10 | ]
11 | 
12 | C = A * B
13 |   158.830  139.610  170.730  147.890
14 |   92.090  53.250  72.430  89.330
15 |   43.440  36.910  58.520  71.770
16 |   101.650  120.930  125.870  85.970
17 | 
18 | C * B
19 |   3376.441  3253.290  3915.041  3279.244
20 |   1574.501  1465.606  1849.233  1682.392
21 |   1181.715  1067.772  1349.337  1186.150
22 |   2485.417  2436.238  2827.357  2261.864
23 | 
24 | D = A' * A
25 |   131.630  76.190  79.670  24.760
26 |   76.190  110.700  90.420  77.000
27 |   79.670  90.420  86.520  62.180
28 |   24.760  77.000  62.180  203.180
29 | 
30 | inverse(D)
31 |    0.020   0.006  -0.027   0.004
32 |    0.006   0.067  -0.073  -0.004
33 |   -0.027  -0.073   0.116  -0.005
34 |    0.004  -0.004  -0.005   0.007
35 | 
36 | [v,d] = eig(D);
37 | 
38 | diag(d)
39 |      5.781  35.665  149.952  340.633
40 | v'
41 |    0.166   0.566  -0.807   0.013
42 |    0.662  -0.622  -0.295   0.297
43 |    0.589   0.159   0.220  -0.761
44 |    0.433   0.518   0.461   0.576
45 | 
46 | v * v'
47 |    1.000   0.000   0.000   0.000
48 |    0.000   1.000   0.000   0.000
49 |    0.000   0.000   1.000   0.000
50 |    0.000   0.000   0.000   1.000
51 | 
52 | sqrtm(D)
53 |   10.390   3.048   3.783   0.293
54 |    3.048   8.333   4.828   2.943
55 |    3.783   4.828   6.603   2.302
56 |    0.293   2.943   2.302  13.753
57 | 
58 | sqrtm(D) * sqrtm(D)
59 |   131.630  76.190  79.670  24.760
60 |   76.190  110.700  90.420  77.000
61 |   79.670  90.420  86.520  62.180
62 |   24.760  77.000  62.180  203.180
63 | 


--------------------------------------------------------------------------------
/tests/malloctest.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 1999-2020 Massachusetts Institute of Technology.
 2 |  *
 3 |  * This program is free software; you can redistribute it and/or modify
 4 |  * it under the terms of the GNU General Public License as published by
 5 |  * the Free Software Foundation; either version 2 of the License, or
 6 |  * (at your option) any later version.
 7 |  *
 8 |  * This program is distributed in the hope that it will be useful,
 9 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 |  * GNU General Public License for more details.
12 |  *
13 |  * You should have received a copy of the GNU General Public License
14 |  * along with this program; if not, write to the Free Software
15 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 |  */
17 | 
18 | #include <stdlib.h>
19 | #include <stdio.h>
20 | #include <time.h>
21 | 
22 | #include "config.h"
23 | #include <check.h>
24 | 
25 | #define NUM_POINTERS 1000
26 | #define MAX_SIZE 65536
27 | #define NUM_MALLOCS 3000000
28 | 
29 | int main(void)
30 | {
31 |      char *pointers[NUM_POINTERS];
32 |      int i, iter;
33 |      clock_t start_time;
34 |      double elapsed_time;
35 | 
36 | #ifdef DEBUG_MALLOC
37 |      printf("Using debug_malloc and debug_free routines.\n");
38 | #else
39 |      fprintf(stderr, 
40 | 	     "***** NOTE: malloctest is designed to be run when the package\n"
41 | 	     "            is configured with --enable-debug, to test the\n"
42 | 	     "            debugging malloc/free routines.\n");
43 | #endif
44 | 
45 |      srand(time(NULL));
46 | 
47 |      for (i = 0; i < NUM_POINTERS; ++i)
48 | 	  pointers[i] = NULL;
49 | 
50 |      printf("Doing %d malloc/free calls...\n", NUM_MALLOCS);
51 |      start_time = clock();
52 |      for (iter = 0; iter < NUM_MALLOCS; ++iter) {
53 | 	  i = rand() % NUM_POINTERS;
54 | 	  if (pointers[i])
55 | 	       free(pointers[i]);
56 | 	  CHK_MALLOC(pointers[i], char, rand() % MAX_SIZE + 1);
57 | 	  if ((iter + 1) % (NUM_MALLOCS / 20) == 0)
58 | 	       printf("...completed %d...\n", iter + 1);
59 |      }
60 |      elapsed_time = (clock() - start_time) * 1.0 / CLOCKS_PER_SEC;
61 |      printf("Done.\n");
62 | 
63 |      printf("Total time = %g seconds, %g us per iteration\n",
64 | 	    elapsed_time, elapsed_time * 1e6 / NUM_MALLOCS);
65 | 
66 |      for (i = 0; i < NUM_POINTERS; ++i)
67 | 	  if (pointers[i])
68 | 	       free(pointers[i]);
69 | 
70 | #ifdef DEBUG_MALLOC
71 |      debug_check_memory_leaks();
72 | #endif
73 |      
74 |      printf("Okay.\n");
75 | 
76 |      return EXIT_SUCCESS;
77 | }
78 | 


--------------------------------------------------------------------------------
/utils/Makefile.am:
--------------------------------------------------------------------------------
 1 | if !MPI
 2 | bin_PROGRAMS = mpb@MPB_SUFFIX@-data
 3 | endif
 4 | 
 5 | mpb@MPB_SUFFIX@_data_SOURCES = mpb-data.c
 6 | mpb@MPB_SUFFIX@_data_LDADD = $(top_builddir)/src/matrixio/libmatrixio.a $(top_builddir)/src/libmpb@MPB_SUFFIX@.la -lctlgeom
 7 | mpb@MPB_SUFFIX@_data_CPPFLAGS = $(CTLGEOM_H_CPPFLAG) -I$(top_srcdir)/src/util -I$(top_srcdir)/src/matrices -I$(top_srcdir)/src/matrixio
 8 | 
 9 | dist_man_MANS = mpb-data.1
10 | 


--------------------------------------------------------------------------------
/utils/mpb-data.1:
--------------------------------------------------------------------------------
  1 | .\" Copyright (C) 1999-2014 Massachusetts Institute of Technology.
  2 | .\"
  3 | .\" This program is free software; you can redistribute it and/or modify
  4 | .\" it under the terms of the GNU General Public License as published by
  5 | .\" the Free Software Foundation; either version 2 of the License, or
  6 | .\" (at your option) any later version.
  7 | .\"
  8 | .\" This program is distributed in the hope that it will be useful,
  9 | .\" but WITHOUT ANY WARRANTY; without even the implied warranty of
 10 | .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11 | .\" GNU General Public License for more details.
 12 | .\"
 13 | .\" You should have received a copy of the GNU General Public License
 14 | .\" along with this program; if not, write to the Free Software
 15 | .\" Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 16 | .\"
 17 | .TH MPB-DATA 1 "January 27, 2000" "MPB" "MIT Photonic-Bands Package"
 18 | .SH NAME
 19 | mpb-data \- transformations of HDF5 files output by MPB
 20 | .SH SYNOPSIS
 21 | .B mpb-data
 22 | [\fIOPTION\fR]... [\fIHDF5FILE\fR]...
 23 | .SH DESCRIPTION
 24 | .PP
 25 | ." Add any additional description here
 26 | mpb-data is a utility to perform additional processing and
 27 | transformations of HDF5 files output by MPB, the MIT Photonic-Bands
 28 | program.  In particular, it is designed to make the output more
 29 | amenable to visualization by reformatting it into a rectangular grid,
 30 | extending it to multiple periods, and rescaling the data.
 31 | .PP
 32 | MIT Photonic Bands (MPB) is a free program to compute the band
 33 | structures (dispersion relations) and electromagnetic modes of
 34 | periodic dielectric structures.
 35 | .PP
 36 | HDF5 is a free, portable binary format and supporting library developed
 37 | by the National Center for Supercomputing Applications at the University
 38 | of Illinois in Urbana-Champaign.  A single
 39 | .I h5
 40 | file can contain multiple data sets; by default,
 41 | .I mpb-data
 42 | operates on all of the MPB-produced datasets in the file, but this can
 43 | be changed via the
 44 | .B -d
 45 | option, or by using the syntax \fIHDF5FILE:DATASET\fR.
 46 | .PP
 47 | .I mpb-data
 48 | writes its output datasets as additional datasets in the input file(s), with "-new" appended to the dataset names.  Alternatively, it can write its output to a separate file, specified by the
 49 | .B -o
 50 | option.
 51 | .PP
 52 | Note also that, by default, the output datasets are identical to the
 53 | input datasets; you must use one or more of the options below to
 54 | specify a transformation (e.g. the \fB\-r\fR/\fB\-e\fR and
 55 | .B -n
 56 | options are very useful).
 57 | .SH OPTIONS
 58 | .TP
 59 | .B -h
 60 | Display help on the command-line options and usage.
 61 | .TP
 62 | .B -V
 63 | Print the version number and copyright info for mpb-data.
 64 | .TP
 65 | .B -v
 66 | Verbose output.
 67 | .TP
 68 | \fB\-o\fR \fIfile\fR
 69 | Write output datasets to
 70 | .I file
 71 | (for the first input file only) rather than as additional datasets in
 72 | the input file(s) (the default).
 73 | .TP
 74 | .B -r
 75 | Output a rectangular cell with the same volume as the cell of the
 76 | input data.  This option is particularly useful for visualizing data
 77 | from non-orthogonal unit cells (e.g. a triangular lattice), as
 78 | otherwise the data will appear skewed or warped in most graphics
 79 | programs.  This option should almost always be accompanied by the
 80 | \fB\-n\fR option to ensure a uniform resolution.
 81 | .TP
 82 | \fB\-e\fR \fIx,y,z\fR
 83 | As the \fB\-r\fR option, but also make the first axis of the output along
 84 | the \fIx,y,z\fR direction (in Cartesian coordinates) instead of along
 85 | the first lattice vector as for \fB\-r\fR.
 86 | .TP
 87 | \fB\-P\fR \fIphaseangle\fR
 88 | For complex-valued datasets, this option causes the output values to
 89 | be rotated by \fIphaseangle\fR degrees in the complex plane.  That is,
 90 | they are multiplied by exp(2 pi i \fIphaseangle\fR / 360).
 91 | .TP
 92 | \fB\-n\fR \fIn\fR
 93 | Output
 94 | .I n
 95 | grid points per lattice unit ("a").  This is useful not only for interpolating
 96 | to finer (or coarser) resolutions, but also to ensure that the resolution
 97 | is uniform in each direction (to prevent the data from looking distorted
 98 | when you visualize it).
 99 | .TP
100 | \fB\-x\fR \fImx\fR, \fB\-y\fR \fImy\fR, \fB\-z\fR \fImz\fR
101 | This tells
102 | .I mpb-data
103 | to output multiple periods in the corresponding lattice directions.
104 | to use a particular slice of a two- or three-dimensional dataset.  e.g.
105 | .B -x 3.2
106 | causes the output of 3.2 periods in the first lattice direction.  The
107 | default is to output only a single period.
108 | .TP
109 | \fB\-m\fR \fIs\fR
110 | Output
111 | .I s
112 | periods in each lattice direction; equivalent to:
113 | \fB\-x\fR \fIs\fR \fB\-y\fR \fIs\fR \fB\-z\fR \fIs\fR.
114 | .TP
115 | .B -T
116 | The output has the first two dimensions (x and y) transposed.  This
117 | is useful in conjunction with the parallel (MPI) version of MPB,
118 | which for performance reasons outputs all arrays with the first two
119 | dimensions transposed.
120 | .B -T
121 | can undo this transposition.
122 | .TP
123 | .B -p
124 | Pixellized output.  Normally, the input data is linearly interpolated to
125 | the output grid, but the
126 | .B -p
127 | option causes it to instead use the nearest grid point in the input data.
128 | This is useful, for example, if you want to study the discretization of the
129 | dielectric-function representation.
130 | .TP
131 | \fB\-d\fR \fIname\fR
132 | Use dataset
133 | .I name
134 | from the input files; otherwise, the first dataset from each file is used.
135 | Alternatively, use the syntax \fIHDF5FILE:DATASET\fR, which allows you
136 | to specify a different dataset for each file.
137 | You can use the
138 | .I h5ls
139 | command (included with hdf5) to find the names of datasets within a file.
140 | 
141 | Note that this option is generally unnecessary, since mpb-data can
142 | already find the relevant dataset(s) for files created by MPB.  Also,
143 | note that mpb-data treats the dataset specified by this option as a
144 | real scalar dataset and does not include the exp(ikx) factors when
145 | extending the dataset to multiple periods.
146 | .SH BUGS
147 | Send bug reports to S. G. Johnson, stevenj@alum.mit.edu.
148 | .SH AUTHORS
149 | Written by Steven G. Johnson.  Copyright (c) 1999-2012 by
150 | the Massachusetts Institute of Technology.
151 | .SH "SEE ALSO"
152 | mpb(1)
153 | 


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