Website build

Author: colinjcotter

.buildinfo

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: d90650463c76001ce4fae7e2e1c30cc0
+config: 082ecbcbbeeaf13a176965b05301a940
 tags: 645f666f9bcd5a90fca523b33c5a78b7

1_quadrature.html

@@ -185,14 +185,14 @@ <h2><span class="section-number">1.3. </span>Reference elements<a class="headerl
 </section>
 <section id="python-implementations-of-reference-elements">
 <h2><span class="section-number">1.4. </span>Python implementations of reference elements<a class="headerlink" href="#python-implementations-of-reference-elements" title="Permalink to this headline">¶</a></h2>
-<p>The <a class="reference internal" href="fe_utils.html#fe_utils.reference_elements.ReferenceCell" title="fe_utils.reference_elements.ReferenceCell"><code class="xref py py-class docutils literal notranslate"><span class="pre">ReferenceCell</span></code></a> class provides
+<p>The <code class="xref py py-class docutils literal notranslate"><span class="pre">ReferenceCell</span></code> class provides
 Python objects encoding the geometry and topology of the reference
 cell. At this stage, the relevant information is the dimension of the
 reference cell and the list of vertices. The topology will become
 important when we consider <a class="reference internal" href="3_meshes.html"><span class="doc">meshes</span></a>. The reference cells we will
 require for this course are the
-<a class="reference internal" href="fe_utils.html#fe_utils.reference_elements.ReferenceInterval" title="fe_utils.reference_elements.ReferenceInterval"><code class="xref py py-data docutils literal notranslate"><span class="pre">ReferenceInterval</span></code></a> and
-<a class="reference internal" href="fe_utils.html#fe_utils.reference_elements.ReferenceTriangle" title="fe_utils.reference_elements.ReferenceTriangle"><code class="xref py py-data docutils literal notranslate"><span class="pre">ReferenceTriangle</span></code></a>.</p>
+<code class="xref py py-data docutils literal notranslate"><span class="pre">ReferenceInterval</span></code> and
+<code class="xref py py-data docutils literal notranslate"><span class="pre">ReferenceTriangle</span></code>.</p>
 </section>
 <section id="quadrature-rules-on-reference-elements">
 <h2><span class="section-number">1.5. </span>Quadrature rules on reference elements<a class="headerlink" href="#quadrature-rules-on-reference-elements" title="Permalink to this headline">¶</a></h2>
@@ -297,11 +297,11 @@ <h2><span class="section-number">1.8. </span>Implementing quadrature rules in Py
 allowfullscreen></iframe></div>
 <p class="card-text">Imperial students can also <a class="reference external" href="https://imperial.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=e5f1084f-c163-46d3-b317-ac9f00c1c772">watch this video on Panopto</a></p>
 </div>
-</details><p>The <a class="reference internal" href="fe_utils.html#module-fe_utils.quadrature" title="fe_utils.quadrature"><code class="xref py py-mod docutils literal notranslate"><span class="pre">fe_utils.quadrature</span></code></a> module provides the
-<a class="reference internal" href="fe_utils.html#fe_utils.quadrature.QuadratureRule" title="fe_utils.quadrature.QuadratureRule"><code class="xref py py-class docutils literal notranslate"><span class="pre">QuadratureRule</span></code></a> class which records
+</details><p>The <code class="xref py py-mod docutils literal notranslate"><span class="pre">fe_utils.quadrature</span></code> module provides the
+<code class="xref py py-class docutils literal notranslate"><span class="pre">QuadratureRule</span></code> class which records
 quadrature points and weights for a given
-<a class="reference internal" href="fe_utils.html#fe_utils.reference_elements.ReferenceCell" title="fe_utils.reference_elements.ReferenceCell"><code class="xref py py-class docutils literal notranslate"><span class="pre">ReferenceCell</span></code></a>. The
-<a class="reference internal" href="fe_utils.html#fe_utils.quadrature.gauss_quadrature" title="fe_utils.quadrature.gauss_quadrature"><code class="xref py py-func docutils literal notranslate"><span class="pre">gauss_quadrature()</span></code></a> function creates
+<code class="xref py py-class docutils literal notranslate"><span class="pre">ReferenceCell</span></code>. The
+<code class="xref py py-func docutils literal notranslate"><span class="pre">gauss_quadrature()</span></code> function creates
 quadrature rules for a prescribed degree of precision and reference
 cell.</p>
 <div class="proof proof-type-exercise" id="id3">
