diff --git a/model_code_inputs/.github/ISSUE_TEMPLATE/bug_report.md b/model_code_inputs/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000..b770fa2
--- /dev/null
+++ b/model_code_inputs/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,23 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Environment**
+The provided Dockerfile or other, e.g. baremental install, HPC
diff --git a/model_code_inputs/.gitkeep b/model_code_inputs/.gitkeep
deleted file mode 100644
index 8b13789..0000000
--- a/model_code_inputs/.gitkeep
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/model_code_inputs/BP5-FD_imcompressible.py b/model_code_inputs/BP5-FD_imcompressible.py
new file mode 100644
index 0000000..e6de3fd
--- /dev/null
+++ b/model_code_inputs/BP5-FD_imcompressible.py
@@ -0,0 +1,896 @@
+# %%
+# coding: utf-8
+import underworld as uw
+from underworld import function as fn
+
+import numpy as np
+import math
+import os,csv
+import mpi4py
+import random
+comm = mpi4py.MPI.COMM_WORLD
+
+from underworld.scaling import units as u
+from underworld.scaling import non_dimensionalise as nd
+
+
+
+inputPath = os.path.join(os.path.abspath("."),"BENCHMARK_JGR_3D_128_64_64_dtvep2_Pre1BC1_FixedVStressD3_D1ms_Max50yr_0T1s_shearSameHalf_NoAdv/")
+outputPath = inputPath
+if uw.mpi.rank==0:
+    print (uw.__version__)
+    if not os.path.exists(outputPath):
+        os.makedirs(outputPath)
+uw.mpi.barrier
+
+if uw.mpi.rank==0:
+    if not os.path.exists(inputPath):
+        os.makedirs(inputPath)
+uw.mpi.barrier
+# continue running from specific time step
+LoadFromFile = False
+Elasticity = True
+meshdeform= False
+
+scaling_coefficients = uw.scaling.get_coefficients()
+
+# Define scale criteria
+tempMin = 273.*u.degK 
+tempMax = (500.+ 273.)*u.degK
+bodyforce = 3300 * u.kilogram / u.metre**3 * 9.8 * u.meter / u.second**2
+velocity = 4e10*u.centimeter/u.year
+
+KL = 100e3*u.meter
+Kt = KL/velocity
+KT = tempMax 
+KM = bodyforce * KL**2 * Kt**2
+K  = 1.*u.mole
+lengthScale = 100e3
+
+scaling_coefficients["[length]"] = KL
+scaling_coefficients["[time]"] = Kt
+scaling_coefficients["[mass]"]= KM
+scaling_coefficients["[temperature]"] = KT
+scaling_coefficients["[substance]"] = K
+
+gravity = nd(9.81 * u.meter / u.second**2)
+R = nd(8.3144621 * u.joule / u.mole / u.degK)
+
+# use low resolution if running in serial
+xRes = 128
+yRes = 64
+zRes = 64
+dim  = 3
+
+minX = nd(   -48.* u.kilometer)
+maxX = nd( 48. * u.kilometer)
+minY = nd(  -50. * u.kilometer)
+maxY = nd( 50. * u.kilometer)
+minZ = nd(   -40. * u.kilometer)
+maxZ = nd( 0. * u.kilometer)
+stickyAirthick = nd(0. * u.kilometer)
+stressNormalFn = nd(25e6*u.pascal)
+
+H = nd(18*u.kilometer)
+V0 = nd(1e-6*u.meter/u.second) # nd(4e-9*u.meter/u.second) # 
+
+# Rate-and-state properties
+miu0 = 0.6
+
+L = nd(0.14*u.meter) 
+# L = nd(0.01*u.meter) 
+mu = nd(3.2e10*u.pascal) # elastic modulus
+cs = nd(3464*u.meter/u.second)   #shear wave velocity
+a_max = 0.04 #0.015 # 
+a0 = 0.004 #0.003 #
+b = 0.03 #0.009 #  
+
+theta_rock = nd(1e16*u.year) # nd(102000.*u.year) #
+
+pre_f  = 1.
+BC_f = 1.
+
+V_plate = nd(1e-9*u.meter/u.second)
+shearVelocity = 0.5*V_plate #/np.pi*np.arctan(maxX/H)   #2*nd(6.3*u.centimeter/u.year)
+
+thickUpCrust = nd(15. * u.kilometer)
+BDLayer = nd(0. * u.kilometer)
+
+stickyAirIndex        = 0
+crustSouthIndex       = 1
+crustNorthUpIndex     = 2
+crustNorthLowIndex    = 3
+crustValleyUpIndex    = 4
+crustValleyLowIndex   = 5
+mantleIndex           = 6
+mantleWeekIndex       = 7
+crustWeekIndex        = 8
+fault                 = 9
+
+if(LoadFromFile == True):
+    step = 3000
+    step_out = 100
+    nsteps = 10000
+    timestep = float(np.load(inputPath+"time"+str(step).zfill(4)+".npy"))
+    dt_e = fn.misc.constant(float(np.load(outputPath+"dt"+str(step).zfill(4)+".npy"))) #fn.misc.constant(nd(0.02*u.second)) #
+    Eqk = True
+else:
+    step = 0
+    step_out = 100
+    nsteps = 10000
+    timestep = 0. 
+    dt_e    = fn.misc.constant(nd(1.*u.second)) #fn.misc.constant(nd(0.02*u.year)) 
+    Eqk = True
+    # %%
+
+dt_min= nd(1e-5*u.second)
+dt_max = nd(50.*u.year)
+
+
+mesh = uw.mesh.FeMesh_Cartesian( elementType = ("Q1/dQ0"),
+                                 elementRes  = (xRes, yRes, zRes), 
+                                 minCoord    = (minX, minY, minZ), 
+                                 maxCoord    = (maxX, maxY, maxZ),
+                                 periodic    = [False, True, False]) 
+
+# function to define refined mesh in the fault zone if needed
+# not used in the example shown in this ms, but can be implemented easily
+
+def mesh_Uni(section,minX,maxX,res,x1,x2,factor,mi):
+    # section: mesh to be refined and return
+    # res: segments numbers, same as resX(Y/Z)
+    # x1: startpoint of the area to be refined
+    # x2: endpoint of the area to be refine (x2>x1)
+    # factor: the ratio of the finest area over the average of the section (maxX-minX)/resX
+    # mi: power of two ending segments; mi>1 is required 
+    section_cp = np.copy(section)
+    Uni_all = (maxX-minX)/res
+    spacing_Refine = Uni_all*factor 
+    N_refine = ((x2-x1)/spacing_Refine)
+    
+    midPoint = (x1+x2)/2
+    ratio = 0.5#(x1-minX)/(maxX-x2+x1-minX)
+    startPoint1 =  midPoint-Uni_all*N_refine*ratio
+    startPoint2 =  midPoint+Uni_all*N_refine*(1-ratio)
+    
+    
+#     print (spacing_Refine,N_refine,startPoint1, startPoint2)
+    
+#     startPoint2-startPoint1)
+
+    for index in range(len(section)):
+        
+        
+        if section_cp[index]<=startPoint2 and section_cp[index]>=startPoint1:
+            section[index] = x1 + (section_cp[index]-startPoint1)/Uni_all*spacing_Refine
+            if section[index]>x2:
+                section[index] = x2
+                
+        if  section_cp[index]<startPoint1:
+            section[index] = x1 + (minX-x1)*((section_cp[index]-startPoint1)/(minX-startPoint1))**mi
+
+        if section_cp[index]>startPoint2:        
+            section[index] = x2 + (maxX-x2)*((section_cp[index]-startPoint2)/(maxX-startPoint2))**mi
+            
+    return section
+
+
+dx = (maxX-minX)/xRes
+dy = (maxY-minY)/yRes
+dz = (maxZ-minZ)/zRes
+
+interface_z = 0.
+mesh.reset()
+if (meshdeform == True):
+    with mesh.deform_mesh():
+         mesh_Uni(mesh.data[:,0],minX,maxX,xRes,-nd(1000*u.meter),nd(1000*u.meter),0.2,1.2);
+
+    dx_min = (maxX-minX)/xRes*0.2
+    
+else:
+    dx_min = dx
+
+velocityField   = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=dim )
+pressureField   = uw.mesh.MeshVariable( mesh=mesh.subMesh, nodeDofCount=1 )
+pressureField0   = uw.mesh.MeshVariable( mesh=mesh.subMesh, nodeDofCount=1 )
+stressField    = uw.mesh.MeshVariable( mesh=mesh, nodeDofCount=3 )
+
+maskMesh    = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=1 )
+temperatureField    = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=1 )
+temperatureDotField = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=1 )
+temperatureFieldCopy    = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=1 )
+
+stressField.data[:] = [0.,0.,0.]
+velocityField.data[:] = [0.,0.,0.]
+pressureField.data[:] = 0.
+pressureField0.data[:] = 0.
+
+
+    
+# send boundary condition information to underworld
+iWalls = mesh.specialSets["MinI_VertexSet"] + mesh.specialSets["MaxI_VertexSet"]
+jWalls = mesh.specialSets["MinJ_VertexSet"] + mesh.specialSets["MaxJ_VertexSet"]
+kWalls = mesh.specialSets["MinK_VertexSet"] + mesh.specialSets["MaxK_VertexSet"]
+base    = mesh.specialSets["MinK_VertexSet"]
+back    = mesh.specialSets["MaxJ_VertexSet"]
+top    = mesh.specialSets["MaxK_VertexSet"]
+left   = mesh.specialSets["MinI_VertexSet"]
+right   = mesh.specialSets["MaxI_VertexSet"]
+baseFix = mesh.specialSets['Empty']
+leftFix = mesh.specialSets['Empty']
+rightFix = mesh.specialSets['Empty']
+
+velocityField.data[:] = 0.
+
+# set "easier" intial velocity for the solver to solve
+
+x = fn.input()[0]
+conditionVMesh = [(True,-shearVelocity+(x-minX)*2.*shearVelocity/(maxX-minX))]
+velocityField.data[:,1] = fn.branching.conditional(conditionVMesh).evaluate(mesh)[:,0]
+
+
+    
+for index in mesh.specialSets["MaxI_VertexSet"]:
+    velocityField.data[index] = [0.,shearVelocity,0.] 
+    
+for index in mesh.specialSets["MinI_VertexSet"]:
+    velocityField.data[index] = [0.,-shearVelocity,0.]
+
+
+half_width = pre_f*dx_min
+BC_half_width = BC_f*dx_min
+
+for index in mesh.specialSets["MinK_VertexSet"]:
+    #if mesh.data[index][0]<-BC_half_width:
+    if mesh.data[index][0]<0.:
+        velocityField.data[index][1] = -shearVelocity #+ (mesh.data[index][0]-minX)*2.*shearVelocity/(maxX-minX)
+    #elif mesh.data[index][0]>=-BC_half_width and mesh.data[index][0]<=BC_half_width:
+    elif mesh.data[index][0]>=0. and mesh.data[index][0]<=BC_half_width:
+        # velocityField.data[index][1] = -shearVelocity + (mesh.data[index][0]+BC_half_width)*shearVelocity/BC_half_width
+        velocityField.data[index][1] = -shearVelocity + (mesh.data[index][0])*shearVelocity/BC_half_width
+    else:
+        velocityField.data[index][1] = shearVelocity
+        
+freeslipBC = uw.conditions.DirichletCondition( variable        = velocityField,
+                                               indexSetsPerDof = (iWalls,iWalls+base,kWalls) )    
+    
+    
+swarm = uw.swarm.Swarm( mesh=mesh,particleEscape=True )
+pop_control = uw.swarm.PopulationControl(swarm,aggressive=True,particlesPerCell=125)
+surfaceSwarm = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+surfaceSwarm2 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+faultSwarm = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+previousVm =  swarm.add_variable( dataType="double", count=3 )
+previousVm2 =  swarm.add_variable( dataType="double", count=3 )
+
+velA  =  swarm.add_variable( dataType="double", count=3 )
+vel_eff  =  swarm.add_variable( dataType="double", count=3 )
+
+materialVariable   = swarm.add_variable( dataType="int", count=1 )
+
+markSwarm1 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+markSwarm2 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+markSwarm3 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+markSwarm4 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+
+plasticStrain  = swarm.add_variable( dataType="double",  count=1 )
+plasticStrain0 = swarm.add_variable( dataType="double",  count=1 )
+
+
+
+cohesionStrength  = swarm.add_variable( dataType="double",  count=1 )
+cohesionStrength_slip  = swarm.add_variable( dataType="double",  count=1 )
+a_field  = swarm.add_variable( dataType="double",  count=1 )
+L_field  = swarm.add_variable( dataType="double",  count=1 )
+thetaField = swarm.add_variable( dataType="double",  count=1 )
+swarmYield = swarm.add_variable( dataType="double",  count=1 )
+
+#frictionInf  = swarm.add_variable( dataType="double",  count=1 )
+#cohesion  = swarm.add_variable( dataType="double",  count=1 )
+previousStress         = swarm.add_variable( dataType="double", count=6 )
+faultVariable = faultSwarm.add_variable( dataType="double", count=1)
+
+if(LoadFromFile == False): 
+    #swarmLayout = uw.swarm.layouts.PerCellGaussLayout( swarm=swarm, gaussPointCount=5 )
+    swarmLayout = uw.swarm.layouts.PerCellSpaceFillerLayout(swarm=swarm,particlesPerCell= 125)
+    swarm.populate_using_layout( layout=swarmLayout )
+
+if(LoadFromFile == True):    
+    #surfaceSwarm.load(inputPath+"surfaceSwarm"+str(step).zfill(4))
+    swarm.load(inputPath+"swarm"+str(step).zfill(4))
+    materialVariable.load(inputPath+"materialVariable"+str(step).zfill(4))  
+#     materialIndex.load(inputPath+"materialIndex"+str(step).zfill(4))
+#     materialIndex1.load(inputPath+"materialIndex1"+str(step).zfill(4))
+#     materialIndex2.load(inputPath+"materialIndex2"+str(step).zfill(4))
+#     materialIndex3.load(inputPath+"materialIndex3"+str(step).zfill(4))
+#     materialIndex4.load(inputPath+"materialIndex4"+str(step).zfill(4))
+    velocityField.load(inputPath+"velocityField"+str(step).zfill(4)) 
+    
+#     plasticStrain.load(inputPath+"plasticStrain"+str(step).zfill(4))
+    previousStress.load(inputPath+"previousStress"+str(step).zfill(4))
+    a_field.load(inputPath+"a_field"+str(step).zfill(4))
+    L_field.load(inputPath+"L_field"+str(step).zfill(4))
+    thetaField.load(inputPath+"thetaField"+str(step).zfill(4))
+    surfaceSwarm.load(inputPath+"surfaceSwarm"+str(step).zfill(4))
+    surfaceSwarm2.load(inputPath+"surfaceSwarm2"+str(step).zfill(4))
+    previousVm.load(inputPath+"previousVm"+str(step).zfill(4))
+    previousVm2.load(inputPath+"previousVm2"+str(step).zfill(4))    
+
+# set observation points 
+
+y_ob = (maxY+minY)/2.
+
+markSwarm1.add_particles_with_coordinates(np.array([[half_width,y_ob,-nd(1.*u.kilometer)]]))
+markSwarm2.add_particles_with_coordinates(np.array([[half_width,y_ob,-nd(10.*u.kilometer)]]))
+markSwarm3.add_particles_with_coordinates(np.array([[half_width,y_ob,-nd(20.*u.kilometer)]]))
+markSwarm4.add_particles_with_coordinates(np.array([[half_width,y_ob,-nd(28.*u.kilometer)]]))
+
+
+if(LoadFromFile == False):
+
+    
+    xcd3 = 0.
+    starty = -nd(50.*u.kilometer)
+    endy   = nd(50.*u.kilometer)
+    
+    faultShape3  = np.array([ (xcd3,starty), (xcd3+half_width,starty), (xcd3+half_width,endy),(xcd3,endy)])
+    fault3= fn.shape.Polygon( faultShape3 )
+    
+    starty1 = -nd(30.*u.kilometer)
+    endy1   = -nd(18.*u.kilometer)
+    faultShape4  = np.array([ (xcd3,starty1), (xcd3+half_width,starty1), (xcd3+half_width,endy1),(xcd3,endy1)])
+    fault4= fn.shape.Polygon( faultShape4 )
+    
+#fn.misc.max(-coordz*nd(28e6*u.pascal/u.kilometer)-nd(100e6*u.pascal), -coordz*nd(10e6*u.pascal/u.kilometer))
+
+if LoadFromFile == False:    
+    coordz =  fn.input()[2] 
+    coordy =  fn.input()[1] 
+    condMat = [(fault3,fault),
+               (coordz<nd(-40.*u.kilometer), crustNorthLowIndex),
+               (True,crustNorthUpIndex)]
+    materialVariable.data[:] = fn.branching.conditional(condMat).evaluate(swarm) 
+
+    rangey0 = (coordy>nd(-30.*u.kilometer))  & (coordy<nd(30.*u.kilometer))
+    range_L = (coordy<=nd(-30.*u.kilometer)) & (coordy>=nd(-32.*u.kilometer))
+    range_R = (coordy>=nd(30.*u.kilometer))  & (coordy<=nd(32.*u.kilometer))
+    rangez0  = (coordz>nd(-16.*u.kilometer)) & (coordz<nd(-4.*u.kilometer))
+    rangez1  = coordz>nd(-40.*u.kilometer)
+    
+    Vi = nd(0.03*u.meter/u.second)
+    theta0 = L/V_plate
+    theta1 = L/Vi
+    ####>>>>>>>>>>>Earthquake    
+#     condition_theta = [ #(coordz<nd(-18.*u.kilometer), nd(1.9e16*u.year)),
+#                         (fault3,nd(0.029*u.year)),
+#                         (True, nd(1.9e16*u.year))]
+#     range_lf = coordy<=nd(50.*u.kilometer) and coordy>=nd(-50.*u.kilometer)
+    condition_theta = [ ((fault4 & rangez0),theta1 ),
+                        ((fault3 & rangez1),theta0),
+                        (True, nd(1.9e20*u.year))]
+        
+    thetaField.data[:] = fn.branching.conditional(condition_theta).evaluate(swarm)
+    
+    
+    #thetaField.save(inputPath+"thetaField0"+str(step).zfill(4)) 
+    
+    
+
+    
+    condition_a = [     ((range_L & (coordz<-nd(2.*u.kilometer)) & (coordz>=-nd(18.*u.kilometer))),a0-(a_max-a0)*(coordy+nd(30.*u.kilometer))/nd(2.*u.kilometer)),
+                        ((range_R & (coordz<-nd(2.*u.kilometer)) & (coordz>=-nd(18.*u.kilometer))),a0+(a_max-a0)*(coordy-nd(30.*u.kilometer))/nd(2.*u.kilometer)), 
+                        ((rangey0 & (coordz<-nd(2.*u.kilometer)) & (coordz>=-nd(4.*u.kilometer))),a0-(-a_max+a0)*(coordz+nd(4.*u.kilometer))/nd(2.*u.kilometer)),
+                        ((rangey0 & (coordz<-nd(4.*u.kilometer)) & (coordz>=-nd(16.*u.kilometer))),a0),
+                        ((rangey0 & (coordz<-nd(16.*u.kilometer)) & (coordz>=-nd(18.*u.kilometer))),a0-(a_max-a0)*(coordz+nd(16.*u.kilometer))/nd(2.*u.kilometer)),
+                        (True, a_max)]
+    
+#     condition_a = [ (True, a_max)]
+    
+#     condition_a =      [(coordz>-nd(15.*u.kilometer),a0),
+#                        (True, a_max)]
+    a_field.data[:] = fn.branching.conditional(condition_a).evaluate(swarm)
+    
+    condition_Vi = [    ((fault4 & rangez0),Vi),
+                        (True, V_plate)]
+        
+    ViFn = fn.branching.conditional(condition_Vi)
+
+    condition_L = [    ((fault4 & rangez0),nd(0.13*u.meter)),
+                       (True, nd(0.14*u.meter))]
+        
+    L_field.data[:] = fn.branching.conditional(condition_L).evaluate(swarm)
+    
+    kernalX = ViFn/(2.*V0)*fn.math.exp((miu0 + b*fn.math.log(V0/ViFn))/a_field)
+    frictionFn0 = a_field*fn.math.log(kernalX+fn.math.sqrt(kernalX*kernalX+1.))
+
+
+    #eta_factor = 2.*mu/cs
+    stressShearFn = frictionFn0*stressNormalFn
+    previousStress.data[:] = 1e-20 #0.1*stressNormalFn#
+    previousStress.data[:,3] = stressShearFn.evaluate(swarm)[:,0] # + eta_factor*V_plate ( + for static only) #nd(0.7e7*u.pascal) # 
+
+    ####>>>>>>>>>>>Earthquake
+    
+    countz=zRes*2
+    
+    zcoord = np.linspace(minZ,maxZ, countz)
+    surfacePoints = np.zeros((countz,3))
+    
+    for k in range(countz):       
+
+        surfacePoints[k,0] = dx_min#xcoord[j] 
+        surfacePoints[k,1] = y_ob
+        surfacePoints[k,2] = zcoord[k]  
+    surfaceSwarm.add_particles_with_coordinates( surfacePoints )
+    
+
+    county=yRes*2
+    
+    ycoord = np.linspace(minY+nd(10*u.kilometer), maxY-nd(10*u.kilometer), county)   
+    surfacePoints2 = np.zeros((county,3))
+    for k in range(county):       
+
+        surfacePoints2[k,0] = dx_min#xcoord[j] 
+        surfacePoints2[k,1] = ycoord[k]
+        surfacePoints2[k,2] = nd(-10*u.kilometer)  
+        
+    surfaceSwarm2.add_particles_with_coordinates( surfacePoints2 )
+    
+    
+# maskCoreFn1 = fn.branching.conditional([(materialIndex1>1e8, 1.),
+#                                             (True, 0.)])
+# maskCoreFn2 = fn.branching.conditional([(materialIndex2>1e8, 1.),
+#                                             (True, 0.)])
+# maskCoreFn3 = fn.branching.conditional([(materialIndex3>1e8, 1.),
+#                                             (True, 0.)])
+# maskCoreFn4 = fn.branching.conditional([(materialIndex4>1e8, 1.),
+#                                             (True, 0.)])
+
+# maskCoreFn = fn.branching.conditional([(materialIndex>1e8, 1.),
+#                                             (True, 0.)])
+
+
+
+
+strainRateFn = fn.tensor.symmetric( velocityField.fn_gradient )
+strainRate_2ndInvariantFn = fn.tensor.second_invariant(strainRateFn)+nd(1e-18/u.second)
+
+plasticStrain0.data[:] = 0.
+
+VpFn = 2.*strainRate_2ndInvariantFn*half_width
+thetaFieldFn  =  L_field/VpFn+(thetaField-L_field/VpFn)*fn.math.exp(-VpFn/L_field*dt_e)
+
+if Eqk == True:
+
+    #kernalX = VpFn/(2.*V0)*fn.math.exp((miu0 + b*fn.math.log(V0*thetaField/L))/a_field)
+    #frictionFn = a_field*fn.math.log(kernalX+fn.math.sqrt(kernalX*kernalX+1.))
+    
+    frictionFn = miu0 + a_field*fn.math.log(VpFn/V0) +b*fn.math.log(V0*thetaField/L_field)
+    yieldStressFn = frictionFn*stressNormalFn#pressureField nd(1e6*u.pascal)+
+
+
+    densityMap0 = { fault           : nd(   2670. * u.kilogram / u.metre**3),
+                 crustNorthUpIndex  : nd(   2670. * u.kilogram / u.metre**3),
+                 crustNorthLowIndex : nd(   2670. * u.kilogram / u.metre**3),
+                 }
+densityFn = fn.branching.map( fn_key = materialVariable, mapping = densityMap0 )
+z_hat=( 0.0, 0.0, -1.0 )
+buoyancyFn = densityFn * z_hat *gravity
+
+
+
+
+if (Elasticity == True):
+    mappingDictViscosity = {  fault             : nd(5e29 * u.pascal * u.second),
+                             crustNorthUpIndex  : nd(5e29 * u.pascal * u.second),
+                             crustNorthLowIndex : nd(5e29 * u.pascal * u.second)}
+    viscosityMapFn1 = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = mappingDictViscosity )
+
+    alpha   = viscosityMapFn1 / mu                         # viscoelastic relaxation time
+
+    viscoelasticViscosity  = ( viscosityMapFn1 * dt_e ) / (alpha + dt_e)  # effective viscosity
+
+    visElsMap = {                       fault  : viscoelasticViscosity,
+                            crustNorthUpIndex  : viscoelasticViscosity,
+                            crustNorthLowIndex : viscoelasticViscosity}
+
+    viscosityMapFn  = fn.branching.map( fn_key = materialVariable, 
+                                               mapping = visElsMap )
+    
+    strainRate_effective = strainRateFn + 0.5*previousStress/(mu*dt_e)
+    strainRate_effective_2ndInvariant = fn.tensor.second_invariant(strainRate_effective)+nd(1e-18/u.second)
+    yieldingViscosityFn =  0.5 * yieldStressFn / strainRate_effective_2ndInvariant
+
+    #viscosityFn = fn.exception.SafeMaths( fn.misc.max(fn.misc.min(yieldingViscosityFn, 
+    #                                                             viscosityMapFn), min_viscosity))    
+    #viscosityFn = fn.exception.SafeMaths( fn.misc.min(yieldingViscosityFn,viscosityMapFn))
+    
+    
+    yieldFnMap = {                    fault     : yieldingViscosityFn,
+                             crustNorthUpIndex  : nd(1e20*u.pascal),
+                             crustNorthLowIndex : nd(1e20*u.pascal)}
+
+    yieldFn  = fn.branching.map( fn_key =  materialVariable, 
+                                    mapping = yieldFnMap )
+    
+    viscosityFn = ( fn.misc.min(yieldFn,viscosityMapFn))
+    
+    # contribution from elastic rheology
+    tauHistoryFn    = viscosityFn / ( mu * dt_e ) * previousStress 
+    # stress from all contributions, including elastic,viscous,plastic (if yielded)
+    allStressFn     = 2. * viscosityFn * strainRate_effective#
+    allStressFn_2nd = fn.tensor.second_invariant(allStressFn)
+    
+    visStrainRateFn = allStressFn/(2.*viscosityMapFn1)
+    
+    elaStrainRateFn = (allStressFn-previousStress)/dt_e/(2.*mu)
+    
+    plaStrainRateFn = strainRateFn - visStrainRateFn - elaStrainRateFn
+    
+    plaStrainRateFn_2nd = fn.tensor.second_invariant(plaStrainRateFn)  
+
+    vis_vp = viscosityMapFn1*allStressFn_2nd/(2.*viscosityMapFn1*plaStrainRateFn_2nd+allStressFn_2nd)
+    
+    swarmYield_Cond = [(viscosityMapFn>viscosityFn,1.),
+                       (True,0.)]
+    swarmYieldFn = fn.branching.conditional(swarmYield_Cond)
+    
+    
+    #plaRate2nd = strainRate_2ndInvariant*swarmYieldFn
+    #plaStrainRateFn_2nd = fn.tensor.second_invariant(plaStrainRateFn)
+    #elaStrainRateFn_2nd = fn.tensor.second_invariant(elaStrainRateFn)
+    #visStrainRateFn_2nd = fn.tensor.second_invariant(visStrainRateFn)
+    
+    plaIncrement = plaStrainRateFn_2nd*swarmYieldFn
+    #elaIncrement = elaStrainRateFn_2nd*swarmYieldFn
+    #visIncrement = visStrainRateFn_2nd*swarmYieldFn
+    
+    stressMapFn = allStressFn
+    
+    LHS_fn = densityFn/dt_e 
+    RHS_fn = densityFn*previousVm/dt_e
+    
+    stokes = uw.systems.Stokes(velocityField = velocityField, 
+                               pressureField = pressureField,
+                               voronoi_swarm = swarm, 
+                               conditions    = freeslipBC,
+                               fn_viscosity  = viscosityFn, 
+                               #fn_bodyforce  = buoyancyFn,
+                               fn_bodyforce  = buoyancyFn+RHS_fn,
+                               fn_stresshistory = tauHistoryFn)
+    
+    massMatrixTerm = uw.systems.sle.MatrixAssemblyTerm_NA__NB__Fn(
+                        assembledObject  = stokes._kmatrix,
+                        integrationSwarm = stokes._constitMatTerm._integrationSwarm,
+                        fn   = LHS_fn,
+                        mesh = mesh)     
+    
+
+# Create solver & solve
+solver = uw.systems.Solver(stokes)
+
+
+# %%
+
+# use "lu" direct solve if running in serial
+if(uw.mpi.size==1):
+    solver.set_inner_method("lu")
+else:
+    solver.set_inner_method('mg')    
+solver.set_penalty(1e-3) 
+#solver.options.ksp_rtol=1e-8
+
+inner_rtol = 1e-5
+solver.set_inner_rtol(inner_rtol)
+solver.set_outer_rtol(10*inner_rtol)
+
+# solver.options.ksp_rtol=1e-5
+# solver.options.scr.ksp_rtol = 1.0e-5
+
+
+
+
+surfaceArea = uw.utils.Integral(fn=1.0,mesh=mesh, integrationType='surface', surfaceIndexSet=top)
+surfacePressureIntegral = uw.utils.Integral(fn=pressureField, mesh=mesh, integrationType='surface', surfaceIndexSet=top)
+
+
+def pressure_calibrate():
+    
+    (area,) = surfaceArea.evaluate()
+    (p0,) = surfacePressureIntegral.evaluate()
+    offset = p0/area
+    #print "Zeroing pressure using mean upper surface pressure {}".format( offset )
+    pressureField.data[:] -= offset
+    #plasticStrain0.data[:] = plaIncrement.evaluate(swarm) # plaRate2nd.evaluate(swarm)
+    
+
+def nonLinearSolver(step, nl_tol=1e-2, nl_maxIts=10):
+    # a hand written non linear loop for stokes, with pressure correction
+
+    er = 1.0
+    its = 0                      # iteration count
+    v_old = velocityField.copy() # old velocityField 
+
+    while er > nl_tol and its < nl_maxIts:
+
+        v_old.data[:] = velocityField.data[:]
+        solver.solve(nonLinearIterate=False)
+
+        # pressure correction for bob (the feed back pressure)
+        
+        (area,) = surfaceArea.evaluate()
+        (p0,) = surfacePressureIntegral.evaluate()
+        offset = p0/area
+        #print "Zeroing pressure using mean upper surface pressure {}".format( offset )
+        pressureField.data[:] -= offset
+        #plasticStrain0.data[:] = plaIncrement.evaluate(swarm)
+
+
+        # calculate relative error
+        absErr = uw.utils._nps_2norm(velocityField.data-v_old.data)
+        magT   = uw.utils._nps_2norm(v_old.data)
+        er = absErr/magT
+        if uw.mpi.rank==0.:
+            print ("tolerance=", er,"iteration times=",its)
+        uw.mpi.barrier
+        
+        its += 1
+        
+G_star = mu/(1.-0.5)
+k_stiff = (2./3.1415926)*G_star/dx_min
+
+
+# see Herrendorfer et al., 2018 for the defination of de_thea, dt_w, dt_vep
+
+pusei = 0.25*fn.math.pow((k_stiff*L_field/(a_field*stressNormalFn)-(b-a_field)/a_field),2.)-k_stiff*L/(a_field*stressNormalFn)
+
+pusei_Cond = [(pusei>0,a_field*stressNormalFn/(k_stiff*L_field-(b-a_field)*stressNormalFn)),
+              (True,1.-(b-a_field)*stressNormalFn/(k_stiff*L_field))]
+puseiFn = fn.branching.conditional(pusei_Cond)
+
+   
+dt_theta = fn.misc.min(fn.misc.constant(0.2),puseiFn)
+
+# condw = [(plasticStrain0>0,dt_theta *L_field/VpFn),
+#               (True,dt_theta *L_field/VpFn)]
+
+
+
+# dt_wFn0 = fn.branching.conditional(condw)
+# dt_wFn = fn.view.min_max(dt_wFn0)
+
+dt_wFn = fn.view.min_max(0.3*L_field/VpFn)
+
+#dt_wFn.evaluate(swarm)
+#dt_w = dt_wFn.min_global()
+
+dt_hFn = fn.view.min_max(thetaField*0.2)
+#dt_vepFn = fn.view.min_max(0.2*vis_vp/mu)
+dt_vepFn = fn.view.min_max(0.2*vis_vp/mu)
+
+#delta_Fn = (yieldingViscosityFn-allStressFn_2nd)**2./pressureField**2.
+#surfaceArea = uw.utils.Integral(fn=1.0,mesh=mesh)
+#surface_dF_Integral = uw.utils.Integral(fn=delta_Fn, mesh=mesh)
+        
+               
+        
+advMat  = uw.systems.SwarmAdvector( swarm=swarm,     velocityField=velocityField, order=2 )
+advSurf  = uw.systems.SwarmAdvector( swarm=surfaceSwarm, velocityField=velocityField, order=2 )
+advSurf2  = uw.systems.SwarmAdvector( swarm=surfaceSwarm2, velocityField=velocityField, order=2 )
+#The root mean square Velocity
+velSquared = uw.utils.Integral( fn.math.dot(velocityField,velocityField), mesh )
+area = uw.utils.Integral( 1., mesh )
+Vrms = math.sqrt( velSquared.evaluate()[0]/area.evaluate()[0] )
+
+
+time_factor = nd(1*u.year)
+
+def update():
+
+    dt = dt_e.value
+    velA.data[:] = velocityField.evaluate(swarm)  
+    vel_eff.data[:] = 1./4.*(velA.data[:]+2.*previousVm.data[:]+previousVm2.data[:])   
+    # vel_eff.data[:] = 1./2.*(velA.data[:]+1.*previousVm.data[:])  
+    previousVm2.data[:] = np.copy(previousVm.data[:])
+    previousVm.data[:] = np.copy(velA.data[:])      
+    # swarm advection can be ignored in earthquake cycle simulations due to small displacement with respect to grid size
+    # with swarm.deform_swarm():
+    #     swarm.data[:] += vel_eff.data[:]*dt 
+
+    #update theta value in the RS frictional relationship
+    condition_theta =  {               fault  : thetaFieldFn,
+                           crustNorthUpIndex  : theta_rock,
+                           crustNorthLowIndex : theta_rock
+                       }
+        
+    thetaField.data[:] = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = condition_theta ).evaluate(swarm) 
+    
+    
+    stressMapFn_data = stressMapFn.evaluate(swarm)
+ 
+
+    previousStress.data[:] = stressMapFn_data[:]
+
+     
+#     advMat.integrate(dt)
+    advSurf.integrate(dt)
+    advSurf2.integrate(dt)
+    #advMark.integrate(dt)
+    pop_control.repopulate()     
+
+    dt_wFn.reset()       
+    dt_wFn.evaluate(swarm)    
+    dt_w = dt_wFn.min_global()    
+
+    dt_hFn.reset()
+    dt_hFn.evaluate(swarm)
+    dt_h = dt_hFn.min_global()
+
+    dt_vepFn.reset()
+    dt_vepFn.evaluate(swarm)
+    dt_vep = dt_vepFn.min_global()
+    
+
+    V_fault =  fn.view.min_max(VpFn)
+    V_fault.evaluate(mesh.subMesh)
+    Vp_max = V_fault.max_global()
+
+#     dt0 = np.min([dt_max,dt_vep,dt_w])
+#   dt0 = np.min([dt_max,dt_vep,dt_w,2*dt_e.value])
+    dt0 = np.min([dt_max,dt_vep])
+#     dt_e.value =  np.max([dt0,dt_min,0.5*dt_e.value]) 
+    dt_e.value =  np.max([dt0,dt_min]) 
+
+    return timestep+dt, step+1
+
+
+stressSample = np.zeros([4,1])
+thetaSample = np.zeros([4,1])
+fricSample = np.zeros([4,1])
+velSample = np.zeros([4,1])
+
+plsticIncrement = np.zeros([5,1])
+Dissipation = np.zeros([9,1])
+
+yieldHis = np.zeros([4,1])
+
+if step == 0:
+    title = ['step','time','F1','F2','F3','F4','dt_e','V1','V2','V3','V4']
+    with open(outputPath+'Sample.csv', 'w') as f:
+        csv_write = csv.writer(f)
+        csv_write.writerow(title)
+
+    
+vdotv = uw.utils.Integral(fn.math.dot(velocityField,velocityField),mesh=mesh)
+meshInt = uw.utils.Integral(fn=1.0,mesh=mesh)
+Vrms = shearVelocity
+V_rate_old = 0.
+jump_step = 1.
+while step<nsteps:
+    
+        
+    solver.solve( nonLinearIterate=True,  nonLinearTolerance=1e-3, nonLinearMaxIterations=15,callback_post_solve = pressure_calibrate)
+
+    picard_h = solver.get_nonLinearStats() 
+    
+    if picard_h.picard_residual>0.005:
+        if uw.mpi.rank==0:
+            print('more itr is called')
+        uw.mpi.barrier()
+#         dt_e.value = 0.9*dt_e.value
+        solver.solve( nonLinearIterate=True,  nonLinearTolerance=1e-3, nonLinearMaxIterations=5,callback_post_solve = pressure_calibrate)        
+#         picard_h = solver.get_nonLinearStats()
+   
+    
+    dt_inner = advMat.get_max_dt() 
+    while dt_inner < dt_e.value :
+        
+        dt_e.value = 0.5*dt_e.value
+        #nonLinearSolver(step, nl_tol=1e-3, nl_maxIts=30)
+        solver.solve(nonLinearIterate=True,  nonLinearTolerance=1e-3, nonLinearMaxIterations=30,callback_post_solve = pressure_calibrate)       
+        dt_inner = advMat.get_max_dt()  
+    
+    visMin = 0.
+    
+    VelMM = fn.view.min_max(fn.math.abs(velocityField[1])*maskMesh)
+    VelMM.evaluate(mesh)
+    Vrms_new = VelMM.max_global()
+    #Vrms = Vrms_new
+
+  
+    meshStress = uw.mesh.MeshVariable( mesh, 1 )
+    projectorStress = uw.utils.MeshVariable_Projection( meshStress, allStressFn[3], type=0 )
+    projectorStress.solve() 
+    # output figure to file at intervals = steps_output
+    if step %step_out == 0 or step == nsteps-1:
+        #Important to set the timestep for the store object here or will overwrite previous step
+
+        if (Elasticity == True):
+            previousStress.save(outputPath+"previousStress"+str(step).zfill(4))
+
+        
+
+        '''
+        meshFriction = uw.mesh.MeshVariable( mesh, 1 )
+        projectorStress = uw.utils.MeshVariable_Projection( meshFriction, frictionFn, type=0 )
+        projectorStress.solve() 
+        frictionInf.data[:] = frictionFn.evaluate(swarm)
+        '''
+
+        mesh.save(outputPath+"mesh"+str(step).zfill(4))
+        swarm.save(outputPath+"swarm"+str(step).zfill(4))
+        materialVariable.save(outputPath+"materialVariable"+str(step).zfill(4))
+
+        a_field.save(outputPath+"a_field"+str(step).zfill(4))
+        L_field.save(outputPath+"L_field"+str(step).zfill(4))
+        thetaField.save(outputPath+"thetaField"+str(step).zfill(4)) 
+        previousVm.save(outputPath+"previousVm"+str(step).zfill(4))
+        previousVm2.save(outputPath+"previousVm2"+str(step).zfill(4))
+        
+        #swarmYield.save(inputPath+"yieldSwarm"+str(step).zfill(4))
+    if step % 10 == 0 :
+        meshStress.save(outputPath+"meshStress"+str(step).zfill(4))     
+        velocityField.save(outputPath+"velocityField"+str(step).zfill(4)) 
+           
+    if uw.mpi.rank==0:
+        np.save(outputPath+"time"+str(step).zfill(4),timestep)
+        np.save(outputPath+"dt"+str(step).zfill(4),dt_e.value)
+#         np.save(outputPath+"plstRateAll0"+str(step).zfill(4),plstRateAll0)
+    uw.mpi.barrier()
+
+    dicMesh = { 'elements' : mesh.elementRes, 
+                'minCoord' : mesh.minCoord,
+                'maxCoord' : mesh.maxCoord}
+
+    fo = open(outputPath+"dicMesh"+str(step).zfill(4),'w')
+    fo.write(str(dicMesh))
+    fo.close()
+
+
+    stressMM = fn.view.min_max(fn.math.abs(meshStress))
+    stressMM.evaluate(markSwarm2)
+    stressSample[1] = stressMM.max_global()
+
+    stressMM = fn.view.min_max(fn.math.abs(meshStress))
+    stressMM.evaluate(markSwarm3)
+    stressSample[2] = stressMM.max_global()
+
+
+    velMM = fn.view.min_max(fn.math.abs(velocityField[1]))
+    velMM.evaluate(markSwarm2)
+    velSample[3] = velMM.max_global()
+
+    velMM = fn.view.min_max(fn.math.abs(velocityField[1]))
+    velMM.evaluate(markSwarm3)
+    velSample[2] = velMM.max_global()
+
+    V_fault =  fn.view.min_max(VpFn)
+    V_fault.evaluate(mesh.subMesh)
+    velSample[1] = V_fault.max_global()
+
+
+    
+    
+    if uw.mpi.rank==0:
+        SP_output = [step,timestep,stressSample[0,0],stressSample[1,0],stressSample[2,0],stressSample[3,0],dt_e.value,velSample[0,0],velSample[1,0],velSample[2,0],velSample[3,0]]
+        with open(outputPath+'Sample.csv', 'a') as f:
+            csv_write = csv.writer(f)  
+            csv_write.writerow(SP_output)
+    uw.mpi.barrier()
+    
+
+    surfaceSwarm.save(outputPath+"surfaceSwarm"+str(step).zfill(4)) 
+    surfaceSwarm2.save(outputPath+"surfaceSwarm2"+str(step).zfill(4)) 
+    
+    if uw.mpi.rank==0:
+        print('step = {0:6d}; time = {1:.3e};'.format(step,timestep/nd(1.*u.year)))
+    uw.mpi.barrier()
+    
+    
+    timestep, step = update()
+
+
+
+
diff --git a/model_code_inputs/Dockerfile b/model_code_inputs/Dockerfile
new file mode 100644
index 0000000..717cbb9
--- /dev/null
+++ b/model_code_inputs/Dockerfile
@@ -0,0 +1,16 @@
+# Please choose your required Underworld/UWGeo image version here.
+# Available images may be found at
+#   https://hub.docker.com/r/underworldcode/underworld2/tags
+#   https://hub.docker.com/r/underworldcode/uwgeodynamics/tags
+FROM underworldcode/uwgeodynamics:v2.8.5
+
+# THE FOLLOWING WILL USUALLY NOT REQUIRE MODIFICATION.
+
+# This command will copy in all the files in your repo.
+COPY --chown=jovyan:users . /home/jovyan/community_model
+
+# Set working directory to where we've put files. 
+WORKDIR /home/jovyan/community_model
+
+# Create symbolic link to documentation. 
+RUN ln -s .. underworld_documentation
diff --git a/model_code_inputs/Example_Reynolds_Strouhal_CylinderInFlow.ipynb b/model_code_inputs/Example_Reynolds_Strouhal_CylinderInFlow.ipynb
new file mode 100644
index 0000000..8f8e744
--- /dev/null
+++ b/model_code_inputs/Example_Reynolds_Strouhal_CylinderInFlow.ipynb
@@ -0,0 +1,839 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import underworld as uw\n",
+    "from underworld import function as fn\n",
+    "from underworld import visualisation as glucifer\n",
+    "import numpy as np\n",
+    "import math\n",
+    "import warnings\n",
+    "import os,csv\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "\n",
+    "from underworld.scaling import units as u\n",
+    "from underworld.scaling import non_dimensionalise as nd\n",
+    "\n",
+    "outputPath = os.path.join(os.path.abspath(\".\"),\"Reynolds_Tube_FixBall2/\")\n",
+    "if uw.mpi.rank == 0:\n",
+    "    if not os.path.exists(outputPath):\n",
+    "        os.makedirs(outputPath)\n",
+    "uw.mpi.barrier()\n",
+    "\n",
+    "scaling_coefficients = uw.scaling.get_coefficients()\n",
+    "\n",
+    "tempMin = 273.*u.degK \n",
+    "tempMax = (1400.+ 273.)*u.degK\n",
+    "bodyforce = 3300 * u.kilogram / u.metre**3 * 9.81 * u.meter / u.second**2\n",
+    "velocity = 1.0 *u.meter/u.second\n",
+    "\n",
+    "KL = 0.1*u.meter\n",
+    "Kt = KL/velocity\n",
+    "KT = tempMax \n",
+    "KM = bodyforce * KL**2 * Kt**2\n",
+    "K  = 1.*u.mole\n",
+    "\n",
+    "scaling_coefficients[\"[length]\"] = KL\n",
+    "scaling_coefficients[\"[time]\"] = Kt\n",
+    "scaling_coefficients[\"[mass]\"]= KM\n",
+    "scaling_coefficients[\"[temperature]\"] = KT\n",
+    "scaling_coefficients[\"[substance]\"] = K\n",
+    "\n",
+    "\n",
+    "gravity = 0*nd(9.81 * u.meter / u.second**2)\n",
+    "R = nd(8.3144621 * u.joule / u.mole / u.degK)\n",
+    "\n",
+    "time_factor=nd(1*u.second)\n",
+    "vis_factor = nd(1*u.pascal*u.second)\n",
+    "vel_factor = nd(1*u.meter/u.second) \n",
+    "strainRate_factor = nd(1/u.second)\n",
+    "length_factor = nd(1*u.centimeter)\n",
+    "stress_factor = nd(1*u.pascal)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Setup parameters\n",
+    "-----\n",
+    "\n",
+    "Set simulation parameters for the test and position of the cylinder."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set the resolution.\n",
+    "resx = 64\n",
+    "resy = 128\n",
+    "# Set size and position of dense sphere.\n",
+    "sphereRadius = nd(2.*1.27/2*u.centimeter)\n",
+    "sphereCentre = (0.,nd(80.*u.centimeter))\n",
+    "minX = nd(-12*u.centimeter)\n",
+    "maxX = nd(12*u.centimeter)\n",
+    "minY = 0.\n",
+    "maxY = nd(120.*u.centimeter)\n",
+    "\n",
+    "Vy  =  -nd(1.0*u.meter/u.second)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vis = nd(0.031*u.pascal*u.second)\n",
+    "rho = nd(876.*u.kilogram/u.meter**3)\n",
+    "D = nd(1.27*u.centimeter)\n",
+    "v = nd(2*u.meter/u.second)\n",
+    "Re = rho*v*D/vis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Check the desinged Reynolds nunber"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "717.7548387096776\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(Re)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create mesh and finite element variables\n",
+    "------"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tGlobal element size: 64x128\n",
+      "\tLocal offset of rank 0: 0x0\n",
+      "\tLocal range of rank 0: 64x128\n"
+     ]
+    }
+   ],
+   "source": [
+    "mesh = uw.mesh.FeMesh_Cartesian( elementType = (\"Q1/dQ0\"), \n",
+    "                                 elementRes  = (resx, resy), \n",
+    "                                 minCoord    = (minX, minY), \n",
+    "                                 maxCoord    = (maxX, maxY),\n",
+    "                                 periodic    =  [False, False] )\n",
+    "\n",
+    "velocityField    = mesh.add_variable(         nodeDofCount=2 )\n",
+    "pressureField    = mesh.subMesh.add_variable( nodeDofCount=1 )\n",
+    "stressField      = mesh.add_variable(         nodeDofCount=2 )\n",
+    "step = 0 \n",
+    "if uw.mpi.rank == 0:\n",
+    "\n",
+    "    dicMesh = { 'elements' : mesh.elementRes, \n",
+    "                'minCoord' : mesh.minCoord,\n",
+    "                'maxCoord' : mesh.maxCoord}\n",
+    "\n",
+    "    fo = open(outputPath+\"dicMesh\"+str(step).zfill(4),'w')\n",
+    "    fo.write(str(dicMesh))\n",
+    "    fo.close()  \n",
+    "\n",
+    "uw.mpi.barrier()\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Set initial conditions and boundary conditions\n",
+    "----------\n",
+    "\n",
+    "**Initial and boundary conditions**\n",
+    "\n",
+    "Initialise the velocity and pressure fields to zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "velocityField.data[:] = [0.,0.]\n",
+    "pressureField.data[:] = 0."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Conditions on the boundaries**\n",
+    "\n",
+    "Construct sets for the both horizontal and vertical walls to define conditons for underworld solvers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "iWalls = mesh.specialSets[\"MinI_VertexSet\"] + mesh.specialSets[\"MaxI_VertexSet\"]\n",
+    "jWalls = mesh.specialSets[\"MinJ_VertexSet\"] + mesh.specialSets[\"MaxJ_VertexSet\"]\n",
+    "top = mesh.specialSets[\"MaxJ_VertexSet\"]\n",
+    "base = mesh.specialSets[\"MinJ_VertexSet\"]\n",
+    "\n",
+    "Ball = mesh.specialSets['Empty']\n",
+    "#make the ball/cylinder fixed\n",
+    "for index, coord in enumerate(mesh.data):\n",
+    "    x = coord[0]\n",
+    "    y = coord[1]\n",
+    "    sphere =  (x - sphereCentre[0])**2+(y - sphereCentre[1])**2\n",
+    "\n",
+    "    if sphere < sphereRadius**2:\n",
+    "        Ball+=index\n",
+    "        \n",
+    "for index in mesh.specialSets[\"MaxJ_VertexSet\"]:\n",
+    "    velocityField.data[index] = Vy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Boundary condition for the example of a falling cylinder "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# freeslipBC = uw.conditions.DirichletCondition( variable      = velocityField, \n",
+    "#                                                indexSetsPerDof = (iWalls,iWalls+jWalls) )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Boundary condition for the example of  a fixed cylinder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "freeslipBC = uw.conditions.DirichletCondition( variable      = velocityField, \n",
+    "                                               indexSetsPerDof = (iWalls,Ball+jWalls) )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a particle swarm\n",
+    "------\n",
+    "\n",
+    "Swarms refer to (large) groups of particles which can advect with the fluid flow. These can be used to determine 'materials' as they can carry local information such as the fluid density and viscosity."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Setup a swarm**\n",
+    "\n",
+    "To set up a swarm of particles the following steps are needed:\n",
+    "1. Initialise and name a swarm, here called ``swarm``.\n",
+    "2. Define data variable (``materialIndex``) to store an index that will state what material a given particle is.\n",
+    "3. Populate the swarm over the whole domain using the layout command, here this is used to allocate 20 particles in each element."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create the swarm and an advector associated with it\n",
+    "swarm = uw.swarm.Swarm( mesh=mesh,particleEscape=True )\n",
+    "advector = uw.systems.SwarmAdvector( swarm=swarm, velocityField=velocityField, order=2 )\n",
+    "\n",
+    "# Add a data variable which will store an index to determine material.\n",
+    "materialIndex = swarm.add_variable( dataType=\"int\", count=1 )\n",
+    "previousVm =  swarm.add_variable( dataType=\"double\", count=2 )\n",
+    "velSwarm =  swarm.add_variable( dataType=\"double\", count=2 )\n",
+    "densitySwarm =  swarm.add_variable( dataType=\"double\", count=1 )\n",
+    "\n",
+    "# Create a layout object that will populate the swarm across the whole domain.\n",
+    "swarmLayout = uw.swarm.layouts.PerCellGaussLayout( swarm=swarm, gaussPointCount=5 )\n",
+    "pop_control = uw.swarm.PopulationControl(swarm,aggressive=True,particlesPerCell=20)\n",
+    "\n",
+    "# Go ahead and populate the swarm.\n",
+    "swarm.populate_using_layout( layout=swarmLayout )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Define a shape**\n",
+    " 1. Define an underworld `function` that descripes the geometry of a shape (a sphere), called `fn_sphere`.\n",
+    " 2. Set up a `fn.branching.conditional` to run `fn_sphere` and return a given index - either `materialLightIndex` or `materialHeavyIndex`.\n",
+    " 3. Execute the above underworld functions on the swarm we created and save the result on the `materialIndex` swarm variable.\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create a function for a sphere. returns `True` if query is inside sphere, `False` otherwise.\n",
+    "coord = fn.input() - sphereCentre\n",
+    "fn_sphere = fn.math.dot( coord, coord ) < sphereRadius**2\n",
+    "\n",
+    "# define some names for our index \n",
+    "materialLightIndex = 0\n",
+    "materialHeavyIndex = 1\n",
+    "\n",
+    "# set up the condition for being in a sphere. If not in sphere then will return light index.\n",
+    "conditions = [ ( fn_sphere , materialHeavyIndex), \n",
+    "               ( True      , materialLightIndex) ]\n",
+    "\n",
+    "# Execute the branching conditional function, evaluating at the location of each particle in the swarm.\n",
+    "# The results are copied into the materialIndex swarm variable.\n",
+    "materialIndex.data[:] = fn.branching.conditional( conditions ).evaluate(swarm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Branching conditional function**\n",
+    "\n",
+    "For more information on the `fn.branching.conditional` see the Functions user guide [here](../user_guide/05_Functions.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Define minimum y coordinate function**\n",
+    "\n",
+    " 1. Define a new swarm called `tracerSwarm`, with one particle at the base of the sphere. (This swarm behaves as a passive tracer swarm).\n",
+    " 2. Define a function that finds the minimum y coordinate value of the `tracerSwarm` in a parallel safe way."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# build a tracer swarm with one particle\n",
+    "tracerSwarm = uw.swarm.Swarm(mesh,particleEscape=True)\n",
+    "advector_tracer = uw.systems.SwarmAdvector( swarm=tracerSwarm, velocityField=velocityField, order=2 )\n",
+    "\n",
+    "# build a numpy array with one particle, specifying it's exact location\n",
+    "x_pos = sphereCentre[0]\n",
+    "y_pos = sphereCentre[1]#-sphereRadius\n",
+    "coord_array = np.array(object=(x_pos,y_pos),ndmin=2)\n",
+    "tracerSwarm.add_particles_with_coordinates(coord_array)\n",
+    "\n",
+    "# define a y coordinate `min_max` function\n",
+    "fn_ycoord = fn.view.min_max( fn.coord()[1] )\n",
+    "\n",
+    "def GetSwarmYMin():\n",
+    "    fn_ycoord.reset()\n",
+    "    fn_ycoord.evaluate(tracerSwarm),velocityField.evaluate(tracerSwarm.particleCoordinates.data)\n",
+    "    return fn_ycoord.min_global(),velocityField[1].evaluate(tracerSwarm.particleCoordinates.data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 0.,  8.]])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tracerSwarm.data[:]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Design band swarm to visualize flow patterns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bandSwarm = uw.swarm.Swarm(mesh,particleEscape=True)\n",
+    "advector_band = uw.systems.SwarmAdvector( swarm=bandSwarm, velocityField=velocityField, order=2 )\n",
+    "material_band = bandSwarm.add_variable( dataType=\"int\", count=1 )\n",
+    "#swarmLayout_band = uw.swarm.layouts.PerCellGaussLayout( swarm=bandSwarm, gaussPointCount=1 )\n",
+    "swarmLayout_band = uw.swarm.layouts.PerCellSpaceFillerLayout( swarm=bandSwarm, particlesPerCell=8 )\n",
+    "pop_control_band = uw.swarm.PopulationControl(bandSwarm,aggressive=True,particlesPerCell=8)\n",
+    "\n",
+    "bandSwarm.populate_using_layout( layout=swarmLayout_band )\n",
+    "\n",
+    "y  = fn.input()[1]\n",
+    "x  = fn.input()[0]\n",
+    "nband = 19\n",
+    "bW = (maxX-minX)/nband/2\n",
+    "x_c = np.linspace(minX,maxX,nband)\n",
+    "# conditions_band = [ (fn_sphere, 3),\n",
+    "#                     ( (y > sphereCentre[1]+sphereRadius)&(fn.math.abs(x-x_c[1])<bW) , 1),\n",
+    "#                     ( (y > sphereCentre[1]+sphereRadius)&(fn.math.abs(x-x_c[3])<bW) , 2),\n",
+    "#                     ( (y > sphereCentre[1]+sphereRadius)&(fn.math.abs(x-x_c[5])<bW) , 3),\n",
+    "#                     ( (y > sphereCentre[1]+sphereRadius)&(fn.math.abs(x-x_c[7])<bW) , 1),\n",
+    "#                     ( (y > sphereCentre[1]+sphereRadius)&(fn.math.abs(x-x_c[9])<bW) , 2),\n",
+    "#                     ( (y > sphereCentre[1]+sphereRadius)&(fn.math.abs(x-x_c[10])<bW) ,3),\n",
+    "#                     ( (y > sphereCentre[1]+sphereRadius)&(fn.math.abs(x-x_c[13])<bW) ,1),\n",
+    "#                     ( (y > sphereCentre[1]+sphereRadius)&(fn.math.abs(x-x_c[15])<bW) ,2),\n",
+    "#                     ( (y > sphereCentre[1]+sphereRadius)&(fn.math.abs(x-x_c[17])<bW) ,3),\n",
+    "#                      (True,      0) ]\n",
+    "\n",
+    "conditions_band = [ (fn_sphere, 4),\n",
+    "                    ((fn.math.abs(x-x_c[1])<bW) , 1),\n",
+    "                    ((fn.math.abs(x-x_c[3])<bW) , 2),\n",
+    "                    ((fn.math.abs(x-x_c[5])<bW) , 3),\n",
+    "                    ((fn.math.abs(x-x_c[7])<bW) , 1),\n",
+    "                    ((fn.math.abs(x-x_c[9])<bW) , 2),\n",
+    "                    ((fn.math.abs(x-x_c[11])<bW) , 3),\n",
+    "                    ((fn.math.abs(x-x_c[13])<bW) , 1),\n",
+    "                    ((fn.math.abs(x-x_c[15])<bW) , 2),\n",
+    "                    ((fn.math.abs(x-x_c[17])<bW) , 3),\n",
+    "                     (True,      0) ]\n",
+    "\n",
+    "material_band.data[:] =  fn.branching.conditional( conditions_band ).evaluate(bandSwarm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "** Test minimum y coordinate function**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Minimum y value for sinker = 8.000e+00,velocity = 8.000e+00)\n"
+     ]
+    }
+   ],
+   "source": [
+    "outPutTrack = GetSwarmYMin()\n",
+    "print('Minimum y value for sinker = {0:.3e},velocity = {0:.3e})'.format(outPutTrack[0],outPutTrack[1]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Plot the particles by material**\n",
+    "\n",
+    "Plot the initial positions of all swarm particles coloured by their material indices."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'material' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[33], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m fig1 \u001b[38;5;241m=\u001b[39m glucifer\u001b[38;5;241m.\u001b[39mFigure( figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m600\u001b[39m,\u001b[38;5;241m1400\u001b[39m) )\n\u001b[0;32m----> 2\u001b[0m fig1\u001b[38;5;241m.\u001b[39mPoints(swarm, \u001b[43mmaterial\u001b[49m, colourBar\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, pointSize\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.3\u001b[39m)\n\u001b[1;32m      3\u001b[0m fig1\u001b[38;5;241m.\u001b[39mVectorArrows(mesh, velocityField,scale\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1e3\u001b[39m)\n\u001b[1;32m      4\u001b[0m fig1\u001b[38;5;241m.\u001b[39mshow()\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'material' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "fig1 = glucifer.Figure( figsize=(600,1400) )\n",
+    "fig1.Points(swarm, material, colourBar=True, pointSize=1.3)\n",
+    "fig1.VectorArrows(mesh, velocityField,scale=1e3)\n",
+    "fig1.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Set up material parameters and functions\n",
+    "-----\n",
+    "\n",
+    "Here the functions for density and viscosity are set using the ``map`` function. This function evaluates a key function (here the material index), and the result (i.e. the key) is used to determine which function to evaluate to obtain the actual result (such as the particle density). \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set constants for the viscosity and density of the sinker.\n",
+    "viscSphere = nd(1e6*u.pascal*u.second)\n",
+    "densitySphere = nd(7780. * u.kilogram / u.metre**3 )\n",
+    "\n",
+    "# Here we set a viscosity value of '1.' for both materials  nd(0.31e-1*u.pascal*u.second)\n",
+    "mappingDictViscosity = { materialLightIndex:nd(0.31e-1*u.pascal*u.second), materialHeavyIndex:viscSphere }\n",
+    "# Create the viscosity map function.\n",
+    "viscosityMapFn = fn.branching.map( fn_key=materialIndex, mapping=mappingDictViscosity )\n",
+    "# Here we set a density of '0.' for the lightMaterial, and '1.' for the heavymaterial.\n",
+    "mappingDictDensity = { materialLightIndex:nd(876. * u.kilogram / u.metre**3 ), materialHeavyIndex:densitySphere }\n",
+    "# Create the density map function.\n",
+    "densityFn = fn.branching.map( fn_key=materialIndex, mapping=mappingDictDensity )\n",
+    "\n",
+    "# And the final buoyancy force function.\n",
+    "z_hat = ( 0.0, -0.0 )\n",
+    "buoyancyFn = densityFn * z_hat * gravity\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "previousVm.data[:] = 0.\n",
+    "dt_e = fn.misc.constant(nd(1e-1*u.second))\n",
+    "\n",
+    "LHS_fn = densityFn/dt_e \n",
+    "RHS_fn = densityFn*previousVm/dt_e"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stokes0 = uw.systems.Stokes(    velocityField = velocityField, \n",
+    "                               pressureField = pressureField,\n",
+    "                               #voronoi_swarm = swarm, \n",
+    "                               conditions    = [freeslipBC,],\n",
+    "                               fn_viscosity  = viscosityMapFn, \n",
+    "                               #fn_bodyforce  = buoyancyFn)\n",
+    "                               #fn_stresshistory = inertiaFn,\n",
+    "                               fn_bodyforce  = buoyancyFn+RHS_fn)\n",
+    "                               #fn_one_on_lambda  = oneonlambdaFn)\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "massMatrixTerm = uw.systems.sle.MatrixAssemblyTerm_NA__NB__Fn(\n",
+    "                        assembledObject  = stokes0._kmatrix,\n",
+    "                        integrationSwarm = stokes0._constitMatTerm._integrationSwarm,\n",
+    "                        fn   = LHS_fn,\n",
+    "                        mesh = mesh)\n",
+    "\n",
+    "solver0 = uw.systems.Solver( stokes0 )\n",
+    "solver0.set_inner_method('mumps') \n",
+    "solver0.set_penalty(1e3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "top = mesh.specialSets[\"MaxJ_VertexSet\"]\n",
+    "surfaceArea = uw.utils.Integral(fn=1.0,mesh=mesh, integrationType='surface', surfaceIndexSet=top)\n",
+    "surfacePressureIntegral = uw.utils.Integral(fn=pressureField, mesh=mesh, integrationType='surface', surfaceIndexSet=top)\n",
+    "\n",
+    "# a callback function to calibrate the pressure - will pass to solver later\n",
+    "def pressure_calibrate():\n",
+    "    (area,) = surfaceArea.evaluate()\n",
+    "    (p0,) = surfacePressureIntegral.evaluate()\n",
+    "    offset = p0/area\n",
+    "    #print(\"Zeroing pressure using mean upper surface pressure {}\".format( offset ))\n",
+    "    pressureField.data[:] -= offset\n",
+    "    #velSwarm.data[:] = velocityField.evaluate(swarm)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Analysis tools\n",
+    "-----\n",
+    "\n",
+    "**RMS velocity**\n",
+    "\n",
+    "Set up integrals used to calculate the RMS velocity."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vdotv = fn.math.dot( velocityField, velocityField )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Main simulation loop\n",
+    "-----\n",
+    "\n",
+    "The main time stepping loop begins here. Before this the time and timestep are initialised to zero and the output statistics arrays are set up. Also the frequency of outputting basic statistics to the screen is set in steps_output.\n",
+    "\n",
+    "Note that there are two ``advector.integrate`` steps, one for each swarm, that need to be done each time step."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define an update function\n",
+    "def update():\n",
+    "    # Retrieve the maximum possible timestep for the advection system.\n",
+    "    \n",
+    "    dt1 = advector.get_max_dt()\n",
+    "    dt2 = dt_e.value\n",
+    "    dt = min(dt1,dt2)\n",
+    "    \n",
+    "    dt_e.value = dt\n",
+    "    print (\"dt_adv=\",dt1/nd(1.*u.second),\"dt_e=\",dt_e.value/nd(1.*u.second),\"dt=\",dt/nd(1.*u.second))        \n",
+    "\n",
+    "    previousVm.data[:] =  velocityField.evaluate(swarm) #( phi*previousVm_data[:] + ( 1.-phi )*previousVm.data[:] )\n",
+    "    \n",
+    "    \n",
+    "    #densitySwarm = densityFn.evaluate(swarm)\n",
+    "    \n",
+    "    # Advect using this timestep size.    \n",
+    "    advector.integrate(dt)\n",
+    "    advector_tracer.integrate(dt)\n",
+    "    advector_band.integrate(dt)\n",
+    "    \n",
+    "    pop_control.repopulate()\n",
+    "    pop_control_band.repopulate()\n",
+    "    \n",
+    "    return time+dt, step+1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Linear solver (OO4DX61N__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.011886 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02989 secs / 1 its\n",
+      "  Pressure Solve:         = 206.2 secs / 10000 its\n",
+      "  Final V Solve:          = 0.02037 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 210.372666 seconds\n",
+      "\n",
+      "Linear solver (OO4DX61N__system-execute), solution time 2.103912e+02 (secs)\n",
+      "step =      0; time = 0.000e+00; v_rms = 1.196e+05; height = 8.00000e+01\n",
+      "Vy-max= 628270.848263\n",
+      "dt_adv= 2.9837138618742044e-09 dt_e= 2.9837138618742044e-09 dt= 2.9837138618742044e-09\n",
+      "Time Integration\n",
+      "\t2nd order:                 EX9JD1SA__integrand -    0.1462 [min] /    0.1462 [max] (secs)\n",
+      "Time Integration - 0.146288 [min] / 0.146288 [max] (secs)\n",
+      "Time Integration\n",
+      "\t2nd order:                 90CDJ7S1__integrand -    0.0000 [min] /    0.0000 [max] (secs)\n",
+      "Time Integration - 5.88894e-05 [min] / 5.88894e-05 [max] (secs)\n",
+      "Time Integration\n",
+      "\t2nd order:                 KE2416J4__integrand -    0.0521 [min] /    0.0521 [max] (secs)\n",
+      "Time Integration - 0.0521569 [min] / 0.0521569 [max] (secs)\n",
+      "In func WeightsCalculator_CalculateAll(): for swarm \"EILB2G4H__swarm\"\n",
+      "\tdone 33% (2731 cells)...\n",
+      "\tdone 67% (5462 cells)...\n",
+      "\tdone 100% (8192 cells)...\n",
+      "WeightsCalculator_CalculateAll(): finished update of weights for swarm \"EILB2G4H__swarm\"\n",
+      "In func WeightsCalculator_CalculateAll(): for swarm \"AOFBISSH__swarm\"\n",
+      "\tdone 33% (2731 cells)...\n",
+      "\tdone 67% (5462 cells)...\n",
+      "\tdone 100% (8192 cells)...\n",
+      "WeightsCalculator_CalculateAll(): finished update of weights for swarm \"AOFBISSH__swarm\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Stepping. Initialise time and timestep.\n",
+    "time = 0.\n",
+    "step = 0\n",
+    "nsteps = 1\n",
+    "\n",
+    "tSinker = np.zeros(nsteps)\n",
+    "ySinker = np.zeros([nsteps,3])\n",
+    "steps_output = 20\n",
+    "\n",
+    "if step == 0:\n",
+    "    title = ['step','time','Y','Vy']\n",
+    "    with open(outputPath+'Sample.csv', 'w') as f:\n",
+    "        csv_write = csv.writer(f)\n",
+    "        csv_write.writerow(title)\n",
+    "        \n",
+    "fn_Vy = fn.view.min_max(velocityField[1])  \n",
+    "\n",
+    "# Perform 10 steps\n",
+    "while step<nsteps:\n",
+    "\n",
+    "    \n",
+    "    solver0.solve()\n",
+    "    if step % steps_output == 0 or step == nsteps-1:\n",
+    "        mesh.save(outputPath+\"mesh\"+str(step).zfill(4)) \n",
+    "        swarm.save(outputPath+\"swarm\"+str(step).zfill(4))\n",
+    "        materialIndex.save(outputPath+\"materialVariable\"+str(step).zfill(4))\n",
+    "        velocityField.save(outputPath+\"velocityField\"+str(step).zfill(4))\n",
+    "        bandSwarm.save(outputPath+\"bandSwarm\"+str(step).zfill(4))\n",
+    "        material_band.save(outputPath+\"materialBand\"+str(step).zfill(4))\n",
+    "        \n",
+    "    outPutTrack = GetSwarmYMin()\n",
+    "    # Calculate the RMS velocity\n",
+    "    vrms = math.sqrt( mesh.integrate(vdotv)[0] / mesh.integrate(1.)[0] )\n",
+    "    if uw.mpi.rank==0:\n",
+    "        ySinker[step,0] = outPutTrack[0]\n",
+    "        ySinker[step,1] = outPutTrack[1]\n",
+    "        tSinker[step] = time\n",
+    "        print('step = {0:6d}; time = {1:.3e}; v_rms = {2:.3e}; height = {3:.5e}'\n",
+    "              .format(step,time/time_factor,vrms/vel_factor,outPutTrack[0]/length_factor))\n",
+    "        print  (\"Vy-max=\",np.max(-velocityField.data[:,1]/nd(1.*u.meter/u.second)))\n",
+    "        fn_ycoord.evaluate(tracerSwarm)\n",
+    "    fn_Vy.evaluate(tracerSwarm)\n",
+    "    velocityField.evaluate(tracerSwarm.particleCoordinates.data)\n",
+    "    \n",
+    "    ySinker[step,0] = fn_ycoord.min_global()\n",
+    "    ySinker[step,1] = fn_Vy.min_global()\n",
+    "    ySinker[step,2] = time\n",
+    "    tSinker[step] = time       \n",
+    "    \n",
+    "    if uw.mpi.rank == 0:\n",
+    "  \n",
+    "        dicMesh = { 'elements' : mesh.elementRes, \n",
+    "                    'minCoord' : mesh.minCoord,\n",
+    "                    'maxCoord' : mesh.maxCoord}\n",
+    "\n",
+    "        fo = open(outputPath+\"dicMesh\"+str(step).zfill(4),'w')\n",
+    "        fo.write(str(dicMesh))\n",
+    "        fo.close()  \n",
+    "        \n",
+    "    uw.mpi.barrier()\n",
+    "    \n",
+    "    if uw.mpi.rank== 0:\n",
+    "        SP_output = [step,time, ySinker[step,0],ySinker[step,1]]\n",
+    "        with open(outputPath+'Sample.csv', 'a') as f:\n",
+    "            csv_write = csv.writer(f)  \n",
+    "            csv_write.writerow(SP_output)\n",
+    "    uw.mpi.barrier()        \n",
+    "    \n",
+    "    # update\n",
+    "    time, step = update()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "underworld",
+   "language": "python",
+   "name": "underworld"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/model_code_inputs/FallingBall.gif b/model_code_inputs/FallingBall.gif
new file mode 100644
index 0000000..bf317f4
Binary files /dev/null and b/model_code_inputs/FallingBall.gif differ
diff --git a/model_code_inputs/High-order_2ndOrd_RodWave_Maxwell.ipynb b/model_code_inputs/High-order_2ndOrd_RodWave_Maxwell.ipynb
new file mode 100644
index 0000000..5e19149
--- /dev/null
+++ b/model_code_inputs/High-order_2ndOrd_RodWave_Maxwell.ipynb
@@ -0,0 +1,4186 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f0d4a50a",
+   "metadata": {},
+   "source": [
+    "# Interia term #\n",
+    "## $\\frac{\\partial \\sigma_{ij}}{\\partial x_j} =  -\\rho g_i  + \\rho \\frac{DV_i}{Dt} \\;\\;\\;(1)$  ## \n",
+    "**The Lagrangian implementation of finite difference of $\\frac{DV_i}{Dt}$** with second order precision\n",
+    "## $\\frac{\\partial \\sigma_{ij}}{\\partial x_j}=  -\\rho g_i +  \\rho [\\phi \\frac{V_i^{t+\\Delta t}-V_i^{t}}{\\Delta t} + (1-\\phi)\\frac{V_i^t-V_i^{t-\\Delta t}}{\\Delta t}] \\;\\;\\;(2)$ ##\n",
+    "\n",
+    "where $V_i^{t+\\Delta t}$, $V_i^{t}$, $V_i^{t-\\Delta t}$, is $V_i$ at next time step $t+\\Delta t$, current time step $t$ and previous time step $t-\\Delta t$, respectively\n",
+    "\n",
+    "Move to the current time step $V_i$ to  the left handside\n",
+    "\n",
+    "## $\\frac{\\partial \\sigma_{ij}}{\\partial x_j} - \\rho (1-2\\phi)\\frac{V_i^{t}}{\\Delta t} =  -\\rho g_i +  \\rho [\\phi \\frac{V_i^{t+\\Delta t}} {\\Delta t} - (1-\\phi)\\frac{V_i^{t-\\Delta t}}{\\Delta t}] \\;\\;\\;(3)$ ##\n",
+    "\n",
+    "With the consitutive equation, we get\n",
+    "## $2\\eta \\frac{\\partial^2 V_i^{t} }{\\partial x_j^2} - \\rho (1-2\\phi)\\frac{V_i^{t}}{\\Delta t}   - \\frac{\\partial P }{\\partial x_i}=  -\\rho g_i +  \\rho [\\phi \\frac{V_i^{t+\\Delta t}} {\\Delta t} - (1-\\phi)\\frac{V_i^{t-\\Delta t}}{\\Delta t}] \\;\\;\\;(4)$ ##\n",
+    "Consider the mass conservation for imcompressional material \n",
+    "$\\frac{\\partial V_i^t }{\\partial x_i} = 0$\n",
+    "\n",
+    "## $\\begin{bmatrix}\n",
+    " 2\\eta \\frac{\\partial^2 }{\\partial x_j^2} -\\frac{ \\rho (1-2\\phi)}{\\Delta t}  & \\frac{\\partial }{\\partial x_i} \\\\ \n",
+    " \\frac{\\partial }{\\partial x_i} & 0\n",
+    "\\end{bmatrix} \n",
+    "\\begin{bmatrix}\n",
+    " V_i^t \\\\ \n",
+    "P\n",
+    "\\end{bmatrix} = \\begin{bmatrix}\n",
+    " -\\rho [g_i - (\\phi \\frac{V_i^{t+\\Delta t}} {\\Delta t} - (1-\\phi)\\frac{V_i^{t-\\Delta t}}{\\Delta t})]\n",
+    "\\\\ \n",
+    "0\n",
+    "\\end{bmatrix} \\;\\;\\;(5) $ ##\n",
+    "\n",
+    "# Viscoelastic material - Maxwell implementation #\n",
+    "## $\\dot{\\varepsilon}_{ij} = \\dot{\\varepsilon}^e_{ij}  + \\dot{\\varepsilon}^v_{ij} = \\frac{{\\tau}'_{ij}}{2G} + \\frac{{\\tau}_{ij}}{2\\eta} \\;\\;\\;(6) $  ##\n",
+    "where $G$ is shear modulus and $\\eta$ is viscosity.\n",
+    "writing ${\\tau}'_{ij}$ in the second-order finite difference approximation\n",
+    "## ${\\tau}'_{ij} \\approx  [\\phi \\frac{\\tau_{ij}^{t+\\Delta t}-\\tau_{ij}^{t}}{\\Delta t} + (1-\\phi)\\frac{\\tau_{ij}^t-\\tau_{ij}^{t-\\Delta t}}{\\Delta t}] \\;\\;\\;(7)$  ##\n",
+    "Substituting Eq. (7) to Eq. (6), we have\n",
+    "## ${\\tau}_{ij} = 2\\eta \\frac{G\\Delta t}{G\\Delta t + (1-2\\phi)\\eta}[\\dot{\\varepsilon}_{ij}+\\frac{(1-\\phi)\\tau_{ij}^{t-\\Delta t}-\\phi\\tau_{ij}^{t+\\Delta t}}{2G\\Delta t}] \\;\\;\\;(8)$  ##\n",
+    "where effective viscoelastic viscosity $\\eta^{ve} = \\eta \\frac{G\\Delta t}{G\\Delta t + (1-2\\phi)\\eta} $ and effective viscoelastic strain rate\n",
+    "$\\dot{\\varepsilon}^{ve}_{ij} = \\dot{\\varepsilon}_{ij}+\\frac{(1-\\phi)\\tau_{ij}^{t-\\Delta t}-\\phi\\tau_{ij}^{t+\\Delta t}}{2G\\Delta t}$\n",
+    "substitute equation to momentum equation leads to \n",
+    "### $\\eta^{ve} \\frac{\\partial^2 V_i^{t} }{\\partial x_j^2} - \\rho (1-2\\phi)\\frac{V_i^{t}}{\\Delta t}   - \\frac{\\partial P }{\\partial x_i}=  -\\rho g_i +  \\rho [\\phi \\frac{V_i^{t+\\Delta t}} {\\Delta t} - (1-\\phi)\\frac{V_i^{t-\\Delta t}}{\\Delta t}]-\\frac{\\eta^{ve}}{G\\Delta t}\\frac{\\partial}{\\partial x_j}[(1-\\phi)\\tau_{ij}^{t-\\Delta t}-\\phi\\tau_{ij}^{t+\\Delta t}] \\;\\;\\;(9)$ ###\n",
+    "\n",
+    "Consider the mass conservation for imcompressional material \n",
+    "$\\frac{\\partial V_i^t }{\\partial x_i} = 0$ and combine it with Eq. (9)\n",
+    "\n",
+    "## $\\begin{bmatrix}\n",
+    " 2\\eta \\frac{\\partial^2 }{\\partial x_j^2} - \\frac{\\rho (1-2\\phi)}{\\Delta t}  & \\frac{\\partial }{\\partial x_i} \\\\ \n",
+    " \\frac{\\partial }{\\partial x_i} & 0\n",
+    "\\end{bmatrix} \n",
+    "\\begin{bmatrix}\n",
+    " V_i^t \\\\ \n",
+    "P\n",
+    "\\end{bmatrix} = \\begin{bmatrix}\n",
+    " -\\rho [g_i - (\\phi \\frac{V_i^{t+\\Delta t}} {\\Delta t} - (1-\\phi)\\frac{V_i^{t-\\Delta t}}{\\Delta t})]-\\frac{\\eta^{ve}}{G\\Delta t}\\frac{\\partial}{\\partial x_j}[(1-\\phi)\\tau_{ij}^{t-\\Delta t}-\\phi\\tau_{ij}^{t+\\Delta t}]\n",
+    "\\\\ \n",
+    "0\n",
+    "\\end{bmatrix} \\;\\;\\;(10) $ ##\n",
+    "\n",
+    "### Note that if $\\phi = 0 $,  it degrades to first order approximation and equals to what is implemented in Moresi et al. (2003) and Farrington et al. (2014). \n",
+    "## ***For the second-order implementation, $V_i^{t+\\Delta t}$ need to be predicted and corrected in an iterative fashion !!!*** ##"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9651b2be",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tGlobal element size: 800x3\n",
+      "\tLocal offset of rank 0: 0x0\n",
+      "\tLocal range of rank 0: 800x3\n",
+      "\tGlobal element size: 800x3\n",
+      "\tLocal offset of rank 0: 0x0\n",
+      "\tLocal range of rank 0: 800x3\n"
+     ]
+    }
+   ],
+   "source": [
+    "import underworld as uw\n",
+    "from underworld import function as fn\n",
+    "# %%\n",
+    "# coding: utf-8\n",
+    "import underworld as uw\n",
+    "from underworld import function as fn\n",
+    "#import glucifer\n",
+    "\n",
+    "import numpy as np\n",
+    "import math\n",
+    "import os,csv\n",
+    "import mpi4py\n",
+    "import random\n",
+    "comm = mpi4py.MPI.COMM_WORLD\n",
+    "\n",
+    "#from unsupported.lithopress import lithoPressure\n",
+    "#from unsupported.LMR import *\n",
+    "from underworld.scaling import units as u\n",
+    "from underworld.scaling import non_dimensionalise as nd\n",
+    "# %%\n",
+    "\n",
+    "\n",
+    "LoadFromFile = False\n",
+    "Fractal = False\n",
+    "Eqk = True\n",
+    "#outputPath = os.path.join(os.path.abspath(\".\"),\"Rate_state_2D_B4/\")\n",
+    "\n",
+    "outputPath = os.path.join(os.path.abspath(\".\"),\"Wave_taoD05_dt001_8003_rk2_hybrid_omiga1_combined/\")\n",
+    "inputPath  = outputPath\n",
+    "if uw.mpi.rank == 0:\n",
+    "    if not os.path.exists(outputPath):\n",
+    "        os.makedirs(outputPath)\n",
+    "uw.mpi.barrier()\n",
+    "if uw.mpi.rank == 0:\n",
+    "    if not os.path.exists(inputPath):\n",
+    "        os.makedirs(inputPath)\n",
+    "uw.mpi.barrier()\n",
+    "\n",
+    "scaling_coefficients = uw.scaling.get_coefficients()\n",
+    "\n",
+    "nsteps = 600\n",
+    "\n",
+    "\n",
+    "# Define scale criteria\n",
+    "tempMin = 273.*u.degK \n",
+    "tempMax = (1400.+ 273.)*u.degK\n",
+    "bodyforce = 3300. * u.kilogram / u.metre**3 * 0.01 * u.meter / u.second**2\n",
+    "velocity = 1*u.meter/u.second\n",
+    "\n",
+    "KL = 100*u.meter\n",
+    "Kt = KL/velocity\n",
+    "KT = tempMax \n",
+    "KM = bodyforce * KL**2 * Kt**2\n",
+    "K  = 1.*u.mole\n",
+    "lengthScale = 100e3\n",
+    "\n",
+    "scaling_coefficients[\"[length]\"] = KL\n",
+    "scaling_coefficients[\"[time]\"] = Kt\n",
+    "scaling_coefficients[\"[mass]\"]= KM\n",
+    "scaling_coefficients[\"[temperature]\"] = KT\n",
+    "scaling_coefficients[\"[substance]\"] = K\n",
+    "\n",
+    "gravity = nd(0. * u.meter / u.second**2)\n",
+    "R = nd(8.3144621 * u.joule / u.mole / u.degK)\n",
+    "\n",
+    "dt_min = nd(1e-5*u.second) \n",
+    "dt_max = nd(5.*u.year)\n",
+    "\n",
+    "if(LoadFromFile == True):\n",
+    "    step = 650\n",
+    "    step_out = 10\n",
+    "    time = fn.misc.constant(float(np.load(inputPath+\"time\"+str(step).zfill(4)+\".npy\")))\n",
+    "    dt_e = fn.misc.constant(float(np.load(inputPath+\"dt\"+str(step).zfill(4)+\".npy\")))\n",
+    "    step1 = 13\n",
+    "    Eqk = True\n",
+    "    \n",
+    "if(LoadFromFile == False):\n",
+    "    step = 0\n",
+    "    step_out = 50\n",
+    "    time = fn.misc.constant(0.)  # Initial time\n",
+    "    dt_e   = fn.misc.constant(nd(1.*0.001*u.second))\n",
+    "    omiga  = fn.misc.constant(0.1)\n",
+    "    omiga_v = fn.misc.constant(0.1)\n",
+    "    step1 = 13\n",
+    "    Eqk = True\n",
+    "elementType = \"Q2/dpc1\"  \n",
+    "# elementType = \"Q1/dQ0\" \n",
+    "\n",
+    "resX = 800\n",
+    "resY = 3\n",
+    "materialA = 1\n",
+    "materialB = 0\n",
+    "mesh = uw.mesh.FeMesh_Cartesian( elementType = (elementType), \n",
+    "                                 elementRes  = ( resX, resY)\n",
+    "                                  ) \n",
+    "\n",
+    "#if(LoadFromFile == False):      \n",
+    "minX  = nd(-550 * u.meter)\n",
+    "maxX  = nd(550 * u.meter)\n",
+    "minY  = nd(-2.34 * u.meter)\n",
+    "maxY  = nd( 2.34 * u.meter)\n",
+    "\n",
+    "\n",
+    "mesh = uw.mesh.FeMesh_Cartesian( elementType = (elementType), \n",
+    "                                 elementRes  = ( resX, resY), \n",
+    "                                 minCoord    = ( minX, minY), \n",
+    "                                 maxCoord    = ( maxX, maxY),\n",
+    "                                 periodic    = [False,True]  ) \n",
+    "\n",
+    "\n",
+    "\n",
+    "velocityField    = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=mesh.dim )\n",
+    "pressureField    = uw.mesh.MeshVariable( mesh=mesh.subMesh, nodeDofCount=1 )\n",
+    "\n",
+    "previousVel = uw.mesh.MeshVariable( mesh=mesh, nodeDofCount=2 )\n",
+    "previousVel.data[:] = [0.,0.]\n",
+    "velocityField.data[:] = [0.,0.]\n",
+    "pressureField.data[:] = 0.\n",
+    "\n",
+    "\n",
+    "#  Boundary conditions\n",
+    " \n",
+    "# Pure shear with moving  walls — all boundaries are zero traction with \n",
+    "\n",
+    "# In[4]:\n",
+    "\n",
+    "iWalls = mesh.specialSets[\"MinI_VertexSet\"] + mesh.specialSets[\"MaxI_VertexSet\"]\n",
+    "jWalls = mesh.specialSets[\"MinJ_VertexSet\"] + mesh.specialSets[\"MaxJ_VertexSet\"]\n",
+    "base   = mesh.specialSets[\"MinJ_VertexSet\"]\n",
+    "top    = mesh.specialSets[\"MaxJ_VertexSet\"]\n",
+    "right  = mesh.specialSets[\"MaxI_VertexSet\"]\n",
+    "left   = mesh.specialSets[\"MinI_VertexSet\"]\n",
+    "\n",
+    "allWalls = iWalls + jWalls\n",
+    "\n",
+    "        \n",
+    "for index in mesh.specialSets[\"MaxI_VertexSet\"]:\n",
+    "    velocityField.data[index,1] = 20#20.*np.sin(nd(f_factor*np.pi*2./u.second)*time.value)#   \n",
+    "    \n",
+    "velocityBCs = uw.conditions.DirichletCondition( variable        = velocityField, \n",
+    "                                                indexSetsPerDof = (iWalls,iWalls-jWalls) )\n",
+    "\n",
+    "swarm  = uw.swarm.Swarm( mesh=mesh,particleEscape=True )\n",
+    "gaussSwarm = uw.swarm.GaussIntegrationSwarm( mesh=mesh,particleCount=5)\n",
+    "\n",
+    "\n",
+    "pop_control = uw.swarm.PopulationControl(swarm,aggressive=True,particlesPerCell=30)\n",
+    "previousStress  = swarm.add_variable( dataType=\"double\", count=3 )\n",
+    "previousVm =  swarm.add_variable( dataType=\"double\", count=2 )\n",
+    "previousVm2 =  swarm.add_variable( dataType=\"double\", count=2 )\n",
+    "previousStress2  = swarm.add_variable( dataType=\"double\", count=3 )\n",
+    "previousVm2B =  swarm.add_variable( dataType=\"double\", count=2 )\n",
+    "previousStress2B  = swarm.add_variable( dataType=\"double\", count=3 )\n",
+    "StressB  = swarm.add_variable( dataType=\"double\", count=3 )\n",
+    "\n",
+    "velA  =  swarm.add_variable( dataType=\"double\", count=2 )\n",
+    "velB =  swarm.add_variable( dataType=\"double\", count=2 )\n",
+    "\n",
+    "\n",
+    "\n",
+    "advMat        = uw.systems.SwarmAdvector( swarm=swarm, velocityField=velocityField, order=2 )\n",
+    "\n",
+    "materialVariable = swarm.add_variable( dataType=\"int\", count=1 )\n",
+    "\n",
+    "if(LoadFromFile == True):  \n",
+    "    swarm.load(inputPath+\"swarm\"+str(step).zfill(4))\n",
+    "    #import ipdb; ipdb.set_trace()\n",
+    "    materialVariable.load(inputPath+\"materialVariable\"+str(step).zfill(4))   \n",
+    "    materialIndex.load(inputPath+\"materialIndex\"+str(step).zfill(4)) \n",
+    "\n",
+    "\n",
+    "\n",
+    "    if (Elasticity ==True):\n",
+    "        previousStress.load(outputPath+\"previousStress\"+str(step).zfill(4))\n",
+    "        previousStress2.load(outputPath+\"previousStress2\"+str(step).zfill(4))\n",
+    "        previousVm.load(outputPath+\"previousVm\"+str(step).zfill(4))\n",
+    "        previousVm2.load(outputPath+\"previousVm2\"+str(step).zfill(4))\n",
+    "\n",
+    "if(LoadFromFile == False): \n",
+    "    \n",
+    "    swarmLayout = uw.swarm.layouts.PerCellSpaceFillerLayout(swarm=swarm,particlesPerCell= 30 )\n",
+    "    swarm.populate_using_layout( layout=swarmLayout )\n",
+    " \n",
+    "    \n",
+    "    coord = fn.input()\n",
+    "    material_map = [((coord[0]<minX*0.9),materialB),                   \n",
+    "                    (True,materialA)]\n",
+    "    materialVariable.data[:] = fn.branching.conditional(material_map).evaluate(swarm)                                        \n",
+    "    \n",
+    "    \n",
+    "    previousStress.data[:] = 0.\n",
+    "    previousStress2.data[:] = 0.\n",
+    "    previousVm.data[:] = 0.\n",
+    "    previousVm2.data[:] = 0."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4140934f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "densityMap = { materialA: nd(   2700. * u.kilogram / u.metre**3),\n",
+    "           materialB: nd(   2700. * u.kilogram / u.metre**3)}\n",
+    "\n",
+    "densityFn = fn.branching.map( fn_key=materialVariable, mapping=densityMap )\n",
+    "\n",
+    "# And the final buoyancy force function. For the benchmark model, no bouyancy is considered.\n",
+    "z_hat = ( 1.0, 0.0 )      \n",
+    "buoyancyFn = densityFn * z_hat * gravity\n",
+    "\n",
+    "\n",
+    "viscosityA = nd(3e10*0.05 * u.pascal * u.second) \n",
+    "\n",
+    "mu = nd(3e10 * u.pascal)                  \n",
+    "\n",
+    "\n",
+    "\n",
+    "mappingDictViscosity1   = { materialA: viscosityA,\n",
+    "                            materialB: viscosityA}\n",
+    "viscosityMapFn1         = fn.branching.map( fn_key=materialVariable, mapping=mappingDictViscosity1 )\n",
+    "\n",
+    "mappingDictMu     = { materialA: mu,\n",
+    "                      materialB: mu}\n",
+    "muFn   = fn.branching.map( fn_key=materialVariable, mapping=mappingDictMu )\n",
+    "\n",
+    "alpha   = viscosityMapFn1/ muFn                         # viscoelastic relaxation time"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81161e20",
+   "metadata": {},
+   "source": [
+    "## first define the first-order approximation for Navier-Stokes funciton"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7e7d9e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eta_eff = ( viscosityMapFn1 * dt_e ) / (alpha + dt_e)  # effective viscosity\n",
+    "\n",
+    "mappingDictViscosity   = { materialA: eta_eff,\n",
+    "                           materialB: eta_eff}\n",
+    "viscosityFn   = fn.branching.map( fn_key=materialVariable, mapping=mappingDictViscosity )\n",
+    "\n",
+    "tauHistoryFn    = viscosityFn / ( muFn * dt_e ) * previousStress\n",
+    "\n",
+    "strainRateFn = fn.tensor.symmetric( velocityField.fn_gradient )\n",
+    "\n",
+    "strainRate_eff = strainRateFn+previousStress/(2.*muFn*dt_e)\n",
+    "\n",
+    "stressMapFn    = 2. * viscosityFn  * strainRate_eff\n",
+    "\n",
+    "\n",
+    "\n",
+    "LHS_fn = densityFn/dt_e \n",
+    "RHS_fn = densityFn*previousVm/dt_e\n",
+    "\n",
+    "stokes0 = uw.systems.Stokes(    velocityField = velocityField, \n",
+    "                           pressureField = pressureField,\n",
+    "                           voronoi_swarm = swarm, \n",
+    "#                                gauss_swarm = gaussSwarm,\n",
+    "                           conditions    = [velocityBCs,],\n",
+    "                           fn_viscosity  = viscosityFn, \n",
+    "                           fn_bodyforce  = buoyancyFn+RHS_fn,\n",
+    "                           fn_stresshistory = tauHistoryFn)\n",
+    "\n",
+    "massMatrixTerm = uw.systems.sle.MatrixAssemblyTerm_NA__NB__Fn(\n",
+    "                    assembledObject  = stokes0._kmatrix,\n",
+    "                    integrationSwarm = stokes0._constitMatTerm._integrationSwarm,\n",
+    "                    fn   = LHS_fn,\n",
+    "                    mesh = mesh)\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "solver = uw.systems.Solver( stokes0 )\n",
+    "\n",
+    "\n",
+    "\n",
+    "solver.set_inner_method('mumps') \n",
+    "solver.set_penalty(1e3) \n",
+    "solver.options.ksp_rtol=1e-8\n",
+    "solver.options.scr.ksp_rtol = 1.0e-6"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f73d372",
+   "metadata": {},
+   "source": [
+    "## define the second-order approximation for Navier-Stokes funciton"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "cfd7c613",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/haibin/miniconda3/envs/underworld/lib/python3.8/site-packages/underworld/systems/_stokes.py:180: UserWarning: Voronoi integration may yield unsatisfactory results for Q2 mesh.\n",
+      "  warnings.warn(\"Voronoi integration may yield unsatisfactory results for Q2 mesh.\")\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "In func WeightsCalculator_CalculateAll(): for swarm \"49TC5MXK__swarm\"\n",
+      "\tdone 33% (800 cells)...\n",
+      "\tdone 67% (1600 cells)...\n",
+      "\tdone 100% (2400 cells)...\n",
+      "WeightsCalculator_CalculateAll(): finished update of weights for swarm \"49TC5MXK__swarm\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "eta_eff1 = ( viscosityMapFn1 * dt_e ) / ((1.-2.*omiga)*alpha + dt_e)  # effective viscosity\n",
+    "\n",
+    "mappingDictViscosity1   = { materialA: eta_eff1,\n",
+    "                           materialB: eta_eff1}\n",
+    "viscosityFn1   = fn.branching.map( fn_key=materialVariable, mapping=mappingDictViscosity1 )\n",
+    "\n",
+    "tauHistoryFn1    = viscosityFn1 / ( muFn * dt_e) * ((1.-omiga)*previousStress2-omiga*StressB)\n",
+    "\n",
+    "strainRateFn1 = fn.tensor.symmetric( velocityField.fn_gradient )\n",
+    "\n",
+    "strainRate_eff1 = strainRateFn1+((1.-omiga)*previousStress2-omiga*StressB)/(2.*muFn*dt_e)\n",
+    "\n",
+    "stressMapFn1    = 2. * viscosityFn1  * strainRate_eff1\n",
+    "\n",
+    "\n",
+    "\n",
+    "LHS_fn1 = densityFn*(1.-2.*omiga_v)/dt_e    \n",
+    "RHS_fn1 = densityFn*((1.-omiga_v)*previousVm2/dt_e-omiga_v*velB/dt_e)\n",
+    "\n",
+    "stokes1 = uw.systems.Stokes(    velocityField = velocityField, \n",
+    "                           pressureField = pressureField,\n",
+    "                           voronoi_swarm = swarm, \n",
+    "#                                gauss_swarm = gaussSwarm,\n",
+    "                           conditions    = [velocityBCs,],\n",
+    "                           fn_viscosity  = viscosityFn1, \n",
+    "                           fn_bodyforce  = buoyancyFn+RHS_fn1,\n",
+    "                           fn_stresshistory = tauHistoryFn1)\n",
+    "\n",
+    "massMatrixTerm1 = uw.systems.sle.MatrixAssemblyTerm_NA__NB__Fn(\n",
+    "                    assembledObject  = stokes1._kmatrix,\n",
+    "                    integrationSwarm = stokes1._constitMatTerm._integrationSwarm,\n",
+    "                    fn   = LHS_fn1,\n",
+    "                    mesh = mesh)\n",
+    "\n",
+    "solver1 = uw.systems.Solver( stokes1 )\n",
+    "solver1.set_inner_method('mumps') \n",
+    "solver1.set_penalty(1e3) \n",
+    "solver1.options.ksp_rtol=1e-8\n",
+    "solver1.options.scr.ksp_rtol = 1.0e-6\n",
+    "\n",
+    "# test it out"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "5dd781f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028868 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03309 secs / 1 its\n",
+      "  Pressure Solve:         = 1.683 secs / 62 its\n",
+      "  Final V Solve:          = 0.02143 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.142459 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.144479e+00 (secs)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/haibin/miniconda3/envs/underworld/lib/python3.8/site-packages/underworld/systems/_bsscr.py:501: UserWarning: A floating-point error has been detected during the solve. Solution fields are possibly erroneous. \n",
+      "\n",
+      "This is likely due to overly large value variations within your linear system, or a fragile (or incorrect) solver configuration. If your inputs are constructed using real world physical units, you may need to rescale them for solver amenability. \n",
+      "\n",
+      "\n",
+      "  warnings.warn(estring)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.024732 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02123 secs / 1 its\n",
+      "  Pressure Solve:         = 2.191 secs / 80 its\n",
+      "  Final V Solve:          = 0.02203 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.560380 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.561706e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.027416 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03802 secs / 1 its\n",
+      "  Pressure Solve:         = 2.072 secs / 89 its\n",
+      "  Final V Solve:          = 0.02176 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.484437 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.485614e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.020937 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02161 secs / 1 its\n",
+      "  Pressure Solve:         = 1.856 secs / 80 its\n",
+      "  Final V Solve:          = 0.02185 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.142575 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.143944e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.020958229521479396, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.023634 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02116 secs / 1 its\n",
+      "  Pressure Solve:         = 2.025 secs / 89 its\n",
+      "  Final V Solve:          = 0.02171 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.319710 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.320905e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.022128 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02127 secs / 1 its\n",
+      "  Pressure Solve:         = 1.785 secs / 80 its\n",
+      "  Final V Solve:          = 0.02069 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.078564 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.080242e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.001852838712656615, its_num=1\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =      0; time = 0.000e+00;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.023461 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02158 secs / 1 its\n",
+      "  Pressure Solve:         = 1.631 secs / 70 its\n",
+      "  Final V Solve:          = 0.02217 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 1.924859 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 1.926084e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.022263 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0223 secs / 1 its\n",
+      "  Pressure Solve:         = 1.969 secs / 84 its\n",
+      "  Final V Solve:          = 0.0216 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.258931 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.260158e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.024435 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02117 secs / 1 its\n",
+      "  Pressure Solve:         = 2.044 secs / 88 its\n",
+      "  Final V Solve:          = 0.02189 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.342447 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.343639e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.022536 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02192 secs / 1 its\n",
+      "  Pressure Solve:         = 1.993 secs / 84 its\n",
+      "  Final V Solve:          = 0.02134 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.288062 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.289257e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.011968788414069223, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.027063 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02266 secs / 1 its\n",
+      "  Pressure Solve:         = 2.052 secs / 88 its\n",
+      "  Final V Solve:          = 0.02413 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.375637 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.377055e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.027641 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02828 secs / 1 its\n",
+      "  Pressure Solve:         = 2.164 secs / 84 its\n",
+      "  Final V Solve:          = 0.02398 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.531476 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.533150e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.001123701651395, its_num=1\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =      1; time = 1.000e-03;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.027806 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02587 secs / 1 its\n",
+      "  Pressure Solve:         = 1.763 secs / 71 its\n",
+      "  Final V Solve:          = 0.02269 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.099662 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.101057e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025969 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02424 secs / 1 its\n",
+      "  Pressure Solve:         = 2.044 secs / 84 its\n",
+      "  Final V Solve:          = 0.02307 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.388994 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.390523e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026344 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02467 secs / 1 its\n",
+      "  Pressure Solve:         = 2.071 secs / 88 its\n",
+      "  Final V Solve:          = 0.02172 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.412468 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.413813e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.024360 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02361 secs / 1 its\n",
+      "  Pressure Solve:         = 2.043 secs / 84 its\n",
+      "  Final V Solve:          = 0.0223 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.360223 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.361609e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.00840136176289883, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "step =      2; time = 2.000e-03;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026583 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02321 secs / 1 its\n",
+      "  Pressure Solve:         = 1.738 secs / 70 its\n",
+      "  Final V Solve:          = 0.02154 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.062182 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.063547e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.023598 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02353 secs / 1 its\n",
+      "  Pressure Solve:         = 1.973 secs / 83 its\n",
+      "  Final V Solve:          = 0.02279 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.292131 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.293503e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.030448 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02508 secs / 1 its\n",
+      "  Pressure Solve:         = 2.161 secs / 88 its\n",
+      "  Final V Solve:          = 0.02319 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.504937 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.506479e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026713 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02343 secs / 1 its\n",
+      "  Pressure Solve:         = 1.958 secs / 83 its\n",
+      "  Final V Solve:          = 0.02286 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.297562 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.299178e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.006028331425581865, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =      3; time = 3.000e-03;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025235 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02271 secs / 1 its\n",
+      "  Pressure Solve:         = 1.618 secs / 70 its\n",
+      "  Final V Solve:          = 0.02205 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 1.934278 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 1.935583e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.030921 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02476 secs / 1 its\n",
+      "  Pressure Solve:         = 2.04 secs / 83 its\n",
+      "  Final V Solve:          = 0.02349 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.382652 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.384247e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.030615 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0285 secs / 1 its\n",
+      "  Pressure Solve:         = 2.29 secs / 88 its\n",
+      "  Final V Solve:          = 0.02279 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.664552 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.665993e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.024816 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02684 secs / 1 its\n",
+      "  Pressure Solve:         = 2.066 secs / 83 its\n",
+      "  Final V Solve:          = 0.02328 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.409632 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.411002e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0048659334779358005, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =      4; time = 4.000e-03;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.030932 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02473 secs / 1 its\n",
+      "  Pressure Solve:         = 1.807 secs / 70 its\n",
+      "  Final V Solve:          = 0.02924 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.157124 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.158457e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026115 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03009 secs / 1 its\n",
+      "  Pressure Solve:         = 1.989 secs / 83 its\n",
+      "  Final V Solve:          = 0.02167 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.360482 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.361997e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025929 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.024 secs / 1 its\n",
+      "  Pressure Solve:         = 2.13 secs / 87 its\n",
+      "  Final V Solve:          = 0.02198 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.461139 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.462434e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025658 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02548 secs / 1 its\n",
+      "  Pressure Solve:         = 2.035 secs / 83 its\n",
+      "  Final V Solve:          = 0.02179 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.367891 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.369521e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0040627024633010135, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =      5; time = 5.000e-03;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026646 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0242 secs / 1 its\n",
+      "  Pressure Solve:         = 1.654 secs / 70 its\n",
+      "  Final V Solve:          = 0.0219 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 1.979976 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 1.981409e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025661 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02437 secs / 1 its\n",
+      "  Pressure Solve:         = 2.024 secs / 83 its\n",
+      "  Final V Solve:          = 0.02279 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.355618 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.357196e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.034146 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02862 secs / 1 its\n",
+      "  Pressure Solve:         = 2.259 secs / 87 its\n",
+      "  Final V Solve:          = 0.02376 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.649416 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.651177e+00 (secs)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028734 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02607 secs / 1 its\n",
+      "  Pressure Solve:         = 2.095 secs / 83 its\n",
+      "  Final V Solve:          = 0.0225 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.458017 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.459747e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.003472802839017443, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =      6; time = 6.000e-03;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.027989 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03042 secs / 1 its\n",
+      "  Pressure Solve:         = 1.709 secs / 70 its\n",
+      "  Final V Solve:          = 0.02191 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.084984 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.086363e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.024205 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02534 secs / 1 its\n",
+      "  Pressure Solve:         = 2.118 secs / 83 its\n",
+      "  Final V Solve:          = 0.02398 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.449236 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.450575e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.030832 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02598 secs / 1 its\n",
+      "  Pressure Solve:         = 2.269 secs / 87 its\n",
+      "  Final V Solve:          = 0.02506 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.632629 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.634281e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028871 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03039 secs / 1 its\n",
+      "  Pressure Solve:         = 2.298 secs / 83 its\n",
+      "  Final V Solve:          = 0.02322 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.688529 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.690134e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0030228800961876485, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =      7; time = 7.000e-03;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029201 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02903 secs / 1 its\n",
+      "  Pressure Solve:         = 1.791 secs / 70 its\n",
+      "  Final V Solve:          = 0.02372 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.159373 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.160824e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028204 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03246 secs / 1 its\n",
+      "  Pressure Solve:         = 2.31 secs / 83 its\n",
+      "  Final V Solve:          = 0.0243 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.701886 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.703488e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.038257 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.04268 secs / 1 its\n",
+      "  Pressure Solve:         = 2.674 secs / 87 its\n",
+      "  Final V Solve:          = 0.02691 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.149055 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 3.150880e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.031070 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03341 secs / 1 its\n",
+      "  Pressure Solve:         = 2.333 secs / 83 its\n",
+      "  Final V Solve:          = 0.02514 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.746794 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.748433e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0026687822260674137, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =      8; time = 8.000e-03;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028704 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02674 secs / 1 its\n",
+      "  Pressure Solve:         = 1.794 secs / 70 its\n",
+      "  Final V Solve:          = 0.02397 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.149859 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.151434e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029598 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02803 secs / 1 its\n",
+      "  Pressure Solve:         = 2.207 secs / 83 its\n",
+      "  Final V Solve:          = 0.02403 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.572450 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.574182e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.035793 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02959 secs / 1 its\n",
+      "  Pressure Solve:         = 2.357 secs / 87 its\n",
+      "  Final V Solve:          = 0.02506 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.757790 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.759843e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028581 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02964 secs / 1 its\n",
+      "  Pressure Solve:         = 2.121 secs / 83 its\n",
+      "  Final V Solve:          = 0.02332 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.486035 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.487595e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0023831693013623406, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =      9; time = 9.000e-03;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029210 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02592 secs / 1 its\n",
+      "  Pressure Solve:         = 1.71 secs / 70 its\n",
+      "  Final V Solve:          = 0.02314 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.064823 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.066275e+00 (secs)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.031682 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02688 secs / 1 its\n",
+      "  Pressure Solve:         = 2.038 secs / 82 its\n",
+      "  Final V Solve:          = 0.02322 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.398992 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.400898e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028706 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02531 secs / 1 its\n",
+      "  Pressure Solve:         = 2.143 secs / 87 its\n",
+      "  Final V Solve:          = 0.02246 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.488297 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.489942e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029009 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02737 secs / 1 its\n",
+      "  Pressure Solve:         = 2.106 secs / 83 its\n",
+      "  Final V Solve:          = 0.0242 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.460083 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.461798e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0021479315841398216, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     10; time = 1.000e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.031614 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03107 secs / 1 its\n",
+      "  Pressure Solve:         = 1.864 secs / 70 its\n",
+      "  Final V Solve:          = 0.02434 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.254543 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.256116e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.039090 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03816 secs / 1 its\n",
+      "  Pressure Solve:         = 2.865 secs / 82 its\n",
+      "  Final V Solve:          = 0.02649 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.341475 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 3.344105e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.038115 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03295 secs / 1 its\n",
+      "  Pressure Solve:         = 2.559 secs / 87 its\n",
+      "  Final V Solve:          = 0.02473 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.988069 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.990696e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.038823 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0311 secs / 1 its\n",
+      "  Pressure Solve:         = 2.31 secs / 82 its\n",
+      "  Final V Solve:          = 0.0243 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.707867 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.709936e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0019507264082257835, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     11; time = 1.100e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029337 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03158 secs / 1 its\n",
+      "  Pressure Solve:         = 1.785 secs / 69 its\n",
+      "  Final V Solve:          = 0.0239 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.158378 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.159827e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.033173 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03004 secs / 1 its\n",
+      "  Pressure Solve:         = 2.241 secs / 82 its\n",
+      "  Final V Solve:          = 0.02454 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.636668 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.638805e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029081 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02894 secs / 1 its\n",
+      "  Pressure Solve:         = 2.191 secs / 87 its\n",
+      "  Final V Solve:          = 0.02358 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.552768 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.554213e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026738 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0267 secs / 1 its\n",
+      "  Pressure Solve:         = 2.05 secs / 83 its\n",
+      "  Final V Solve:          = 0.02269 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.417329 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.418807e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.001782972234622857, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     12; time = 1.200e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.027680 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02763 secs / 1 its\n",
+      "  Pressure Solve:         = 1.684 secs / 69 its\n",
+      "  Final V Solve:          = 0.02206 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.034630 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.036043e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028405 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02538 secs / 1 its\n",
+      "  Pressure Solve:         = 1.954 secs / 82 its\n",
+      "  Final V Solve:          = 0.02616 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.293190 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.294571e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.030454 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02978 secs / 1 its\n",
+      "  Pressure Solve:         = 2.251 secs / 87 its\n",
+      "  Final V Solve:          = 0.02272 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.665109 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.666807e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025214 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02451 secs / 1 its\n",
+      "  Pressure Solve:         = 2.036 secs / 82 its\n",
+      "  Final V Solve:          = 0.02287 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.366426 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.367877e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0016385778123726546, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "step =     13; time = 1.300e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026515 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02291 secs / 1 its\n",
+      "  Pressure Solve:         = 1.621 secs / 69 its\n",
+      "  Final V Solve:          = 0.02149 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 1.946988 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 1.948319e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025452 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02532 secs / 1 its\n",
+      "  Pressure Solve:         = 1.966 secs / 82 its\n",
+      "  Final V Solve:          = 0.02171 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.282943 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.284269e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026946 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02582 secs / 1 its\n",
+      "  Pressure Solve:         = 2.155 secs / 87 its\n",
+      "  Final V Solve:          = 0.02361 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.494703 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.496130e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.033418 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02795 secs / 1 its\n",
+      "  Pressure Solve:         = 2.18 secs / 82 its\n",
+      "  Final V Solve:          = 0.02342 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.556871 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.558597e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0015131094838343449, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     14; time = 1.400e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.027906 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02799 secs / 1 its\n",
+      "  Pressure Solve:         = 1.779 secs / 69 its\n",
+      "  Final V Solve:          = 0.02451 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.144141 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.145539e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.030860 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02825 secs / 1 its\n",
+      "  Pressure Solve:         = 2.162 secs / 82 its\n",
+      "  Final V Solve:          = 0.0248 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.533569 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.535379e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.034763 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03256 secs / 1 its\n",
+      "  Pressure Solve:         = 2.713 secs / 86 its\n",
+      "  Final V Solve:          = 0.02776 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.114923 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 3.116614e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.036331 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03056 secs / 1 its\n",
+      "  Pressure Solve:         = 2.268 secs / 82 its\n",
+      "  Final V Solve:          = 0.02441 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.668783 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.670775e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0014032375447571124, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     15; time = 1.500e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029476 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03074 secs / 1 its\n",
+      "  Pressure Solve:         = 1.811 secs / 69 its\n",
+      "  Final V Solve:          = 0.02393 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.223411 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.224881e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028483 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03063 secs / 1 its\n",
+      "  Pressure Solve:         = 2.283 secs / 82 its\n",
+      "  Final V Solve:          = 0.02525 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.669412 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.671041e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.042089 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03707 secs / 1 its\n",
+      "  Pressure Solve:         = 2.729 secs / 86 its\n",
+      "  Final V Solve:          = 0.02756 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.208941 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 3.211498e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.033589 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03319 secs / 1 its\n",
+      "  Pressure Solve:         = 2.373 secs / 82 its\n",
+      "  Final V Solve:          = 0.02556 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.775889 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.778019e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0013063662285774053, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     16; time = 1.600e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028470 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02695 secs / 1 its\n",
+      "  Pressure Solve:         = 1.802 secs / 69 its\n",
+      "  Final V Solve:          = 0.02445 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.171954 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.173503e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.041859 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03219 secs / 1 its\n",
+      "  Pressure Solve:         = 2.334 secs / 82 its\n",
+      "  Final V Solve:          = 0.02752 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.769470 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.771979e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.035816 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0308 secs / 1 its\n",
+      "  Pressure Solve:         = 2.341 secs / 86 its\n",
+      "  Final V Solve:          = 0.02495 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.739650 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.742135e+00 (secs)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.036114 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03701 secs / 1 its\n",
+      "  Pressure Solve:         = 2.351 secs / 82 its\n",
+      "  Final V Solve:          = 0.02563 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.793771 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.795835e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0012204032738249721, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     17; time = 1.700e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.033648 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.04967 secs / 1 its\n",
+      "  Pressure Solve:         = 2.59 secs / 69 its\n",
+      "  Final V Solve:          = 0.03228 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.184360 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 3.185794e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.066605 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0306 secs / 1 its\n",
+      "  Pressure Solve:         = 2.552 secs / 82 its\n",
+      "  Final V Solve:          = 0.0249 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.039944 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 3.042717e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.031201 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03443 secs / 1 its\n",
+      "  Pressure Solve:         = 2.733 secs / 86 its\n",
+      "  Final V Solve:          = 0.02836 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.134037 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 3.135719e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.031913 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03141 secs / 1 its\n",
+      "  Pressure Solve:         = 2.337 secs / 82 its\n",
+      "  Final V Solve:          = 0.02618 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.736008 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.737571e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0011436342811180227, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     18; time = 1.800e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.024399 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02835 secs / 1 its\n",
+      "  Pressure Solve:         = 1.814 secs / 68 its\n",
+      "  Final V Solve:          = 0.02346 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.191500 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.192903e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.027915 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02763 secs / 1 its\n",
+      "  Pressure Solve:         = 2.098 secs / 82 its\n",
+      "  Final V Solve:          = 0.02478 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.456041 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.457446e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025267 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02495 secs / 1 its\n",
+      "  Pressure Solve:         = 2.198 secs / 86 its\n",
+      "  Final V Solve:          = 0.02376 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.539687 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.541085e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.027033 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02465 secs / 1 its\n",
+      "  Pressure Solve:         = 2.37 secs / 82 its\n",
+      "  Final V Solve:          = 0.02385 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.715417 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.716793e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0010746554564457754, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     19; time = 1.900e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025940 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02856 secs / 1 its\n",
+      "  Pressure Solve:         = 2.04 secs / 69 its\n",
+      "  Final V Solve:          = 0.02949 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.399466 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.400881e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.032006 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02866 secs / 1 its\n",
+      "  Pressure Solve:         = 2.258 secs / 82 its\n",
+      "  Final V Solve:          = 0.03065 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.655383 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.657028e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029141 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02949 secs / 1 its\n",
+      "  Pressure Solve:         = 2.252 secs / 86 its\n",
+      "  Final V Solve:          = 0.02374 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.628402 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.629898e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028133 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0272 secs / 1 its\n",
+      "  Pressure Solve:         = 2.196 secs / 82 its\n",
+      "  Final V Solve:          = 0.0276 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.552814 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.554203e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.001012324910798448, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     20; time = 2.000e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026394 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03073 secs / 1 its\n",
+      "  Pressure Solve:         = 1.89 secs / 68 its\n",
+      "  Final V Solve:          = 0.02471 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.262636 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.264098e+00 (secs)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028796 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03068 secs / 1 its\n",
+      "  Pressure Solve:         = 2.167 secs / 82 its\n",
+      "  Final V Solve:          = 0.02437 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.526538 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.528030e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026350 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02823 secs / 1 its\n",
+      "  Pressure Solve:         = 2.388 secs / 86 its\n",
+      "  Final V Solve:          = 0.02651 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.753592 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.755080e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.035376 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03316 secs / 1 its\n",
+      "  Pressure Solve:         = 2.565 secs / 82 its\n",
+      "  Final V Solve:          = 0.03022 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.016030 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 3.017798e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.000955716741761278, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     21; time = 2.100e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.030493 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03039 secs / 1 its\n",
+      "  Pressure Solve:         = 1.953 secs / 68 its\n",
+      "  Final V Solve:          = 0.02688 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.343772 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.345345e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.034760 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03512 secs / 1 its\n",
+      "  Pressure Solve:         = 2.571 secs / 82 its\n",
+      "  Final V Solve:          = 0.02846 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.006127 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 3.007983e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028744 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03417 secs / 1 its\n",
+      "  Pressure Solve:         = 2.451 secs / 86 its\n",
+      "  Final V Solve:          = 0.02624 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.825657 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.827269e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029734 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02886 secs / 1 its\n",
+      "  Pressure Solve:         = 2.199 secs / 82 its\n",
+      "  Final V Solve:          = 0.02486 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.576103 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.577683e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0009040793448936807, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     22; time = 2.200e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025002 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03024 secs / 1 its\n",
+      "  Pressure Solve:         = 1.802 secs / 68 its\n",
+      "  Final V Solve:          = 0.02466 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.152075 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.153528e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028143 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02402 secs / 1 its\n",
+      "  Pressure Solve:         = 2.129 secs / 82 its\n",
+      "  Final V Solve:          = 0.02525 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.452245 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.453663e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.024734 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02795 secs / 1 its\n",
+      "  Pressure Solve:         = 2.195 secs / 86 its\n",
+      "  Final V Solve:          = 0.0242 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.535407 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.536826e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028176 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02647 secs / 1 its\n",
+      "  Pressure Solve:         = 2.211 secs / 82 its\n",
+      "  Final V Solve:          = 0.02613 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.569944 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.571415e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0008568008064684448, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     23; time = 2.300e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028903 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03131 secs / 1 its\n",
+      "  Pressure Solve:         = 1.89 secs / 68 its\n",
+      "  Final V Solve:          = 0.0254 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.277288 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.278927e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029786 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02829 secs / 1 its\n",
+      "  Pressure Solve:         = 2.3 secs / 82 its\n",
+      "  Final V Solve:          = 0.02807 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.679212 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.680823e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029490 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02782 secs / 1 its\n",
+      "  Pressure Solve:         = 2.413 secs / 85 its\n",
+      "  Final V Solve:          = 0.02541 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.795637 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.797259e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.031394 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02826 secs / 1 its\n",
+      "  Pressure Solve:         = 2.214 secs / 82 its\n",
+      "  Final V Solve:          = 0.03544 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.599752 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.601245e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0008133800863045782, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "step =     24; time = 2.400e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028496 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02668 secs / 1 its\n",
+      "  Pressure Solve:         = 1.949 secs / 68 its\n",
+      "  Final V Solve:          = 0.02374 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.323752 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.325307e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028123 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02808 secs / 1 its\n",
+      "  Pressure Solve:         = 2.188 secs / 82 its\n",
+      "  Final V Solve:          = 0.02498 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.564280 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.565733e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.031848 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03488 secs / 1 its\n",
+      "  Pressure Solve:         = 2.44 secs / 85 its\n",
+      "  Final V Solve:          = 0.02675 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.851406 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.853060e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.035395 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.04016 secs / 1 its\n",
+      "  Pressure Solve:         = 2.796 secs / 82 its\n",
+      "  Final V Solve:          = 0.02878 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.253941 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 3.255843e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0007734022385584622, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     25; time = 2.500e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.034244 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03373 secs / 1 its\n",
+      "  Pressure Solve:         = 2.108 secs / 68 its\n",
+      "  Final V Solve:          = 0.02684 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.555715 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.557474e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028417 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03115 secs / 1 its\n",
+      "  Pressure Solve:         = 2.336 secs / 82 its\n",
+      "  Final V Solve:          = 0.02528 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.725083 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.726691e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029377 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02908 secs / 1 its\n",
+      "  Pressure Solve:         = 2.321 secs / 85 its\n",
+      "  Final V Solve:          = 0.02406 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.703697 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.705189e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.025272 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02721 secs / 1 its\n",
+      "  Pressure Solve:         = 2.129 secs / 81 its\n",
+      "  Final V Solve:          = 0.03157 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.491773 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.493194e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.000736517838083965, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     26; time = 2.600e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029900 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02851 secs / 1 its\n",
+      "  Pressure Solve:         = 1.83 secs / 68 its\n",
+      "  Final V Solve:          = 0.026 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.207249 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.210277e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.033561 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0332 secs / 1 its\n",
+      "  Pressure Solve:         = 2.625 secs / 82 its\n",
+      "  Final V Solve:          = 0.02904 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.025022 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 3.027160e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.035789 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03085 secs / 1 its\n",
+      "  Pressure Solve:         = 2.413 secs / 85 its\n",
+      "  Final V Solve:          = 0.02635 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.824371 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.826442e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.027803 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0368 secs / 1 its\n",
+      "  Pressure Solve:         = 2.927 secs / 82 its\n",
+      "  Final V Solve:          = 0.03577 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.368154 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 3.369781e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.000702426699233768, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     27; time = 2.700e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.054114 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03234 secs / 1 its\n",
+      "  Pressure Solve:         = 2.169 secs / 68 its\n",
+      "  Final V Solve:          = 0.03345 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.684568 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.687052e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.035566 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03253 secs / 1 its\n",
+      "  Pressure Solve:         = 3.382 secs / 81 its\n",
+      "  Final V Solve:          = 0.03712 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.882664 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 3.884873e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029028 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.07971 secs / 1 its\n",
+      "  Pressure Solve:         = 2.839 secs / 85 its\n",
+      "  Final V Solve:          = 0.02497 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.618778 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 3.620264e+00 (secs)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.062563 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02753 secs / 1 its\n",
+      "  Pressure Solve:         = 2.605 secs / 81 its\n",
+      "  Final V Solve:          = 0.0245 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.031882 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 3.034163e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0006708643076238936, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     28; time = 2.800e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.034847 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0322 secs / 1 its\n",
+      "  Pressure Solve:         = 1.993 secs / 68 its\n",
+      "  Final V Solve:          = 0.02506 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.401390 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.403443e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.026972 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02827 secs / 1 its\n",
+      "  Pressure Solve:         = 2.084 secs / 82 its\n",
+      "  Final V Solve:          = 0.02413 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.448136 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.449643e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.029444 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02886 secs / 1 its\n",
+      "  Pressure Solve:         = 2.228 secs / 85 its\n",
+      "  Final V Solve:          = 0.02432 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.600583 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.602118e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.032896 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03016 secs / 1 its\n",
+      "  Pressure Solve:         = 2.764 secs / 82 its\n",
+      "  Final V Solve:          = 0.03271 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 3.143710 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 3.145835e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.000641589537783765, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     29; time = 2.900e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.035717 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02892 secs / 1 its\n",
+      "  Pressure Solve:         = 2.156 secs / 68 its\n",
+      "  Final V Solve:          = 0.02627 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.552606 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.554467e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.047234 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.04064 secs / 1 its\n",
+      "  Pressure Solve:         = 3.618 secs / 81 its\n",
+      "  Final V Solve:          = 0.04686 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 4.229056 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 4.230757e+00 (secs)\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.030911 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.02777 secs / 1 its\n",
+      "  Pressure Solve:         = 2.489 secs / 85 its\n",
+      "  Final V Solve:          = 0.02543 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.877483 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.878979e+00 (secs)\n",
+      "Linear solver (64ZJWZYY__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.028001 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.0378 secs / 1 its\n",
+      "  Pressure Solve:         = 2.304 secs / 81 its\n",
+      "  Final V Solve:          = 0.0252 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.694071 seconds\n",
+      "\n",
+      "Linear solver (64ZJWZYY__system-execute), solution time 2.695819e+00 (secs)\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "nonlinear iteration: err=0.0006143747476590937, its_num=0\n",
+      "\n",
+      ">>>>>>>>>>>>>>>>>\n",
+      "\n",
+      "step =     30; time = 3.000e-02;\n",
+      "dt= 0.001\n",
+      "Linear solver (0G2JVDCU__system-execute) \n",
+      "\n",
+      "BSSCR -- Block Stokes Schur Compliment Reduction Solver \n",
+      "\n",
+      "\n",
+      "-----  K2_GMG  ------\n",
+      "\n",
+      "AUGMENTED LAGRANGIAN K2 METHOD - Penalty = 1000.000000\n",
+      "\n",
+      "\n",
+      "\t* K+p*K2 in time: 0.036298 seconds\n",
+      "\n",
+      "  Setting schur_pc to \"gkgdiag\" \n",
+      "\n",
+      "\n",
+      "SCR Solver Summary:\n",
+      "\n",
+      "  RHS V Solve:            = 0.03214 secs / 1 its\n",
+      "  Pressure Solve:         = 2.006 secs / 68 its\n",
+      "  Final V Solve:          = 0.03884 secs / 1 its\n",
+      "\n",
+      "  Total BSSCR Linear solve time: 2.427309 seconds\n",
+      "\n",
+      "Linear solver (0G2JVDCU__system-execute), solution time 2.429011e+00 (secs)\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[4], line 8\u001b[0m\n\u001b[1;32m      4\u001b[0m its \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m                      \u001b[38;5;66;03m# iteration count\u001b[39;00m\n\u001b[1;32m      6\u001b[0m dt_e\u001b[38;5;241m.\u001b[39mvalue  \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2.\u001b[39m\n\u001b[0;32m----> 8\u001b[0m \u001b[43msolver\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msolve\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[43mnonLinearIterate\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m     10\u001b[0m StressB\u001b[38;5;241m.\u001b[39mdata[:] \u001b[38;5;241m=\u001b[39m stressMapFn\u001b[38;5;241m.\u001b[39mevaluate(swarm)\n\u001b[1;32m     11\u001b[0m velB\u001b[38;5;241m.\u001b[39mdata[:] \u001b[38;5;241m=\u001b[39m  velocityField\u001b[38;5;241m.\u001b[39mevaluate(swarm)\n",
+      "File \u001b[0;32m~/miniconda3/envs/underworld/lib/python3.8/site-packages/underworld/systems/_bsscr.py:450\u001b[0m, in \u001b[0;36mStokesSolver.solve\u001b[0;34m(self, nonLinearIterate, nonLinearTolerance, nonLinearKillNonConvergent, nonLinearMinIterations, nonLinearMaxIterations, callback_post_solve, print_stats, reinitialise, **kwargs)\u001b[0m\n\u001b[1;32m    448\u001b[0m     libUnderworld\u001b[38;5;241m.\u001b[39mStgFEM\u001b[38;5;241m.\u001b[39mSystemLinearEquations_NonLinearExecute(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_stokesSLE\u001b[38;5;241m.\u001b[39m_cself, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m    449\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 450\u001b[0m     \u001b[43mlibUnderworld\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mStgFEM\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mSystemLinearEquations_ExecuteSolver\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_stokesSLE\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cself\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m    451\u001b[0m     libUnderworld\u001b[38;5;241m.\u001b[39mStgFEM\u001b[38;5;241m.\u001b[39mSystemLinearEquations_UpdateSolutionOntoNodes(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_stokesSLE\u001b[38;5;241m.\u001b[39m_cself, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m    454\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m print_stats:\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "while step<nsteps:\n",
+    "    \n",
+    "    er = 1.0\n",
+    "    its = 0                      # iteration count\n",
+    "    \n",
+    "    dt_e.value  *= 2.\n",
+    "    \n",
+    "    solver.solve( nonLinearIterate=False)\n",
+    "\n",
+    "    StressB.data[:] = stressMapFn.evaluate(swarm)\n",
+    "    velB.data[:] =  velocityField.evaluate(swarm)\n",
+    "\n",
+    "    dt_e.value  /= 2.\n",
+    "    \n",
+    "    solver1.solve( nonLinearIterate=False)\n",
+    "        \n",
+    "    v_old = velocityField.copy() \n",
+    "    \n",
+    "    # prediction and correction for the velocity field\n",
+    "    while er > 1e-2 and its < 5:\n",
+    "        \n",
+    "        v_old.data[:] = velocityField.data[:]\n",
+    "            \n",
+    "        previousVm.data[:] = velocityField.evaluate(swarm) \n",
+    "        previousStress.data[:] = stressMapFn1.evaluate(swarm)       \n",
+    "    \n",
+    "        solver.solve( nonLinearIterate=False)\n",
+    "        \n",
+    "        StressB.data[:] = stressMapFn.evaluate(swarm)\n",
+    "        velB.data[:] =  velocityField.evaluate(swarm)\n",
+    "        \n",
+    "        solver1.solve( nonLinearIterate=False)\n",
+    "        \n",
+    "#         velA.data[:] = velocityField.evaluate(swarm)   \n",
+    "  \n",
+    "        absErr = uw.utils._nps_2norm(velocityField.data-v_old.data)\n",
+    "        magT   = uw.utils._nps_2norm(v_old.data)\n",
+    "                                                    \n",
+    "        er = absErr/magT\n",
+    "        \n",
+    "        if uw.mpi.rank==0:\n",
+    "            print(\">>>>>>>>>>>>>>>>>\\n\")\n",
+    "            print(f\"nonlinear iteration: err={er}, its_num={its}\\n\")\n",
+    "            print(\">>>>>>>>>>>>>>>>>\\n\")      \n",
+    "        uw.mpi.barrier()\n",
+    "        \n",
+    "        its += 1\n",
+    "                                                                                      \n",
+    "    \n",
+    "    if (step%step_out==0):  \n",
+    "        \n",
+    "        if (Elasticity == True):\n",
+    " \n",
+    "            previousStress.save(outputPath+\"previousStress\"+str(step).zfill(4))\n",
+    "\n",
+    "        mesh.save(outputPath+\"mesh\"+str(step).zfill(4))\n",
+    "        swarm.save(outputPath+\"swarm\"+str(step).zfill(4))\n",
+    "        materialVariable.save(outputPath+\"materialVariable\"+str(step).zfill(4))\n",
+    "        velocityField.save(outputPath+\"velocityField\"+str(step).zfill(4))   \n",
+    "        previousVm.save(outputPath+\"previousVm\"+str(step).zfill(4))\n",
+    "        previousVm2.save(outputPath+\"previousVm2\"+str(step).zfill(4))\n",
+    "\n",
+    "        dicMesh = { 'elements' : mesh.elementRes, \n",
+    "                    'minCoord' : mesh.minCoord,\n",
+    "                    'maxCoord' : mesh.maxCoord}\n",
+    "\n",
+    "        fo = open(outputPath+\"dicMesh\"+str(step).zfill(4),'w')\n",
+    "        fo.write(str(dicMesh))\n",
+    "        fo.close()  \n",
+    "    \n",
+    "    if uw.mpi.rank == 0:\n",
+    "        np.save(outputPath+\"time\"+str(step).zfill(4),time.value)\n",
+    "        np.save(outputPath+\"dt\"+str(step).zfill(4),dt_e.value)\n",
+    "    uw.mpi.barrier()\n",
+    "    \n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    " \n",
+    "    \n",
+    "    \n",
+    "    Stress = uw.mesh.MeshVariable( mesh, 1 )\n",
+    "    projectorViscosity = uw.utils.MeshVariable_Projection(Stress,stressMapFn1[2], type=0 )\n",
+    "    projectorViscosity.solve()\n",
+    "        \n",
+    "    Stress.save(outputPath+\"stress\"+str(step).zfill(4))\n",
+    "    \n",
+    "    if uw.mpi.rank==0:   \n",
+    "        print('step = {0:6d}; time = {1:.3e};'.format(step,time.value/nd(1.*u.second)))\n",
+    "    uw.mpi.barrier()\n",
+    "\n",
+    "    dt = dt_e.value\n",
+    "    \n",
+    "    print (\"dt=\",dt/nd(1.*u.second))\n",
+    "    velA.data[:] = velocityField.evaluate(swarm)     \n",
+    "    \n",
+    "    previousVm2.data[:] = np.copy(velA.data[:])     \n",
+    "    previousStress2.data[:] = stressMapFn1.evaluate(swarm) \n",
+    "\n",
+    "    previousVm2B.data[:] = np.copy(velA.data[:])     \n",
+    "    previousStress2B.data[:] = stressMapFn1.evaluate(swarm) \n",
+    "    \n",
+    "    time.value = time.value+dt\n",
+    "    step = step + 1    \n",
+    "\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "2be867df",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "import underworld as uw\n",
+    "import math\n",
+    "from underworld import function as fn\n",
+    "from underworld import visualisation as glucifer\n",
+    "\n",
+    "import numpy as np\n",
+    "import os\n",
+    "\n",
+    "from underworld.scaling import units as u\n",
+    "from underworld.scaling import non_dimensionalise as nd\n",
+    "\n",
+    "import random\n",
+    "import matplotlib.pyplot as plt\n",
+    "from numpy import genfromtxt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "bf04a30d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tGlobal element size: 800x3\n",
+      "\tLocal offset of rank 0: 0x0\n",
+      "\tLocal range of rank 0: 800x3\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "vel = uw.mesh.MeshVariable( mesh, 3 )\n",
+    "meshRatio = uw.mesh.MeshVariable( mesh, 1 )\n",
+    "fig,ax0=plt.subplots(1,1,figsize=(10,6))\n",
+    "# fig,ax0=plt.subplots(1,1)\n",
+    "\n",
+    "\n",
+    "countx = 400\n",
+    "dy = (maxY-minY)/resY\n",
+    "dx = (maxX-minX)/resX\n",
+    "xcoord = np.linspace(minX, maxX, countx)\n",
+    "xcoord_a = np.linspace(0, 10, countx)\n",
+    "# xcoord = np.linspace(0.1, 0.25, countx)\n",
+    "#zcoord = np.linspace(0.0,maxY, countz)\n",
+    "surfacePoints = np.zeros((countx,2))\n",
+    "surfacePoints[:,0] = xcoord \n",
+    "surfacePoints[:,1] = 0.*dy \n",
+    "\n",
+    "tao0= 0.05\n",
+    "v0 = np.sqrt(3e10/2700)\n",
+    "sigma0 = nd(2700*v0*20*u.pascal)\n",
+    "\n",
+    "styles = ['k--','b--']\n",
+    "num = 1\n",
+    "import scipy\n",
+    "\n",
+    "# Path = [\"Wave_taoD05_dt0001_8003\",\"Wave_taoD05_dt001_8003\"]\n",
+    "Path = [\"Wave_taoD05_dt001_8003_rk2_hybrid_omiga1_nonlinear\"]\n",
+    "# Path = [\"Wave_taoD05_dt001_8003_rk2_Origin2\"]\n",
+    "for j in range(len(Path)):\n",
+    "    \n",
+    "    outputPath = os.path.join(os.path.abspath(\".\"),Path[j]+\"/\") \n",
+    "    step = 0\n",
+    "    fo = open(outputPath+\"dicMesh\"+str(step).zfill(4),'r')\n",
+    "    meshDic=eval(fo.read())\n",
+    "    elementType = \"Q2/dpc1\"\n",
+    "    # elementType = \"Q1/dQ0\"\n",
+    "    \n",
+    "    mesh = uw.mesh.FeMesh_Cartesian( elementType = elementType,\n",
+    "                                     elementRes  = meshDic['elements'], \n",
+    "                                     minCoord    = meshDic['minCoord'], \n",
+    "                                     maxCoord    = meshDic['maxCoord'],\n",
+    "                                     ) \n",
+    "\n",
+    "    resX=meshDic['elements'][0]\n",
+    "    resY=meshDic['elements'][1]\n",
+    "    vel = uw.mesh.MeshVariable( mesh, 2 )\n",
+    "    stress = uw.mesh.MeshVariable( mesh, 1 ) \n",
+    "\n",
+    "    for i in range(num):\n",
+    "        if j ==0:\n",
+    "#             step = 500*(0+i)+500\n",
+    "#             step = 50*(0+i)+50\n",
+    "            step = 50*(0+i)+50\n",
+    "        else:\n",
+    "            step =  50*(0+i)+50\n",
+    "        time = np.load(outputPath+\"time\"+str(step).zfill(4)+\".npy\")/nd(1.*u.second)\n",
+    "#         vel.load(outputPath+'velocityField'+str(step).zfill(4))\n",
+    "        stress.load(outputPath+'stress'+str(step).zfill(4))\n",
+    "    #     ax0.plot((xcoord),vel[1].evaluate(surfacePoints))\n",
+    "        psi = (xcoord)/nd(1.*u.meter)/(v0*tao0)\n",
+    "        psi_trans =  (maxX-xcoord)/nd(1.*u.meter)/(v0*tao0)\n",
+    "        tau = i+1\n",
+    "        psi_a = xcoord_a/nd(1.*u.meter)/(v0*tao0)\n",
+    "        f_a = np.exp(-tau/2.)*np.i0(0.5*np.sqrt(tau**2-psi_a**2))*np.heaviside(tau-psi_a,0)\n",
+    "        if i<num-1:            \n",
+    "            if j==0:\n",
+    "                ax0.plot(psi_a,f_a,color='C1',linewidth=4)\n",
+    "                ax0.text(0.2,1.02*np.nanmax(f_a),r'$\\tau=$'+str(i+1),fontsize=12)\n",
+    "            ax0.plot(psi_trans,stress.evaluate(surfacePoints)/sigma0,styles[j])\n",
+    "            \n",
+    "        else:\n",
+    "            if j == 0:\n",
+    "                ax0.plot(psi_a,f_a,color='C1',linewidth=4,label='Lee and Kanter(1953)')  \n",
+    "                ax0.plot(psi_trans,stress.evaluate(surfacePoints)/sigma0,styles[j],label='Underworld:dt=0.001s,0.3,nonlinear')\n",
+    "                ax0.text(0.2,1.02*np.nanmax(f_a),r'$\\tau=$'+str(i+1),fontsize=12)\n",
+    "            else:\n",
+    "                ax0.plot(psi_trans,stress.evaluate(surfacePoints)/sigma0,styles[j],label='Underworld:dt=0.001s')\n",
+    "\n",
+    "\n",
+    "        \n",
+    "\n",
+    "    # ax0.invert_xaxis()  \n",
+    "ax0.legend(fontsize=14)\n",
+    "\n",
+    "ax0.grid()\n",
+    "# ax0.set_xlim([0,1])\n",
+    "ax0.set_xlim([0.1,6.4])   \n",
+    "ax0.set_xlabel(r'$\\xi=x/c \\tau_0$', fontsize=16)\n",
+    "ax0.set_ylabel(r'$f=\\sigma/\\rho c v $', fontsize=16)\n",
+    "ax0.tick_params(axis='x', labelsize= 16)\n",
+    "ax0.tick_params(axis='y', labelsize= 16)\n",
+    "# plt.savefig('/home/haibin/Desktop/'+'Maxwell_tauD005_D001_Q2_800_dt_compare_0D3_nonlinear.jpg',dpi=300)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "underworld",
+   "language": "python",
+   "name": "underworld"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/model_code_inputs/README.md b/model_code_inputs/README.md
index d4d8796..35c8272 100644
--- a/model_code_inputs/README.md
+++ b/model_code_inputs/README.md
@@ -1,3 +1,47 @@
-# Model Code & Inputs
+<table>
+ <tr>
+  <td><img src='./Re40.gif'> Reynolds Number=40</td>
+  <td><img src='./Re400.gif'> Reynolds Number=400</td>
+ </tr>
+ <tr>
+  <td colspan="2"><img src='./Wave_Propagation.gif'> Viscoelastic Wave Propagation</td>
+ </tr>
+</table>
 
-## Notes:
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/underworld-community/template-project/master)
+
+[![DOI](https://zenodo.org/badge/636547421.svg)](https://zenodo.org/badge/latestdoi/636547421)
+
+Abstract
+-----
+Visco-elastic-plastic modelling approaches for long-term tectonic deformation assume that co-seismic fault displacement can be integrated over 1,000s-10,000s years (tens of earthquake cycles) with the appropriate failure law, and that short-timescale fluctuations in the stress field due to individual earthquakes have no effect on long-term behavior. Models of the earthquake rupture process generally assume that the tectonic (long-range) stress field or kinematic boundary conditions are steady over the course of multiple earthquake cycles. This study is aimed to fill the gap between long-term and short-term deformations by modeling earthquake cycles with the rate-and-state frictional relationship in Navier-Stokes equations. We reproduce benchmarks at the earthquake timescale to demonstrate the effectiveness of our approach. We then discuss how these high-resolution models degrade if the time-step cannot capture the rupture process accurately and, from this, infer when it is important to consider coupling of the two timescales and the level of accuracy required. To build upon these benchmarks, we undertake a generic study of a thrust fault in the crust with a prescribed geometry. It is found that lower crustal rheology affects the periodic time of characteristic earthquake cycles and the inter-seismic, free-surface deformation rate. In particular, the relaxation of the surface of a cratonic region (with a relatively strong lower crust) has a characteristic double-peaked uplift profile that persists for thousands of years after a major slip event. This pattern might be diagnostic of active faults in cratonic regions.
+
+
+
+File | Purpose
+--- | ---
+`Example_Reynolds_Strouhal_CylinderFlow.ipynb` | Viscous-incertial flow (Section 3.1 in MS). 
+`High-order_2ndOrd_RodWave_Maxwell.ipynb`| Vicoelastic wave Propation in a Maxwell Rod (Section 3.２ in MS). 
+`BP5-FD_imcompressible.py` | Fully dynamic modelling with incompressible media   (Section 3.3 in MS).
+`Thrust_2D.py` | 2D thrust fault model (case study in the MS).
+`Thrust_3D.py` | 3D thrust fault model (case study in the MS).
+'Re40.gif' | flow pattern with Re=40
+'Re400.gif' | flow pattern with Re=400
+'Wave_Propapgation.gif' | Visco-ealsctic wave propagation (different BC from that in MS) 
+
+Tests
+-----
+
+This study uses Underworld to reproduce the benchmark models provided by 
+
+_Kolomenskiy, D. and Schneider, K., 2009. A Fourier spectral method for the Navier–Stokes equations with volume penalization for moving solid obstacles. Journal of Computational Physics, 228(16), pp.5687-5709._
+
+_Lee, E.H. and Kanter, I., 1953. Wave propagation in finite rods of viscoelastic material. Journal of applied physics, 24(9), pp.1115-1122._
+
+_Jiang, J., Erickson, B.A., Lambert, V.R., Ampuero, J.P., Ando, R., Barbot, S.D., Cattania, C., Zilio, L.D., Duan, B., Dunham, E.M. and Gabriel, A.A., 2022. Community‐driven code comparisons for three‐dimensional dynamic modeling of sequences of earthquakes and aseismic slip. Journal of Geophysical Research: Solid Earth, 127(3), p.e2021JB023519._
+
+Better to take notebook file 'High-order_2ndOrd_RodWave_Maxwell.ipynb' as a start to check how different order FD approximaiton is implemented in the UW2 code
+
+Parallel Safe
+-------------
+3D model results can be obtained in parallel operation.
diff --git a/model_code_inputs/Re40.gif b/model_code_inputs/Re40.gif
new file mode 100644
index 0000000..35cbf5e
Binary files /dev/null and b/model_code_inputs/Re40.gif differ
diff --git a/model_code_inputs/Re400.gif b/model_code_inputs/Re400.gif
new file mode 100644
index 0000000..874bc71
Binary files /dev/null and b/model_code_inputs/Re400.gif differ
diff --git a/model_code_inputs/Thrust_2D.py b/model_code_inputs/Thrust_2D.py
new file mode 100644
index 0000000..7cfdcad
--- /dev/null
+++ b/model_code_inputs/Thrust_2D.py
@@ -0,0 +1,757 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[ ]:
+import warnings
+warnings.filterwarnings("ignore")
+import underworld as uw
+import math
+from underworld import function as fn
+import numpy as np
+import os,csv
+import mpi4py 
+# comm = mpi4py.MPI.COMM_WORLD
+import random
+
+from scipy.interpolate import interp1d
+
+from underworld.scaling import units as u
+from underworld.scaling import non_dimensionalise as nd
+
+from scipy.interpolate import interp1d
+import underworld as uw
+from mpi4py import MPI as _MPI
+
+comm = _MPI.COMM_WORLD
+rank = comm.rank
+size = comm.size
+
+# In[ ]:
+
+inputPath = os.path.join(os.path.abspath("."),"LMS72096_dep33_2D/")
+outputPath = os.path.join(os.path.abspath("."),"LMS72096_dep33_2D/")
+
+if uw.mpi.rank==0:
+    if not os.path.exists(outputPath):
+        os.makedirs(outputPath)
+if uw.mpi.rank==0:
+    if not os.path.exists(inputPath):
+        os.makedirs(inputPath)
+uw.mpi.barrier
+# continue running from specific time step
+LoadFromFile= False
+# partial melting funciton in mantle
+MeltFunction= False
+# set upper limit of the topography
+MaskTopo = False
+# refine mesh in specific area
+meshdeform = False
+# topo_effect
+Topography = False
+# useFreeSurface = True
+
+
+# Define scale criteria
+tempMin = 273.*u.degK 
+tempMax = (1400.+ 273.)*u.degK
+bodyforce = 3300 * u.kilogram / u.metre**3 * 9.81 * u.meter / u.second**2
+velocity = 1e8*u.centimeter/u.year
+
+KL = 100e3*u.meter
+Kt = KL/velocity
+KT = tempMax 
+KM = bodyforce * KL**2 * Kt**2
+K  = 1.*u.mole
+lengthScale = 100e3
+
+scaling_coefficients = uw.scaling.get_coefficients()
+
+scaling_coefficients["[length]"] = KL
+scaling_coefficients["[time]"] = Kt
+scaling_coefficients["[mass]"]= KM
+scaling_coefficients["[temperature]"] = KT
+scaling_coefficients["[substance]"] = K
+
+gravity =  nd(9.81 * u.meter / u.second**2)
+R = nd(8.3144621 * u.joule / u.mole / u.degK)
+
+# use low resolution if running in serial
+
+xRes = 720
+zRes = 96
+dim  = 2
+
+minX = nd(   -200.* u.kilometer)
+maxX = nd( 200. * u.kilometer)
+minZ = nd(   -40. * u.kilometer)
+maxZ = nd( 0. * u.kilometer)
+
+stickyAirthick = nd(0. * u.kilometer)
+stressNormalFn = nd(25e6*u.pascal)
+meshV = (maxX-minX)*nd(1.*u.centimeter/u.year)/nd(400.*u.kilometer)# nd(1.*u.centimeter/u.year)
+
+    
+elementType = "Q1/dQ0"
+resolution = (xRes,zRes)
+
+
+H = nd(18*u.kilometer)
+V0 = nd(4e-9*u.meter/u.second) # nd(4e-9*u.meter/u.second) # 
+
+a_field = 0.003 #0.011 # 
+
+b0 = 0.009# 0.017
+b_max = 0.001
+    
+miu0 = 0.3
+# b = 0.015 #0.009 #
+L = nd(0.01*u.meter)#nd(0.01*u.meter) 
+
+theta_rock = nd(1.9e16*u.year) # nd(102000.*u.year) #
+
+pre_f  = 1.
+BC_f = 2.
+f_vep = 0.15
+
+stressNormalFn = nd(30e6*u.pascal)
+
+#index materials
+
+UC = 1
+LC = 2
+fault = 3
+faultLC = 4
+
+# for mpi run
+def global_max(localmax):
+    return comm.allreduce(localmax, op=mpi4py.MPI.MAX) 
+
+def global_min(localmin):
+    return comm.allreduce(localmax, op=mpi4py.MPI.MIN) 
+
+if(LoadFromFile == True):
+    step = 6600
+    step_out = 100
+    maxSteps = 20000
+    timestep = float(np.load(outputPath+"time"+str(step).zfill(4)+".npy"))
+    dt_e =  fn.misc.constant(float(np.load(outputPath+"dt"+str(step).zfill(4)+".npy")))
+    Eqk = True
+else:
+    step = 0
+    step_out = 100
+    maxSteps = 20000
+    timestep = 0. 
+    dt_e    = fn.misc.constant(nd(1e3*u.year)) 
+    Eqk = True
+
+    # %%
+    
+dx = (maxX-minX)/xRes
+dy = (maxZ-minZ)/zRes
+
+dt_min = nd(1e-2*u.second)
+dt_max = nd(100000.*u.year)
+dx_min = 3.*1.*dx #nd(3.*u.kilometer)    
+
+LC_vis = nd(1e21 * u.pascal * u.second)
+fault_lowDip = -nd(33.*u.kilometer)
+x_shift = nd(0.*u.kilometer)
+# In[ ]:
+
+mesh = uw.mesh.FeMesh_Cartesian( elementType = ("Q1/dQ0"),
+                                 elementRes  = (xRes, zRes), 
+                                 minCoord    = (minX, minZ), 
+                                 maxCoord    = (maxX, maxZ),
+                                 periodic    = [False, False]) 
+velocityField   = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=dim )
+pressureField   = uw.mesh.MeshVariable( mesh=mesh.subMesh, nodeDofCount=1 )
+temperatureField    = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=1 )
+temperatureDotField = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=1 )
+temperatureFieldCopy    = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=1 )
+
+previousVmMesh = uw.mesh.MeshVariable(mesh=mesh, nodeDofCount=mesh.dim)
+velAMesh  =  uw.mesh.MeshVariable(mesh=mesh, nodeDofCount=mesh.dim)
+vel_effMesh  =  uw.mesh.MeshVariable(mesh=mesh, nodeDofCount=mesh.dim)
+
+velocityField.data[:] = 0.
+pressureField.data[:] = 0.
+
+
+
+if(LoadFromFile == True):
+    # Setup mesh and temperature field for 64*64 data file.
+    # read in saved steady state temperature field data
+
+#     temperatureField.load(inputPath+"temperatureField"+str(step).zfill(4)) 
+    velocityField.load(inputPath+"velocityField"+str(step).zfill(4))
+    previousVmMesh.load(inputPath+"previousVmMesh"+str(step).zfill(4))
+#     pressureField.load(inputPath+"pressureField"+str(step).zfill(4))    
+    #velocityField.data[:] = [0.,0.]
+
+# In[ ]:
+
+# set initial conditions (and boundary values)
+
+
+    
+# send boundary condition information to underworld
+iWalls = mesh.specialSets["MinI_VertexSet"] + mesh.specialSets["MaxI_VertexSet"]
+jWalls = mesh.specialSets["MinJ_VertexSet"] + mesh.specialSets["MaxJ_VertexSet"]
+
+top    = mesh.specialSets["MaxJ_VertexSet"]
+base   = mesh.specialSets["MinJ_VertexSet"]
+# left   = mesh.specialSets["MinI_VertexSet"]
+
+
+swarm = uw.swarm.Swarm( mesh=mesh,particleEscape=True )
+faultSwarm = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+surfaceSwarm1 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+surfaceSwarm2 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+surfaceV1 = surfaceSwarm1.add_variable( dataType="double", count=mesh.dim )
+surfaceV2 = surfaceSwarm2.add_variable( dataType="double", count=mesh.dim )
+pop_control = uw.swarm.PopulationControl(swarm,aggressive=True,particlesPerCell= 30)
+
+materialVariable   = swarm.add_variable( dataType="int", count=1 )
+plasticStrain  = swarm.add_variable( dataType="double",  count=1 )
+frictionInf  = swarm.add_variable( dataType="double",  count=1 )
+cohesion  = swarm.add_variable( dataType="double",  count=1 )
+
+
+previousVm =  swarm.add_variable( dataType="double", count=mesh.dim  )
+previousVm2 =  swarm.add_variable( dataType="double", count=mesh.dim  )
+velA  =  swarm.add_variable( dataType="double", count=mesh.dim  )
+vel_eff  =  swarm.add_variable( dataType="double", count=mesh.dim  )
+
+# a_field  = swarm.add_variable( dataType="double",  count=1 )
+b  = swarm.add_variable( dataType="double",  count=1 )
+
+thetaField = swarm.add_variable( dataType="double",  count=1 )
+swarmYield = swarm.add_variable( dataType="double",  count=1 )
+previousStress         = swarm.add_variable( dataType="double", count=3 )
+
+markSwarm1 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+markSwarm2 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+markSwarm3 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+markSwarm4 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+
+
+markSwarm1.add_particles_with_coordinates(np.array([[-nd(1.5*u.kilometer)+x_shift+0.5*dx_min,-nd(3*u.kilometer)]]))
+markSwarm2.add_particles_with_coordinates(np.array([[-nd(14.5*u.kilometer)+x_shift+0.5*dx_min,-nd(10*u.kilometer)]]))
+markSwarm3.add_particles_with_coordinates(np.array([[-nd(14.5*u.kilometer)+x_shift+0.5*dx_min,-nd(10*u.kilometer)]]))
+# markSwarm3.add_particles_with_coordinates(np.array([[-nd(30*u.kilometer),-nd(20.*u.kilometer)]]))
+markSwarm4.add_particles_with_coordinates(np.array([[-nd(63*u.kilometer)+x_shift+0.5*dx_min,-nd(28*u.kilometer)]]))
+
+
+
+if(LoadFromFile == False): 
+    swarmLayout = uw.swarm.layouts.PerCellSpaceFillerLayout( swarm=swarm, particlesPerCell= 30 )
+    swarm.populate_using_layout( layout=swarmLayout )
+    
+    previousVm.data[:] = 0.
+    previousVmMesh.data[:] = 0.
+
+    
+if(LoadFromFile == True):    
+    swarm.load(inputPath+"swarm"+str(step).zfill(4))
+    materialVariable.load(inputPath+"materialVariable"+str(step).zfill(4))   
+#     plasticStrain.load(inputPath+"plasticStrain"+str(step).zfill(4))
+    previousStress.load(inputPath+"previousStress"+str(step).zfill(4))
+    b.load(inputPath+"a_field"+str(step).zfill(4))
+    thetaField.load(inputPath+"thetaField"+str(step).zfill(4))
+#     surfaceSwarm.load(inputPath+"surfaceSwarm"+str(step).zfill(4))
+    previousVm.load(inputPath+"previousVm"+str(step).zfill(4))
+#     previousVm2.load(inputPath+"previousVm2"+str(step).zfill(4))   
+    
+p01 = fn.misc.constant([-nd(120.*u.kilometer),nd(0.0*u.kilometer),nd(0.0*u.kilometer)])
+p02 = fn.misc.constant([nd(0.*u.kilometer),nd(0.0*u.kilometer),nd(0.0*u.kilometer)])
+
+
+coord = fn.input()
+x=coord[0]
+y=coord[1]
+
+
+x_ref = nd(-120.*u.kilometer)
+#     x_ref = nd(-50.*u.kilometer)
+x1 = x_ref+x_shift#-Tibet_ELC_width #nd(-210.*u.kilometer)
+top_coord = nd(-2.*u.kilometer)
+base_coord = fault_lowDip #nd(-15.*u.kilometer)
+diff_coord = top_coord-base_coord
+y1 = diff_coord/((x_shift-x1)**2)*(x-x1)**2+base_coord
+x1_r = fn.math.abs(fn.math.sqrt((y-base_coord)*(x1-x_shift)**2/diff_coord))+x1
+
+
+material_map = [(((y>y1-1*dx_min) & (x<x_shift) & (x>x1) & (y<y1) & (y<top_coord) & (y>nd(-30.*u.kilometer))),fault),
+(((x>x1_r) & (x<x1_r+dx_min) & (y<y1) & (y<top_coord) & (y>nd(-30.*u.kilometer)) ),fault),               
+(((y>y1-1*dx_min) & (x<x_shift) & (x>x1) & (y<y1) & (y<top_coord) & (y<=nd(-30.*u.kilometer))),faultLC),
+(((x>x1_r) & (x<x1_r+dx_min) & (y<y1) & (y<top_coord) & (y<=nd(-30.*u.kilometer))  ),faultLC),             
+                (y>nd(-30*u.kilometer),UC),                    
+                (True,LC)]
+
+
+materialVariable.data[:] = fn.branching.conditional(material_map).evaluate(swarm)
+
+
+plasticStrain.data[:] = 0.
+
+countz = 100
+surfacePoints = np.zeros((countz,2))
+surfacePoints[:,0] = np.linspace(x1,x_shift,countz)
+surfacePoints[:,1] = diff_coord/((x_shift-x1)**2)*(surfacePoints[:,0]-x1)**2+base_coord
+faultSwarm.add_particles_with_coordinates( surfacePoints )
+
+countz = 100
+surfacePoints1 = np.zeros((countz,2))
+
+surfacePoints1[:,0] = np.linspace(minX,maxX,countz)
+surfacePoints1[:,1] = 0.
+
+surfacePoints2 = np.zeros((countz,2))
+
+surfacePoints2[:,0] = np.linspace(minX,maxX,countz)
+surfacePoints2[:,1] = 0.
+
+surfaceSwarm1.add_particles_with_coordinates( surfacePoints1 )
+surfaceSwarm2.add_particles_with_coordinates( surfacePoints2 )
+
+surfaceSwarm1.save(outputPath+"surfaceSwarm1"+str(0).zfill(4))
+surfaceSwarm2.save(outputPath+"surfaceSwarm2"+str(0).zfill(4))
+
+if LoadFromFile == False:    
+    coordz =  fn.input()[1] 
+
+    condition_b =      [(coordz>p01.value[1],b_max),
+                        (((coordz>-nd(27.*u.kilometer)) & (coordz<= p01.value[1])),b0),
+                        (coordz>-nd(30.*u.kilometer),b0-(b_max-b0)*(coordz+nd(27.*u.kilometer))/nd(3.*u.kilometer)),
+                        (True, b_max)]
+    
+    b.data[:] = fn.branching.conditional(condition_b).evaluate(swarm)
+    
+    previousStress.data[:] = 0. #0.1*stressNormalFn#
+    
+    condition_theta = {         
+                                   UC  : theta_rock,
+                                   LC  : theta_rock,
+                                fault  : nd(0.029*u.year),
+                              faultLC  : nd(0.029*u.year),
+                   }
+
+    thetaField.data[:] = fn.branching.map( fn_key = materialVariable, 
+                                               mapping = condition_theta ).evaluate(swarm)  
+    
+    
+strainRateFn = fn.tensor.symmetric( velocityField.fn_gradient )
+strainRate_2ndInvariantFn = fn.tensor.second_invariant(strainRateFn)+nd(1e-18/u.second)
+
+
+VpFn = 2.*strainRate_2ndInvariantFn*dx_min 
+thetaFieldFn  =  L/VpFn+(thetaField-L/VpFn)*fn.math.exp(-VpFn/L*dt_e)
+
+
+kernalX = VpFn/(2.*V0)*fn.math.exp((miu0 + b*fn.math.log(V0*thetaField/L))/a_field)
+frictionFn = a_field*fn.math.log(kernalX+fn.math.sqrt(kernalX*kernalX+1.))
+
+
+
+yieldStressFn0  = frictionFn*stressNormalFn #pressureField nd(1e6*u.pascal)+
+
+yieldMax = nd(1e20*u.pascal)
+
+yieldMap =  {                
+                               UC  : yieldMax,
+                               LC  : yieldMax,
+                            fault  : yieldStressFn0,
+                          faultLC  : yieldStressFn0,
+            }
+
+yieldStressFn  = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = yieldMap )
+
+
+viscosityMap = {            
+                               UC  : nd(1e27 * u.pascal * u.second),
+                               LC  : LC_vis,
+                          fault    : nd(1e27 * u.pascal * u.second),
+                         faultLC   : LC_vis,
+               }
+
+viscosityMapFn1  = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = viscosityMap )
+# viscosityMapFn = fn.exception.SafeMaths( fn.misc.min(yieldingViscosityFn ,backgroundViscosityFn))
+
+
+mu0      = nd(3e10*u.pascal) # elastic modulus
+
+muMap =        {           
+                               UC  : mu0,
+                               LC  : mu0, 
+                            fault  : mu0,
+                          faultLC  : mu0,
+               }
+
+mu  = fn.branching.map( fn_key = materialVariable, 
+                       mapping = muMap )
+
+
+alpha   = viscosityMapFn1 / mu                         # viscoelastic relaxation time
+
+viscoelasticViscosity  = ( viscosityMapFn1 * dt_e ) / (alpha + dt_e)  # effective viscosity
+
+visElsMap = { 
+                                UC  : viscoelasticViscosity,
+                                LC  : viscoelasticViscosity,
+                            fault   : viscoelasticViscosity,
+                            faultLC   : viscoelasticViscosity,
+               }
+
+viscosityMapFn  = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = visElsMap )
+
+strainRate_effective = strainRateFn + 0.5*previousStress/(mu*dt_e)
+strainRate_effective_2ndInvariant = fn.tensor.second_invariant(strainRate_effective)+nd(1e-18/u.second)
+yieldingViscosityFn =  0.5 * yieldStressFn / strainRate_effective_2ndInvariant
+
+viscosityFn0 = ( fn.misc.min(yieldingViscosityFn,viscosityMapFn))
+
+
+viscosityFnMp = {           
+                               UC  : viscosityFn0,
+                               LC  : viscosityFn0,
+                           fault   : viscosityFn0,
+                         faultLC   : viscosityFn0,
+               }
+
+viscosityFn  = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = viscosityFnMp )
+
+# contribution from elastic rheology
+tauHistoryFn    = viscosityFn / ( mu * dt_e ) * previousStress 
+# stress from all contributions, including elastic,viscous,plastic (if yielded)
+allStressFn     = 2. * viscosityFn * strainRate_effective#
+allStressFn_2nd = fn.tensor.second_invariant(allStressFn)
+
+visStrainRateFn = allStressFn/(2.*viscosityMapFn1)
+
+elaStrainRateFn = (allStressFn-previousStress)/dt_e/(2.*mu)
+
+plaStrainRateFn = strainRateFn - visStrainRateFn - elaStrainRateFn
+
+plaStrainRateFn_2nd = fn.tensor.second_invariant(plaStrainRateFn)  
+
+vis_vp = viscosityMapFn1*allStressFn_2nd/(2.*viscosityMapFn1*plaStrainRateFn_2nd+allStressFn_2nd)
+
+swarmYield_Cond = [(viscosityMapFn>viscosityFn,1.),
+                   (True,0.)]
+swarmYieldFn = fn.branching.conditional(swarmYield_Cond)
+
+plaIncrement = plaStrainRateFn_2nd*swarmYieldFn
+
+densityMap0  = {           
+                               UC  : nd(   2700. * u.kilogram / u.metre**3),
+                               LC  : nd(   2950. * u.kilogram / u.metre**3),
+                         fault     : nd(   2700. * u.kilogram / u.metre**3),
+                       faultLC     : nd(   2950. * u.kilogram / u.metre**3)
+               }
+
+densityFn = fn.branching.map( fn_key = materialVariable, mapping = densityMap0 )
+
+# Define our vertical unit vector using a python tuple
+z_hat = ( 0.0, -1.0 )
+
+# now create a buoyancy force vector
+buoyancyFn = densityFn * z_hat * gravity
+
+
+
+velocityField.data[:] = 0.
+for index in mesh.specialSets["MinI_VertexSet"]:
+    velocityField.data[index,0] = meshV # 0. + (mesh.data[index][1]-minY)*meshV/(maxY-minY)
+for index in mesh.specialSets["MaxI_VertexSet"]:
+    velocityField.data[index,0] = 0.
+
+        
+freeslipBC = uw.conditions.DirichletCondition( variable        = velocityField, 
+                                               indexSetsPerDof = (iWalls,base) )
+
+
+
+LHS_fn = densityFn/dt_e 
+RHS_fn = densityFn*previousVm/dt_e
+
+stokes = uw.systems.Stokes(    velocityField = velocityField, 
+                           pressureField = pressureField,
+                           voronoi_swarm = swarm, 
+                           conditions    = freeslipBC,
+                           fn_viscosity  = viscosityFn, 
+                           #fn_bodyforce  = buoyancyFn,
+                           fn_bodyforce  = buoyancyFn+RHS_fn,
+                           fn_stresshistory = tauHistoryFn)
+
+massMatrixTerm = uw.systems.sle.MatrixAssemblyTerm_NA__NB__Fn(
+                    assembledObject  = stokes._kmatrix,
+                    integrationSwarm = stokes._constitMatTerm._integrationSwarm,
+                    fn   = LHS_fn,
+                    mesh = mesh)
+    
+# Create solver & solve
+solver = uw.systems.Solver(stokes)
+
+
+# In[ ]:
+
+# use "lu" direct solve if running in serial
+if(uw.mpi.size==1):
+    solver.set_inner_method("lu")
+else:
+    solver.set_inner_method("mumps")    
+solver.set_penalty(1.0e-3)
+
+
+# In[7]:
+
+
+advector1  = uw.systems.SwarmAdvector( swarm=swarm,     velocityField=velocityField, order=2 )
+
+surfaceArea = uw.utils.Integral(fn=1.0,mesh=mesh, integrationType='surface', surfaceIndexSet=top)
+surfacePressureIntegral = uw.utils.Integral(fn=pressureField, mesh=mesh, integrationType='surface', surfaceIndexSet=top)
+
+def pressure_calibrate():
+    
+    (area,) = surfaceArea.evaluate()
+    (p0,) = surfacePressureIntegral.evaluate()
+    offset = p0/area
+    #print "Zeroing pressure using mean upper surface pressure {}".format( offset )
+    pressureField.data[:] -= offset
+
+
+
+#The root mean square Velocity
+velSquared = uw.utils.Integral( fn.math.dot(velocityField,velocityField), mesh )
+area = uw.utils.Integral( 1., mesh )
+Vrms = math.sqrt( velSquared.evaluate()[0]/area.evaluate()[0] )
+
+G_star = mu/(1.-0.5)
+k_stiff = (2./3.1415926)*G_star/dx_min
+
+
+pusei = 0.25*fn.math.pow((k_stiff*L/(a_field*stressNormalFn)-(b-a_field)/a_field),2.)-k_stiff*L/(a_field*stressNormalFn)
+
+pusei_Cond = [(pusei>0,a_field*stressNormalFn/(k_stiff*L-(b-a_field)*stressNormalFn)),
+              (True,1.-(b-a_field)*stressNormalFn/(k_stiff*L))]
+puseiFn = fn.branching.conditional(pusei_Cond)
+   
+dt_theta = fn.misc.min(fn.misc.constant(0.2),puseiFn)
+
+
+dt_wFn0 = dt_theta *L/VpFn #fn.branching.conditional(condw)
+dt_wFn = fn.view.min_max(dt_wFn0)
+
+dt_vepFn = fn.view.min_max(vis_vp/mu)
+
+dt_hFn = fn.view.min_max(thetaField*0.2)
+
+time_factor = nd(1.*u.year)
+
+Km_fn = fn.view.min_max((1.*dx)**2*densityFn/viscosityFn)
+
+
+
+stressSample = np.zeros([4,1])
+thetaSample = np.zeros([4,1])
+fricSample = np.zeros([4,1])
+velSample = np.zeros([4,1])
+
+if step == 0:
+    title = ['step','time','F1','F2','F3','F4','dt_e','V1','V2','V3','V4']
+    with open(outputPath+'Sample.csv', 'w') as f:
+        csv_write = csv.writer(f)
+        csv_write.writerow(title)
+
+    title = ['step','time','Theta1','Theta2','Theta3','Theta4','fric1','fric2','fric3','fric4']
+    with open(outputPath+'Sample2.csv', 'w') as f:
+        csv_write = csv.writer(f)
+        csv_write.writerow(title)
+    
+    title = ['step','time','dt_vep','dt_km','dt_default']
+    with open(outputPath+'Dt.csv', 'w') as f:
+        csv_write = csv.writer(f)
+        csv_write.writerow(title)
+        
+v_abs = fn.math.sqrt(fn.math.dot(velocityField,velocityField))       
+
+while step <= maxSteps:
+    
+    # Solve non linear Stokes system
+    solver.solve( nonLinearIterate=True,  nonLinearTolerance=1e-3, nonLinearMaxIterations=15,callback_post_solve = pressure_calibrate)
+
+
+        
+    stress2Data = fn.tensor.second_invariant(allStressFn)
+    meshStress = uw.mesh.MeshVariable( mesh, 1 )
+    projectorStress = uw.utils.MeshVariable_Projection( meshStress, stress2Data, type=0 )
+    projectorStress.solve()
+    
+    meshFriction = uw.mesh.MeshVariable( mesh, 1 )
+    projectorFriction = uw.utils.MeshVariable_Projection( meshFriction, frictionFn, type=0 )
+    projectorFriction.solve()
+    
+    surfaceV1.data[:] = velocityField.evaluate(surfaceSwarm1)
+    surfaceV2.data[:] = velocityField.evaluate(surfaceSwarm2)
+    
+    # output figure to file at intervals = steps_output    
+    if step % step_out == 0 or step == maxSteps-1:
+
+        meshViscosity = uw.mesh.MeshVariable( mesh, 1 )
+        meshViscosity2 = uw.mesh.MeshVariable( mesh, 1 )
+        
+        
+        meshMeltF = uw.mesh.MeshVariable( mesh, 1 )
+#        
+        
+        projectorViscosity = uw.utils.MeshVariable_Projection( meshViscosity,viscosityFn, type=0 )
+        projectorViscosity.solve()
+
+        projectorViscosity2 = uw.utils.MeshVariable_Projection( meshViscosity2,viscosityMapFn1, type=0 )
+        projectorViscosity2.solve()
+        
+#         projectorStress = uw.utils.MeshVariable_Projection( meshDevStress, stress2Data, type=0 )
+#         projectorStress.solve()
+        
+        meshViscosity2.save(outputPath+"meshViscosity2"+str(step).zfill(4))        
+        meshViscosity.save(outputPath+"meshViscosity"+str(step).zfill(4)) 
+        
+
+#         meshStress = uw.mesh.MeshVariable( mesh, 3 )
+#         meshStress.data[:] = allStressFn.evaluate(mesh)
+        
+
+
+        swarm.save(outputPath+"swarm"+str(step).zfill(4))
+        mesh.save(outputPath+"mesh"+str(step).zfill(4))
+
+        temperatureField.save(outputPath+"temperatureField"+str(step).zfill(4)) 
+        previousStress.save(outputPath+"previousStress"+str(step).zfill(4))
+        materialVariable.save(outputPath+"materialVariable"+str(step).zfill(4))
+
+#         temperatureField.save(outputPath+"temperatureField"+str(step).zfill(4))
+#         pressureField.save(outputPath+"pressureField"+str(step).zfill(4))       
+#         plasticStrain.save(outputPath+"plasticStrain"+str(step).zfill(4))
+        previousVm.save(outputPath+"previousVm"+str(step).zfill(4))
+        b.save(outputPath+"a_field"+str(step).zfill(4))
+        thetaField.save(outputPath+"thetaField"+str(step).zfill(4))
+        meshFriction.save(outputPath+"meshFriction"+str(step).zfill(4))
+        previousVmMesh.save(outputPath+"previousVmMesh"+str(step).zfill(4))    
+
+    velocityField.save(outputPath+"velocityField"+str(step).zfill(4))
+    meshStress.save(outputPath+"meshStress"+str(step).zfill(4)) 
+    surfaceV1.save(outputPath+"surfaceV1"+str(step).zfill(4))
+    surfaceV2.save(outputPath+"surfaceV2"+str(step).zfill(4))
+#     surfaceSwarm.save(outputPath+"surfaceSwarm"+str(step).zfill(4)) 
+    if uw.mpi.rank==0:
+
+        np.save(outputPath+"time"+str(step).zfill(4),timestep)
+        np.save(outputPath+"dt"+str(step).zfill(4),dt_e.value)
+
+    uw.mpi.barrier
+
+    dicMesh = { 'elements' : mesh.elementRes, 
+                'minCoord' : mesh.minCoord,
+                'maxCoord' : mesh.maxCoord}
+
+    fo = open(outputPath+"dicMesh"+str(step).zfill(4),'w')
+    fo.write(str(dicMesh))
+    fo.close()
+        
+    stressMM = fn.view.min_max(fn.math.abs(meshStress))
+    stressMM.evaluate(markSwarm1)
+    stressSample[0] = stressMM.max_global()
+
+    stressMM = fn.view.min_max(fn.math.abs(meshStress))
+    stressMM.evaluate(markSwarm2)
+    stressSample[1] = stressMM.max_global()
+
+    stressMM = fn.view.min_max(fn.math.abs(meshStress))
+    stressMM.evaluate(markSwarm3)
+    stressSample[2] = stressMM.max_global()
+
+    stressMM = fn.view.min_max(fn.math.abs(meshStress))
+    stressMM.evaluate(markSwarm4)
+    stressSample[3] = stressMM.max_global()
+
+    velMM = fn.view.min_max(fn.math.abs(VpFn ))
+    velMM.evaluate(markSwarm1)
+    velSample[0] = velMM.max_global()
+
+    velMM = fn.view.min_max(fn.math.abs(VpFn ))
+    velMM.evaluate(markSwarm2)
+    velSample[1] = velMM.max_global()
+
+    velMM = fn.view.min_max(fn.math.abs(VpFn ))
+    velMM.evaluate(markSwarm3)
+    velSample[2] = velMM.max_global()
+
+    velMM = fn.view.min_max(fn.math.abs(VpFn ))
+    velMM.evaluate(markSwarm4)
+    velSample[3] = velMM.max_global()
+
+    
+    if uw.mpi.rank==0:
+        SP_output = [step,timestep,stressSample[0,0],stressSample[1,0],stressSample[2,0],stressSample[3,0],dt_e.value,velSample[0,0],velSample[1,0],velSample[2,0],velSample[3,0]]
+        with open(outputPath+'Sample.csv', 'a') as f:
+            csv_write = csv.writer(f)  
+#             csv_write.writerow(SP_output)
+            csv_write.writerow(['{:.18e}'.format(x) for x in SP_output])
+    uw.mpi.barrier()
+    
+
+    
+    Vrms = math.sqrt( velSquared.evaluate()[0]/area.evaluate()[0] )
+    
+    if uw.mpi.rank==0:
+        print('step = {0:6d}; time = {1:.3e} yr; Vrms = {2:.3e}'.format(step,timestep/nd(1.*u.year),Vrms))  
+    uw.mpi.barrier()
+    
+    dt = dt_e.value
+    
+    velA.data[:] = velocityField.evaluate(swarm)  
+#     vel_eff.data[:] = 1./4.*(velA.data[:]+2.*previousVm.data[:]+previousVm2.data[:])   
+    vel_eff.data[:] = 1./2.*(velA.data[:]+1.*previousVm.data[:])  
+#     previousVm2.data[:] = np.copy(previousVm.data[:])
+    previousVm.data[:] = np.copy(velA.data[:])      
+
+    velAMesh.data[:] = velocityField.evaluate(mesh)  
+    vel_effMesh.data[:] = 1./2.*(velAMesh.data[:]+1.*previousVmMesh.data[:])  
+
+        
+    previousStress.data[:] = allStressFn.evaluate(swarm)
+    
+ 
+    condition_theta = {      
+                               UC  : theta_rock,
+                               LC  : theta_rock,
+
+                            fault  : thetaFieldFn,
+                           faultLC  : thetaFieldFn,
+               }
+
+    thetaField.data[:] = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = condition_theta ).evaluate(swarm) 
+
+     
+    if step>15:
+        dt_vepFn.reset()
+        dt_vepFn.evaluate(swarm)
+        dt_vep0 = dt_vepFn.min_global()
+
+    
+
+    
+        dt_vep = f_vep*dt_vep0
+        dt0 = np.min([dt_max,dt_vep])
+        dt_e.value =  np.max([dt0,dt_min]) 
+        
+
+            
+    
+    timestep = timestep+dt
+    step = step+1
\ No newline at end of file
diff --git a/model_code_inputs/Thrust_3D.py b/model_code_inputs/Thrust_3D.py
new file mode 100644
index 0000000..3868c08
--- /dev/null
+++ b/model_code_inputs/Thrust_3D.py
@@ -0,0 +1,747 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[ ]:
+import warnings
+warnings.filterwarnings("ignore")
+import underworld as uw
+import math
+from underworld import function as fn
+import numpy as np
+import os,csv
+import mpi4py 
+# comm = mpi4py.MPI.COMM_WORLD
+import random
+
+from scipy.interpolate import interp1d
+
+from underworld.scaling import units as u
+from underworld.scaling import non_dimensionalise as nd
+
+from scipy.interpolate import interp1d
+import underworld as uw
+from mpi4py import MPI as _MPI
+
+comm = _MPI.COMM_WORLD
+rank = comm.rank
+size = comm.size
+
+# In[ ]:
+
+inputPath = os.path.join(os.path.abspath("."),"LMS256_dep24_edge18_ptcl30_L240/")
+outputPath = os.path.join(os.path.abspath("."),"LMS256_dep24_edge18_ptcl30_L240/")
+
+if uw.mpi.rank==0:
+    if not os.path.exists(outputPath):
+        os.makedirs(outputPath)
+if uw.mpi.rank==0:
+    if not os.path.exists(inputPath):
+        os.makedirs(inputPath)
+uw.mpi.barrier
+# continue running from specific time step
+LoadFromFile= True
+# partial melting funciton in mantle
+MeltFunction= False
+# set upper limit of the topography
+MaskTopo = False
+# refine mesh in specific area
+meshdeform = False
+# topo_effect
+Topography = False
+# useFreeSurface = True
+
+
+# Define scale criteria
+tempMin = 273.*u.degK 
+tempMax = (1400.+ 273.)*u.degK
+bodyforce = 3300 * u.kilogram / u.metre**3 * 9.81 * u.meter / u.second**2
+velocity = 1e8*u.centimeter/u.year
+
+KL = 100e3*u.meter
+Kt = KL/velocity
+KT = tempMax 
+KM = bodyforce * KL**2 * Kt**2
+K  = 1.*u.mole
+lengthScale = 100e3
+
+scaling_coefficients = uw.scaling.get_coefficients()
+
+scaling_coefficients["[length]"] = KL
+scaling_coefficients["[time]"] = Kt
+scaling_coefficients["[mass]"]= KM
+scaling_coefficients["[temperature]"] = KT
+scaling_coefficients["[substance]"] = K
+
+gravity =  nd(9.81 * u.meter / u.second**2)
+R = nd(8.3144621 * u.joule / u.mole / u.degK)
+
+# use low resolution if running in serial
+
+xRes = 256
+yRes = 96
+zRes = 64
+dim  = 3
+
+minX = nd(   -180.* u.kilometer)
+maxX = nd( 60. * u.kilometer)
+minY = nd(  -48. * u.kilometer)
+maxY = nd( 48. * u.kilometer)
+minZ = nd(   -40. * u.kilometer)
+maxZ = nd( 0. * u.kilometer)
+
+stickyAirthick = nd(0. * u.kilometer)
+meshV = (maxX-minX)*nd(1.*u.centimeter/u.year)/nd(400.*u.kilometer) # nd(1.*u.centimeter/u.year)
+
+    
+elementType = "Q1/dQ0"
+resolution = (xRes,yRes,zRes)
+
+
+H = nd(18*u.kilometer)
+V0 = nd(4e-9*u.meter/u.second) # nd(4e-9*u.meter/u.second) # 
+
+a_field = 0.003 #0.011 # 
+
+b0 = 0.009# 0.017
+b_max = 0.001
+    
+miu0 = 0.3
+# b = 0.015 #0.009 #
+L = nd(0.01*u.meter)#nd(0.01*u.meter) 
+
+theta_rock = nd(1.9e16*u.year) # nd(102000.*u.year) #
+
+pre_f  = 1.
+BC_f = 2.
+f_vep = 0.15
+
+stressNormalFn = nd(30e6*u.pascal)
+edgeGap = nd(18.*u.kilometer)
+
+#index materials
+
+UC = 1
+LC = 2
+fault = 3
+faultLC = 4
+
+# for mpi run
+def global_max(localmax):
+    return comm.allreduce(localmax, op=mpi4py.MPI.MAX) 
+
+def global_min(localmin):
+    return comm.allreduce(localmax, op=mpi4py.MPI.MIN) 
+
+if(LoadFromFile == True):
+    step = 700
+    step_out = 50
+    maxSteps = 20000
+    timestep = float(np.load(outputPath+"time"+str(step).zfill(4)+".npy"))
+    dt_e =  fn.misc.constant(float(np.load(outputPath+"dt"+str(step).zfill(4)+".npy")))
+    Eqk = True
+else:
+    step = 0
+    step_out = 100
+    maxSteps = 20000
+    timestep = 0. 
+    dt_e    = fn.misc.constant(nd(1e3*u.year)) 
+    Eqk = True
+
+    # %%
+    
+dx = (maxX-minX)/xRes
+dy = (maxY-minY)/yRes
+
+dt_min = nd(1e-2*u.second)
+dt_max = nd(100000.*u.year)
+dx_min = 3.*1.*dx #nd(3.*u.kilometer)    
+
+LC_vis = nd(1e21 * u.pascal * u.second)
+fault_lowDip = -nd(24.*u.kilometer)
+x_shift = nd(0.*u.kilometer)
+# In[ ]:
+
+mesh = uw.mesh.FeMesh_Cartesian( elementType = ("Q1/dQ0"),
+                                 elementRes  = (xRes, yRes, zRes), 
+                                 minCoord    = (minX, minY ,minZ), 
+                                 maxCoord    = (maxX, maxY, maxZ),
+                                 periodic    = [False, False, False]) 
+velocityField   = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=dim )
+pressureField   = uw.mesh.MeshVariable( mesh=mesh.subMesh, nodeDofCount=1 )
+temperatureField    = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=1 )
+temperatureDotField = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=1 )
+temperatureFieldCopy    = uw.mesh.MeshVariable( mesh=mesh,         nodeDofCount=1 )
+
+previousVmMesh = uw.mesh.MeshVariable(mesh=mesh, nodeDofCount=mesh.dim)
+velAMesh  =  uw.mesh.MeshVariable(mesh=mesh, nodeDofCount=mesh.dim)
+vel_effMesh  =  uw.mesh.MeshVariable(mesh=mesh, nodeDofCount=mesh.dim)
+
+velocityField.data[:] = [0.,0.,0]
+pressureField.data[:] = 0.
+
+
+
+if(LoadFromFile == True):
+    # Setup mesh and temperature field for 64*64 data file.
+    # read in saved steady state temperature field data
+
+#     temperatureField.load(inputPath+"temperatureField"+str(step).zfill(4)) 
+    velocityField.load(inputPath+"velocityField"+str(step).zfill(4))
+    previousVmMesh.load(inputPath+"previousVmMesh"+str(step).zfill(4))
+#     pressureField.load(inputPath+"pressureField"+str(step).zfill(4))    
+    #velocityField.data[:] = [0.,0.]
+
+# In[ ]:
+
+# set initial conditions (and boundary values)
+
+
+    
+# send boundary condition information to underworld
+iWalls = mesh.specialSets["MinI_VertexSet"] + mesh.specialSets["MaxI_VertexSet"]
+jWalls = mesh.specialSets["MinJ_VertexSet"] + mesh.specialSets["MaxJ_VertexSet"]
+
+top    = mesh.specialSets["MaxK_VertexSet"]
+base   = mesh.specialSets["MinK_VertexSet"]
+# left   = mesh.specialSets["MinI_VertexSet"]
+
+
+swarm = uw.swarm.Swarm( mesh=mesh,particleEscape=True )
+faultSwarm = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+surfaceSwarm1 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+surfaceSwarm2 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+surfaceV1 = surfaceSwarm1.add_variable( dataType="double", count=mesh.dim )
+surfaceV2 = surfaceSwarm2.add_variable( dataType="double", count=mesh.dim )
+pop_control = uw.swarm.PopulationControl(swarm,aggressive=True,particlesPerCell= 30)
+
+materialVariable   = swarm.add_variable( dataType="int", count=1 )
+plasticStrain  = swarm.add_variable( dataType="double",  count=1 )
+frictionInf  = swarm.add_variable( dataType="double",  count=1 )
+cohesion  = swarm.add_variable( dataType="double",  count=1 )
+
+
+previousVm =  swarm.add_variable( dataType="double", count=3 )
+previousVm2 =  swarm.add_variable( dataType="double", count=3 )
+velA  =  swarm.add_variable( dataType="double", count=3 )
+vel_eff  =  swarm.add_variable( dataType="double", count=3 )
+
+# a_field  = swarm.add_variable( dataType="double",  count=1 )
+b  = swarm.add_variable( dataType="double",  count=1 )
+
+thetaField = swarm.add_variable( dataType="double",  count=1 )
+swarmYield = swarm.add_variable( dataType="double",  count=1 )
+previousStress         = swarm.add_variable( dataType="double", count=6 )
+
+markSwarm1 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+markSwarm2 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+markSwarm3 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+markSwarm4 = uw.swarm.Swarm( mesh=mesh,particleEscape=True  )
+
+
+markSwarm1.add_particles_with_coordinates(np.array([[-nd(1.5*u.kilometer)+x_shift+0.5*dx_min,0.,-nd(3*u.kilometer)]]))
+markSwarm2.add_particles_with_coordinates(np.array([[-nd(14.5*u.kilometer)+x_shift+0.5*dx_min,0.,-nd(10*u.kilometer)]]))
+markSwarm3.add_particles_with_coordinates(np.array([[-nd(14.5*u.kilometer)+x_shift+0.5*dx_min,-nd(22.5*u.kilometer),-nd(10*u.kilometer)]]))
+
+markSwarm4.add_particles_with_coordinates(np.array([[-nd(63*u.kilometer)+x_shift+0.5*dx_min,0.,-nd(28*u.kilometer)]]))
+
+
+if(LoadFromFile == False): 
+    swarmLayout = uw.swarm.layouts.PerCellSpaceFillerLayout( swarm=swarm, particlesPerCell= 30 )
+    swarm.populate_using_layout( layout=swarmLayout )
+    
+    previousVm.data[:] = 0.
+    previousVmMesh.data[:] = 0.
+
+    
+if(LoadFromFile == True):    
+    swarm.load(inputPath+"swarm"+str(step).zfill(4))
+    materialVariable.load(inputPath+"materialVariable"+str(step).zfill(4))   
+#     plasticStrain.load(inputPath+"plasticStrain"+str(step).zfill(4))
+    previousStress.load(inputPath+"previousStress"+str(step).zfill(4))
+    b.load(inputPath+"a_field"+str(step).zfill(4))
+    thetaField.load(inputPath+"thetaField"+str(step).zfill(4))
+#     surfaceSwarm.load(inputPath+"surfaceSwarm"+str(step).zfill(4))
+    previousVm.load(inputPath+"previousVm"+str(step).zfill(4))
+#     previousVm2.load(inputPath+"previousVm2"+str(step).zfill(4))   
+    
+p01 = fn.misc.constant([-nd(120.*u.kilometer),nd(0.0*u.kilometer),nd(0.0*u.kilometer)])
+p02 = fn.misc.constant([nd(0.*u.kilometer),nd(0.0*u.kilometer),nd(0.0*u.kilometer)])
+
+if(LoadFromFile == False):
+    coord = fn.input()
+    x=coord[0]
+    y=coord[2]
+    i0 = coord[1]
+
+    x_ref = nd(-120.*u.kilometer)
+    #     x_ref = nd(-50.*u.kilometer)
+    x1 = x_ref+x_shift#-Tibet_ELC_width #nd(-210.*u.kilometer)
+    top_coord = nd(-2.*u.kilometer)
+    base_coord = fault_lowDip #nd(-15.*u.kilometer)
+    diff_coord = top_coord-base_coord
+    y1 = diff_coord/((x_shift-x1)**2)*(x-x1)**2+base_coord
+    x1_r = fn.math.abs(fn.math.sqrt((y-base_coord)*(x1-x_shift)**2/diff_coord))+x1
+
+    
+    faultRange_x0 =  (i0>=minY+edgeGap) & (i0<=maxY-edgeGap)   
+
+    material_map = [(((y>y1-1*dx_min) & (x<x_shift) & (x>x1) & (y<y1) & (y<top_coord) & (y>nd(-30.*u.kilometer)) & faultRange_x0),fault),
+    (((x>x1_r) & (x<x1_r+dx_min) & (y<y1) & (y<top_coord) & (y>nd(-30.*u.kilometer)) & faultRange_x0 ),fault),               
+    (((y>y1-1*dx_min) & (x<x_shift) & (x>x1) & (y<y1) & (y<top_coord) & (y<=nd(-30.*u.kilometer)) & faultRange_x0 ),faultLC),
+    (((x>x1_r) & (x<x1_r+dx_min) & (y<y1) & (y<top_coord) & (y<=nd(-30.*u.kilometer)) & faultRange_x0 ),faultLC),             
+                    (y>nd(-30*u.kilometer),UC),                    
+                    (True,LC)]
+
+
+    materialVariable.data[:] = fn.branching.conditional(material_map).evaluate(swarm)
+
+
+    plasticStrain.data[:] = 0.
+
+    countz = 100
+    surfacePoints = np.zeros((countz,3))
+    surfacePoints[:,1] = 0.
+    surfacePoints[:,0] = np.linspace(x1,x_shift,countz)
+    surfacePoints[:,2] = diff_coord/((x_shift-x1)**2)*(surfacePoints[:,0]-x1)**2+base_coord
+    faultSwarm.add_particles_with_coordinates( surfacePoints )
+
+countz = 100
+surfacePoints1 = np.zeros((countz,3))
+surfacePoints1[:,1] = 0.
+surfacePoints1[:,0] = np.linspace(minX,maxX,countz)
+surfacePoints1[:,2] = 0.
+
+surfacePoints2 = np.zeros((countz,3))
+surfacePoints2[:,1] = -0.225
+surfacePoints2[:,0] = np.linspace(minX,maxX,countz)
+surfacePoints2[:,2] = 0.
+
+surfaceSwarm1.add_particles_with_coordinates( surfacePoints1 )
+surfaceSwarm2.add_particles_with_coordinates( surfacePoints2 )
+
+surfaceSwarm1.save(outputPath+"surfaceSwarm1"+str(0).zfill(4))
+surfaceSwarm2.save(outputPath+"surfaceSwarm2"+str(0).zfill(4))
+
+if LoadFromFile == False:    
+    coordz =  fn.input()[2] 
+
+    condition_b =      [(coordz>p01.value[2],b_max),
+                        (((coordz>-nd(27.*u.kilometer)) & (coordz<= p01.value[2])),b0),
+                        (coordz>-nd(30.*u.kilometer),b0-(b_max-b0)*(coordz+nd(27.*u.kilometer))/nd(3.*u.kilometer)),
+                        (True, b_max)]
+    
+    b.data[:] = fn.branching.conditional(condition_b).evaluate(swarm)
+    
+    previousStress.data[:] = 0. #0.1*stressNormalFn#
+    
+    condition_theta = {         
+                                   UC  : theta_rock,
+                                   LC  : theta_rock,
+                                fault  : nd(0.029*u.year),
+                              faultLC  : nd(0.029*u.year),
+                   }
+
+    thetaField.data[:] = fn.branching.map( fn_key = materialVariable, 
+                                               mapping = condition_theta ).evaluate(swarm)  
+    
+    
+strainRateFn = fn.tensor.symmetric( velocityField.fn_gradient )
+strainRate_2ndInvariantFn = fn.tensor.second_invariant(strainRateFn)+nd(1e-18/u.second)
+
+
+VpFn = 2.*strainRate_2ndInvariantFn*dx_min 
+thetaFieldFn  =  L/VpFn+(thetaField-L/VpFn)*fn.math.exp(-VpFn/L*dt_e)
+
+
+kernalX = VpFn/(2.*V0)*fn.math.exp((miu0 + b*fn.math.log(V0*thetaField/L))/a_field)
+frictionFn = a_field*fn.math.log(kernalX+fn.math.sqrt(kernalX*kernalX+1.))
+
+
+yieldStressFn0  = frictionFn*stressNormalFn #pressureField nd(1e6*u.pascal)+
+
+yieldMax = nd(1e20*u.pascal)
+
+yieldMap =  {                
+                               UC  : yieldMax,
+                               LC  : yieldMax,
+                            fault  : yieldStressFn0,
+                          faultLC  : yieldStressFn0,
+            }
+
+yieldStressFn  = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = yieldMap )
+
+
+viscosityMap = {            
+                               UC  : nd(1e27 * u.pascal * u.second),
+                               LC  : LC_vis,
+                          fault    : nd(1e27 * u.pascal * u.second),
+                         faultLC   : LC_vis,
+               }
+
+viscosityMapFn1  = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = viscosityMap )
+
+
+mu0      = nd(3e10*u.pascal) # elastic modulus
+
+muMap =        {           
+                               UC  : mu0,
+                               LC  : mu0, 
+                            fault  : mu0,
+                          faultLC  : mu0,
+               }
+
+mu  = fn.branching.map( fn_key = materialVariable, 
+                       mapping = muMap )
+
+
+alpha   = viscosityMapFn1 / mu                         # viscoelastic relaxation time
+
+viscoelasticViscosity  = ( viscosityMapFn1 * dt_e ) / (alpha + dt_e)  # effective viscosity
+
+visElsMap = { 
+                                UC  : viscoelasticViscosity,
+                                LC  : viscoelasticViscosity,
+                            fault   : viscoelasticViscosity,
+                            faultLC   : viscoelasticViscosity,
+               }
+
+viscosityMapFn  = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = visElsMap )
+
+strainRate_effective = strainRateFn + 0.5*previousStress/(mu*dt_e)
+strainRate_effective_2ndInvariant = fn.tensor.second_invariant(strainRate_effective)+nd(1e-18/u.second)
+yieldingViscosityFn =  0.5 * yieldStressFn / strainRate_effective_2ndInvariant
+
+viscosityFn0 = ( fn.misc.min(yieldingViscosityFn,viscosityMapFn))
+
+
+viscosityFnMp = {           
+                               UC  : viscosityFn0,
+                               LC  : viscosityFn0,
+                           fault   : viscosityFn0,
+                         faultLC   : viscosityFn0,
+               }
+
+viscosityFn  = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = viscosityFnMp )
+
+# contribution from elastic rheology
+tauHistoryFn    = viscosityFn / ( mu * dt_e ) * previousStress 
+# stress from all contributions, including elastic,viscous,plastic (if yielded)
+allStressFn     = 2. * viscosityFn * strainRate_effective#
+allStressFn_2nd = fn.tensor.second_invariant(allStressFn)
+
+visStrainRateFn = allStressFn/(2.*viscosityMapFn1)
+
+elaStrainRateFn = (allStressFn-previousStress)/dt_e/(2.*mu)
+
+plaStrainRateFn = strainRateFn - visStrainRateFn - elaStrainRateFn
+
+plaStrainRateFn_2nd = fn.tensor.second_invariant(plaStrainRateFn)  
+
+vis_vp = viscosityMapFn1*allStressFn_2nd/(2.*viscosityMapFn1*plaStrainRateFn_2nd+allStressFn_2nd)
+
+swarmYield_Cond = [(viscosityMapFn>viscosityFn,1.),
+                   (True,0.)]
+swarmYieldFn = fn.branching.conditional(swarmYield_Cond)
+
+plaIncrement = plaStrainRateFn_2nd*swarmYieldFn
+
+densityMap0  = {           
+                               UC  : nd(   2700. * u.kilogram / u.metre**3),
+                               LC  : nd(   2950. * u.kilogram / u.metre**3),
+                         fault     : nd(   2700. * u.kilogram / u.metre**3),
+                       faultLC     : nd(   2950. * u.kilogram / u.metre**3)
+               }
+
+densityFn = fn.branching.map( fn_key = materialVariable, mapping = densityMap0 )
+
+# Define our vertical unit vector using a python tuple
+z_hat = ( 0.0, 0.0, -1.0 )
+
+# now create a buoyancy force vector
+buoyancyFn = densityFn * z_hat * gravity
+
+
+
+velocityField.data[:] = 0.
+for index in mesh.specialSets["MinI_VertexSet"]:
+    velocityField.data[index,0] = meshV # 0. + (mesh.data[index][1]-minY)*meshV/(maxY-minY)
+for index in mesh.specialSets["MaxI_VertexSet"]:
+    velocityField.data[index,0] = 0.
+        
+freeslipBC = uw.conditions.DirichletCondition( variable        = velocityField, 
+                                               indexSetsPerDof = (iWalls, jWalls,base) )
+
+
+
+LHS_fn = densityFn/dt_e 
+RHS_fn = densityFn*previousVm/dt_e
+
+stokes = uw.systems.Stokes(    velocityField = velocityField, 
+                           pressureField = pressureField,
+                           voronoi_swarm = swarm, 
+                           conditions    = freeslipBC,
+                           fn_viscosity  = viscosityFn, 
+                           #fn_bodyforce  = buoyancyFn,
+                           fn_bodyforce  = buoyancyFn+RHS_fn,
+                           fn_stresshistory = tauHistoryFn)
+
+massMatrixTerm = uw.systems.sle.MatrixAssemblyTerm_NA__NB__Fn(
+                    assembledObject  = stokes._kmatrix,
+                    integrationSwarm = stokes._constitMatTerm._integrationSwarm,
+                    fn   = LHS_fn,
+                    mesh = mesh)
+    
+# Create solver & solve
+solver = uw.systems.Solver(stokes)
+
+
+# In[ ]:
+
+# use "lu" direct solve if running in serial
+if(uw.mpi.size==1):
+    solver.set_inner_method("lu")
+else:
+    solver.set_inner_method("mg")    
+solver.set_penalty(1.0e-3)
+
+
+# In[7]:
+
+
+advector1  = uw.systems.SwarmAdvector( swarm=swarm,     velocityField=velocityField, order=2 )
+
+surfaceArea = uw.utils.Integral(fn=1.0,mesh=mesh, integrationType='surface', surfaceIndexSet=top)
+surfacePressureIntegral = uw.utils.Integral(fn=pressureField, mesh=mesh, integrationType='surface', surfaceIndexSet=top)
+
+def pressure_calibrate():
+    
+    (area,) = surfaceArea.evaluate()
+    (p0,) = surfacePressureIntegral.evaluate()
+    offset = p0/area
+    #print "Zeroing pressure using mean upper surface pressure {}".format( offset )
+    pressureField.data[:] -= offset
+
+
+
+#The root mean square Velocity
+velSquared = uw.utils.Integral( fn.math.dot(velocityField,velocityField), mesh )
+area = uw.utils.Integral( 1., mesh )
+Vrms = math.sqrt( velSquared.evaluate()[0]/area.evaluate()[0] )
+
+G_star = mu/(1.-0.5)
+k_stiff = (2./3.1415926)*G_star/dx_min
+
+
+pusei = 0.25*fn.math.pow((k_stiff*L/(a_field*stressNormalFn)-(b-a_field)/a_field),2.)-k_stiff*L/(a_field*stressNormalFn)
+
+pusei_Cond = [(pusei>0,a_field*stressNormalFn/(k_stiff*L-(b-a_field)*stressNormalFn)),
+              (True,1.-(b-a_field)*stressNormalFn/(k_stiff*L))]
+puseiFn = fn.branching.conditional(pusei_Cond)
+   
+dt_theta = fn.misc.min(fn.misc.constant(0.2),puseiFn)
+
+#condw = dt_theta *L/VpFn #[(plasticStrain0>0,dt_theta *L_field/VpFn),
+#                               (True,dt_theta *L_field/VpFn)]
+
+
+
+dt_wFn0 = dt_theta *L/VpFn #fn.branching.conditional(condw)
+dt_wFn = fn.view.min_max(dt_wFn0)
+
+dt_vepFn = fn.view.min_max(vis_vp/mu)
+
+dt_hFn = fn.view.min_max(thetaField*0.2)
+
+time_factor = nd(1.*u.year)
+
+Km_fn = fn.view.min_max((1.*dx)**2*densityFn/viscosityFn)
+
+
+
+stressSample = np.zeros([4,1])
+thetaSample = np.zeros([4,1])
+fricSample = np.zeros([4,1])
+velSample = np.zeros([4,1])
+
+if step == 0:
+    title = ['step','time','F1','F2','F3','F4','dt_e','V1','V2','V3','V4']
+    with open(outputPath+'Sample.csv', 'w') as f:
+        csv_write = csv.writer(f)
+        csv_write.writerow(title)
+
+    title = ['step','time','Theta1','Theta2','Theta3','Theta4','fric1','fric2','fric3','fric4']
+    with open(outputPath+'Sample2.csv', 'w') as f:
+        csv_write = csv.writer(f)
+        csv_write.writerow(title)
+    
+    title = ['step','time','dt_vep','dt_km','dt_default']
+    with open(outputPath+'Dt.csv', 'w') as f:
+        csv_write = csv.writer(f)
+        csv_write.writerow(title)
+        
+v_abs = fn.math.sqrt(fn.math.dot(velocityField,velocityField))       
+
+while step <= maxSteps:
+    
+    # Solve non linear Stokes system
+    solver.solve( nonLinearIterate=True,  nonLinearTolerance=1e-3, nonLinearMaxIterations=15,callback_post_solve = pressure_calibrate)
+
+        
+    stress2Data = fn.tensor.second_invariant(allStressFn)
+    meshStress = uw.mesh.MeshVariable( mesh, 1 )
+    projectorStress = uw.utils.MeshVariable_Projection( meshStress, stress2Data, type=0 )
+    projectorStress.solve()
+    
+    meshFriction = uw.mesh.MeshVariable( mesh, 1 )
+    projectorFriction = uw.utils.MeshVariable_Projection( meshFriction, frictionFn, type=0 )
+    projectorFriction.solve()
+    
+    surfaceV1.data[:] = velocityField.evaluate(surfaceSwarm1)
+    surfaceV2.data[:] = velocityField.evaluate(surfaceSwarm2)
+    
+    # output figure to file at intervals = steps_output    
+    if step % step_out == 0 or step == maxSteps-1:
+
+        meshViscosity = uw.mesh.MeshVariable( mesh, 1 )
+        meshViscosity2 = uw.mesh.MeshVariable( mesh, 1 )
+        
+        
+        meshMeltF = uw.mesh.MeshVariable( mesh, 1 )
+#        
+        
+        projectorViscosity = uw.utils.MeshVariable_Projection( meshViscosity,viscosityFn, type=0 )
+        projectorViscosity.solve()
+
+        projectorViscosity2 = uw.utils.MeshVariable_Projection( meshViscosity2,viscosityMapFn1, type=0 )
+        projectorViscosity2.solve()
+        
+        meshViscosity2.save(outputPath+"meshViscosity2"+str(step).zfill(4))        
+        meshViscosity.save(outputPath+"meshViscosity"+str(step).zfill(4)) 
+
+
+        swarm.save(outputPath+"swarm"+str(step).zfill(4))
+        mesh.save(outputPath+"mesh"+str(step).zfill(4))
+
+        temperatureField.save(outputPath+"temperatureField"+str(step).zfill(4)) 
+        previousStress.save(outputPath+"previousStress"+str(step).zfill(4))
+        materialVariable.save(outputPath+"materialVariable"+str(step).zfill(4))
+
+        previousVm.save(outputPath+"previousVm"+str(step).zfill(4))
+        b.save(outputPath+"a_field"+str(step).zfill(4))
+        thetaField.save(outputPath+"thetaField"+str(step).zfill(4))
+        meshFriction.save(outputPath+"meshFriction"+str(step).zfill(4))
+        previousVmMesh.save(outputPath+"previousVmMesh"+str(step).zfill(4))    
+
+    velocityField.save(outputPath+"velocityField"+str(step).zfill(4))
+    meshStress.save(outputPath+"meshStress"+str(step).zfill(4)) 
+    surfaceV1.save(outputPath+"surfaceV1"+str(step).zfill(4))
+    surfaceV2.save(outputPath+"surfaceV2"+str(step).zfill(4))
+    if uw.mpi.rank==0:
+
+        np.save(outputPath+"time"+str(step).zfill(4),timestep)
+        np.save(outputPath+"dt"+str(step).zfill(4),dt_e.value)
+
+    uw.mpi.barrier
+
+    dicMesh = { 'elements' : mesh.elementRes, 
+                'minCoord' : mesh.minCoord,
+                'maxCoord' : mesh.maxCoord}
+
+    fo = open(outputPath+"dicMesh"+str(step).zfill(4),'w')
+    fo.write(str(dicMesh))
+    fo.close()
+        
+    stressMM = fn.view.min_max(fn.math.abs(meshStress))
+    stressMM.evaluate(markSwarm1)
+    stressSample[0] = stressMM.max_global()
+
+    stressMM = fn.view.min_max(fn.math.abs(meshStress))
+    stressMM.evaluate(markSwarm2)
+    stressSample[1] = stressMM.max_global()
+
+    stressMM = fn.view.min_max(fn.math.abs(meshStress))
+    stressMM.evaluate(markSwarm3)
+    stressSample[2] = stressMM.max_global()
+
+    stressMM = fn.view.min_max(fn.math.abs(meshStress))
+    stressMM.evaluate(markSwarm4)
+    stressSample[3] = stressMM.max_global()
+
+    velMM = fn.view.min_max(fn.math.abs(VpFn ))
+    velMM.evaluate(markSwarm1)
+    velSample[0] = velMM.max_global()
+
+    velMM = fn.view.min_max(fn.math.abs(VpFn ))
+    velMM.evaluate(markSwarm2)
+    velSample[1] = velMM.max_global()
+
+    velMM = fn.view.min_max(fn.math.abs(VpFn ))
+    velMM.evaluate(markSwarm3)
+    velSample[2] = velMM.max_global()
+
+    velMM = fn.view.min_max(fn.math.abs(VpFn ))
+    velMM.evaluate(markSwarm4)
+    velSample[3] = velMM.max_global()
+
+    
+    if uw.mpi.rank==0:
+        SP_output = [step,timestep,stressSample[0,0],stressSample[1,0],stressSample[2,0],stressSample[3,0],dt_e.value,velSample[0,0],velSample[1,0],velSample[2,0],velSample[3,0]]
+        with open(outputPath+'Sample.csv', 'a') as f:
+            csv_write = csv.writer(f)  
+#             csv_write.writerow(SP_output)
+            csv_write.writerow(['{:.18e}'.format(x) for x in SP_output])
+    uw.mpi.barrier()
+    
+
+    
+    Vrms = math.sqrt( velSquared.evaluate()[0]/area.evaluate()[0] )
+    
+    if uw.mpi.rank==0:
+        print('step = {0:6d}; time = {1:.3e} yr; Vrms = {2:.3e}'.format(step,timestep/nd(1.*u.year),Vrms))  
+    uw.mpi.barrier()
+    
+    dt = dt_e.value
+    
+    velA.data[:] = velocityField.evaluate(swarm)   
+    vel_eff.data[:] = 1./2.*(velA.data[:]+1.*previousVm.data[:])  
+    previousVm.data[:] = np.copy(velA.data[:])      
+
+    velAMesh.data[:] = velocityField.evaluate(mesh)  
+    vel_effMesh.data[:] = 1./2.*(velAMesh.data[:]+1.*previousVmMesh.data[:])  
+
+        
+    previousStress.data[:] = allStressFn.evaluate(swarm)
+    
+ 
+    condition_theta = {      
+                               UC  : theta_rock,
+                               LC  : theta_rock,
+
+                            fault  : thetaFieldFn,
+                           faultLC  : thetaFieldFn,
+               }
+
+    thetaField.data[:] = fn.branching.map( fn_key = materialVariable, 
+                                           mapping = condition_theta ).evaluate(swarm) 
+
+     
+    if step>15:
+        dt_vepFn.reset()
+        dt_vepFn.evaluate(swarm)
+        dt_vep0 = dt_vepFn.min_global()
+
+    
+    
+        dt_vep = f_vep*dt_vep0
+        dt0 = np.min([dt_max,dt_vep,4.*dt_e.value])
+        dt_e.value =  np.max([dt0,dt_min,0.25*dt_e.value]) 
+        
+
+            
+    
+    timestep = timestep+dt
+    step = step+1
diff --git a/model_code_inputs/Wave_Propagation.gif b/model_code_inputs/Wave_Propagation.gif
new file mode 100644
index 0000000..b463573
Binary files /dev/null and b/model_code_inputs/Wave_Propagation.gif differ