Complete plot with current and charge density. Need to fix the animation

2026-10-29 13:40:11 +08:00 · 2015-11-15 13:53:46 -08:00
1 parent 6a744bab30
commit 592d27ecc5
@@ -2,31 +2,130 @@ import os

 home_dir = 'C:\Users\dominiquef.MIRAGEOSCIENCE\Documents\GIT\SimPEG\simpegdc\simpegDCIP\Dev'

-inpfile = 'MAG3Cfwr.inp'
-
 os.chdir(home_dir)

 #%%
-from SimPEG import np, Utils, Mesh
+from SimPEG import np, Utils, Mesh, mkvc, SolverLU
 import simpegDCIP as DC
 import pylab as plt
+#from ipywidgets import interact, IntSlider
+from matplotlib import animation
+from JSAnimation import HTMLWriter

 from readUBC_DC2DMesh import readUBC_DC2DMesh
 from readUBC_DC2DModel import readUBC_DC2DModel
 from readUBC_DC2DLoc import readUBC_DC2DLoc

+# Number of padding cells to remove from plotting
+padc = 16
+
 # Load UBC mesh 2D
-mesh = readUBC_DC2DMesh('mesh2d.txt')
+mesh = readUBC_DC2DMesh('mesh2d_fine.txt')

 # Load model
-model = readUBC_DC2DModel('model2d.con')
+model = readUBC_DC2DModel('model2d_fine.con')

 # load obs file
-[tx,rx] = readUBC_DC2DLoc('obs2d_East.loc')
+[txLoc,rxLoc,d,wd] = readUBC_DC2DLoc('obs2d_East.loc')

-#%% Plot model
-fig, axs = plt.subplots(1,1, figsize=(10,7))
-h1 = mesh.plotImage(model, ax = axs)
-plt.ylim([-1000,0])
-plt.xlim([0,2000])
+# Create SimPEG objects
+rx = DC.RxDipole(rxLoc[:,0], rxLoc[:,1])
+#tx = DC.SrcDipole([rx],txLoc[200,0],txLoc[200,1])