@@ -310,7 +310,7 @@ <h2><span class="section-number">1.8. </span>Implementing quadrature rules in Py
         <span class="proof-type">Exercise 1.16</span>
 
     </div><div class="proof-content">
-<p>The <a class="reference internal" href="fe_utils.html#fe_utils.quadrature.QuadratureRule.integrate" title="fe_utils.quadrature.QuadratureRule.integrate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">integrate()</span></code></a> method is
+<p>The <code class="xref py py-meth docutils literal notranslate"><span class="pre">integrate()</span></code> method is
 left unimplemented. Using <a class="reference internal" href="#equation-quadrature">(1.4)</a>, implement this method.</p>
 <p>A test script for your method is provided in the <code class="docutils literal notranslate"><span class="pre">test</span></code> directory
 as <code class="docutils literal notranslate"><span class="pre">test_01_integrate.py</span></code>. Run this script to test your code:</p>
@@ -322,7 +322,7 @@ <h2><span class="section-number">1.8. </span>Implementing quadrature rules in Py
 </div></div><div class="admonition hint">
 <p class="admonition-title">Hint</p>
 <p>You can implement
-<a class="reference internal" href="fe_utils.html#fe_utils.quadrature.QuadratureRule.integrate" title="fe_utils.quadrature.QuadratureRule.integrate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">integrate()</span></code></a> in one line
+<code class="xref py py-meth docutils literal notranslate"><span class="pre">integrate()</span></code> in one line
 using a <a class="reference external" href="https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions">list
 comprehension</a> and <a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.dot.html#numpy.dot" title="(in NumPy v1.24)"><code class="xref py py-func docutils literal notranslate"><span class="pre">numpy.dot()</span></code></a>.</p>
 </div>
@@ -355,7 +355,7 @@ <h2><span class="section-number">1.8. </span>Implementing quadrature rules in Py
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2014-2021, David A. Ham and Colin J. Cotter.
-      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 4.4.0.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 4.5.0.
     </div>
   </body>
 </html>

2_finite_elements.html

@@ -243,7 +243,7 @@ <h2><span class="section-number">2.3. </span>The Lagrange element nodes<a class=
 
     </div><div class="proof-content">
 <p>Use <a class="reference internal" href="#equation-lattice">(2.6)</a> to implement
-<a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.lagrange_points" title="fe_utils.finite_elements.lagrange_points"><code class="xref py py-func docutils literal notranslate"><span class="pre">lagrange_points()</span></code></a>. Make sure your
+<code class="xref py py-func docutils literal notranslate"><span class="pre">lagrange_points()</span></code>. Make sure your
 algorithm also works for one-dimensional elements. Some basic tests
 for your code are to be found in
 <code class="docutils literal notranslate"><span class="pre">test/test_02_lagrange_points.py</span></code>. You can also test your lagrange
@@ -311,7 +311,7 @@ <h2><span class="section-number">2.3. </span>The Lagrange element nodes<a class=
 
     </div><div class="proof-content">
 <p>Use <a class="reference internal" href="#equation-vandermonde">(2.7)</a> to implement
-<a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.vandermonde_matrix" title="fe_utils.finite_elements.vandermonde_matrix"><code class="xref py py-func docutils literal notranslate"><span class="pre">vandermonde_matrix()</span></code></a>. Think
+<code class="xref py py-func docutils literal notranslate"><span class="pre">vandermonde_matrix()</span></code>. Think
 carefully about how to loop over each row to construct the correct
 powers of <span class="math notranslate nohighlight">\(x\)</span> and <span class="math notranslate nohighlight">\(y\)</span>. For the purposes of this exercise you should
 ignore the <code class="docutils literal notranslate"><span class="pre">grad</span></code> argument.</p>
@@ -340,7 +340,7 @@ <h2><span class="section-number">2.5. </span>Implementing finite elements in Pyt
 </details><p>The <a class="reference internal" href="#def-ciarlet"><span class="std std-ref">Ciarlet triple</span></a> <span class="math notranslate nohighlight">\((K, P, N)\)</span> also provides a
 good abstraction for the implementation of software objects
 corresponding to finite elements. In our case <span class="math notranslate nohighlight">\(K\)</span> will be a
