diff --git a/chunkie/@chunker/chunker.m b/chunkie/@chunker/chunker.m index bc8f6c4..e0e2b35 100644 --- a/chunkie/@chunker/chunker.m +++ b/chunkie/@chunker/chunker.m @@ -31,6 +31,7 @@ % precomputed Legendre nodes/weights (optional) % obj = addchunk(obj,nchadd) - add nchadd chunks to the structure % (initialized with zeros) +% obj = obj.move(r0,r1,trotat,scale) - translate, rotate, etc % obj = makedatarows(obj,nrows) - add nrows rows to the data storage. % [obj,info] = sort(obj) - sort the chunks so that adjacent chunks are % stored sequentially @@ -340,6 +341,7 @@ [obj,info] = sort(obj) [rn,dn,d2n,dist,tn,ichn] = nearest(obj,ref,ich,opts,u,xover,aover) obj = reverse(obj) + obj = move(obj,r0,r1,trotat,scale) rmin = min(obj) rmax = max(obj) whts = whts(obj) diff --git a/chunkie/@kernel/kernel.m b/chunkie/@kernel/kernel.m index a68679a..fbc398d 100644 --- a/chunkie/@kernel/kernel.m +++ b/chunkie/@kernel/kernel.m @@ -39,6 +39,11 @@ % data for working with the kernel in a standardized format. For example, % for a kernel K: % +% - K.opdims: a 2-vector [m n] specifying the dimensions of the +% kernel values. K.eval(s,t) is an m x n matrix if s and t are a +% single source and target, respectively. For scalar kernels, +% opdims = [1 1]. +% % - K.fmm: A function handle which calls the FMM for the corresponding % kernel. K.fmm(eps, s, t, sigma) evaluates the kernel with density % sigma from sources s to targets t with accuracy eps. @@ -47,6 +52,8 @@ % integrals using the Helsing-Ojala kernel-split quadrature % technique. +% author: Dan Fortunato + properties name % Name of the kernel diff --git a/chunkie/@kernel/lap2d.m b/chunkie/@kernel/lap2d.m index 1eb548a..86233dc 100644 --- a/chunkie/@kernel/lap2d.m +++ b/chunkie/@kernel/lap2d.m @@ -6,15 +6,27 @@ % KERNEL.LAP2D('d') or KERNEL.LAP2D('double') constructs the double-layer % Laplace kernel. % -% KERNEL.LAP2D('sp') or KERNEL.LAP2D('sprime') constructs the derivative -% of the single-layer Laplace kernel. +% KERNEL.LAP2D('sp') or KERNEL.LAP2D('sprime') constructs the +% normal derivative of the single-layer Laplace kernel. +% +% KERNEL.LAP2D('sg') or KERNEL.LAP2D('sgrad') constructs the +% gradient of the single-layer Laplace kernel. +% +% KERNEL.LAP2D('dp') or KERNEL.LAP2D('dprime') constructs the normal +% derivative of the double-layer Laplace kernel. +% +% KERNEL.LAP2D('dg') or KERNEL.LAP2D('dgrad') constructs the gradient +% of the double-layer Laplace kernel. % % KERNEL.LAP2D('c', coefs) or KERNEL.LAP2D('combined', coefs) constructs -% the combined-layer Laplace kernel with parameter ETA, i.e., -% KERNEL.LAP2D('d') + ETA*KERNEL.LAP2D('s'). +% the combined-layer Laplace kernel with parameter coefs, i.e., +% coefs(1)*KERNEL.LAP2D('d') + coefs(2)*KERNEL.LAP2D('s'). If no +% value of coefs is specified the default is coefs = [1 1] % % See also CHNK.LAP2D.KERN. +% author: Dan Fortunato + if ( nargin < 1 ) error('Missing Laplace kernel type.'); end @@ -71,7 +83,7 @@ case {'c', 'combined'} if ( nargin < 2 ) - warning('Missing combined layer parameter coefs. Defaulting to 1.'); + warning('Missing combined layer parameter coefs. Defaulting to [1 1].'); coefs = ones(2,1); end obj.type = 'c'; diff --git a/chunkie/demo/addpaths_loc.m b/chunkie/demo/addpaths_loc.m index 42927d7..bb32dd6 100644 --- a/chunkie/demo/addpaths_loc.m +++ b/chunkie/demo/addpaths_loc.m @@ -1,5 +1,3 @@ function addpaths_loc() -addpath('../'); -addpath(genpath('../FLAM')); -addpath('../fmm2d/matlab/'); +run('../../startup.m'); diff --git a/chunkie/demo/demo_scatter.m b/chunkie/demo/demo_scatter.m index e87662c..e882ad9 100644 --- a/chunkie/demo/demo_scatter.m +++ b/chunkie/demo/demo_scatter.m @@ -110,7 +110,7 @@ h=pcolor(xxtarg,yytarg,imag(zztarg)); set(h,'EdgeColor','none') clim([-maxu,maxu]) -colormap(brewermap([],'RdBu')); +colormap(redblue); hold on plot(chnkr,'k','LineWidth',2) axis equal tight @@ -123,7 +123,7 @@ h=pcolor(xxtarg,yytarg,imag(zztarg)); set(h,'EdgeColor','none') clim([-maxu,maxu]) -colormap(brewermap([],'RdBu')); +colormap(redblue); hold on plot(chnkr,'k','LineWidth',2) axis equal tight @@ -137,7 +137,7 @@ h=pcolor(xxtarg,yytarg,imag(zztarg)); set(h,'EdgeColor','none') clim([-maxu,maxu]) -colormap(brewermap([],'RdBu')); +colormap(redblue); hold on plot(chnkr,'k','LineWidth',2) axis equal tight diff --git a/chunkie/fmm2d b/chunkie/fmm2d index dda60cd..1ccfd74 160000 --- a/chunkie/fmm2d +++ b/chunkie/fmm2d @@ -1 +1 @@ -Subproject commit dda60cd527f14dcf9bbe38759115278f1412bfbf +Subproject commit 1ccfd7446f764f78c780bd6e5dc455d3c9c80b3d diff --git a/chunkie/guide/addpaths_loc.m b/chunkie/guide/addpaths_loc.m index 64bc844..bb32dd6 100644 --- a/chunkie/guide/addpaths_loc.m +++ b/chunkie/guide/addpaths_loc.m @@ -1,4 +1,3 @@ function addpaths_loc() -addpath('../'); -addpath(genpath('../FLAM')); \ No newline at end of file +run('../../startup.m'); diff --git a/chunkie/guide/guide_simplebvps.m b/chunkie/guide/guide_simplebvps.m index 5d02360..ed83bb3 100644 --- a/chunkie/guide/guide_simplebvps.m +++ b/chunkie/guide/guide_simplebvps.m @@ -18,8 +18,8 @@ % define a boundary condition. because of the symmetries of the % starfish, this function integrates to zero -f = @(r) r(1,:).^2.*r(2,:); -rhs = f(chnkr.r); rhs = rhs(:); +pwfun = @(r) r(1,:).^2.*r(2,:); +rhs = pwfun(chnkr.r); rhs = rhs(:); % get the kernel kernsp = kernel('lap','sprime'); @@ -46,9 +46,138 @@ % plot figure(1); clf h = pcolor(xx,yy,uu); set(h,'EdgeColor','none'); colorbar +hold on; plot(chnkr,'k'); colormap(redblue) % END LAPLACE NEUMANN saveas(figure(1),"guide_simplebvps_laplaceneumann.png") +%% % START BASIC SCATTERING +% get a chunker discretization of a peanut-shaped domain +modes = [1.25,-0.25,0,0.5]; +ctr = [0;0]; +chnkr = chunkerfunc(@(t) chnk.curves.bymode(t,modes,ctr)); +% the boundary condition is determined by an incident plane wave +kwav = 3*[-1,-5]; +pwfun = @(r) exp(1i*kwav*r(:,:)); +rhs = -pwfun(chnkr.r); rhs = rhs(:); + +% define the CFIE kernel D - ik S +zk = norm(kwav); +coefs = [1,-1i*zk]; +kerncfie = kernel('h','c',zk,coefs); + +% get a matrix discretization of the boundary integral equation +sysmat = chunkermat(chnkr,kerncfie); +% add the identity term +sysmat = sysmat + 0.5*eye(chnkr.npt); + +% solve the system +sigma = gmres(sysmat,rhs,[],1e-10,100); + +% grid for plotting solution (in exterior) +x1 = linspace(-5,5,300); +[xx,yy] = meshgrid(x1,x1); +targs = [xx(:).'; yy(:).']; +in = chunkerinterior(chnkr,{x1,x1}); +uu = nan(size(xx)); + +% same kernel to evaluate as on boundary +uu(~in) = chunkerkerneval(chnkr,kerncfie,sigma,targs(:,~in)); +uu(~in) = uu(~in) + pwfun(targs(:,~in)).'; + +% plot +figure(1); clf +h = pcolor(xx,yy,real(uu)); set(h,'EdgeColor','none'); colorbar +colormap(redblue); umax = max(abs(uu(:))); clim([-umax,umax]); +hold on +plot(chnkr,'k') % END BASIC SCATTERING +saveas(figure(1),"guide_simplebvps_basicscattering.png") + +%% +% START STOKES VELOCITY +% get a chunker discretization of a peanut-shaped domain +modes = [2.5,0,0,1]; +ctr = [0;0]; +chnkrouter = chunkerfunc(@(t) chnk.curves.bymode(t,modes,ctr)); + +% inner boundaries are circles (reverse them to get orientations right) +chnkrcirc = chunkerfunc(@(t) chnk.curves.bymode(t,0.3,[0;0])); +chnkrcirc = reverse(chnkrcirc); +centers = [ [-2:2, -2:2]; [(0.7 + 0.25*(-1).^(-2:2)) , ... + (-0.7 + 0.25*(-1).^(-2:2))]]; +centers = centers + 0.1*randn(size(centers)); + +% make a boundary out of the outer boundary and several shifted circles +chnkrlist = [chnkrouter]; +for j = 1:size(centers,2) + chnkr1 = chnkrcirc; + chnkr1.r(:,:) = chnkr1.r(:,:) + centers(:,j); + chnkrlist = [chnkrlist chnkr1]; +end +chnkr = merge(chnkrlist); + +%% + +% boundary condition specifies the velocity. two values per node +wid = 0.3; % determines width of Gaussian +f = @(r) [exp(-r(2,:).^2/(2*wid^2)); zeros(size(r(2,:)))]; +rhsout = f(chnkrouter.r(:,:)); rhsout = rhsout(:); +rhs = [rhsout; zeros(2*10*chnkrcirc.npt,1)]; + +% define the combined layer Stokes representation kernel +mu = 1; % stokes viscosity parameter +kerndvel = kernel('stok','dvel',mu); +kernsvel = kernel('stok','svel',mu); + +% get a matrix discretization of the boundary integral equation +dmat = chunkermat(chnkr,kerndvel); +smat = chunkermat(chnkr,kernsvel); + +% add the identity term and nullspace correction +c = -1; +W = normonesmat(chnkr); +sysmat = dmat + c*smat - 0.5*eye(2*chnkr.npt) + W; + +% solve the system +sigma = gmres(sysmat,rhs,[],1e-10,100); + +% grid for plotting solution (in exterior) +x1 = linspace(-3.75,3.75,300); +y1 = linspace(-2,2,300); +[xx,yy] = meshgrid(x1,y1); +targs = [xx(:).'; yy(:).']; +in = chunkerinterior(chnkr,{x1,y1}); +uu = nan([2,size(xx)]); +pres = nan(size(xx)); + +% same kernel to evaluate as on boundary +uu(:,in) = reshape(chunkerkerneval(chnkr,kerndvel,sigma,targs(:,in)),2,nnz(in)); +uu(:,in) = uu(:,in) + c*reshape(chunkerkerneval(chnkr,kernsvel,sigma,targs(:,in)),2,nnz(in)); +uu(:,in) = uu(:,in) + uconst; + +% can evaluate the associated pressure +kerndpres = kernel('stok','dpres',mu); +kernspres = kernel('stok','spres',mu); +opts = []; opts.eps = 1e-3; +pres(in) = chunkerkerneval(chnkr,kerndpres,sigma,targs(:,in),opts); +pres(in) = pres(in) + c*chunkerkerneval(chnkr,kernspres,sigma,targs(:,in),opts); + +% plot +figure(1); clf +h = pcolor(xx,yy,pres); set(h,'EdgeColor','none'); colorbar +colormap("parula"); +hold on +plot(chnkr,'k','LineWidth',2); axis equal + +figure(1) +u = reshape(uu(1,:,:),size(xx)); v = reshape(uu(2,:,:),size(xx)); +startt = linspace(pi-pi/12,pi+pi/12,20); +startr = 0.99*chnk.curves.bymode(startt,modes,[0;0]); +startx = startr(1,:); starty = startr(2,:); + +sl = streamline(xx,yy,u,v,startx,starty); +set(sl,'LineWidth',2,'Color','w') +% END STOKES VELOCITY PROBLEM +saveas(figure(1),"guide_stokesvelocity.png") diff --git a/chunkie/guide/guide_simplebvps_laplaceneumann.png b/chunkie/guide/guide_simplebvps_laplaceneumann.png index a2a8afd..22e1bc1 100644 Binary files a/chunkie/guide/guide_simplebvps_laplaceneumann.png and b/chunkie/guide/guide_simplebvps_laplaceneumann.png differ diff --git a/docs/Makefile b/docs/Makefile index bfded92..b260388 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -46,6 +46,7 @@ help: @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" @echo " coverage to run coverage check of the documentation (if enabled)" + @echo " refresh touch every rst file to trigger a recompile" .PHONY: clean clean: @@ -214,3 +215,8 @@ pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." + +.PHONY: refresh + +refresh: + find . -name "*.rst" -exec touch {} + diff --git a/docs/conf.py b/docs/conf.py index aa90e8e..6022d31 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -17,21 +17,17 @@ # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # -# import os -# import sys -# sys.path.insert(0, os.path.abspath('.')) - # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. # -# needs_sphinx = '1.0' +needs_sphinx = '1.6' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. -extensions = ['sphinx.ext.mathjax'] +extensions = ['sphinx.ext.mathjax', 'sphinx_math_dollar'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] @@ -46,9 +42,9 @@ master_doc = 'index' # General information about the project. -project = 'chunkie' -copyright = '2020, chunkie team' -author = 'chunkie team' +project = 'chunkIE' +copyright = '2024, chunkIE team' +author = 'chunkIE team' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the @@ -139,8 +135,8 @@ # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ - (master_doc, 'chunkie.tex', 'chunkie Documentation', - 'chunkie team', 'manual'), + (master_doc, 'chunkie.tex', 'chunkIE Documentation', + 'chunkIE team', 'manual'), ] @@ -149,7 +145,7 @@ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ - (master_doc, 'chunkie', 'chunkie Documentation', + (master_doc, 'chunkIE', 'chunkIE Documentation', [author], 1) ] @@ -160,8 +156,8 @@ # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ - (master_doc, 'chunkie', 'chunkie Documentation', - author, 'chunkie', 'One line description of project.', + (master_doc, 'chunkIE', 'chunkIE Documentation', + author, 'chunkIE', 'One line description of project.', 'Miscellaneous'), ] diff --git a/docs/getchunkie.rst b/docs/getchunkie.rst index 82d2c23..8fa6f5f 100644 --- a/docs/getchunkie.rst +++ b/docs/getchunkie.rst @@ -1,4 +1,4 @@ -Get Chunkie +Get chunkIE ============ Installation Instructions @@ -50,4 +50,4 @@ Troubleshooting sudo yum install make gcc gcc-c++ gcc-gfortran libgomp -- If installing without submodules, chunkie depends on `FLAM `_, and optionally on the `fmm2d `_ repository. Parts of the library will not function without FLAM and its subdirectories included in the matlab path. +- If installing without submodules, chunkIE depends on `FLAM `_, and optionally on the `fmm2d `_ repository. Parts of the library will not function without FLAM and its subdirectories included in the matlab path. diff --git a/docs/guide.rst b/docs/guide.rst index b24e3e2..d12985d 100644 --- a/docs/guide.rst +++ b/docs/guide.rst @@ -1,6 +1,9 @@ -Chunkie User Guide +chunkIE User Guide =================== +Apologies that this guide is still under construction. There +are examples for the most common uses. + Detailed documentation of all high-level functions and classes can be obtained by viewing the source file or by typing "help [function name]" in a MATLAB command window: @@ -16,6 +19,7 @@ typing "help [function name]" in a MATLAB command window: :caption: Contents: guide/chunkers + guide/kerns guide/simplebvps guide/largerproblems guide/chunkgraphs diff --git a/docs/guide/kerns.rst b/docs/guide/kerns.rst new file mode 100644 index 0000000..76e0ef7 --- /dev/null +++ b/docs/guide/kerns.rst @@ -0,0 +1,133 @@ +.. role:: matlab(code) + :language: matlab + +The Kernel Class +================== +The :matlab:`kernel` class provides a convenient way to specify integral +operators in classical potential theory. +The kernel object has several attributes including parameters required +to define the kernel, the type of singularity for determining the quadrature +to be used, function handles for evaluating the kernel, +and fast multipole method (FMM) acceleration routines if available. + +The constructor for the kernel objects take the form + +.. code:: matlab + + kernel('PDE name', 'kernel name', varargin) + + +The kernel class documentation lists the information that can be stored +in the object + +.. include:: ../../chunkie/@kernel/kernel.m + :literal: + :code: matlab + :start-after: classdef kernel + :end-before: % author + +The :matlab:`ptinfo` format +---------------------------- + + + +Built-in Kernels +--------------------- + +Chunkie includes built-in kernels that arise in the solution of the +following PDEs. + +- :ref:`lap` +- :ref:`helm` +- :ref:`stokes` +- :ref:`elasticity` + +Some common notation used below is that $x=(x_1,x_2)$ will refer to +a "target" location and $y=(y_1,y_2)$ will refer to a "source location. +Likewise, $n(x)$ refers to the curve normal at the target and $n(y)$ refers +to the normal at the source. The notation $|x-y|$ denotes the distance between +the source and target, i.e. + +.. math:: + + |x-y| = \sqrt{ (x_1-y_1)^2 + (x_2-y_2)^2 } \; . + + +.. _lap: + +Laplace kernels +~~~~~~~~~~~~~~~~ + +The free-space Green's function for Laplace's equation in two dimensions, +denoted by $G_{0}(x, y)$, is given by + +.. math:: + + G_{0}(x,y) = -\frac{1}{2\pi} \log |x-y| \,, + +where $x=(x_{1},x_{2})$, and $y=(y_{1},y_{2})$. + +The kernel $S(x,y)=G_0(x,y)$ +is the integral kernel for the single layer potential. The double layer kernel is +then $D(x,y) = n(y)\\cdot \\nabla_y G_0(x,y)$. All Laplace integral kernels are +derived from these two. + +For each of the single layer, double layer, +and combined layer (a linear combination of single and double layer), there +are also kernels for the normal derivative (with the name "prime"), tangential +derivative (with the name "tau"), and the gradient (with the name "grad") taken +at the target location. For a kernel $K(x,y)$, these are the kernels +$n(x)\\cdot \\nabla_xK(x,y)$, $\\tau(x)\\cdot \\nabla_x K(x,y)$, and +$\\nabla_x K(x,y)$, respectively. + +The PDE name for using Laplace kernels can be 'Laplace' or 'l'. These kernel +types can be obtained with either calling sequence below + +.. code:: matlab + + kern = kernel('l',type) + kern = kernel.lap2d(type) + +The documentation of the :matlab:`kernel.lap2d` function has details on any +expected additional arguments and default values: + +.. include:: ../../chunkie/@kernel/lap2d.m + :literal: + :code: matlab + :start-line: 1 + :end-before: % author + +.. _helm: + +Helmholtz kernels +~~~~~~~~~~~~~~~~~~~ + +.. _stokes: + +Stokes kernels +~~~~~~~~~~~~~~~~ + +.. _elasticity: + +Linear elasticity kernels +~~~~~~~~~~~~~~~~~~~~~~~~~~ + + +Defining your own kernel class object +-------------------------------------- + + + +Combining kernel objects +-------------------------- + + +Defining a matrix of kernel objects +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + +Adding and scaling kernel objects +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + + diff --git a/docs/guide/simplebvps.rst b/docs/guide/simplebvps.rst index c5d70fc..56d6bfc 100644 --- a/docs/guide/simplebvps.rst +++ b/docs/guide/simplebvps.rst @@ -228,13 +228,86 @@ can be solved with very little coding: .. image:: ../../chunkie/guide/guide_simplebvps_laplaceneumann.png :width: 500px - :alt: combined chunker + :alt: solution of Laplace equation :align: center A Helmholtz Scattering Problem ------------------------------- +In a scattering problem, an incident field $u^{\\textrm{inc}}$ is specified +in the exterior of an object and a scattered field $u^{\\textrm{scat}}$ is +determined so that the total field $u = u^{\\textrm{inc}}+u^{\\textrm{scat}}$ +satisfies the PDE and a given boundary condition. It is also required that +the scattered field radiates outward from the object. For a sound-soft object +in acoustic scattering, the total field is zero on the object boundary. +This results in the following boundary value problem for $u^{\\textrm{scat}}$ +in the exterior of the object: + +.. math:: + + \begin{align*} + (\Delta + k^2) u^{\textrm{scat}} &= 0 & \textrm{ in } \mathbb{R}^2 \setminus \Omega \; , \\ + u^{\textrm{scat}} &= -u^{\textrm{inc}} & \textrm{ on } \Gamma \; , \\ + \sqrt{|x|} \left( \frac{x}{|x|} \cdot \nabla u^{\textrm{scat}} - ik u^{\textrm{scat}} \right ) + &\to 0 & \textrm{ as } |x|\to \infty \; , + \end{align*} + +The Green function for the Helmholtz equation is + +.. math:: + + G_k (x,y) = \frac{i}{4} H_0^{(1)}( k|x-y|) \; . + +Analogous to the above, this Green function can be used to define +single and double layer potential operators + +.. math:: + + \begin{align*} + [S\sigma](x) &:= \int_\Gamma G_k(x,y) \sigma(y) ds(y) \\ + [D\sigma](x) &:= \int_\Gamma n(y)\cdot \nabla_y G_k(x,y) \sigma(y) ds(y) + \end{align*} + +A robust choice for the layer potential representation for this problem is +a *combined field* layer potential, which is a linear combination +of the single and double layer potentials: + +.. math:: + + u^{\textrm{scat}}(x) = [(D - ik S)\sigma](x) \; . + +Then, imposing the boundary conditions on this representation +results in the equation + +.. math:: + + \begin{align*} + -u^{\textrm{inc}}(x_0) &= \lim_{x\in \mathbb{R}^2\setminus \Omega, x\to x_0} [(D-ik S)\sigma](x) \\ + &= \frac{1}{2} \sigma(x_0) + [ (\mathcal{D} -ik \mathcal{S})\sigma ](x_0) + \end{align*} + +where we have used the exterior jump condition for the double layer potential. +As above, the integrals in the operators restricted to the boundary must sometimes +be interpreted in the principal value or Hadamard finite-part sense. +The above is a second kind integral equation and is invertible. + + +As before, this is relatively straightforward to implement in :matlab:`chunkie` +using the built-in kernels: + +.. include:: ../../chunkie/guide/guide_simplebvps.m + :literal: + :code: matlab + :start-after: % START BASIC SCATTERING + :end-before: % END BASIC SCATTERING + + +.. image:: ../../chunkie/guide/guide_simplebvps_basicscattering.png + :width: 500px + :alt: acoustic scattering around a peanut shape + :align: center + diff --git a/docs/index.rst b/docs/index.rst index ce8bbec..51a30ba 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,4 +1,4 @@ -.. chunkie documentation master file, created by +.. chunkIE documentation master file, created by sphinx-quickstart on Tue Apr 28 21:16:39 2020. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. @@ -6,7 +6,7 @@ .. role:: matlab(code) :language: matlab -chunkie +chunkIE ========== .. image:: assets/images/scatter_star_trim.png @@ -15,13 +15,13 @@ chunkie :align: center -chunkie is a MATLAB package for solving partial differential -equations in two dimensional domains. The name "chunkie" derives +chunkIE is a MATLAB package for solving partial differential +equations in two dimensional domains. The name "chunkIE" derives from the use of chunks (panels with scaled Legendre nodes) to discretize the domain boundary and the use of an integral equation method to solve the PDE. -With chunkie, you can solve the Helmholtz equation on an exterior +With chunkIE, you can solve the Helmholtz equation on an exterior domain in a few lines of MATLAB. The code below defines and solves a scattering problem, producing the image above: @@ -77,39 +77,39 @@ a scattering problem, producing the image above: Features -------- -- easy-to-use: most chunkie functionality only requires that +- easy-to-use: most chunkIE functionality only requires that you specify two things, the geometry (as a "chunker" object) and the integral kernel (as a "kernel" object). The distribution includes pre-defined kernels for the Laplace, Helmholtz, and Stokes PDEs and convenient tools for visualizing domains and plotting solutions. -- capable: chunkie uses high order accurate quadrature rules +- capable: chunkIE uses high order accurate quadrature rules and fast algorithms to provide accurate solutions with linear - scaling. The chunkie utilities can be used to solve singular + scaling. The chunkIE utilities can be used to solve singular problems on domains with corners and multiple material junctions with relative ease. - flexible: allows you to define your own integral kernels and use the quadrature routines in a modular fashion. -How to Get Chunkie +How to Get chunkIE ------------------- -- `Get chunkie `_ (includes installation instructions +- `Get chunkIE `_ (includes installation instructions and troubleshooting guide) - `Source Code `_ -Using Chunkie +Using chunkIE ---------------- -The `chunkie guide `_ -provides an overview of the chunkie approach to PDEs and a detailed -look at chunkie's capabilities. +The `chunkIE guide `_ +provides an overview of the chunkIE approach to PDEs and a detailed +look at chunkIE's capabilities. Gallery -------- -The `gallery `_ has examples of chunkie applications +The `gallery `_ has examples of chunkIE applications submitted by users. Contributing @@ -127,8 +127,8 @@ License ------- The project is licensed under a modified BSD 3-clause -license. - +license. See `repository `_ +for license details. diff --git a/docs/requirements.txt b/docs/requirements.txt index 483a4e9..4cf4ee2 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1 +1,2 @@ sphinx_rtd_theme +sphinx-math-dollar