davidshepherd7

;; Just use the transformation from the example then pull out the velocity from the tuple.
(define (velocity-transform coordinate-transform)
  (compose (lambda (tuple) (velocity tuple)) (F->C coordinate-transform)))

;; ;; Or explicitly using Gamma-bar this is:
;; (define (velocity-transform coordinate-transform)
;;   (define (f-bar q-prime)
;;     (define q (compose coordinate-transform (Gamma q-prime)))
;;     (Gamma q))
;;   (compose (lambda (x) (velocity x)) (Gamma-bar f-bar))) 

davidshepherd7

(define (q t) (abs (- t 5))

davidshepherd7

#!/usr/bin/env python


import subprocess as subp
from multiprocessing import Pool
import itertools
import sys
import numbers
import argparse

davidshepherd7

# Changes to defaults for "make"
# ============================================================
# How many cores do we have? Find out from /proc/cpuinfo (using regexp matching
# the start of info for a new processor).
NCORES=`grep --count '^processor[[:space:]]*:' /proc/cpuinfo`

# Apparently make runs fastest with one more job than there are cores.
NJOBS=$(($NCORES + 1))
export MAKEFLAGS="-j$NJOBS"

davidshepherd7

 /// \short Indexed output function to print a matrix to the stream outfile
 /// as i,j,a(i,j) for a(i,j)!=0 only with a specified precision.
 void sparse_indexed_output(std::ostream &outfile,
                            const unsigned &precision,
                            const bool& output_bottom_right_entry_regardless=false) const
  {
   // Note: we might have to specify "output_bottom_right_entry_regardless"
   // as well (can't be a default). C++ can silently convert between
   // unsigned and bool, so having a default set for
   // output_bottom_right_entry_regardless would give the same function

davidshepherd7

def emr_step(dt_n, y_n, dy_n, dt_nm1, y_nm1):
    """Take a single step of the explicit midpoint rule.
    From G&S pg. 715 and Prinja's thesis pg.45.
    """
    dtr = dt_n / dt_nm1
    y_np1 = (1 - dtr**2)*y_n + (1 + dtr)*dt_n*dy_n + (dtr**2)*(y_nm1)
    return y_np1

def bdf2_dydt(ts, ys):
    """Get dy/dt at time ts[-1] (allowing for varying dt).

davidshepherd7

double Problem::
adaptive_unsteady_newton_solve(const double &dt_desired,
                               const double &epsilon,
                               const bool &shift_values)
{
 //First, we need to backup the existing dofs, in case the timestep is
 //rejected

 //Find total number of dofs on current processor
 unsigned n_dof_local = dof_distribution_pt()->nrow_local();

davidshepherd7

(defun true1 () t)
(setq function-list (list #'true1))
(cons 'or function-list)
(eval (cons 'or function-list))

davidshepherd7

(defun dwim-entire-line (function)
  (if (region-active-p)
       (funcall function (region-beginning) (region-end))
     ;; else
     (funcall function (point-at-bol) (point-at-beginning-of-next-line))))

(global-set-key (kbd "M-;") (lambda () (interactive)
  (dwim-entire-line 'comment-or-uncomment-region)))

davidshepherd7

\newcommand{\scalemath}[2]{\scalebox{#1}{\begin{math} {#2} \end{math}}}
\newcommand{\Aprime}{\scalemath{0.5}{\begin{matrix} \Amm & \Abound \\ \zm & -\Idm \end{matrix}}}
\newcommand{\Gprime}{\scalemath{0.5}{\begin{matrix} \zm & \zm \\ \zm & \bm \end{matrix}}}
\newcommand{\Qprime}{\scalemath{0.5}{\begin{matrix} \Qm \\ \zm \end{matrix}}}

Combining the above with the Jacobian matrix as derived in \cref{sec:llg-magn-coupl}, the complete Jacobian is
\begin{equation}
  \Jm =
  \scalemath{2}{