-<a class="reference internal" href="fe_utils.html#fe_utils.reference_elements.ReferenceCell" title="fe_utils.reference_elements.ReferenceCell"><code class="xref py py-class docutils literal notranslate"><span class="pre">ReferenceCell</span></code></a>. In this course we
+<code class="xref py py-class docutils literal notranslate"><span class="pre">ReferenceCell</span></code>. In this course we
 will only implement finite element spaces consisting of complete
 polynomial spaces so we will specify <span class="math notranslate nohighlight">\(P\)</span> by providing the maximum
 degree of the polynomials in the space. Since we will only deal with
@@ -353,7 +353,7 @@ <h2><span class="section-number">2.5. </span>Implementing finite elements in Pyt
 
     </div><div class="proof-content">
 <p>Implement the rest of the
-<a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.FiniteElement" title="fe_utils.finite_elements.FiniteElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">FiniteElement</span></code></a> <code class="xref py py-meth docutils literal notranslate"><span class="pre">__init__()</span></code>
+<code class="xref py py-class docutils literal notranslate"><span class="pre">FiniteElement</span></code> <code class="xref py py-meth docutils literal notranslate"><span class="pre">__init__()</span></code>
 method. You should construct a Vandermonde matrix for the nodes and
 invert it to create the basis function coefs. Store these as
 <code class="docutils literal notranslate"><span class="pre">self.basis_coefs</span></code>.</p>
@@ -380,12 +380,12 @@ <h2><span class="section-number">2.6. </span>Implementing the Lagrange Elements<
 allowfullscreen></iframe></div>
 <p class="card-text">Imperial students can also <a class="reference external" href="https://imperial.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=d78e85a7-fa59-433c-ac4c-ac9f00e02668">watch this video on Panopto</a></p>
 </div>
-</details><p>The <a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.FiniteElement" title="fe_utils.finite_elements.FiniteElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">FiniteElement</span></code></a> class implements
+</details><p>The <code class="xref py py-class docutils literal notranslate"><span class="pre">FiniteElement</span></code> class implements
 a general finite element object assuming we have provided the cell,
 polynomial, degree and nodes. The
-<a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.LagrangeElement" title="fe_utils.finite_elements.LagrangeElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">LagrangeElement</span></code></a> class is a
+<code class="xref py py-class docutils literal notranslate"><span class="pre">LagrangeElement</span></code> class is a
 <a class="reference external" href="https://docs.python.org/3/tutorial/classes.html#inheritance">subclass</a> of
-<a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.FiniteElement" title="fe_utils.finite_elements.FiniteElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">FiniteElement</span></code></a> which will implement
+<code class="xref py py-class docutils literal notranslate"><span class="pre">FiniteElement</span></code> which will implement
 the particular case of the equispaced Lagrange elements.</p>
 <div class="proof proof-type-exercise" id="id10">
 <span id="ex-lagrange-element"></span>
@@ -394,12 +394,12 @@ <h2><span class="section-number">2.6. </span>Implementing the Lagrange Elements<
 
     </div><div class="proof-content">
 <p>Implement the <code class="xref py py-meth docutils literal notranslate"><span class="pre">__init__()</span></code> method of
-<a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.LagrangeElement" title="fe_utils.finite_elements.LagrangeElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">LagrangeElement</span></code></a>. Use
-<a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.lagrange_points" title="fe_utils.finite_elements.lagrange_points"><code class="xref py py-func docutils literal notranslate"><span class="pre">lagrange_points()</span></code></a> to obtain the
+<code class="xref py py-class docutils literal notranslate"><span class="pre">LagrangeElement</span></code>. Use
+<code class="xref py py-func docutils literal notranslate"><span class="pre">lagrange_points()</span></code> to obtain the
 nodes. For the purpose of this exercise, you may ignore the
 <code class="docutils literal notranslate"><span class="pre">entity_nodes</span></code> argument.</p>
 <p><strong>After</strong> you have implemented