+# Create sub-mesh for plotting
+hx = mesh.hx
+hy = mesh.hy
+
+hx_sub = hx[padc:-padc]
+hy_sub = hy[padc:]
+mesh_sub = Mesh.TensorMesh([hx_sub,hy_sub],(hx_sub[0], -sum(hy_sub)))
+model_sub = model.reshape(mesh.nCy,mesh.nCx)
+model_sub = mkvc(model_sub[padc:,padc:-padc].T)
+
+xx = mesh_sub.vectorCCx
+yy = mesh_sub.vectorCCy
+
+#%% Solve
+txii = range(500,1500,200)
+jx_CC_sub = np.zeros((len(txii),mesh_sub.nCx,mesh_sub.nCy))
+jy_CC_sub = np.zeros((len(txii),mesh_sub.nCx,mesh_sub.nCy))
+
+
+#==============================================================================
+# line1, = mesh_sub.plotImage([], ax = axs)
+# line2, = axs.streamplot([], [], [], [],color='k')
+#==============================================================================
+
+
+
+#==============================================================================
+# def init():
+#     line1.set_data([])
+#     line2.set_data([], [], [], [])
+#     return line1, line2,
+# 
+# def animate(ii):
+#==============================================================================
+    
+    
+
+for ii in range(len(txii)):
+    
+    fig, axs = plt.subplots(1,1, figsize=(14,7))
+    
+    tx = DC.SrcDipole([rx],txii[ii],txii[ii])
+    
+    survey = DC.SurveyDC([tx])
+    problem = DC.ProblemDC_CC(mesh)
+    problem.pair(survey)
+    problem.Solver = SolverLU
+    
+    u1 = problem.fields(model)
+    
+    Msig1 = Utils.sdiag(1./(mesh.aveF2CC.T*(1./model)))
+    
+    j = Msig1*mesh.cellGrad*u1[tx, 'phi_sol']
+    j_CC = mesh.aveF2CCV*j
+    
+    # Compute charge density solving div*grad*phi
+    Q = mesh.faceDiv*mesh.cellGrad*u1[tx, 'phi_sol']
+    
+    jx_CC = j_CC[0:mesh.nC].reshape(mesh.nCy,mesh.nCx).T
+    jy_CC = j_CC[mesh.nC:].reshape(mesh.nCy,mesh.nCx).T
+    
+    #%% Grab only the core for presentation
+    jx_CC_sub[ii,:,:] = jx_CC[padc:-padc,padc:]
+    jy_CC_sub[ii,:,:] = jy_CC[padc:-padc,padc:]
+    Q_sub = Q.reshape(mesh.nCy,mesh.nCx)   
+    Q_sub = Q_sub[padc:,padc:-padc]
+    
+    J_rho = np.sqrt(jx_CC_sub[ii,:,:]**2 + jy_CC_sub[ii,:,:]**2)
+    lw = np.log10(J_rho/J_rho.min())
+    
+#==============================================================================
+#     line1.set_data(model_sub)
+#     line2.set_data(mesh_sub.vectorCCx, mesh_sub.vectorCCy, jx_CC_sub[2,:,:].T, jy_CC_sub[2,:,:].T)
+#==============================================================================
+    axs.imshow(Q_sub,alpha=0.75,extent = (xx[0],xx[-1],yy[-1],yy[0]),interpolation='nearest',vmin=-1e-2, vmax=1e-2)    
+    axs.imshow(np.log10(model_sub.reshape(mesh_sub.nCy,mesh_sub.nCx)),alpha=0.2,extent = (xx[0],xx[-1],yy[-1],yy[0]),interpolation='nearest',cmap='gray')     
+    axs.streamplot(mesh_sub.vectorCCx, mesh_sub.vectorCCy, jx_CC_sub[ii,:,:].T, jy_CC_sub[ii,:,:].T,color='k',linewidth = lw.T)
+    plt.ylim([-800,0])
+    plt.xlim([25,2000])
+    plt.show()
+
+#%% Create widget
+
+#def viewInv(msh,iteration):
+
+
+
+#, linewidth=lw.T
+#%%   
+#interact(viewInv,msh = mesh_sub, iteration = IntSlider(min=0, max=len(txii)-1 ,step=1, value=0))
+# set embed_frames=True to embed base64-encoded frames directly in the HTML
+#==============================================================================
+# anim = animation.FuncAnimation(fig, animate, init_func=init,
+#                                frames=100, interval=20, blit=True)
+#                                
+# anim.save('animation.html', writer=HTMLWriter(embed_frames=True))
+#==============================================================================
@@ -0,0 +1,92 @@
+from .html_writer import HTMLWriter
+from matplotlib.animation import Animation
+import matplotlib.pyplot as plt
+import tempfile
+import random
+import os
+
+
+__all__ = ['anim_to_html', 'display_animation']
+
+
+class _NameOnlyTemporaryFile(object):
+    """A context-managed temporary file which is not opened.
+
+    The file should be accessible by name on any system.
+
+    Parameters
+    ----------
+    suffix : string
+        The suffix of the temporary file (default = '')
+    prefix : string
+        The prefix of the temporary file (default = '_tmp_')
+    hash_length : string
+        The length of the random hash.  The size of the hash space will
+        be 16 ** hash_length (default=8)
+    seed : integer
+        the seed for the random number generator.  If not specified, the
+        system time will be used as a seed.
+    absolute : boolean
+        If true, return an absolute path to a temporary file in the current
+        working directory.
+
+    Example
+    -------
+
+    >>> with _NameOnlyTemporaryFile(seed=0, absolute=False) as f:
+    ...     print(f)
+    ...
+    _tmp_d82c07cd
+    >>> os.path.exists('_tmp_d82c07cd')  # file removed after context
+    False
+
+    """
+    def __init__(self, prefix='_tmp_', suffix='', hash_length=8,
+                 seed=None, absolute=True):
+        rng = random.Random(seed)
+        self.name = '%s%0*x%s' % (prefix, hash_length,
+                                  rng.getrandbits(4 * hash_length), suffix)
+        if absolute:
+            self.name = os.path.abspath(self.name)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        if os.path.exists(self.name):
+            os.remove(self.name)
+
+
+def anim_to_html(anim, fps=None, embed_frames=True, default_mode='loop'):
+    """Generate HTML representation of the animation"""
+    if fps is None and hasattr(anim, '_interval'):
+        # Convert interval in ms to frames per second
+        fps = 1000. / anim._interval
+
+    plt.close(anim._fig)
+    if hasattr(anim, "_html_representation"):
+        return anim._html_representation
+    else:
+        # tempfile can't be used here: we need a filename, and this
+        # fails on windows.  Instead, we use a custom filename generator
+        #with tempfile.NamedTemporaryFile(suffix='.html') as f:
+        with _NameOnlyTemporaryFile(suffix='.html') as f:
+            anim.save(f.name,  writer=HTMLWriter(fps=fps,
+                                                 embed_frames=embed_frames,
+                                                 default_mode=default_mode))
+            html = open(f.name).read()
+
+        anim._html_representation = html
+        return html
+
+
+def display_animation(anim, **kwargs):
+    """Display the animation with an IPython HTML object"""
+    from IPython.display import HTML
+    return HTML(anim_to_html(anim, **kwargs))
+
+
+# This is the magic that makes animations display automatically in the
+# IPython notebook.  The _repr_html_ method is a special method recognized
+# by IPython.
+Animation._repr_html_ = anim_to_html
@@ -0,0 +1 @@
+from .html_writer import HTMLWriter
@@ -0,0 +1,97 @@
+import numpy as np
+from matplotlib import pyplot as plt
+from matplotlib import animation
+from JSAnimation import IPython_display
+
+def basic_animation(frames=100, interval=30):
+    """Plot a basic sine wave with oscillating amplitude"""
+    fig = plt.figure()
+    ax = plt.axes(xlim=(0, 10), ylim=(-2, 2))
+    line, = ax.plot([], [], lw=2)
+
+    x = np.linspace(0, 10, 1000)
+
+    def init():
+        line.set_data([], [])
+        return line,
+
+    def animate(i):
+        y = np.cos(i * 0.02 * np.pi) * np.sin(x - i * 0.02 * np.pi)
+        line.set_data(x, y)
+        return line,
+
+    return animation.FuncAnimation(fig, animate, init_func=init,
+                                   frames=frames, interval=interval)
+
+
+def lorenz_animation(N_trajectories=20, rseed=1, frames=200, interval=30):
+    """Plot a 3D visualization of the dynamics of the Lorenz system"""
+    from scipy import integrate
+    from mpl_toolkits.mplot3d import Axes3D
+    from matplotlib.colors import cnames
+
+    def lorentz_deriv(coords, t0, sigma=10., beta=8./3, rho=28.0):
+        """Compute the time-derivative of a Lorentz system."""
+        x, y, z = coords
+        return [sigma * (y - x), x * (rho - z) - y, x * y - beta * z]
+
+    # Choose random starting points, uniformly distributed from -15 to 15
+    np.random.seed(rseed)
+    x0 = -15 + 30 * np.random.random((N_trajectories, 3))
+
+    # Solve for the trajectories
+    t = np.linspace(0, 2, 500)
+    x_t = np.asarray([integrate.odeint(lorentz_deriv, x0i, t)
+                      for x0i in x0])
+
+    # Set up figure & 3D axis for animation
+    fig = plt.figure()
+    ax = fig.add_axes([0, 0, 1, 1], projection='3d')
+    ax.axis('off')
+
+    # choose a different color for each trajectory
+    colors = plt.cm.jet(np.linspace(0, 1, N_trajectories))
+
+    # set up lines and points
+    lines = sum([ax.plot([], [], [], '-', c=c)
+                 for c in colors], [])
+    pts = sum([ax.plot([], [], [], 'o', c=c, ms=4)
+               for c in colors], [])
+
+    # prepare the axes limits
+    ax.set_xlim((-25, 25))
+    ax.set_ylim((-35, 35))
+    ax.set_zlim((5, 55))
+
+    # set point-of-view: specified by (altitude degrees, azimuth degrees)
+    ax.view_init(30, 0)
+
+    # initialization function: plot the background of each frame
+    def init():
+        for line, pt in zip(lines, pts):
+            line.set_data([], [])
+            line.set_3d_properties([])
+
+            pt.set_data([], [])
+            pt.set_3d_properties([])
+        return lines + pts
+
+    # animation function: called sequentially
+    def animate(i):
+        # we'll step two time-steps per frame.  This leads to nice results.
+        i = (2 * i) % x_t.shape[1]
+
+        for line, pt, xi in zip(lines, pts, x_t):
+            x, y, z = xi[:i + 1].T
+            line.set_data(x, y)
+            line.set_3d_properties(z)
+
+            pt.set_data(x[-1:], y[-1:])
+            pt.set_3d_properties(z[-1:])
+
+        ax.view_init(30, 0.3 * i)
+        fig.canvas.draw()
+        return lines + pts
+
+    return animation.FuncAnimation(fig, animate, init_func=init,
+                                   frames=frames, interval=interval)
@@ -0,0 +1,327 @@
+import os
+import sys
+import random
+import string
+import warnings
+if sys.version_info < (3, 0):
+    from cStringIO import StringIO as InMemory
+else:
+    from io import BytesIO as InMemory
+from matplotlib.animation import writers, FileMovieWriter
+from base64 import b64encode
+
+
+ICON_DIR = os.path.join(os.path.dirname(__file__), 'icons')
+
+
+class _Icons(object):
+    """This class is a container for base64 representations of the icons"""
+    icons = ['first', 'prev', 'reverse', 'pause', 'play', 'next', 'last']
+
+    def __init__(self, icon_dir=ICON_DIR, extension='png'):
+        self.icon_dir = icon_dir
+        self.extension = extension
+        for icon in self.icons:
+            setattr(self, icon,
+                    self._load_base64('{0}.{1}'.format(icon, extension)))
+
+    def _load_base64(self, filename):
+        data = open(os.path.join(self.icon_dir, filename), 'rb').read()
+        return 'data:image/{0};base64,{1}'.format(self.extension,
+                                                  b64encode(data).decode('ascii'))
+
+
+JS_INCLUDE = """
+<script language="javascript">
+  /* Define the Animation class */
+  function Animation(frames, img_id, slider_id, interval, loop_select_id){
+    this.img_id = img_id;
+    this.slider_id = slider_id;
+    this.loop_select_id = loop_select_id;
+    this.interval = interval;
+    this.current_frame = 0;
+    this.direction = 0;
+    this.timer = null;
+    this.frames = new Array(frames.length);
+
+    for (var i=0; i<frames.length; i++)
+    {
+     this.frames[i] = new Image();
+     this.frames[i].src = frames[i];
+    }
+    document.getElementById(this.slider_id).max = this.frames.length - 1;
+    this.set_frame(this.current_frame);
+  }
+
+  Animation.prototype.get_loop_state = function(){
+    var button_group = document[this.loop_select_id].state;
+    for (var i = 0; i < button_group.length; i++) {
+        var button = button_group[i];
+        if (button.checked) {
+            return button.value;
+        }
+    }
+    return undefined;
+  }
+
+  Animation.prototype.set_frame = function(frame){
+    this.current_frame = frame;
+    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;
+    document.getElementById(this.slider_id).value = this.current_frame;
+  }
+
+  Animation.prototype.next_frame = function()
+  {
+    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));
+  }
+
+  Animation.prototype.previous_frame = function()
+  {
+    this.set_frame(Math.max(0, this.current_frame - 1));
+  }
+
+  Animation.prototype.first_frame = function()
+  {
+    this.set_frame(0);
+  }
+
+  Animation.prototype.last_frame = function()
+  {
+    this.set_frame(this.frames.length - 1);
+  }
+
+  Animation.prototype.slower = function()
+  {
+    this.interval /= 0.7;
+    if(this.direction > 0){this.play_animation();}
+    else if(this.direction < 0){this.reverse_animation();}
+  }
+
+  Animation.prototype.faster = function()
+  {
+    this.interval *= 0.7;
+    if(this.direction > 0){this.play_animation();}
+    else if(this.direction < 0){this.reverse_animation();}
+  }
+
+  Animation.prototype.anim_step_forward = function()
+  {
+    this.current_frame += 1;
+    if(this.current_frame < this.frames.length){
+      this.set_frame(this.current_frame);
+    }else{
+      var loop_state = this.get_loop_state();
+      if(loop_state == "loop"){
+        this.first_frame();
+      }else if(loop_state == "reflect"){
+        this.last_frame();
+        this.reverse_animation();
+      }else{
+        this.pause_animation();
+        this.last_frame();
+      }
+    }
+  }
+
+  Animation.prototype.anim_step_reverse = function()
+  {
+    this.current_frame -= 1;
+    if(this.current_frame >= 0){
+      this.set_frame(this.current_frame);
+    }else{
+      var loop_state = this.get_loop_state();
+      if(loop_state == "loop"){
+        this.last_frame();
+      }else if(loop_state == "reflect"){
+        this.first_frame();
+        this.play_animation();
+      }else{
+        this.pause_animation();
+        this.first_frame();
+      }
+    }
+  }
+
+  Animation.prototype.pause_animation = function()
+  {
+    this.direction = 0;
+    if (this.timer){
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  Animation.prototype.play_animation = function()
+  {
+    this.pause_animation();
+    this.direction = 1;
+    var t = this;
+    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);
+  }
+
+  Animation.prototype.reverse_animation = function()
+  {
+    this.pause_animation();
+    this.direction = -1;
+    var t = this;
+    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);
+  }
+</script>
+"""
+
+
+DISPLAY_TEMPLATE = """
+<div class="animation" align="center">
+    <img id="_anim_img{id}">
+    <br>
+    <input id="_anim_slider{id}" type="range" style="width:350px" name="points" min="0" max="1" step="1" value="0" onchange="anim{id}.set_frame(parseInt(this.value));"></input>
+    <br>
+    <button onclick="anim{id}.slower()">&#8211;</button>
+    <button onclick="anim{id}.first_frame()"><img class="anim_icon" src="{icons.first}"></button>
+    <button onclick="anim{id}.previous_frame()"><img class="anim_icon" src="{icons.prev}"></button>
+    <button onclick="anim{id}.reverse_animation()"><img class="anim_icon" src="{icons.reverse}"></button>
+    <button onclick="anim{id}.pause_animation()"><img class="anim_icon" src="{icons.pause}"></button>
+    <button onclick="anim{id}.play_animation()"><img class="anim_icon" src="{icons.play}"></button>
+    <button onclick="anim{id}.next_frame()"><img class="anim_icon" src="{icons.next}"></button>
+    <button onclick="anim{id}.last_frame()"><img class="anim_icon" src="{icons.last}"></button>
+    <button onclick="anim{id}.faster()">+</button>
+  <form action="#n" name="_anim_loop_select{id}" class="anim_control">
+    <input type="radio" name="state" value="once" {once_checked}> Once </input>
+    <input type="radio" name="state" value="loop" {loop_checked}> Loop </input>
+    <input type="radio" name="state" value="reflect" {reflect_checked}> Reflect </input>
+  </form>
+</div>
+
+
+<script language="javascript">
+  /* Instantiate the Animation class. */
+  /* The IDs given should match those used in the template above. */
+  (function() {{
+    var img_id = "_anim_img{id}";
+    var slider_id = "_anim_slider{id}";
+    var loop_select_id = "_anim_loop_select{id}";
+    var frames = new Array({Nframes});
+    {fill_frames}
+
+    /* set a timeout to make sure all the above elements are created before
+       the object is initialized. */
+    setTimeout(function() {{
+        anim{id} = new Animation(frames, img_id, slider_id, {interval}, loop_select_id);
+    }}, 0);
+  }})()
+</script>
+"""
+
+INCLUDED_FRAMES = """
+  for (var i=0; i<{Nframes}; i++){{
+    frames[i] = "{frame_dir}/frame" + ("0000000" + i).slice(-7) + ".{frame_format}";
+  }}
+"""
+
+
+def _included_frames(frame_list, frame_format):
+    """frame_list should be a list of filenames"""
+    return INCLUDED_FRAMES.format(Nframes=len(frame_list),
+                                  frame_dir=os.path.dirname(frame_list[0]),
+                                  frame_format=frame_format)
+
+
+def _embedded_frames(frame_list, frame_format):
+    """frame_list should be a list of base64-encoded png files"""
+    template = '  frames[{0}] = "data:image/{1};base64,{2}"\n'
+    embedded = "\n"
+    for i, frame_data in enumerate(frame_list):
+        embedded += template.format(i, frame_format,
+                                    frame_data.replace('\n', '\\\n'))
+    return embedded
+
+
+@writers.register('html')
+class HTMLWriter(FileMovieWriter):
+    # we start the animation id count at a random number: this way, if two
+    # animations are meant to be included on one HTML page, there is a
+    # very small chance of conflict.
+    rng = random.Random()
+    exec_key = 'animation.ffmpeg_path'
+    args_key = 'animation.ffmpeg_args'
+    supported_formats = ['png', 'jpeg', 'tiff', 'svg']
+
+    @classmethod
+    def new_id(cls):
+        #return '%16x' % cls.rng.getrandbits(64)
+        return ''.join(cls.rng.choice(string.ascii_uppercase)
+                       for x in range(16))
+
+    def __init__(self, fps=30, codec=None, bitrate=None, extra_args=None,
+                 metadata=None, embed_frames=False, default_mode='loop'):
+        self.embed_frames = embed_frames
+        self.default_mode = default_mode.lower()
+
+        if self.default_mode not in ['loop', 'once', 'reflect']:
+            self.default_mode = 'loop'
+            warnings.warn("unrecognized default_mode: using 'loop'")
+
+        self._saved_frames = list()
+        super(HTMLWriter, self).__init__(fps, codec, bitrate,
+                                         extra_args, metadata)
+
+    def setup(self, fig, outfile, dpi, frame_dir=None):
+        if os.path.splitext(outfile)[-1] not in ['.html', '.htm']:
+            raise ValueError("outfile must be *.htm or *.html")
+
+        if not self.embed_frames:
+            if frame_dir is None:
+                frame_dir = outfile.rstrip('.html') + '_frames'
+            if not os.path.exists(frame_dir):
+                os.makedirs(frame_dir)
+            frame_prefix = os.path.join(frame_dir, 'frame')
+        else:
+            frame_prefix = None
+
+        super(HTMLWriter, self).setup(fig, outfile, dpi,
+                                      frame_prefix, clear_temp=False)
+
+    def grab_frame(self, **savefig_kwargs):
+        if self.embed_frames:
+            suffix = '.' + self.frame_format
+            f = InMemory()
+            self.fig.savefig(f, format=self.frame_format,
+                             dpi=self.dpi, **savefig_kwargs)
+            f.seek(0)
+            self._saved_frames.append(b64encode(f.read()).decode('ascii'))
+        else:
+            return super(HTMLWriter, self).grab_frame(**savefig_kwargs)
+
+    def _run(self):
+        # make a ducktyped subprocess standin
+        # this is called by the MovieWriter base class, but not used here.
+        class ProcessStandin(object):
+            returncode = 0
+            def communicate(self):
+                return ('', '')
+        self._proc = ProcessStandin()
+
+        # save the frames to an html file
+        if self.embed_frames:
+            fill_frames = _embedded_frames(self._saved_frames,
+                                           self.frame_format)
+        else:
+            # temp names is filled by FileMovieWriter
+            fill_frames = _included_frames(self._temp_names,
+                                           self.frame_format)
+
+        mode_dict = dict(once_checked='',
+                         loop_checked='',
+                         reflect_checked='')
+        mode_dict[self.default_mode + '_checked'] = 'checked'
+
+        interval = int(1000. / self.fps)
+
+        with open(self.outfile, 'w') as of:
+            of.write(JS_INCLUDE)
+            of.write(DISPLAY_TEMPLATE.format(id=self.new_id(),
+                                             Nframes=len(self._temp_names),
+                                             fill_frames=fill_frames,
+                                             interval=interval,
+                                             icons=_Icons(),
+                                             **mode_dict))
@@ -0,0 +1,185 @@
+
+<script language="javascript">
+  /* Define the Animation class */
+  function Animation(frames, img_id, slider_id, interval, loop_select_id){
+    this.img_id = img_id;
+    this.slider_id = slider_id;
+    this.loop_select_id = loop_select_id;
+    this.interval = interval;
+    this.current_frame = 0;
+    this.direction = 0;
+    this.timer = null;
+    this.frames = new Array(frames.length);
+
+    for (var i=0; i<frames.length; i++)
+    {
+     this.frames[i] = new Image();
+     this.frames[i].src = frames[i];
+    }
+    document.getElementById(this.slider_id).max = this.frames.length - 1;
+    this.set_frame(this.current_frame);
+  }
+
+  Animation.prototype.get_loop_state = function(){
+    var button_group = document[this.loop_select_id].state;
+    for (var i = 0; i < button_group.length; i++) {
+        var button = button_group[i];
+        if (button.checked) {
+            return button.value;
+        }
+    }
+    return undefined;
+  }
+
+  Animation.prototype.set_frame = function(frame){
+    this.current_frame = frame;
+    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;
+    document.getElementById(this.slider_id).value = this.current_frame;
+  }
+
+  Animation.prototype.next_frame = function()
+  {
+    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));
+  }
+
+  Animation.prototype.previous_frame = function()
+  {
+    this.set_frame(Math.max(0, this.current_frame - 1));
+  }
+
+  Animation.prototype.first_frame = function()
+  {
+    this.set_frame(0);
+  }
+
+  Animation.prototype.last_frame = function()
+  {
+    this.set_frame(this.frames.length - 1);
+  }
+
+  Animation.prototype.slower = function()
+  {
+    this.interval /= 0.7;
+    if(this.direction > 0){this.play_animation();}
+    else if(this.direction < 0){this.reverse_animation();}
+  }
+
+  Animation.prototype.faster = function()
+  {
+    this.interval *= 0.7;
+    if(this.direction > 0){this.play_animation();}
+    else if(this.direction < 0){this.reverse_animation();}
+  }
+
+  Animation.prototype.anim_step_forward = function()
+  {
+    this.current_frame += 1;
+    if(this.current_frame < this.frames.length){
+      this.set_frame(this.current_frame);
+    }else{
+      var loop_state = this.get_loop_state();
+      if(loop_state == "loop"){
+        this.first_frame();
+      }else if(loop_state == "reflect"){
+        this.last_frame();
+        this.reverse_animation();
+      }else{
+        this.pause_animation();
+        this.last_frame();
+      }
+    }
+  }
+
+  Animation.prototype.anim_step_reverse = function()
+  {
+    this.current_frame -= 1;
+    if(this.current_frame >= 0){
+      this.set_frame(this.current_frame);
+    }else{
+      var loop_state = this.get_loop_state();
+      if(loop_state == "loop"){
+        this.last_frame();
+      }else if(loop_state == "reflect"){
+        this.first_frame();
+        this.play_animation();
+      }else{
+        this.pause_animation();
+        this.first_frame();
+      }
+    }
+  }
+
+  Animation.prototype.pause_animation = function()
+  {
+    this.direction = 0;
+    if (this.timer){
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  Animation.prototype.play_animation = function()
+  {
+    this.pause_animation();
+    this.direction = 1;
+    var t = this;
+    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);
+  }
+
+  Animation.prototype.reverse_animation = function()
+  {
+    this.pause_animation();
+    this.direction = -1;
+    var t = this;
+    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);
+  }
+</script>
+
+<div class="animation" align="center">
+    <img id="_anim_imgVVVYOGEGZTDOEBZX">
+    <br>
+    <input id="_anim_sliderVVVYOGEGZTDOEBZX" type="range" style="width:350px" name="points" min="0" max="1" step="1" value="0" onchange="animVVVYOGEGZTDOEBZX.set_frame(parseInt(this.value));"></input>
+    <br>
+    <button onclick="animVVVYOGEGZTDOEBZX.slower()">&#8211;</button>
+    <button onclick="animVVVYOGEGZTDOEBZX.first_frame()"><img class="anim_icon" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAQAAAAngNWGAAAAAXNSR0IArs4c6QAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3QURCAgaeZk4EQAAASlJREFUKM/dkj9LQnEUhp9zr3bpj1uBcKGiJWxzLWivKAIRjIhcCqcgqJbKRagPICiVSVEuNTu0tLYGUg4tkRGUdxLJ0u79Ndxr5FfwTO/L+xzO4XCgO+v2T70AFU+/A/Dhmlzg6Pr0DKAMwOH4zQxAAbAkv2xNeF2RoQUVc1ytgttXUbWVdN1dOPE8pz4j4APQsdFtKA0WY6vpKjqvVciHnvZTS6Ja4HgggJLs7MHxl9nCh8NYcO+iGG0agiaC4h9oa6Vsw2yiK+QHSZT934YoEQABNBcTNDszsrhm1m1B+bFS86PT6QFppx6oeSaeOwlMXRp1h4aK13Y2kuHhUo9ykPboPvFjeEvsrhTMt3ylHyB0r8KZyYdCrbfj4OveoHMANjuyx+76rV+/blxKMZUnLgAAAABJRU5ErkJggg=="></button>
+    <button onclick="animVVVYOGEGZTDOEBZX.previous_frame()"><img class="anim_icon" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAQAAAAngNWGAAAAAXNSR0IArs4c6QAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3QURCAgyTCyQ6wAAANRJREFUKM9jYBjO4AiUfgzFGGAp4+yayUvX6jMwMDCsYmBgOCS4OAOrSYmMgcc8/pd5Q3irC+Neh/1AlmeBMVgZmP8yMLD8/c/cqv9r90whzv/MX7Eq/MfAwMDIwCuZdfSV8U8WDgZGRmYGrAoZGRgY/jO8b3sj/J2F6T8j4z80pzEhmIwMjAxsSbqqlkeZGP//Z8SlkJnhPwMjwx/Guoe1NhmRwk+YGH5jV8jOwMPHzcDBysAwh8FrxQwtPU99HrwBXsnAwMDAsJiBgYGBoZ1xmKYqALHhMpn1o7igAAAAAElFTkSuQmCC"></button>
+    <button onclick="animVVVYOGEGZTDOEBZX.reverse_animation()"><img class="anim_icon" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAQAAAAngNWGAAAAAXNSR0IArs4c6QAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3QURCAgmVvZElgAAAVFJREFUKM+t0k8ow3EYx/H3s/2aLDUSZctFkgsHEi1XLi5ukpPSWsuJklwclsPSsDKFi7MSJ0I5qF2GHO2m0FY7+BdNv7Y9DpuxDSt5vsfvq+fT9/k+8D8VBxIAWH6H0ead4Qb5BRwCENoceZi5Stl/6BgCBmtWhjzxg4mUQ02rAhil7JgB9tze7aTLxFAKsUUd14B9ZzCyFUk401gQyQJaDNcBHwv7t7ETd0ZVQFEEzcNCdE/1wtj15imGWlEB8qkf2QaAWjbG/bPSamIDyX65/iwDIFx7tWjUvWCoSo5oGbYATN7PORt7W9IZEQXJH8ohuN7C0VVX91KNqYhq4a1lEGJI0j892tazXCWQRUpwAbYDcHczPxXuajq3mbnhfANz5eOJxsuNvs7+jud0UcuyL3QAkuEMx4rnIvBYq1JhEwPAUb3fG7x8tVdc292/7Po7f2VqA+Yz7ZwAAAAASUVORK5CYII="></button>
+    <button onclick="animVVVYOGEGZTDOEBZX.pause_animation()"><img class="anim_icon" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAQAAAAngNWGAAAAAXNSR0IArs4c6QAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3QURCAkR91DQ2AAAAKtJREFUKM9jYCANTEVib2K4jcRbzQihGWEC00JuNjN8Z2Q0Zo3VYWA4lL005venH9+c3ZK5IfIsMIXMBtc12Bj+MMgxMDAwMPzWe2TBzPCf4SLcZCYY4/9/RgZGBiaYFf8gljFhKiQERhUOeoX/Gf8y/GX4y/APmlj+Mfxj+MfwH64Qnnq0zr9fyfLrPzP3eQYGBobvk5x4GX4xMIij23gdib0cRWYHiVmAAQDK5ircshCbHQAAAABJRU5ErkJggg=="></button>
+    <button onclick="animVVVYOGEGZTDOEBZX.play_animation()"><img class="anim_icon" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAQAAAAngNWGAAAAAXNSR0IArs4c6QAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3QURCAkEmo00MwAAAS9JREFUKM+tkj1IQmEUhp9j94LQj0FD4RRBLdLQ3ftb26PRcCiQIIiIDFwKC0OhaAiam5wVDBpqCKohQojMLYzaAiUatOtpuQrKVQl64fu+4Xt4OLwc+Fs+nNM16jsPAWS6gZXggoZfXmfhog3hcZ6aTXF87Sp68OmH4/YggAo8bmfyyeh6Z1AAKPVldyO1+Iz2uILq3AriJSe3l+H7aj+cuRnrTsVDxSxay+VYbMDnCtZxxQOU9G4nlU9E1HQBxRkCQMRGRnIbpxMARkvxCIoAorYMMrq0mJ0qu4COUW3xyVDqJC4P+86P0ewDQbQqgevhlc2C8ETApXAEFLzvwa3EXG9BoIE1GQUbv1h7k4fTXxBu6cKgUbX5M3ZzNC+a7rQ936HV56SlRpcle+Mf8wvgJ16zo/4BtQAAAABJRU5ErkJggg=="></button>
+    <button onclick="animVVVYOGEGZTDOEBZX.next_frame()"><img class="anim_icon" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAQAAAAngNWGAAAAAXNSR0IArs4c6QAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3QURCAkd/uac8wAAAMhJREFUKM9jYBie4DEUQ8B+fEq3+3UrMzAwMFxjYGBgYJizYubaOUxYFUaXh/6vWfRfEMIL/+//P5gZJoei4/f/7wxnY1PeNUXdE2RgYGZgYoCrY2BBVsjKwMDAwvCS4f3SG/dXxm5gYESSQ1HIwvCPgZmB8f8Pxv+Kxxb/YfiPJIdi9T8GJgaG/38ZFd4Fx0xUYsZt4h8GBgb2D2bLy7KnMTAwMEIxFoVCXIYr1IoDnkF4XAysqNIwUMDAwMDAsADKS2NkGL4AAIARMlfNIfZMAAAAAElFTkSuQmCC"></button>
+    <button onclick="animVVVYOGEGZTDOEBZX.last_frame()"><img class="anim_icon" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAQAAAAngNWGAAAAAXNSR0IArs4c6QAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3QURCAknOOpFQQAAAS9JREFUKM/dkrEvQ3EQxz/33mtoQxiYpANbLU26NAabSCcSUouGBVNDjYQaOiDpIEiKjURIw2Kx04hEYmkHEpGoJpSISaXq9Wd4P03/ht5y98197/u9XA4aK4rAWw3lgWddZ3S+/G9mEovtAB8AHE4pgTQAx8PbJweRmsq6GimmNpxaNYXVzMNNCI6A2figimwCGACK786zuWgh3qcsKf/w0pM4X0m/doNVFVzVGlEQsdRj193VxEWpH0RsdRu+zi3tVMqCAsDShoiYqiSV4OouVDFEqS9Pbiyg7vV62lpQ2BJ4Gg0meg0MbNpkYG/e+540NNFyrE1a8qHk5BaAjfnrzUaHfAWImVrLIXbgnx4/9X06s35cweWsVACa3a24PVp0X+rPv1aHFnSONdiL8Qci0lzwpOM5sQAAAABJRU5ErkJggg=="></button>
+    <button onclick="animVVVYOGEGZTDOEBZX.faster()">+</button>
+  <form action="#n" name="_anim_loop_selectVVVYOGEGZTDOEBZX" class="anim_control">
+    <input type="radio" name="state" value="once" > Once </input>
+    <input type="radio" name="state" value="loop" checked> Loop </input>
+    <input type="radio" name="state" value="reflect" > Reflect </input>
+  </form>
+</div>
+
+
+<script language="javascript">
+  /* Instantiate the Animation class. */
+  /* The IDs given should match those used in the template above. */
+  (function() {
+    var img_id = "_anim_imgVVVYOGEGZTDOEBZX";
+    var slider_id = "_anim_sliderVVVYOGEGZTDOEBZX";
+    var loop_select_id = "_anim_loop_selectVVVYOGEGZTDOEBZX";
+    var frames = new Array(0);
+    
+  frames[0] = "data:image/png;base64,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 truncated
+  frames[1] = "data:image/png;base64,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 truncated
+  frames[2] = "data:image/png;base64,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 truncated
+  frames[3] = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABXgAAAK8CAYAAABV1dcbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzs3X+0HVWV6Pt5Eo75QQhiaEgICK3XaBQ1ieHHBbrTkR9RHD243YNgiITrBcK40LwxABVCbrfjddsgEhQGzeBnE6OBiDz7Nb6hPJV0n8iNIGKb+JCGxvYXvxIREDCYHE7IeX/EU6mTU7XXmnPNVftU8v2MwWCn9qq11q5dtap2nTVn9QwODg4KAAAAAAAAAKB1xnS7AwAAAAAAAAAAG27wAgAAAAAAAEBLcYMXAAAAAAAAAFqKG7wAAAAAAAAA0FLc4AUAAAAAAACAluIGLwAAAAAAAAC0FDd4AQAAAAAAAKCluMELAAAAAAAAAC3FDV4AAAAAAAAAaClu8AIAAAAAAABAS3GDFwAAAAAAAABaihu8AAAAAAAAANBS3OAFAAAAAAAAgJbiBi8AAAAAAAAAtBQ3eAEAAAAAAACgpbjBCwAAAAAAAAAtxQ1eAAAAAAAAAGgpbvACAAAAAAAAQEtxgxcAAAAAAAAAWoobvAAAAAAAAADQUtzgBQAAAAAAAICW4gYvAAAAAAAAALQUN3gBAAAAAAAAoKW4wQsAAAAAAAAALcUNXgAAAAAAAABoKW7wAgAAAAAAAEBLcYMXAAAAAAAAAFqKG7wAAAAAAAAA0FLc4AUAAAAAAACAluIGLwAAAAAAAAC0FDd4AQAAAAAAAKCluMELAAAAAAAAAC3FDV4AAAAAAAAAaClu8AIAAAAAAABAS3GDFwAAAAAAAABaihu8AAAAAAAAANBS3OAFAAAAAAAAgJbiBi8AAAAAAAAAtBQ3eAEAAAAAAACgpbjBCwAAAAAAAAAtxQ1eAAAAAAAAAGgpbvACAAAAAAAAQEtxgxcAAAAAAAAAWoobvAAAAAAAAADQUtzgBQAAAAAAAICW4gYvAAAAAAAAALQUN3gBAAAAAAAAoKW4wQsAAAAAAAAALcUNXgAAAAAAAABoKW7wAgAAAAAAAEBLcYMXAAAAAAAAAFqKG7wAAAAAAAAA0FLc4AUAAAAAAACAluIGLwAAAAAAAAC0FDd4AQAAAAAAAKCluMELAAAAAAAAAC3FDV4AAAAAAAAAaClu8AIAAAAAAABAS3GDFwAAAAAAAABaihu8AAAAAAAAANBS3OAFAAAAAAAAgJbiBi8AAAAAAAAAtBQ3eAEAAAAAAACgpbjBCwAAAAAAAAAtxQ1eAAAAAAAAAGgpbvACAAAAAAAAQEtxgxcAAAAAAAAAWoobvAAAAAAAAADQUtzgBQAAAAAAAICW4gYvAAAAAAAAALQUN3gBAAAAAAAAoKW4wQsAAAAAAAAALcUNXgAAAAAAAABoKW7wAgAAAAAAAEBLcYMXAAAAAAAAAFqKG7wAAAAAAAAA0FLc4AUAAAAAAACAluIGLwAAAAAAAAC0FDd4AQAAAAAAAKCluMELAAAAAAAAAC3FDV4AAAAAAAAAaClu8AIAAAAAAABAS3GDFwAAAAAAAABaihu8AAAAAAAAANBS3OAFAAAAAAAAgJbiBi8AAAAAAAAAtBQ3eAEAAAAAAACgpbjBCwAAAAAAAAAtxQ1eAAAAAAAAAGgpbvACAAAAAAAAQEtxgxcAAAAAAAAAWoobvAAAAAAAAADQUtzgBQAAAAAAAICW4gYvAAAAAAAAALQUN3gBAAAAAAAAoKW4wQsAAAAAAAAALcUNXgAAAAAAAABoKW7wAgAAAAAAAEBLcYMXAAAAAAAAAFqKG7wAAAAAAAAA0FLc4AUAAAAAAACAluIGLwAAAAAAAAC0FDd4AQAAAAAAAKCluMELAAAAAAAAAC3FDV4AAAAAAAAAaClu8AIAAAAAAABAS3GDFwAAAAAAAABaihu8AAAAAAAAANBS3OAFAAAAAAAAgJbiBi8AAAAAAAAAtBQ3eAEAAAAAAACgpbjBCwAAAAAAAAAtxQ1eAAAAAAAAAGgpbvACAAAAAAAAQEtxgxcAAAAAAAAAWoobvAAAAAAAAADQUtzgBQAAAAAAAICW4gYvAAAAAAAAALQUN3gBAAAAAAAAoKW4wQsAAAAAAAAALcUNXgAAAAAAAABoKW7wYlTo7++Xyy+/XA455BCZOHGiHHvssbJ27dpudwsAAAAAAAAY1bjBi1Hh4x//uFx33XWyZMkSueGGG2Ts2LFy6qmnyve+971udw0AAAAAAAAYtXoGBwcHu90J7N1+8IMfyLHHHivXXnutXHrppSKyc0bvkUceKQcddBA3eQEAAAAAAIAazOBF133ta1+TffbZR84///xi2bhx4+Tcc8+Vhx56SJ599tku9g4AAAAAAAAYvbjBi67bsGGDzJgxQyZNmjRs+VFHHSUiIhs3buxGtwAAAAAAAIBRjxu86LpNmzbJtGnTRiwfWvbcc8813SUAAAAAAACgFbjBi67bunWrjBs3bsTy8ePHF+8DAAAAAAAAGGmfbncAmDBhgvT3949Yvm3btuL93b3wwgvy7W9/W4444ojK9wEAAAAAANpo69at8stf/lIWLFggBx54YLe7gxbgBi+6btq0aZVpGDZt2iQiIocccsiI97797W/LWWedlb1vAAAAAAAA3XDnnXfKxz72sW53Ay3ADV503ezZs2XdunXyu9/9Tvbbb79i+cMPPywiIrNmzRqxzhFHHCEiIkvvPEemzdyZq/cNGVu8P1beKF6Xl1e9XzZUtu59DU27lno96vLsQ2j7d+uz1/WryT7U9acsVF/q5/DeDrHteWyn2DruvuQeWXTdGW59CPXNuh+Wdeu7tNYR+uxV9X7z/OpLjQ/dNjiibMx2yj0OaMaynvO/VVnH9ts+MqJseTtUffZcfdfsezHn0X3O/+aI9YY+b0obVer67rV+XR27jyW5ac6pofc9x/rQ/pTrWir3Z4hpo4k+pK6neb8s9Xtp4pyaa/tPki0j3t8q1ZGAL8lbRix7i7wU3W55HGn6GiyHbl1HerfXrXEt5Jt3/GXl8o+c+38Paz9nH3Jp8rvsZr05fvNuenyTrDzr9uLeBxDCDV503emnny7XXnut3HbbbfKJT3xCRET6+/vli1/8ohx77LEyffr0EesMpWWYNnOaHD7ncBHhBm+TuMHLDd7Y9pr8gT9h/wnFeODRh1DfuMEbV+9++/VWlj18zo4RZdt2g3dM6Y+SZQN/2A/LZcvboeqz5+q79w3e3orPPFA67qxtVOnWDd7dx5LcuMEbbteKG7wj7c03ePeXV0a8v0UmVa43QQ4asewgqR7zK9cvjSNtvjk3hBu8eX9/7fetOZXLD5/zb8Paz9mHXEbbjdhc9ea8j0BKSsTiBi+67uijj5aFCxfKFVdcIc8//7y8/e1vly996Uvy1FNPyRe/+MWO674hY4ODqeWi1/Mmg/UmaF3Z0fBDpGq5dft73gDQ9Mvah1w35Cz7saa90B89ymU8vh/NRXOn9bVibujErufxXXiu73nhaK3D9r1OrFk+ciZVTL8sY4J13/McWxf3db6pGzPmpI4TuX4U5v4DlbUNa1uD0mM63jzHuybOFZp+dXt7aOvVbKeqsrm3Y0wb1j7musHe5E2lbt1k8zDUR8044vGHr9zbpOk/QFl/J4Xet45rnr+vmlgvti7P3wflMtaxyrqPWIX62+Q+AnjgBi9GhS9/+cvyN3/zN7J69Wr57W9/K+9///vlG9/4hpxwwgnd7hoAAAAAAAAwanGDF6PCuHHj5JprrpFrrrmm210BAAAAAAAAWoMbvGi1nQka9OEQ1rQKljo0YUptya+kCVfRhAOFwmo98yB5hmda00RUlcmVziE1LK68XPO9NxHOO7TeUWce22h7mvQf1vCzJvOAeYTFVS6fWnpY1eaflcr+a3TfyroVom5Zr+78kZpGpU4olNM6VuVKKxI6P4TGsrr1NGGfVWWPPfOojp/Zuw+heq19sNQV2gdi2rXsp9Z9JBSG7XENFvperOknLKmBrNtf89msfQxt01B/rWH9lnGkU9860Zwn68aR1GsAj2swy/4fCmEv04y9mvVivjPN2Jt67Mf0vep9C+s1gud5x5qmoIntr+lDVVlrahrruBd7LTua7wdgdBrT7Q4AAODh6DOP6XYXAOwBjjnz6G53AUDLMY4AAJrGDV4AAAAAAAAAaClSNKDVdiZo8H9CbUp/YllD+WPrsvLeNtZQ70404aQxUvtgZQ3hsqRzqFuW4/spr9dkW7u3l1pvqD1rOFfufdO6njUktq6t1fN7//BqVbFsSd9Achs5xnpruGPor+RNhOd7hGanhhHXsRwLqWlJyuvFpMiwvO8RQhpqLzSma0KvQ23FrB8Kew4J1RuzT4fKVrXnnWrBM+S+ah3NWNREaoiqMprvKqYPVaHI1nQBVQ6Ql4vXY0plX5QpHdvSsIZpW9qwXu950hzPdSznK+/0CaEweE1Ifd16qTyP/TLPFCXWNCmx75fLpI63det5nCs0+0in9VPqAJjBCwAAAAAAAAAtxQxetNrO+btxf9FrYnZg6syyXLMIPMqWef5VMddfKzUPWbD0JaavsQn0tX2wzCLwnMXn3cdQX6wz0nL/9buJz6apq6qMZpaf58NEtHVo3k89rqrKaraT9XsPLfeeadit2fsamnHCMqZbj7XQd+F97qw6BkOzJD36kHtGmke0TepYpWkr1K5HvZrZjtbvStOHXOt7bjPLdUj5/R2l+Uw7KuY21Y8TO6LLVvE4r6SOL57Xax7HhPW3Wur4rpkZHFpPcz3n+bvOo49lntsp9boo5rtMvV5I7Y/H2Ot5PQHUYQYvAAAAAAAAALQUN3gBAAAAAAAAoKVI0YA9Rq6E53Vt5HhwgTWkqYlUC6khNRrWEK7UNB0x9cbWVccj9MiyD3inibCUDdVhDf3KFcqvCb0L1esZnhzDM/Suqo6qkPHd2+i0fkofLOLine truncated
+  frames[4] = "data:image/png;base64,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 truncated
+  frames[5] = "data:image/png;base64,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 truncated
+  frames[6] = "data:image/png;base64,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 truncated
+  frames[7] = "data:image/png;base64,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 truncated
+
+
+    /* set a timeout to make sure all the above elements are created before
+       the object is initialized. */
+    setTimeout(function() {
+        animVVVYOGEGZTDOEBZX = new Animation(frames, img_id, slider_id, 33, loop_select_id);
+    }, 0);
+  })()
+</script>
@@ -0,0 +1,54 @@
+35
+-4349.9 -2908.3 1
+    -1947.17 1
+    -1306.45 1
+    -879.30 1
+    -594.53 1
+    -404.69 1
+    -278.13 1
+    -193.75 1
+    -137.50 1
+    -100.00 1
+    -75.00 1
+    -55.00 1
+    -30.00 1
+    -20 1
+    -12.5 1
+    -5 1
+    0 1
+    2000.00 400
+    2005 1
+    2012.5 1
+    2020 1
+    2030 1
+    2055 1
+    2075.00 1
+    2100.00 1
+    2137.50 1
+    2193.75 1
+    2278.13 1
+    2404.69 1
+    2594.53 1
+    2879.30 1
+    3306.45 1
+    3947.17 1
+    4908.25 1
+    6349.88 1
+
+16
+0.00 975.00 195
+    980 1
+    987.5 1
+    1000 1
+    1015 1
+    1035 1
+    1060 1
+    1095 1
+    1145 1
+    1215 1
+    1315 1
+    1455 1
+    1655 1
+    1930 1
+    2315 1
+    2850 1
@@ -0,0 +1,57 @@
+def readUBC_DC2DLoc(fileName):
+
+    from SimPEG import np
+    """
+        Read UBC GIF 2D observation file and generate arrays for tx-rx location
+
+        Input:
+        :param fileName, path to the UBC GIF 2D model file
+
+        Output:
+        :param rx, tx
+        :return
+        
+        Created on Thu Nov 12 13:14:10 2015
+
+        @author: dominiquef
+
+    """
+    
+    # Open fileand skip header... assume that we know the mesh already
+#==============================================================================
+#     fopen = open(fileName,'r')
+#     lines = fopen.readlines()
+#     fopen.close()
+#==============================================================================
+
+    # Load file
+    obsfile = np.genfromtxt(fileName,delimiter=' \n',dtype=np.str,comments='!')
+    
+    # Check first line and figure out if 2D or 3D file format
+    line = np.array(obsfile[0].split(),dtype=float)   
+    
+    tx_A  = []
+    tx_B  = []
+    rx_M  = []
+    rx_N  = []
+    d   = []
+    wd  = []
+    
+    for ii in range(obsfile.shape[0]):
+        
+        # If len==3, then simple format where tx-rx is listed on each line
+        if len(line) == 4:
+        
+            temp = np.fromstring(obsfile[ii], dtype=float,sep=' ')
+            tx_A = np.hstack((tx_A,temp[0]))
+            tx_B = np.hstack((tx_B,temp[1]))
+            rx_M = np.hstack((rx_M,temp[2]))
+            rx_N = np.hstack((rx_N,temp[3]))
+            
+        
+    rx = np.transpose(np.array((rx_M,rx_N)))    
+    tx = np.transpose(np.array((tx_A,tx_B)))
+    
+    return tx, rx, d, wd
+
+