-<a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.FiniteElement.tabulate" title="fe_utils.finite_elements.FiniteElement.tabulate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">tabulate()</span></code></a> in the
+<code class="xref py py-meth docutils literal notranslate"><span class="pre">tabulate()</span></code> in the
 next exercise, you can use
 <code class="docutils literal notranslate"><span class="pre">plot_lagrange_basis_functions</span></code> to visualise your
 Lagrange basis functions.</p>
@@ -441,7 +441,7 @@ <h2><span class="section-number">2.7. </span>Tabulating basis functions<a class=
         <span class="proof-type">Exercise 2.49</span>
 
     </div><div class="proof-content">
-<p>Implement <a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.FiniteElement.tabulate" title="fe_utils.finite_elements.FiniteElement.tabulate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">tabulate()</span></code></a>.
+<p>Implement <code class="xref py py-meth docutils literal notranslate"><span class="pre">tabulate()</span></code>.
 You can use a Vandermonde matrix to evaluate the polynomial terms
 and take the matrix product of this with the basis function
 coefficients. The method should have at most two executable
@@ -492,7 +492,7 @@ <h2><span class="section-number">2.8. </span>Gradients of basis functions<a clas
         <span class="proof-type">Exercise 2.50</span>
 
     </div><div class="proof-content">
-<p>Extend <a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.vandermonde_matrix" title="fe_utils.finite_elements.vandermonde_matrix"><code class="xref py py-meth docutils literal notranslate"><span class="pre">vandermonde_matrix()</span></code></a> so that
+<p>Extend <code class="xref py py-meth docutils literal notranslate"><span class="pre">vandermonde_matrix()</span></code> so that
 setting <code class="docutils literal notranslate"><span class="pre">grad</span></code> to <code class="docutils literal notranslate"><span class="pre">True</span></code> produces a rank 3 generalised
 Vandermonde tensor whose indices represent points, monomial basis function,
 and gradient component respectively. That is:</p>
@@ -523,11 +523,11 @@ <h2><span class="section-number">2.8. </span>Gradients of basis functions<a clas
         <span class="proof-type">Exercise 2.51</span>
 
     </div><div class="proof-content">
-<p>Extend <a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.FiniteElement.tabulate" title="fe_utils.finite_elements.FiniteElement.tabulate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">tabulate()</span></code></a> to
+<p>Extend <code class="xref py py-meth docutils literal notranslate"><span class="pre">tabulate()</span></code> to
 pass the <code class="docutils literal notranslate"><span class="pre">grad</span></code> argument through to
-<a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.vandermonde_matrix" title="fe_utils.finite_elements.vandermonde_matrix"><code class="xref py py-meth docutils literal notranslate"><span class="pre">vandermonde_matrix()</span></code></a>. Then
+<code class="xref py py-meth docutils literal notranslate"><span class="pre">vandermonde_matrix()</span></code>. Then
 generalise the matrix product in
-<a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.FiniteElement.tabulate" title="fe_utils.finite_elements.FiniteElement.tabulate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">tabulate()</span></code></a> so that
+<code class="xref py py-meth docutils literal notranslate"><span class="pre">tabulate()</span></code> so that
 the result of this function (when <code class="docutils literal notranslate"><span class="pre">grad</span></code> is true) is a rank 3
 tensor:</p>
 <div class="math notranslate nohighlight" id="equation-2-finite-elements-8">
@@ -594,7 +594,7 @@ <h2><span class="section-number">2.9. </span>Interpolating functions to the fini
         <span class="proof-type">Exercise 2.52</span>
 
     </div><div class="proof-content">
-<p>Implement <a class="reference internal" href="fe_utils.html#fe_utils.finite_elements.FiniteElement.interpolate" title="fe_utils.finite_elements.FiniteElement.interpolate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">interpolate()</span></code></a>.</p>
+<p>Implement <code class="xref py py-meth docutils literal notranslate"><span class="pre">interpolate()</span></code>.</p>
 </div></div><p>Once you have done this, you can use the script provided to plot
 functions of your choice interpolated onto any of the finite
 elements you can make:</p>
@@ -628,7 +628,7 @@ <h2><span class="section-number">2.9. </span>Interpolating functions to the fini
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2014-2021, David A. Ham and Colin J. Cotter.
-      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 4.4.0.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 4.5.0.
     </div>
   </body>
 </html>