Electro-elastic “blister” instability

• Code for 3D large deformation electro-elasticity with u-p formulation

• Electro-viscoelastic instability of out of plane deformation of a diaphragm.

• Uses quadrature representation of internal variable: viscous deformation tensor Cv.

• VHB material properties taken from Wang et al., JMPS (2016).

Units

• Length: mm

• Mass: kg

• Time: s

• Charge: nC

• Force: mN

• Stress: kPa

• Energy: microJ

• Electric potential: kV

Software:

• Dolfinx v0.8.0

Import modules

# Import FEnicSx/dolfinx
import dolfinx

# For numerical arrays
import numpy as np

# For MPI-based parallelization
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()

# PETSc solvers
from petsc4py import PETSc

# specific functions from dolfinx modules
from dolfinx import fem, mesh, io, plot, log
from dolfinx.fem import (Constant, dirichletbc, Function, functionspace, Expression )
from dolfinx.fem.petsc import NonlinearProblem
from dolfinx.nls.petsc import NewtonSolver
from dolfinx.io import VTXWriter, XDMFFile


# specific functions from ufl modules
import ufl
from ufl import (TestFunctions, TrialFunction, Identity, grad, det, div, dev, inv, tr, sqrt, conditional ,\
                 gt, dx, inner, derivative, dot, ln, split, exp, eq, cos, acos, ge, le, outer)

# basix finite elements
import basix
from basix.ufl import element, mixed_element, quadrature_element

# Matplotlib for plotting
import matplotlib.pyplot as plt
plt.close('all')

# For timing the code
from datetime import datetime


# Set level of detail for log messages (integer)
# Guide:
# CRITICAL  = 50, // errors that may lead to data corruption
# ERROR     = 40, // things that HAVE gone wrong
# WARNING   = 30, // things that MAY go wrong later
# INFO      = 20, // information of general interest (includes solver info)
# PROGRESS  = 16, // what's happening (broadly)
# TRACE     = 13, // what's happening (in detail)
# DBG       = 10  // sundry
#
log.set_log_level(log.LogLevel.WARNING)

Define geometry

# geometry nominal dimensions
boxSize = 150.0 # mm
electrodeDiameter = 90.0 # mm
thickness = 0.612 # mm

domain = mesh.create_box(MPI.COMM_WORLD, [[0.0,0.0,0.0], [boxSize/2.0,thickness,boxSize/2.0]],\
                         [25,2,25], mesh.CellType.tetrahedron)

x = ufl.SpatialCoordinate(domain)

# Identify the planar boundaries of the mesh
#
def xFace(x):
    return np.isclose(x[0], boxSize/2.0)
def zFace(x):
    return np.isclose(x[2], boxSize/2.0)
def TopElectrode(x):
    return np.logical_and(np.isclose(x[1], thickness), x[0]*x[0] + x[2]*x[2] < (electrodeDiameter/2.0)**2)
def BotElectrode(x):
    return np.logical_and(np.isclose(x[1], 0.0), x[0]*x[0] + x[2]*x[2] < (electrodeDiameter/2.0)**2)
def xSym(x):
    return np.isclose(x[0], 0.0)
def zSym(x):
    return np.isclose(x[2], 0.0)
def Bottom(x):
    return np.isclose(x[1], 0.0)

# Mark the sub-domains
boundaries = [(1,xFace),(2,zFace),(3,TopElectrode),(4,BotElectrode),(5,xSym),(6,zSym),(7,Bottom)]


# build collections of facets on each subdomain and mark them appropriately.
facet_indices, facet_markers = [], [] # initalize empty collections of indices and markers.
fdim = domain.topology.dim - 1 # geometric dimension of the facet (mesh dimension - 1)
for (marker, locator) in boundaries:
    facets = mesh.locate_entities(domain, fdim, locator) # an array of all the facets in a 
                                                         # given subdomain ("locator")
    facet_indices.append(facets)                         # add these facets to the collection.
    facet_markers.append(np.full_like(facets, marker))   # mark them with the appropriate index.

# Format the facet indices and markers as required for use in dolfinx.
facet_indices = np.hstack(facet_indices).astype(np.int32)
facet_markers = np.hstack(facet_markers).astype(np.int32)
sorted_facets = np.argsort(facet_indices)
# 
# Add these marked facets as "mesh tags" for later use in BCs.
facet_tags = mesh.meshtags(domain, fdim, facet_indices[sorted_facets], facet_markers[sorted_facets])

Print out the unique facet index numbers

top_imap = domain.topology.index_map(2)      # index map of 2D entities in domain (facets)
values = np.zeros(top_imap.size_global)      # an array of zeros of the same size as number of 2D entities
values[facet_tags.indices]=facet_tags.values # populating the array with facet tag index numbers
print(np.unique(facet_tags.values))          # printing the unique indices

[1 2 3 4 5 6 7]

Visualize reference configuration and boundary facets

import pyvista
pyvista.set_jupyter_backend('html')
from dolfinx.plot import vtk_mesh
pyvista.start_xvfb()

# initialize a plotter
plotter = pyvista.Plotter()


showFace = pyvista.UnstructuredGrid(*vtk_mesh(domain, domain.topology.dim-1,facet_tags.indices[facet_tags.values==4]) )
actor = plotter.add_mesh(showFace, show_edges=True,color="red")

# Add the mesh.
topology, cell_types, geometry = plot.vtk_mesh(domain, domain.topology.dim)
grid = pyvista.UnstructuredGrid(topology, cell_types, geometry)
plotter.add_mesh(grid, show_edges=True, opacity=0.1) 

labels = dict(zlabel='Z', xlabel='X', ylabel='Y')
plotter.add_axes(**labels)

plotter.screenshot("results/ElectroDiaphramMesh.png")

from IPython.display import Image
Image(filename='results/ElectroDiaphramMesh.png') 

Un-comment this cell to see an interactive visualization of the mesh

# plotter.show()

Define boundary and volume integration measure

# Define the boundary integration measure "ds" using the facet tags,
# also specify the number of surface quadrature points.
ds = ufl.Measure('ds', domain=domain, subdomain_data=facet_tags, metadata={'quadrature_degree':4})

# Define the volume integration measure "dx" 
# also specify the number of volume quadrature points.
dx = ufl.Measure('dx', domain=domain, metadata={'quadrature_degree': 4})

# Create facet to cell connectivity required to determine boundary facets.
domain.topology.create_connectivity(domain.topology.dim, domain.topology.dim)
domain.topology.create_connectivity(domain.topology.dim, domain.topology.dim-1)
domain.topology.create_connectivity(domain.topology.dim-1, domain.topology.dim)

#  Define facet normal
n = ufl.FacetNormal(domain)

Material parameters

# Equilibrium material parameters
#
rho = Constant(domain, PETSc.ScalarType(1e-6))           # 1000 kg/m^3 = 1e-6 kg/mm^3
#
Geq_0   = Constant(domain, PETSc.ScalarType(15.36))      # Shear modulus, kPa
Kbulk   = Constant(domain, PETSc.ScalarType(1e3*Geq_0))  # Bulk modulus, kPa
lambdaL = Constant(domain, PETSc.ScalarType(5.99))        # Arruda-Boyce locking stretch

# Viscoelasticity parameters from Wang et al (2016) for VHB4910
#
Gneq_1  = Constant(domain, PETSc.ScalarType(26.06))    #  Non-equilibrium shear modulus, kPa
tau_1   = Constant(domain, PETSc.ScalarType(0.6074))   #  relaxation time, s
#
Gneq_2  = Constant(domain, PETSc.ScalarType(26.53))    #  Non-equilibrium shear modulus, kPa
tau_2   = Constant(domain, PETSc.ScalarType(6.56))     #  relaxation time, s
#
Gneq_3  = Constant(domain, PETSc.ScalarType(10.83))    #  Non-equilinrium shear modulus, kPa
tau_3   = Constant(domain, PETSc.ScalarType(61.25))    #  relaxation time, s

# Electrostatic  parameters
vareps_0 = Constant(domain, PETSc.ScalarType(8.85E-3)) #  permittivity of free space pF/mm
vareps_r = Constant(domain, PETSc.ScalarType(4.8))     #  relative permittivity, dimensionless
vareps   = vareps_r*vareps_0         #  permittivity of the material

Simulation time-control related params

# start time (sec)
t = 0.0

# Final normalized value of phi.  Normalization parameter for voltage: l*sqrt(Geq_0/vareps)
#
phiTot = 1.5*float(thickness*np.sqrt(float(Geq_0)/float(vareps)))

# ramp rate (1/sec)
rampRate = 1.0e-1

# Time for loading (sec)
#
Ttot = phiTot/rampRate

# initial time step size (sec)
#
dt = Ttot/100

# maximum time increment (sec)
#
dtMax = Ttot/25

# Create a constant for the time step
#
dk = Constant(domain, PETSc.ScalarType(dt))

# Function to ramp the applied potential
def phiRamp(t):
    phi = phiTot*t/Ttot
    return phi

# Generalized-alpha method parameters for calculating acceleration and velocity
alpha   = Constant(domain, PETSc.ScalarType(0.0))
gamma   = Constant(domain, PETSc.ScalarType(0.5+alpha))
beta    = Constant(domain, PETSc.ScalarType(0.25*(gamma+0.5)**2))

Function spaces

U2 = element("Lagrange", domain.basix_cell(), 2, shape=(3,))  # For displacement
P1 = element("Lagrange", domain.basix_cell(), 1)  # For pressure and electric potential
P0 = quadrature_element(domain.basix_cell(), degree=2, scheme="default")
# Note: it seems that for the current version of dolfinx, 
# only degree=2 quadrature elements actually function properly 
# in e.g. visualization interpolations and problem solution.
T0 = basix.ufl.blocked_element(P0, shape=(3, 3)) # for Cv
#
TH = mixed_element([U2, P1, P1])  # Taylor-Hood style mixed element
ME = functionspace(domain, TH)    # Total space for all DOFs
#
V1 = functionspace(domain, P1) # Scalar function space.
V2 = functionspace(domain, U2) # Vector function space
V3 = functionspace(domain, T0) # Tensor function space
#
# Define actual functions with the required DOFs
w = Function(ME)
u, p, phi = split(w) # displacement u, presssure p, and electric potential phi

# A copy of functions to store values in the previous step
w_old  = Function(ME)
u_old, p_old, phi_old = split(w_old)   

# Define test functions   
u_test, p_test, phi_test = TestFunctions(ME)    

# Define trial functions needed for automatic differentiation
dw = TrialFunction(ME)

# Define a tensor-valued function for Cv.
Cv_1_old = Function(V3) 
Cv_2_old = Function(V3) 
Cv_3_old = Function(V3) 

# Functions for storing the velocity and acceleration at prev. step
v_old = Function(V2)
a_old = Function(V2)

# Initial conditions: 

# A function for constructing the identity matrix.
#
# To use the interpolate() feature, this must be defined as a 
# function of x.
def identity(x):
    values = np.zeros(((domain.geometry.dim)*(domain.geometry.dim),
                      x.shape[1]), dtype=np.float64)
    values[0] = 1
    values[4] = 1
    values[8] = 1
    return values

# interpolate the identity onto the tensor-valued Cv function.
Cv_1_old.interpolate(identity)  
Cv_2_old.interpolate(identity) 
Cv_3_old.interpolate(identity)   

Subroutines for kinematics and constitutive equations

#------------------------------------------------------------- 
# Utility subroutines
#-------------------------------------------------------------
 
# Subroutine for a "safer" sqrt() function which avoids a divide by zero 
# when differentiated. 
def safe_sqrt(x):
    return sqrt(x + 1.0e-16)

#------------------------------------------------------------- 
# Subroutines for kinematics
#-------------------------------------------------------------

# Deformation gradient 
def F_calc(u):
    Id = Identity(3) 
    F = Id + grad(u) 
    return F

# Subrountine for computing the effective stretch
def lambdaBar_calc(u):
    F = F_calc(u)
    J = det(F)
    Fbar = J**(-1/3)*F
    Cbar = Fbar.T*Fbar
    I1 = tr(Cbar)
    lambdaBar = safe_sqrt(I1/3.0)
    return lambdaBar

#------------------------------------------------------------- 
# Subroutines for computing the viscous flow update
#-------------------------------------------------------------

# Subroutine for computing the viscous stretch Cv at the end of the step.
def Cv_update(u, Cv_old, tau_r):
    F = F_calc(u)
    J = det(F)
    C = F.T*F
    # new update from Shawn here
    Cbar = J**(-2./3.)*C
    fac = Cv_old + (dk/tau_r)*Cbar
    Cv_new = (det(fac))**(-1./3.) * fac
    return Cv_new 
 
#------------------------------------------------------------- 
# Subroutines for calculating the electric field and displacement
#-------------------------------------------------------------

# Referential electric displacement 
def Dmat_calc(u, phi):
    F = F_calc(u)
    J = det(F)
    C = F.T*F
    e_R  = - grad(phi) # referential electric field
    Dmat = vareps * J* inv(C)*e_R
    return Dmat

#------------------------------------------------------------- 
# Subroutines for calculating the Cauchy stress
#-------------------------------------------------------------

# Subroutine for computing the zeta-function in the Arruda-Boyce model.
def zeta_calc(u):
    lambdaBar = lambdaBar_calc(u)
    # Use Pade approximation of Langevin inverse (A. Cohen, 1991)
    # This is sixth-order accurate.
    z = lambdaBar/lambdaL
    z = conditional(gt(z,0.99), 0.99, z) # Keep from blowing up
    beta = z*(3.0 - z**2.0)/(1.0 - z**2.0)
    zeta = (lambdaL/(3*lambdaBar))*beta
    return zeta

# Generalized shear modulus for Arruda-Boyce model
def Geq_AB_calc(u):
    zeta = zeta_calc(u)
    Geq_AB  = Geq_0 * zeta
    return Geq_AB

# Subroutine for calculating the  equilibrium Cauchy stress
def T_eq_calc(u,p):
    F = F_calc(u)
    J = det(F)
    Fbar = J**(-1./3.)*F
    Bbar = Fbar*Fbar.T
    Geq  = Geq_AB_calc(u)
    T_eq = (1/J)* Geq * dev(Bbar) - p * Identity(3)
    return T_eq


# Subroutine for calculating the electrotatic contribution to the Cauchy stress
def T_maxw_calc(u,phi):
    F = F_calc(u)
    e_R  = - grad(phi)    # referential electric field
    e_sp = inv(F.T)*e_R   # spatial electric field 
    # Spatial Maxwel stress
    T_maxw = vareps*(outer(e_sp,e_sp) - 1/2*(inner(e_sp,e_sp))*Identity(3))
    return T_maxw

# Subroutine for the non-equilibrium Cauchy stress.
def T_neq_calc(u, Cv, Gneq):
    F  = F_calc(u)
    J = det(F)
    C = F.T*F
    # Shawn update here
    Fbar = J**(-1./3.) * F
    Cbar = J**(-2./3.) * C
    T_neq = J**(-1.) * Gneq * (Fbar * inv(Cv) * Fbar.T - (1./3.) * inner(Cbar, inv(Cv)) * Identity(3) ) 
    return T_neq

#------------------------------------------------------------- 
# Subroutine for calculating the total Piola stress
#-------------------------------------------------------------
   
# Subroutine for the total Piola stress.
def  Piola_calc(u, p, Cv_1, Cv_2, Cv_3, Gneq_1, Gneq_2, Gneq_3):
    F  = F_calc(u)
    J = det(F)
    
    T_eq = T_eq_calc(u,p)
    
    T_maxw = T_maxw_calc(u,phi)
    
    T_neq_1 = T_neq_calc(u, Cv_1, Gneq_1)
    
    T_neq_2 = T_neq_calc(u, Cv_2, Gneq_2)
        
    T_neq_3 = T_neq_calc(u, Cv_3, Gneq_3)
    
    T = T_eq + T_maxw + T_neq_1 + T_neq_2 + T_neq_3
    
    Piola = J*T*inv(F.T)
    
    return Piola

#---------------------------------------------------------------------
# Subroutine for updating  acceleration using the Newmark beta method:
# a = 1/(2*beta)*((u - u0 - v0*dt)/(0.5*dt*dt) - (1-2*beta)*a0)
#---------------------------------------------------------------------
def update_a(u, u_old, v_old, a_old):
    return (u-u_old-dk*v_old)/beta/dk**2 - (1-2*beta)/2/beta*a_old

#---------------------------------------------------------------------
# Subroutine for updating  velocity using the Newmark beta method
# v = dt * ((1-gamma)*a0 + gamma*a) + v0
#---------------------------------------------------------------------
def update_v(a, u_old, v_old, a_old):
    return v_old + dk*((1-gamma)*a_old + gamma*a)

#---------------------------------------------------------------------
# alpha-method averaging function
#---------------------------------------------------------------------
def avg(x_old, x_new, alpha):
    return alpha*x_old + (1-alpha)*x_new

Evaluate kinematics and constitutive relations

# Get acceleration and velocity at end of step
a_new = update_a(u, u_old, v_old, a_old)
v_new = update_v(a_new, u_old, v_old, a_old)

# get avg (u,p) fields for generalized-alpha method
u_avg  = avg(u_old, u, alpha)
p_avg  = avg(p_old, p, alpha)

# Kinematical quantities
F  = F_calc(u_avg)
J  = det(F)
lambdaBar = lambdaBar_calc(u_avg)

# update the Cv tensors
Cv_1 = Cv_update(u_avg, Cv_1_old, tau_1)
Cv_2 = Cv_update(u_avg, Cv_2_old, tau_2)
Cv_3 = Cv_update(u_avg, Cv_3_old, tau_3)

# Referential electric displacement
Dmat = Dmat_calc(u_avg, phi)

#  Evaulate the total Piola stress
Piola = Piola_calc(u_avg, p_avg, Cv_1, Cv_2, Cv_3, Gneq_1, Gneq_2, Gneq_3)

Weak forms

# The weak form for the equilibrium equation
#
Res_1  =  inner( Piola, grad(u_test))*dx \
     + inner(rho*a_new, u_test)*dx 

# The auxiliary equation for the pressure
#
Res_2 = inner((p_avg/Kbulk + ln(J)/J) , p_test)*dx

#  The weak form for Gauss's equation
Res_3 = inner(Dmat, grad(phi_test))*dx 

# The total residual
Res = Res_1 + Res_2 + Res_3

# Automatic differentiation tangent:
a = derivative(Res, w, dw)

Set-up output files

# results file name
results_name = "DiaphramActuation"

# Function space for projection of results
P1 = element("Lagrange", domain.basix_cell(), 1)
VV1 = fem.functionspace(domain, P1) # linear scalar function space
#
U1 = element("Lagrange", domain.basix_cell(), 1, shape=(3,)) 
VV2 = fem.functionspace(domain, U1) # linear Vector function space
#
T1 = element("Lagrange", domain.basix_cell(), 1, shape=(3,3)) 
VV3 = fem.functionspace(domain, T1) # linear tensor function space

# For visualization purposes, we need to re-project the stress tensor onto a linear function space before 
# we write it (and its components and the von Mises stress, etc) to the VTX file. 
#
# This is because the stress is a complicated "mixed" function of the (quadratic Lagrangian) displacements
# and the (quadrature representation) plastic strain tensor and scalar equivalent plastic strain. 
#
# First, define a function for setting up this kind of projection problem for visualization purposes:
def setup_projection(u, V):

    trial = ufl.TrialFunction(V)
    test  = ufl.TestFunction(V)   

    a = ufl.inner(trial, test)*dx
    L = ufl.inner(u, test)*dx

    projection_problem = dolfinx.fem.petsc.LinearProblem(a, L, [], \
        petsc_options={"ksp_type": "cg", "ksp_rtol": 1e-16, "ksp_atol": 1e-16, "ksp_max_it": 1000})
    
    return projection_problem

# Create a linear problem for projecting the stress tensor onto the linear tensor function space VV3.
#
tensor_projection_problem = setup_projection(Piola, VV3)
Piola_temp = tensor_projection_problem.solve()

# primary fields to write to output file
u_vis      = Function(VV2, name="disp")
p_vis      = Function(VV1, name="p")
phi_vis    = Function(VV1, name="phi")

# Mises stress
T     = Piola_temp*F.T/J
T0    = T - (1/3)*tr(T)*Identity(3)
Mises = sqrt((3/2)*inner(T0, T0))
Mises_vis= Function(VV1,name="Mises")
Mises_expr = Expression(Mises,VV1.element.interpolation_points())

# Cauchy stress components
T11 = Function(VV1)
T11.name = "T11"
T11_expr = Expression(T[0,0],VV1.element.interpolation_points())

T22 = Function(VV1)
T22.name = "T22"
T22_expr = Expression(T[1,1],VV1.element.interpolation_points())

T33 = Function(VV1)
T33.name = "T33"
T33_expr = Expression(T[2,2],VV1.element.interpolation_points())

# Stretch measure
lambdaBar_vis      = Function(VV1)
lambdaBar_vis.name = "lambdaBar"
lambdaBar_expr     = Expression(lambdaBar, VV1.element.interpolation_points())

# Volumetric deformation
J_vis      = Function(VV1)
J_vis.name = "J"
J_expr     = Expression(J, VV1.element.interpolation_points())

# set up the output VTX files.
file_results = VTXWriter(
    MPI.COMM_WORLD,
    "results/" + results_name + ".bp",
    [  # put the functions here you wish to write to output
        u_vis, p_vis, phi_vis, # DOF outputs
        Mises_vis, T11, T22, T33, # stress outputs
        lambdaBar_vis, J_vis, # Kinematical outputs
    ],
    engine="BP4",
)

def writeResults(t):
    
    # Update the output fields before writing to VTX.
    #
    u_vis.interpolate(w.sub(0))
    p_vis.interpolate(w.sub(1))
    phi_vis.interpolate(w.sub(2))
    #
    # re-project to smooth visualization of quadrature functions
    # before interpolating.
    Piola_temp = tensor_projection_problem.solve()
    Mises_vis.interpolate(Mises_expr)
    T11.interpolate(T11_expr)
    T22.interpolate(T22_expr)
    T33.interpolate(T33_expr)
    #
    lambdaBar_vis.interpolate(lambdaBar_expr)
    J_vis.interpolate(J_expr)
       
    # Finally, write output fields to VTX.
    #
    file_results.write(t) 

Infrastructure for pulling out time history data (force, displacement, etc.)

# # computing the reaction force using the stress field
# traction = dot(Piola_temp, n)
# Force    = dot(traction, n)*ds(3)
# rxnForce = fem.form(Force)

# infrastructure for evaluating functions at a certain point efficiently
pointForEval = np.array([0.0, thickness, 0.0])

bb_tree = dolfinx.geometry.bb_tree(domain,domain.topology.dim)
cell_candidates = dolfinx.geometry.compute_collisions_points(bb_tree, pointForEval)
colliding_cells = dolfinx.geometry.compute_colliding_cells(domain, cell_candidates, pointForEval).array

Boundary condtions

# Constant for applied electric potential
phi_cons_top = Constant(domain,PETSc.ScalarType(phiRamp(0)))

xFace_u1_dofs = fem.locate_dofs_topological(ME.sub(0).sub(0), facet_tags.dim, facet_tags.find(1))
xFace_u2_dofs = fem.locate_dofs_topological(ME.sub(0).sub(1), facet_tags.dim, facet_tags.find(1))
xFace_u3_dofs = fem.locate_dofs_topological(ME.sub(0).sub(2), facet_tags.dim, facet_tags.find(1))
zFace_u1_dofs = fem.locate_dofs_topological(ME.sub(0).sub(0), facet_tags.dim, facet_tags.find(2))
zFace_u2_dofs = fem.locate_dofs_topological(ME.sub(0).sub(1), facet_tags.dim, facet_tags.find(2))
zFace_u3_dofs = fem.locate_dofs_topological(ME.sub(0).sub(2), facet_tags.dim, facet_tags.find(2))
#
xSym_u1_dofs = fem.locate_dofs_topological(ME.sub(0).sub(0), facet_tags.dim, facet_tags.find(5))
zSym_u3_dofs = fem.locate_dofs_topological(ME.sub(0).sub(2), facet_tags.dim, facet_tags.find(6))
#
Top_phi_dofs = fem.locate_dofs_topological(ME.sub(2), facet_tags.dim, facet_tags.find(3))
# Bot_phi_dofs = fem.locate_dofs_topological(ME.sub(2), facet_tags.dim, facet_tags.find(4))
Bot_phi_dofs = fem.locate_dofs_topological(ME.sub(2), facet_tags.dim, facet_tags.find(7))

# building Dirichlet BCs
bcs_1 = dirichletbc(0.0, xFace_u1_dofs, ME.sub(0).sub(0))  # u1 - xFace
bcs_2 = dirichletbc(0.0, xFace_u2_dofs, ME.sub(0).sub(1))  # u2 fix - xFace
bcs_3 = dirichletbc(0.0, xFace_u3_dofs, ME.sub(0).sub(2))  # u3 fix - xFace
bcs_4 = dirichletbc(0.0, zFace_u1_dofs, ME.sub(0).sub(0))  # u1 fix - zFace
bcs_5 = dirichletbc(0.0, zFace_u2_dofs, ME.sub(0).sub(1))  # u2 fix - zFace
bcs_6 = dirichletbc(0.0, zFace_u3_dofs, ME.sub(0).sub(2))  # u3 - zFace
#
bcs_7 = dirichletbc(0.0, xSym_u1_dofs, ME.sub(0).sub(0))  # u1 fix - xSym
bcs_8 = dirichletbc(0.0, zSym_u3_dofs, ME.sub(0).sub(2))  # u3 fix - zSym
#
bcs_9 = dirichletbc(phi_cons_top, Top_phi_dofs, ME.sub(2))  # phi ramp - Top electrode
# bcs_10 = dirichletbc(0.0, Bot_phi_dofs, ME.sub(2))  # phi=0 - Bot electrode
bcs_10 = dirichletbc(0.0, Bot_phi_dofs, ME.sub(2))  # phi=0 - Bottom


bcs = [bcs_1, bcs_2, bcs_3, bcs_4, bcs_5, bcs_6, bcs_7, bcs_8, bcs_9, bcs_10]

Define the nonlinear variational problem

# Set up nonlinear problem
problem = NonlinearProblem(Res, w, bcs, a)

# the global newton solver and params
solver = NewtonSolver(MPI.COMM_WORLD, problem)
solver.convergence_criterion = "incremental"
solver.rtol = 1e-8
solver.atol = 1e-8
solver.max_it = 15
solver.report = True
solver.error_on_nonconvergence = False

#  The Krylov solver parameters.
ksp = solver.krylov_solver
opts = PETSc.Options()
option_prefix = ksp.getOptionsPrefix()
opts[f"{option_prefix}ksp_type"] = "preonly" # "preonly" works equally well
opts[f"{option_prefix}pc_type"] = "lu" # do not use 'gamg' pre-conditioner
opts[f"{option_prefix}pc_factor_mat_solver_type"] = "mumps"
opts[f"{option_prefix}ksp_max_it"] = 30
ksp.setFromOptions()

Start calculation loop

# Give the step a descriptive name
step = "Actuate"

# Variables for storing time history
totSteps = 1000000
timeHist0 = np.zeros(shape=[totSteps])
timeHist1 = np.zeros(shape=[totSteps])
timeHist2 = np.zeros(shape=[totSteps])

# Iinitialize a counter for reporting data
ii=0

# init counter for nonconvergence
notConvergedCount = 0

#  Set up temporary "helper" functions and expressions 
#  for updating the internal variables.
#
# For the Cv tensors:
Cv_1_temp = Function(V3)
Cv_1_expr = Expression(Cv_1, V3.element.interpolation_points())
#
Cv_2_temp = Function(V3)
Cv_2_expr = Expression(Cv_2, V3.element.interpolation_points())
#
Cv_3_temp = Function(V3)
Cv_3_expr = Expression(Cv_3, V3.element.interpolation_points())
#
# and also for the velocity and acceleration.
v_temp = Function(V2)
a_temp = Function(V2)
#
v_expr = Expression(v_new,V2.element.interpolation_points())
a_expr = Expression(a_new,V2.element.interpolation_points())

# Write initial state to file
writeResults(t=0.0)    

# print a message for simulation startup
print("------------------------------------")
print("Simulation Start")
print("------------------------------------")
# Store start time 
startTime = datetime.now()

# Time-stepping solution procedure loop
while (round(t + dt, 9) <= Ttot):
  
  
  # increment time
  t += dt 
    
  # update time variables in time-dependent BCs 
  phi_cons_top.value = phiRamp(t - float(alpha)*dt)
    
  # Solve the problem
  (iter, converged) = solver.solve(w)
  
  if converged:
    
    # If the solver converged, we print the status of the solver, 
    # perform adaptive time-stepping updates, output results, and 
    # update degrees of freedom for the next step, w_old <- w.
  
    # update the counter for nonconverged attempts
    notConvergedCount = 0
    
    # increment counter
    ii += 1

    # Collect results from MPI ghost processes
    w.x.scatter_forward()
        
    # Write output to file
    writeResults(t)

    # Store time history variables at this time
    timeHist0[ii] = t # current time
    timeHist1[ii] = w.sub(2).eval([0.0, thickness, 0.0],colliding_cells[0])[0] # time history of voltage phi
    timeHist2[ii] = w.sub(0).sub(1).eval([0.0, thickness, 0.0],colliding_cells[0])[0] # time history of displacement
    
    # update internal variables 
    #
    # interpolate the values of the internal variables into their "temp" functions
    Cv_1_temp.interpolate(Cv_1_expr)
    Cv_2_temp.interpolate(Cv_2_expr)
    Cv_3_temp.interpolate(Cv_3_expr)
    #
    v_temp.interpolate(v_expr)
    a_temp.interpolate(a_expr)
    
    # Update DOFs for next step
    w_old.x.array[:] = w.x.array
    
    # update the old values of internal variables for next step
    Cv_1_old.x.array[:] = Cv_1_temp.x.array[:]
    Cv_2_old.x.array[:] = Cv_2_temp.x.array[:]
    Cv_3_old.x.array[:] = Cv_3_temp.x.array[:]
    #
    v_old.x.array[:] = v_temp.x.array[:]
    a_old.x.array[:] = a_temp.x.array[:]
    
    # Iteration-based adaptive time-stepping
    #
    # If the newton solver takes 2 or less iterations, 
    # increase the time step by a factor of 1.5:
    if ((iter<=2) and (dt<25)):
      newdt = True
      dtOld = dt
      dt = 1.5*dt
      dk.value = dt
    # If the newton solver takes 5 or more iterations, 
    # decrease the time step by a factor of 2:
    elif iter>=5:
      newdt = True
      dtOld = dt
      dt = dt/2
      dk.value = dt
    else:
      newdt = False
    # otherwise the newton solver took 3-4 iterations,
    # in which case leave the time step alone

    # update the DOFs for the next step.
    w_old.x.array[:] = w.x.array
    
    # print progress of calculation periodically
    if ii%1 == 0:      
        now = datetime.now()
        current_time = now.strftime("%H:%M:%S")
        print("Step: {} |   Increment: {} | Iterations: {}".format(step, ii, iter))
        print("Simulation Time: {} s | dt: {} s".format(round(t,2), round(dt, 4)))
        if newdt:
          print("old dt: {} s | new dt: {} s".format(round(dtOld,4), round(dt, 4)))
        print() 
            
  # If the solver doesn't converge we have to back up in time,
  # cut the size of the time step, and try solving again.
  else: # not(converged)
    
    # update the counter for nonconverged attempts
    notConvergedCount += 1
    
    # first, we back up in time
    # ( to undo the current time step )
    t = t - float(dk)
        
    # Then, we cut back on the time step we're attempting.
    # (by a factor of 2)
    dt = dt/2
    dk.value = dt

    # Re-set the DOFs to their value before the failed step.
    w.x.array[:] = w_old.x.array

    # Set up nonlinear problem
    problem = NonlinearProblem(Res, w, bcs, a)

    # The global newton solver and params
    solver = NewtonSolver(MPI.COMM_WORLD, problem)
    solver.convergence_criterion = "incremental"
    solver.rtol = 1e-8
    solver.atol = 1e-8
    solver.max_it = 15
    solver.report = True
    solver.error_on_nonconvergence = False
    
    #  The Krylov solver parameters.
    ksp = solver.krylov_solver
    opts = PETSc.Options()
    option_prefix = ksp.getOptionsPrefix()
    opts[f"{option_prefix}ksp_type"] = "preonly" # "preonly" works equally well
    opts[f"{option_prefix}pc_type"] = "lu" # do not use 'gamg' pre-conditioner
    opts[f"{option_prefix}pc_factor_mat_solver_type"] = "mumps"
    opts[f"{option_prefix}ksp_max_it"] = 30
    ksp.setFromOptions()
    
    # inform the user about the nonconvergence        
    now = datetime.now()
    current_time = now.strftime("%H:%M:%S")
    print("Not converged, this was attempt {}".format(notConvergedCount))
    print("Step: {} | Increment: {} | Iterations: {}".format(step, ii, iter))
    print("dt: {} | Simulation Time: {} s | Percent of total time: {}%".format(round(dt,4), round(t,4), round(100*t/Ttot,4)))
    print("old dt: {} | new dt {}".format(round(2*dt,4), round(dt,4)))
    print()
    
    # if you have not converged 5 times in a row, give up
    if notConvergedCount >= 5:
      file_results.close()
      print("Ended early due to an excessive number of attempts")
      break
    
    # if the dt is too small, give up
    if dt <= 1.e-4:
      file_results.close()
      print("Ended early due to an excessively small time increment")
      break
    

    
# close the output file.
file_results.close()
         
# End analysis
print("-----------------------------------------")
print("End computation")                 
# Report elapsed real time for the analysis
endTime = datetime.now()
elapseTime = endTime - startTime
print("------------------------------------------")
print("Elapsed real time:  {}".format(elapseTime))
print("------------------------------------------")

------------------------------------
Simulation Start
------------------------------------
Step: Actuate |   Increment: 1 | Iterations: 4
Simulation Time: 1.75 s | dt: 1.7456 s

Step: Actuate |   Increment: 2 | Iterations: 4
Simulation Time: 3.49 s | dt: 1.7456 s

Step: Actuate |   Increment: 3 | Iterations: 5
Simulation Time: 5.24 s | dt: 0.8728 s
old dt: 1.7456 s | new dt: 0.8728 s

Step: Actuate |   Increment: 4 | Iterations: 5
Simulation Time: 6.11 s | dt: 0.4364 s
old dt: 0.8728 s | new dt: 0.4364 s

Step: Actuate |   Increment: 5 | Iterations: 5
Simulation Time: 6.55 s | dt: 0.2182 s
old dt: 0.4364 s | new dt: 0.2182 s

Step: Actuate |   Increment: 6 | Iterations: 4
Simulation Time: 6.76 s | dt: 0.2182 s

Step: Actuate |   Increment: 7 | Iterations: 4
Simulation Time: 6.98 s | dt: 0.2182 s

Step: Actuate |   Increment: 8 | Iterations: 4
Simulation Time: 7.2 s | dt: 0.2182 s

Step: Actuate |   Increment: 9 | Iterations: 4
Simulation Time: 7.42 s | dt: 0.2182 s

Step: Actuate |   Increment: 10 | Iterations: 4
Simulation Time: 7.64 s | dt: 0.2182 s

Step: Actuate |   Increment: 11 | Iterations: 4
Simulation Time: 7.86 s | dt: 0.2182 s

Step: Actuate |   Increment: 12 | Iterations: 4
Simulation Time: 8.07 s | dt: 0.2182 s

Step: Actuate |   Increment: 13 | Iterations: 4
Simulation Time: 8.29 s | dt: 0.2182 s

Step: Actuate |   Increment: 14 | Iterations: 4
Simulation Time: 8.51 s | dt: 0.2182 s

Step: Actuate |   Increment: 15 | Iterations: 4
Simulation Time: 8.73 s | dt: 0.2182 s

Step: Actuate |   Increment: 16 | Iterations: 4
Simulation Time: 8.95 s | dt: 0.2182 s

Step: Actuate |   Increment: 17 | Iterations: 4
Simulation Time: 9.16 s | dt: 0.2182 s

Step: Actuate |   Increment: 18 | Iterations: 4
Simulation Time: 9.38 s | dt: 0.2182 s

Step: Actuate |   Increment: 19 | Iterations: 4
Simulation Time: 9.6 s | dt: 0.2182 s

Step: Actuate |   Increment: 20 | Iterations: 4
Simulation Time: 9.82 s | dt: 0.2182 s

Step: Actuate |   Increment: 21 | Iterations: 4
Simulation Time: 10.04 s | dt: 0.2182 s

Step: Actuate |   Increment: 22 | Iterations: 4
Simulation Time: 10.26 s | dt: 0.2182 s

Step: Actuate |   Increment: 23 | Iterations: 4
Simulation Time: 10.47 s | dt: 0.2182 s

Step: Actuate |   Increment: 24 | Iterations: 4
Simulation Time: 10.69 s | dt: 0.2182 s

Step: Actuate |   Increment: 25 | Iterations: 4
Simulation Time: 10.91 s | dt: 0.2182 s

Step: Actuate |   Increment: 26 | Iterations: 4
Simulation Time: 11.13 s | dt: 0.2182 s

Step: Actuate |   Increment: 27 | Iterations: 4
Simulation Time: 11.35 s | dt: 0.2182 s

Step: Actuate |   Increment: 28 | Iterations: 4
Simulation Time: 11.56 s | dt: 0.2182 s

Step: Actuate |   Increment: 29 | Iterations: 4
Simulation Time: 11.78 s | dt: 0.2182 s

Step: Actuate |   Increment: 30 | Iterations: 4
Simulation Time: 12.0 s | dt: 0.2182 s

Step: Actuate |   Increment: 31 | Iterations: 4
Simulation Time: 12.22 s | dt: 0.2182 s

Step: Actuate |   Increment: 32 | Iterations: 4
Simulation Time: 12.44 s | dt: 0.2182 s

Step: Actuate |   Increment: 33 | Iterations: 4
Simulation Time: 12.66 s | dt: 0.2182 s

Step: Actuate |   Increment: 34 | Iterations: 4
Simulation Time: 12.87 s | dt: 0.2182 s

Step: Actuate |   Increment: 35 | Iterations: 4
Simulation Time: 13.09 s | dt: 0.2182 s

Step: Actuate |   Increment: 36 | Iterations: 4
Simulation Time: 13.31 s | dt: 0.2182 s

Step: Actuate |   Increment: 37 | Iterations: 4
Simulation Time: 13.53 s | dt: 0.2182 s

Step: Actuate |   Increment: 38 | Iterations: 4
Simulation Time: 13.75 s | dt: 0.2182 s

Step: Actuate |   Increment: 39 | Iterations: 4
Simulation Time: 13.96 s | dt: 0.2182 s

Step: Actuate |   Increment: 40 | Iterations: 4
Simulation Time: 14.18 s | dt: 0.2182 s

Step: Actuate |   Increment: 41 | Iterations: 4
Simulation Time: 14.4 s | dt: 0.2182 s

Step: Actuate |   Increment: 42 | Iterations: 4
Simulation Time: 14.62 s | dt: 0.2182 s

Step: Actuate |   Increment: 43 | Iterations: 4
Simulation Time: 14.84 s | dt: 0.2182 s

Step: Actuate |   Increment: 44 | Iterations: 4
Simulation Time: 15.06 s | dt: 0.2182 s

Step: Actuate |   Increment: 45 | Iterations: 4
Simulation Time: 15.27 s | dt: 0.2182 s

Step: Actuate |   Increment: 46 | Iterations: 4
Simulation Time: 15.49 s | dt: 0.2182 s

Step: Actuate |   Increment: 47 | Iterations: 4
Simulation Time: 15.71 s | dt: 0.2182 s

Step: Actuate |   Increment: 48 | Iterations: 4
Simulation Time: 15.93 s | dt: 0.2182 s

Step: Actuate |   Increment: 49 | Iterations: 4
Simulation Time: 16.15 s | dt: 0.2182 s

Step: Actuate |   Increment: 50 | Iterations: 4
Simulation Time: 16.37 s | dt: 0.2182 s

Step: Actuate |   Increment: 51 | Iterations: 4
Simulation Time: 16.58 s | dt: 0.2182 s

Step: Actuate |   Increment: 52 | Iterations: 4
Simulation Time: 16.8 s | dt: 0.2182 s

Step: Actuate |   Increment: 53 | Iterations: 4
Simulation Time: 17.02 s | dt: 0.2182 s

Step: Actuate |   Increment: 54 | Iterations: 4
Simulation Time: 17.24 s | dt: 0.2182 s

Step: Actuate |   Increment: 55 | Iterations: 4
Simulation Time: 17.46 s | dt: 0.2182 s

Step: Actuate |   Increment: 56 | Iterations: 4
Simulation Time: 17.67 s | dt: 0.2182 s

Step: Actuate |   Increment: 57 | Iterations: 4
Simulation Time: 17.89 s | dt: 0.2182 s

Step: Actuate |   Increment: 58 | Iterations: 4
Simulation Time: 18.11 s | dt: 0.2182 s

Step: Actuate |   Increment: 59 | Iterations: 4
Simulation Time: 18.33 s | dt: 0.2182 s

Step: Actuate |   Increment: 60 | Iterations: 4
Simulation Time: 18.55 s | dt: 0.2182 s

Step: Actuate |   Increment: 61 | Iterations: 4
Simulation Time: 18.77 s | dt: 0.2182 s

Step: Actuate |   Increment: 62 | Iterations: 4
Simulation Time: 18.98 s | dt: 0.2182 s

Step: Actuate |   Increment: 63 | Iterations: 4
Simulation Time: 19.2 s | dt: 0.2182 s

Step: Actuate |   Increment: 64 | Iterations: 4
Simulation Time: 19.42 s | dt: 0.2182 s

Step: Actuate |   Increment: 65 | Iterations: 4
Simulation Time: 19.64 s | dt: 0.2182 s

Step: Actuate |   Increment: 66 | Iterations: 4
Simulation Time: 19.86 s | dt: 0.2182 s

Step: Actuate |   Increment: 67 | Iterations: 4
Simulation Time: 20.07 s | dt: 0.2182 s

Step: Actuate |   Increment: 68 | Iterations: 4
Simulation Time: 20.29 s | dt: 0.2182 s

Step: Actuate |   Increment: 69 | Iterations: 4
Simulation Time: 20.51 s | dt: 0.2182 s

Step: Actuate |   Increment: 70 | Iterations: 4
Simulation Time: 20.73 s | dt: 0.2182 s

Step: Actuate |   Increment: 71 | Iterations: 4
Simulation Time: 20.95 s | dt: 0.2182 s

Step: Actuate |   Increment: 72 | Iterations: 4
Simulation Time: 21.17 s | dt: 0.2182 s

Step: Actuate |   Increment: 73 | Iterations: 4
Simulation Time: 21.38 s | dt: 0.2182 s

Step: Actuate |   Increment: 74 | Iterations: 4
Simulation Time: 21.6 s | dt: 0.2182 s

Step: Actuate |   Increment: 75 | Iterations: 4
Simulation Time: 21.82 s | dt: 0.2182 s

Step: Actuate |   Increment: 76 | Iterations: 4
Simulation Time: 22.04 s | dt: 0.2182 s

Step: Actuate |   Increment: 77 | Iterations: 4
Simulation Time: 22.26 s | dt: 0.2182 s

Step: Actuate |   Increment: 78 | Iterations: 4
Simulation Time: 22.47 s | dt: 0.2182 s

Step: Actuate |   Increment: 79 | Iterations: 4
Simulation Time: 22.69 s | dt: 0.2182 s

Step: Actuate |   Increment: 80 | Iterations: 4
Simulation Time: 22.91 s | dt: 0.2182 s

Step: Actuate |   Increment: 81 | Iterations: 4
Simulation Time: 23.13 s | dt: 0.2182 s

Step: Actuate |   Increment: 82 | Iterations: 4
Simulation Time: 23.35 s | dt: 0.2182 s

Step: Actuate |   Increment: 83 | Iterations: 4
Simulation Time: 23.57 s | dt: 0.2182 s

Step: Actuate |   Increment: 84 | Iterations: 4
Simulation Time: 23.78 s | dt: 0.2182 s

Step: Actuate |   Increment: 85 | Iterations: 4
Simulation Time: 24.0 s | dt: 0.2182 s

Step: Actuate |   Increment: 86 | Iterations: 4
Simulation Time: 24.22 s | dt: 0.2182 s

Step: Actuate |   Increment: 87 | Iterations: 4
Simulation Time: 24.44 s | dt: 0.2182 s

Step: Actuate |   Increment: 88 | Iterations: 4
Simulation Time: 24.66 s | dt: 0.2182 s

Step: Actuate |   Increment: 89 | Iterations: 4
Simulation Time: 24.87 s | dt: 0.2182 s

Step: Actuate |   Increment: 90 | Iterations: 4
Simulation Time: 25.09 s | dt: 0.2182 s

Step: Actuate |   Increment: 91 | Iterations: 4
Simulation Time: 25.31 s | dt: 0.2182 s

Step: Actuate |   Increment: 92 | Iterations: 4
Simulation Time: 25.53 s | dt: 0.2182 s

Step: Actuate |   Increment: 93 | Iterations: 4
Simulation Time: 25.75 s | dt: 0.2182 s

Step: Actuate |   Increment: 94 | Iterations: 4
Simulation Time: 25.97 s | dt: 0.2182 s

Step: Actuate |   Increment: 95 | Iterations: 4
Simulation Time: 26.18 s | dt: 0.2182 s

Step: Actuate |   Increment: 96 | Iterations: 4
Simulation Time: 26.4 s | dt: 0.2182 s

Step: Actuate |   Increment: 97 | Iterations: 4
Simulation Time: 26.62 s | dt: 0.2182 s

Step: Actuate |   Increment: 98 | Iterations: 4
Simulation Time: 26.84 s | dt: 0.2182 s

Step: Actuate |   Increment: 99 | Iterations: 4
Simulation Time: 27.06 s | dt: 0.2182 s

Step: Actuate |   Increment: 100 | Iterations: 4
Simulation Time: 27.28 s | dt: 0.2182 s

Step: Actuate |   Increment: 101 | Iterations: 4
Simulation Time: 27.49 s | dt: 0.2182 s

Step: Actuate |   Increment: 102 | Iterations: 4
Simulation Time: 27.71 s | dt: 0.2182 s

Step: Actuate |   Increment: 103 | Iterations: 4
Simulation Time: 27.93 s | dt: 0.2182 s

Step: Actuate |   Increment: 104 | Iterations: 4
Simulation Time: 28.15 s | dt: 0.2182 s

Step: Actuate |   Increment: 105 | Iterations: 4
Simulation Time: 28.37 s | dt: 0.2182 s

Step: Actuate |   Increment: 106 | Iterations: 4
Simulation Time: 28.58 s | dt: 0.2182 s

Step: Actuate |   Increment: 107 | Iterations: 4
Simulation Time: 28.8 s | dt: 0.2182 s

Step: Actuate |   Increment: 108 | Iterations: 4
Simulation Time: 29.02 s | dt: 0.2182 s

Step: Actuate |   Increment: 109 | Iterations: 4
Simulation Time: 29.24 s | dt: 0.2182 s

Step: Actuate |   Increment: 110 | Iterations: 4
Simulation Time: 29.46 s | dt: 0.2182 s

Step: Actuate |   Increment: 111 | Iterations: 4
Simulation Time: 29.68 s | dt: 0.2182 s

Step: Actuate |   Increment: 112 | Iterations: 4
Simulation Time: 29.89 s | dt: 0.2182 s

Step: Actuate |   Increment: 113 | Iterations: 4
Simulation Time: 30.11 s | dt: 0.2182 s

Step: Actuate |   Increment: 114 | Iterations: 4
Simulation Time: 30.33 s | dt: 0.2182 s

Step: Actuate |   Increment: 115 | Iterations: 4
Simulation Time: 30.55 s | dt: 0.2182 s

Step: Actuate |   Increment: 116 | Iterations: 4
Simulation Time: 30.77 s | dt: 0.2182 s

Step: Actuate |   Increment: 117 | Iterations: 4
Simulation Time: 30.98 s | dt: 0.2182 s

Step: Actuate |   Increment: 118 | Iterations: 4
Simulation Time: 31.2 s | dt: 0.2182 s

Step: Actuate |   Increment: 119 | Iterations: 4
Simulation Time: 31.42 s | dt: 0.2182 s

Step: Actuate |   Increment: 120 | Iterations: 4
Simulation Time: 31.64 s | dt: 0.2182 s

Step: Actuate |   Increment: 121 | Iterations: 4
Simulation Time: 31.86 s | dt: 0.2182 s

Step: Actuate |   Increment: 122 | Iterations: 4
Simulation Time: 32.08 s | dt: 0.2182 s

Step: Actuate |   Increment: 123 | Iterations: 4
Simulation Time: 32.29 s | dt: 0.2182 s

Step: Actuate |   Increment: 124 | Iterations: 4
Simulation Time: 32.51 s | dt: 0.2182 s

Step: Actuate |   Increment: 125 | Iterations: 4
Simulation Time: 32.73 s | dt: 0.2182 s

Step: Actuate |   Increment: 126 | Iterations: 4
Simulation Time: 32.95 s | dt: 0.2182 s

Step: Actuate |   Increment: 127 | Iterations: 4
Simulation Time: 33.17 s | dt: 0.2182 s

Step: Actuate |   Increment: 128 | Iterations: 4
Simulation Time: 33.38 s | dt: 0.2182 s

Step: Actuate |   Increment: 129 | Iterations: 4
Simulation Time: 33.6 s | dt: 0.2182 s

Step: Actuate |   Increment: 130 | Iterations: 4
Simulation Time: 33.82 s | dt: 0.2182 s

Step: Actuate |   Increment: 131 | Iterations: 4
Simulation Time: 34.04 s | dt: 0.2182 s

Step: Actuate |   Increment: 132 | Iterations: 4
Simulation Time: 34.26 s | dt: 0.2182 s

Step: Actuate |   Increment: 133 | Iterations: 4
Simulation Time: 34.48 s | dt: 0.2182 s

Step: Actuate |   Increment: 134 | Iterations: 4
Simulation Time: 34.69 s | dt: 0.2182 s

Step: Actuate |   Increment: 135 | Iterations: 4
Simulation Time: 34.91 s | dt: 0.2182 s

Step: Actuate |   Increment: 136 | Iterations: 4
Simulation Time: 35.13 s | dt: 0.2182 s

Step: Actuate |   Increment: 137 | Iterations: 4
Simulation Time: 35.35 s | dt: 0.2182 s

Step: Actuate |   Increment: 138 | Iterations: 4
Simulation Time: 35.57 s | dt: 0.2182 s

Step: Actuate |   Increment: 139 | Iterations: 4
Simulation Time: 35.78 s | dt: 0.2182 s

Step: Actuate |   Increment: 140 | Iterations: 4
Simulation Time: 36.0 s | dt: 0.2182 s

Step: Actuate |   Increment: 141 | Iterations: 4
Simulation Time: 36.22 s | dt: 0.2182 s

Step: Actuate |   Increment: 142 | Iterations: 4
Simulation Time: 36.44 s | dt: 0.2182 s

Step: Actuate |   Increment: 143 | Iterations: 4
Simulation Time: 36.66 s | dt: 0.2182 s

Step: Actuate |   Increment: 144 | Iterations: 4
Simulation Time: 36.88 s | dt: 0.2182 s

Step: Actuate |   Increment: 145 | Iterations: 4
Simulation Time: 37.09 s | dt: 0.2182 s

Step: Actuate |   Increment: 146 | Iterations: 4
Simulation Time: 37.31 s | dt: 0.2182 s

Step: Actuate |   Increment: 147 | Iterations: 4
Simulation Time: 37.53 s | dt: 0.2182 s

Step: Actuate |   Increment: 148 | Iterations: 4
Simulation Time: 37.75 s | dt: 0.2182 s

Step: Actuate |   Increment: 149 | Iterations: 4
Simulation Time: 37.97 s | dt: 0.2182 s

Step: Actuate |   Increment: 150 | Iterations: 4
Simulation Time: 38.19 s | dt: 0.2182 s

Step: Actuate |   Increment: 151 | Iterations: 4
Simulation Time: 38.4 s | dt: 0.2182 s

Step: Actuate |   Increment: 152 | Iterations: 4
Simulation Time: 38.62 s | dt: 0.2182 s

Step: Actuate |   Increment: 153 | Iterations: 4
Simulation Time: 38.84 s | dt: 0.2182 s

Step: Actuate |   Increment: 154 | Iterations: 4
Simulation Time: 39.06 s | dt: 0.2182 s

Step: Actuate |   Increment: 155 | Iterations: 4
Simulation Time: 39.28 s | dt: 0.2182 s

Step: Actuate |   Increment: 156 | Iterations: 4
Simulation Time: 39.49 s | dt: 0.2182 s

Step: Actuate |   Increment: 157 | Iterations: 4
Simulation Time: 39.71 s | dt: 0.2182 s

Step: Actuate |   Increment: 158 | Iterations: 4
Simulation Time: 39.93 s | dt: 0.2182 s

Step: Actuate |   Increment: 159 | Iterations: 4
Simulation Time: 40.15 s | dt: 0.2182 s

Step: Actuate |   Increment: 160 | Iterations: 4
Simulation Time: 40.37 s | dt: 0.2182 s

Step: Actuate |   Increment: 161 | Iterations: 4
Simulation Time: 40.59 s | dt: 0.2182 s

Step: Actuate |   Increment: 162 | Iterations: 4
Simulation Time: 40.8 s | dt: 0.2182 s

Step: Actuate |   Increment: 163 | Iterations: 4
Simulation Time: 41.02 s | dt: 0.2182 s

Step: Actuate |   Increment: 164 | Iterations: 4
Simulation Time: 41.24 s | dt: 0.2182 s

Step: Actuate |   Increment: 165 | Iterations: 4
Simulation Time: 41.46 s | dt: 0.2182 s

Step: Actuate |   Increment: 166 | Iterations: 4
Simulation Time: 41.68 s | dt: 0.2182 s

Step: Actuate |   Increment: 167 | Iterations: 4
Simulation Time: 41.89 s | dt: 0.2182 s

Step: Actuate |   Increment: 168 | Iterations: 4
Simulation Time: 42.11 s | dt: 0.2182 s

Step: Actuate |   Increment: 169 | Iterations: 4
Simulation Time: 42.33 s | dt: 0.2182 s

Step: Actuate |   Increment: 170 | Iterations: 4
Simulation Time: 42.55 s | dt: 0.2182 s

Step: Actuate |   Increment: 171 | Iterations: 4
Simulation Time: 42.77 s | dt: 0.2182 s

Step: Actuate |   Increment: 172 | Iterations: 4
Simulation Time: 42.99 s | dt: 0.2182 s

Step: Actuate |   Increment: 173 | Iterations: 4
Simulation Time: 43.2 s | dt: 0.2182 s

Step: Actuate |   Increment: 174 | Iterations: 4
Simulation Time: 43.42 s | dt: 0.2182 s

Step: Actuate |   Increment: 175 | Iterations: 4
Simulation Time: 43.64 s | dt: 0.2182 s

Step: Actuate |   Increment: 176 | Iterations: 4
Simulation Time: 43.86 s | dt: 0.2182 s

Step: Actuate |   Increment: 177 | Iterations: 4
Simulation Time: 44.08 s | dt: 0.2182 s

Step: Actuate |   Increment: 178 | Iterations: 4
Simulation Time: 44.29 s | dt: 0.2182 s

Step: Actuate |   Increment: 179 | Iterations: 4
Simulation Time: 44.51 s | dt: 0.2182 s

Step: Actuate |   Increment: 180 | Iterations: 4
Simulation Time: 44.73 s | dt: 0.2182 s

Step: Actuate |   Increment: 181 | Iterations: 4
Simulation Time: 44.95 s | dt: 0.2182 s

Step: Actuate |   Increment: 182 | Iterations: 4
Simulation Time: 45.17 s | dt: 0.2182 s

Step: Actuate |   Increment: 183 | Iterations: 4
Simulation Time: 45.39 s | dt: 0.2182 s

Step: Actuate |   Increment: 184 | Iterations: 4
Simulation Time: 45.6 s | dt: 0.2182 s

Step: Actuate |   Increment: 185 | Iterations: 4
Simulation Time: 45.82 s | dt: 0.2182 s

Step: Actuate |   Increment: 186 | Iterations: 4
Simulation Time: 46.04 s | dt: 0.2182 s

Step: Actuate |   Increment: 187 | Iterations: 4
Simulation Time: 46.26 s | dt: 0.2182 s

Step: Actuate |   Increment: 188 | Iterations: 4
Simulation Time: 46.48 s | dt: 0.2182 s

Step: Actuate |   Increment: 189 | Iterations: 4
Simulation Time: 46.69 s | dt: 0.2182 s

Step: Actuate |   Increment: 190 | Iterations: 4
Simulation Time: 46.91 s | dt: 0.2182 s

Step: Actuate |   Increment: 191 | Iterations: 4
Simulation Time: 47.13 s | dt: 0.2182 s

Step: Actuate |   Increment: 192 | Iterations: 4
Simulation Time: 47.35 s | dt: 0.2182 s

Step: Actuate |   Increment: 193 | Iterations: 4
Simulation Time: 47.57 s | dt: 0.2182 s

Step: Actuate |   Increment: 194 | Iterations: 4
Simulation Time: 47.79 s | dt: 0.2182 s

Step: Actuate |   Increment: 195 | Iterations: 4
Simulation Time: 48.0 s | dt: 0.2182 s

Step: Actuate |   Increment: 196 | Iterations: 4
Simulation Time: 48.22 s | dt: 0.2182 s

Step: Actuate |   Increment: 197 | Iterations: 4
Simulation Time: 48.44 s | dt: 0.2182 s

Step: Actuate |   Increment: 198 | Iterations: 4
Simulation Time: 48.66 s | dt: 0.2182 s

Step: Actuate |   Increment: 199 | Iterations: 4
Simulation Time: 48.88 s | dt: 0.2182 s

Step: Actuate |   Increment: 200 | Iterations: 4
Simulation Time: 49.1 s | dt: 0.2182 s

Step: Actuate |   Increment: 201 | Iterations: 4
Simulation Time: 49.31 s | dt: 0.2182 s

Step: Actuate |   Increment: 202 | Iterations: 4
Simulation Time: 49.53 s | dt: 0.2182 s

Step: Actuate |   Increment: 203 | Iterations: 4
Simulation Time: 49.75 s | dt: 0.2182 s

Step: Actuate |   Increment: 204 | Iterations: 4
Simulation Time: 49.97 s | dt: 0.2182 s

Step: Actuate |   Increment: 205 | Iterations: 4
Simulation Time: 50.19 s | dt: 0.2182 s

Step: Actuate |   Increment: 206 | Iterations: 4
Simulation Time: 50.4 s | dt: 0.2182 s

Step: Actuate |   Increment: 207 | Iterations: 4
Simulation Time: 50.62 s | dt: 0.2182 s

Step: Actuate |   Increment: 208 | Iterations: 4
Simulation Time: 50.84 s | dt: 0.2182 s

Step: Actuate |   Increment: 209 | Iterations: 4
Simulation Time: 51.06 s | dt: 0.2182 s

Step: Actuate |   Increment: 210 | Iterations: 4
Simulation Time: 51.28 s | dt: 0.2182 s

Step: Actuate |   Increment: 211 | Iterations: 4
Simulation Time: 51.5 s | dt: 0.2182 s

Step: Actuate |   Increment: 212 | Iterations: 4
Simulation Time: 51.71 s | dt: 0.2182 s

Step: Actuate |   Increment: 213 | Iterations: 4
Simulation Time: 51.93 s | dt: 0.2182 s

Step: Actuate |   Increment: 214 | Iterations: 4
Simulation Time: 52.15 s | dt: 0.2182 s

Step: Actuate |   Increment: 215 | Iterations: 4
Simulation Time: 52.37 s | dt: 0.2182 s

Step: Actuate |   Increment: 216 | Iterations: 4
Simulation Time: 52.59 s | dt: 0.2182 s

Step: Actuate |   Increment: 217 | Iterations: 4
Simulation Time: 52.8 s | dt: 0.2182 s

Step: Actuate |   Increment: 218 | Iterations: 4
Simulation Time: 53.02 s | dt: 0.2182 s

Step: Actuate |   Increment: 219 | Iterations: 4
Simulation Time: 53.24 s | dt: 0.2182 s

Step: Actuate |   Increment: 220 | Iterations: 4
Simulation Time: 53.46 s | dt: 0.2182 s

Step: Actuate |   Increment: 221 | Iterations: 4
Simulation Time: 53.68 s | dt: 0.2182 s

Step: Actuate |   Increment: 222 | Iterations: 4
Simulation Time: 53.9 s | dt: 0.2182 s

Step: Actuate |   Increment: 223 | Iterations: 4
Simulation Time: 54.11 s | dt: 0.2182 s

Step: Actuate |   Increment: 224 | Iterations: 4
Simulation Time: 54.33 s | dt: 0.2182 s

Step: Actuate |   Increment: 225 | Iterations: 4
Simulation Time: 54.55 s | dt: 0.2182 s

Step: Actuate |   Increment: 226 | Iterations: 4
Simulation Time: 54.77 s | dt: 0.2182 s

Step: Actuate |   Increment: 227 | Iterations: 4
Simulation Time: 54.99 s | dt: 0.2182 s

Step: Actuate |   Increment: 228 | Iterations: 4
Simulation Time: 55.2 s | dt: 0.2182 s

Step: Actuate |   Increment: 229 | Iterations: 4
Simulation Time: 55.42 s | dt: 0.2182 s

Step: Actuate |   Increment: 230 | Iterations: 4
Simulation Time: 55.64 s | dt: 0.2182 s

Step: Actuate |   Increment: 231 | Iterations: 4
Simulation Time: 55.86 s | dt: 0.2182 s

Step: Actuate |   Increment: 232 | Iterations: 4
Simulation Time: 56.08 s | dt: 0.2182 s

Step: Actuate |   Increment: 233 | Iterations: 4
Simulation Time: 56.3 s | dt: 0.2182 s

Step: Actuate |   Increment: 234 | Iterations: 4
Simulation Time: 56.51 s | dt: 0.2182 s

Step: Actuate |   Increment: 235 | Iterations: 4
Simulation Time: 56.73 s | dt: 0.2182 s

Step: Actuate |   Increment: 236 | Iterations: 4
Simulation Time: 56.95 s | dt: 0.2182 s

Step: Actuate |   Increment: 237 | Iterations: 4
Simulation Time: 57.17 s | dt: 0.2182 s

Step: Actuate |   Increment: 238 | Iterations: 4
Simulation Time: 57.39 s | dt: 0.2182 s

Step: Actuate |   Increment: 239 | Iterations: 4
Simulation Time: 57.6 s | dt: 0.2182 s

Step: Actuate |   Increment: 240 | Iterations: 4
Simulation Time: 57.82 s | dt: 0.2182 s

Step: Actuate |   Increment: 241 | Iterations: 4
Simulation Time: 58.04 s | dt: 0.2182 s

Step: Actuate |   Increment: 242 | Iterations: 4
Simulation Time: 58.26 s | dt: 0.2182 s

Step: Actuate |   Increment: 243 | Iterations: 4
Simulation Time: 58.48 s | dt: 0.2182 s

Step: Actuate |   Increment: 244 | Iterations: 4
Simulation Time: 58.7 s | dt: 0.2182 s

Step: Actuate |   Increment: 245 | Iterations: 4
Simulation Time: 58.91 s | dt: 0.2182 s

Step: Actuate |   Increment: 246 | Iterations: 4
Simulation Time: 59.13 s | dt: 0.2182 s

Step: Actuate |   Increment: 247 | Iterations: 4
Simulation Time: 59.35 s | dt: 0.2182 s

Step: Actuate |   Increment: 248 | Iterations: 4
Simulation Time: 59.57 s | dt: 0.2182 s

Step: Actuate |   Increment: 249 | Iterations: 4
Simulation Time: 59.79 s | dt: 0.2182 s

Step: Actuate |   Increment: 250 | Iterations: 4
Simulation Time: 60.01 s | dt: 0.2182 s

Step: Actuate |   Increment: 251 | Iterations: 4
Simulation Time: 60.22 s | dt: 0.2182 s

Step: Actuate |   Increment: 252 | Iterations: 4
Simulation Time: 60.44 s | dt: 0.2182 s

Step: Actuate |   Increment: 253 | Iterations: 4
Simulation Time: 60.66 s | dt: 0.2182 s

Step: Actuate |   Increment: 254 | Iterations: 4
Simulation Time: 60.88 s | dt: 0.2182 s

Step: Actuate |   Increment: 255 | Iterations: 4
Simulation Time: 61.1 s | dt: 0.2182 s

Step: Actuate |   Increment: 256 | Iterations: 4
Simulation Time: 61.31 s | dt: 0.2182 s

Step: Actuate |   Increment: 257 | Iterations: 4
Simulation Time: 61.53 s | dt: 0.2182 s

Step: Actuate |   Increment: 258 | Iterations: 4
Simulation Time: 61.75 s | dt: 0.2182 s

Step: Actuate |   Increment: 259 | Iterations: 4
Simulation Time: 61.97 s | dt: 0.2182 s

Step: Actuate |   Increment: 260 | Iterations: 4
Simulation Time: 62.19 s | dt: 0.2182 s

Step: Actuate |   Increment: 261 | Iterations: 4
Simulation Time: 62.41 s | dt: 0.2182 s

Step: Actuate |   Increment: 262 | Iterations: 4
Simulation Time: 62.62 s | dt: 0.2182 s

Step: Actuate |   Increment: 263 | Iterations: 4
Simulation Time: 62.84 s | dt: 0.2182 s

Step: Actuate |   Increment: 264 | Iterations: 4
Simulation Time: 63.06 s | dt: 0.2182 s

Step: Actuate |   Increment: 265 | Iterations: 4
Simulation Time: 63.28 s | dt: 0.2182 s

Step: Actuate |   Increment: 266 | Iterations: 4
Simulation Time: 63.5 s | dt: 0.2182 s

Step: Actuate |   Increment: 267 | Iterations: 4
Simulation Time: 63.71 s | dt: 0.2182 s

Step: Actuate |   Increment: 268 | Iterations: 4
Simulation Time: 63.93 s | dt: 0.2182 s

Step: Actuate |   Increment: 269 | Iterations: 4
Simulation Time: 64.15 s | dt: 0.2182 s

Step: Actuate |   Increment: 270 | Iterations: 4
Simulation Time: 64.37 s | dt: 0.2182 s

Step: Actuate |   Increment: 271 | Iterations: 4
Simulation Time: 64.59 s | dt: 0.2182 s

Step: Actuate |   Increment: 272 | Iterations: 4
Simulation Time: 64.81 s | dt: 0.2182 s

Step: Actuate |   Increment: 273 | Iterations: 4
Simulation Time: 65.02 s | dt: 0.2182 s

Step: Actuate |   Increment: 274 | Iterations: 4
Simulation Time: 65.24 s | dt: 0.2182 s

Step: Actuate |   Increment: 275 | Iterations: 4
Simulation Time: 65.46 s | dt: 0.2182 s

Step: Actuate |   Increment: 276 | Iterations: 4
Simulation Time: 65.68 s | dt: 0.2182 s

Step: Actuate |   Increment: 277 | Iterations: 4
Simulation Time: 65.9 s | dt: 0.2182 s

Step: Actuate |   Increment: 278 | Iterations: 4
Simulation Time: 66.11 s | dt: 0.2182 s

Step: Actuate |   Increment: 279 | Iterations: 4
Simulation Time: 66.33 s | dt: 0.2182 s

Step: Actuate |   Increment: 280 | Iterations: 4
Simulation Time: 66.55 s | dt: 0.2182 s

Step: Actuate |   Increment: 281 | Iterations: 4
Simulation Time: 66.77 s | dt: 0.2182 s

Step: Actuate |   Increment: 282 | Iterations: 4
Simulation Time: 66.99 s | dt: 0.2182 s

Step: Actuate |   Increment: 283 | Iterations: 4
Simulation Time: 67.21 s | dt: 0.2182 s

Step: Actuate |   Increment: 284 | Iterations: 4
Simulation Time: 67.42 s | dt: 0.2182 s

Step: Actuate |   Increment: 285 | Iterations: 4
Simulation Time: 67.64 s | dt: 0.2182 s

Step: Actuate |   Increment: 286 | Iterations: 4
Simulation Time: 67.86 s | dt: 0.2182 s

Step: Actuate |   Increment: 287 | Iterations: 4
Simulation Time: 68.08 s | dt: 0.2182 s

Step: Actuate |   Increment: 288 | Iterations: 4
Simulation Time: 68.3 s | dt: 0.2182 s

Step: Actuate |   Increment: 289 | Iterations: 4
Simulation Time: 68.52 s | dt: 0.2182 s

Step: Actuate |   Increment: 290 | Iterations: 4
Simulation Time: 68.73 s | dt: 0.2182 s

Step: Actuate |   Increment: 291 | Iterations: 4
Simulation Time: 68.95 s | dt: 0.2182 s

Step: Actuate |   Increment: 292 | Iterations: 4
Simulation Time: 69.17 s | dt: 0.2182 s

Step: Actuate |   Increment: 293 | Iterations: 4
Simulation Time: 69.39 s | dt: 0.2182 s

Step: Actuate |   Increment: 294 | Iterations: 4
Simulation Time: 69.61 s | dt: 0.2182 s

Step: Actuate |   Increment: 295 | Iterations: 4
Simulation Time: 69.82 s | dt: 0.2182 s

Step: Actuate |   Increment: 296 | Iterations: 4
Simulation Time: 70.04 s | dt: 0.2182 s

Step: Actuate |   Increment: 297 | Iterations: 4
Simulation Time: 70.26 s | dt: 0.2182 s

Step: Actuate |   Increment: 298 | Iterations: 4
Simulation Time: 70.48 s | dt: 0.2182 s

Step: Actuate |   Increment: 299 | Iterations: 4
Simulation Time: 70.7 s | dt: 0.2182 s

Step: Actuate |   Increment: 300 | Iterations: 4
Simulation Time: 70.92 s | dt: 0.2182 s

Step: Actuate |   Increment: 301 | Iterations: 4
Simulation Time: 71.13 s | dt: 0.2182 s

Step: Actuate |   Increment: 302 | Iterations: 4
Simulation Time: 71.35 s | dt: 0.2182 s

Step: Actuate |   Increment: 303 | Iterations: 4
Simulation Time: 71.57 s | dt: 0.2182 s

Step: Actuate |   Increment: 304 | Iterations: 4
Simulation Time: 71.79 s | dt: 0.2182 s

Step: Actuate |   Increment: 305 | Iterations: 4
Simulation Time: 72.01 s | dt: 0.2182 s

Step: Actuate |   Increment: 306 | Iterations: 4
Simulation Time: 72.22 s | dt: 0.2182 s

Step: Actuate |   Increment: 307 | Iterations: 4
Simulation Time: 72.44 s | dt: 0.2182 s

Step: Actuate |   Increment: 308 | Iterations: 4
Simulation Time: 72.66 s | dt: 0.2182 s

Step: Actuate |   Increment: 309 | Iterations: 4
Simulation Time: 72.88 s | dt: 0.2182 s

Step: Actuate |   Increment: 310 | Iterations: 4
Simulation Time: 73.1 s | dt: 0.2182 s

Step: Actuate |   Increment: 311 | Iterations: 4
Simulation Time: 73.32 s | dt: 0.2182 s

Step: Actuate |   Increment: 312 | Iterations: 4
Simulation Time: 73.53 s | dt: 0.2182 s

Step: Actuate |   Increment: 313 | Iterations: 4
Simulation Time: 73.75 s | dt: 0.2182 s

Step: Actuate |   Increment: 314 | Iterations: 4
Simulation Time: 73.97 s | dt: 0.2182 s

Step: Actuate |   Increment: 315 | Iterations: 4
Simulation Time: 74.19 s | dt: 0.2182 s

Step: Actuate |   Increment: 316 | Iterations: 4
Simulation Time: 74.41 s | dt: 0.2182 s

Step: Actuate |   Increment: 317 | Iterations: 4
Simulation Time: 74.62 s | dt: 0.2182 s

Step: Actuate |   Increment: 318 | Iterations: 4
Simulation Time: 74.84 s | dt: 0.2182 s

Step: Actuate |   Increment: 319 | Iterations: 4
Simulation Time: 75.06 s | dt: 0.2182 s

Step: Actuate |   Increment: 320 | Iterations: 4
Simulation Time: 75.28 s | dt: 0.2182 s

Step: Actuate |   Increment: 321 | Iterations: 4
Simulation Time: 75.5 s | dt: 0.2182 s

Step: Actuate |   Increment: 322 | Iterations: 4
Simulation Time: 75.72 s | dt: 0.2182 s

Step: Actuate |   Increment: 323 | Iterations: 4
Simulation Time: 75.93 s | dt: 0.2182 s

Step: Actuate |   Increment: 324 | Iterations: 4
Simulation Time: 76.15 s | dt: 0.2182 s

Step: Actuate |   Increment: 325 | Iterations: 4
Simulation Time: 76.37 s | dt: 0.2182 s

Step: Actuate |   Increment: 326 | Iterations: 4
Simulation Time: 76.59 s | dt: 0.2182 s

Step: Actuate |   Increment: 327 | Iterations: 4
Simulation Time: 76.81 s | dt: 0.2182 s

Step: Actuate |   Increment: 328 | Iterations: 4
Simulation Time: 77.02 s | dt: 0.2182 s

Step: Actuate |   Increment: 329 | Iterations: 4
Simulation Time: 77.24 s | dt: 0.2182 s

Step: Actuate |   Increment: 330 | Iterations: 4
Simulation Time: 77.46 s | dt: 0.2182 s

Step: Actuate |   Increment: 331 | Iterations: 4
Simulation Time: 77.68 s | dt: 0.2182 s

Step: Actuate |   Increment: 332 | Iterations: 4
Simulation Time: 77.9 s | dt: 0.2182 s

Step: Actuate |   Increment: 333 | Iterations: 4
Simulation Time: 78.12 s | dt: 0.2182 s

Step: Actuate |   Increment: 334 | Iterations: 4
Simulation Time: 78.33 s | dt: 0.2182 s

Step: Actuate |   Increment: 335 | Iterations: 4
Simulation Time: 78.55 s | dt: 0.2182 s

Step: Actuate |   Increment: 336 | Iterations: 4
Simulation Time: 78.77 s | dt: 0.2182 s

Step: Actuate |   Increment: 337 | Iterations: 4
Simulation Time: 78.99 s | dt: 0.2182 s

Step: Actuate |   Increment: 338 | Iterations: 4
Simulation Time: 79.21 s | dt: 0.2182 s

Step: Actuate |   Increment: 339 | Iterations: 4
Simulation Time: 79.43 s | dt: 0.2182 s

Step: Actuate |   Increment: 340 | Iterations: 4
Simulation Time: 79.64 s | dt: 0.2182 s

Step: Actuate |   Increment: 341 | Iterations: 4
Simulation Time: 79.86 s | dt: 0.2182 s

Step: Actuate |   Increment: 342 | Iterations: 4
Simulation Time: 80.08 s | dt: 0.2182 s

Step: Actuate |   Increment: 343 | Iterations: 4
Simulation Time: 80.3 s | dt: 0.2182 s

Step: Actuate |   Increment: 344 | Iterations: 4
Simulation Time: 80.52 s | dt: 0.2182 s

Step: Actuate |   Increment: 345 | Iterations: 4
Simulation Time: 80.73 s | dt: 0.2182 s

Step: Actuate |   Increment: 346 | Iterations: 4
Simulation Time: 80.95 s | dt: 0.2182 s

Step: Actuate |   Increment: 347 | Iterations: 4
Simulation Time: 81.17 s | dt: 0.2182 s

Step: Actuate |   Increment: 348 | Iterations: 4
Simulation Time: 81.39 s | dt: 0.2182 s

Step: Actuate |   Increment: 349 | Iterations: 4
Simulation Time: 81.61 s | dt: 0.2182 s

Step: Actuate |   Increment: 350 | Iterations: 4
Simulation Time: 81.83 s | dt: 0.2182 s

Step: Actuate |   Increment: 351 | Iterations: 4
Simulation Time: 82.04 s | dt: 0.2182 s

Step: Actuate |   Increment: 352 | Iterations: 4
Simulation Time: 82.26 s | dt: 0.2182 s

Step: Actuate |   Increment: 353 | Iterations: 4
Simulation Time: 82.48 s | dt: 0.2182 s

Step: Actuate |   Increment: 354 | Iterations: 4
Simulation Time: 82.7 s | dt: 0.2182 s

Step: Actuate |   Increment: 355 | Iterations: 4
Simulation Time: 82.92 s | dt: 0.2182 s

Step: Actuate |   Increment: 356 | Iterations: 4
Simulation Time: 83.13 s | dt: 0.2182 s

Step: Actuate |   Increment: 357 | Iterations: 4
Simulation Time: 83.35 s | dt: 0.2182 s

Step: Actuate |   Increment: 358 | Iterations: 4
Simulation Time: 83.57 s | dt: 0.2182 s

Step: Actuate |   Increment: 359 | Iterations: 4
Simulation Time: 83.79 s | dt: 0.2182 s

Step: Actuate |   Increment: 360 | Iterations: 4
Simulation Time: 84.01 s | dt: 0.2182 s

Step: Actuate |   Increment: 361 | Iterations: 4
Simulation Time: 84.23 s | dt: 0.2182 s

Step: Actuate |   Increment: 362 | Iterations: 4
Simulation Time: 84.44 s | dt: 0.2182 s

Step: Actuate |   Increment: 363 | Iterations: 4
Simulation Time: 84.66 s | dt: 0.2182 s

Step: Actuate |   Increment: 364 | Iterations: 4
Simulation Time: 84.88 s | dt: 0.2182 s

Step: Actuate |   Increment: 365 | Iterations: 4
Simulation Time: 85.1 s | dt: 0.2182 s

Step: Actuate |   Increment: 366 | Iterations: 4
Simulation Time: 85.32 s | dt: 0.2182 s

Step: Actuate |   Increment: 367 | Iterations: 4
Simulation Time: 85.53 s | dt: 0.2182 s

Step: Actuate |   Increment: 368 | Iterations: 4
Simulation Time: 85.75 s | dt: 0.2182 s

Step: Actuate |   Increment: 369 | Iterations: 4
Simulation Time: 85.97 s | dt: 0.2182 s

Step: Actuate |   Increment: 370 | Iterations: 4
Simulation Time: 86.19 s | dt: 0.2182 s

Step: Actuate |   Increment: 371 | Iterations: 4
Simulation Time: 86.41 s | dt: 0.2182 s

Step: Actuate |   Increment: 372 | Iterations: 4
Simulation Time: 86.63 s | dt: 0.2182 s

Step: Actuate |   Increment: 373 | Iterations: 4
Simulation Time: 86.84 s | dt: 0.2182 s

Step: Actuate |   Increment: 374 | Iterations: 4
Simulation Time: 87.06 s | dt: 0.2182 s

Step: Actuate |   Increment: 375 | Iterations: 4
Simulation Time: 87.28 s | dt: 0.2182 s

Step: Actuate |   Increment: 376 | Iterations: 4
Simulation Time: 87.5 s | dt: 0.2182 s

Step: Actuate |   Increment: 377 | Iterations: 4
Simulation Time: 87.72 s | dt: 0.2182 s

Step: Actuate |   Increment: 378 | Iterations: 4
Simulation Time: 87.93 s | dt: 0.2182 s

Step: Actuate |   Increment: 379 | Iterations: 4
Simulation Time: 88.15 s | dt: 0.2182 s

Step: Actuate |   Increment: 380 | Iterations: 4
Simulation Time: 88.37 s | dt: 0.2182 s

Step: Actuate |   Increment: 381 | Iterations: 4
Simulation Time: 88.59 s | dt: 0.2182 s

Step: Actuate |   Increment: 382 | Iterations: 4
Simulation Time: 88.81 s | dt: 0.2182 s

Step: Actuate |   Increment: 383 | Iterations: 4
Simulation Time: 89.03 s | dt: 0.2182 s

Step: Actuate |   Increment: 384 | Iterations: 4
Simulation Time: 89.24 s | dt: 0.2182 s

Step: Actuate |   Increment: 385 | Iterations: 4
Simulation Time: 89.46 s | dt: 0.2182 s

Step: Actuate |   Increment: 386 | Iterations: 4
Simulation Time: 89.68 s | dt: 0.2182 s

Step: Actuate |   Increment: 387 | Iterations: 4
Simulation Time: 89.9 s | dt: 0.2182 s

Step: Actuate |   Increment: 388 | Iterations: 4
Simulation Time: 90.12 s | dt: 0.2182 s

Step: Actuate |   Increment: 389 | Iterations: 4
Simulation Time: 90.34 s | dt: 0.2182 s

Step: Actuate |   Increment: 390 | Iterations: 4
Simulation Time: 90.55 s | dt: 0.2182 s

Step: Actuate |   Increment: 391 | Iterations: 4
Simulation Time: 90.77 s | dt: 0.2182 s

Step: Actuate |   Increment: 392 | Iterations: 4
Simulation Time: 90.99 s | dt: 0.2182 s

Step: Actuate |   Increment: 393 | Iterations: 4
Simulation Time: 91.21 s | dt: 0.2182 s

Step: Actuate |   Increment: 394 | Iterations: 4
Simulation Time: 91.43 s | dt: 0.2182 s

Step: Actuate |   Increment: 395 | Iterations: 4
Simulation Time: 91.64 s | dt: 0.2182 s

Step: Actuate |   Increment: 396 | Iterations: 4
Simulation Time: 91.86 s | dt: 0.2182 s

Step: Actuate |   Increment: 397 | Iterations: 4
Simulation Time: 92.08 s | dt: 0.2182 s

Step: Actuate |   Increment: 398 | Iterations: 4
Simulation Time: 92.3 s | dt: 0.2182 s

Step: Actuate |   Increment: 399 | Iterations: 4
Simulation Time: 92.52 s | dt: 0.2182 s

Step: Actuate |   Increment: 400 | Iterations: 4
Simulation Time: 92.74 s | dt: 0.2182 s

Step: Actuate |   Increment: 401 | Iterations: 4
Simulation Time: 92.95 s | dt: 0.2182 s

Step: Actuate |   Increment: 402 | Iterations: 4
Simulation Time: 93.17 s | dt: 0.2182 s

Step: Actuate |   Increment: 403 | Iterations: 4
Simulation Time: 93.39 s | dt: 0.2182 s

Step: Actuate |   Increment: 404 | Iterations: 4
Simulation Time: 93.61 s | dt: 0.2182 s

Step: Actuate |   Increment: 405 | Iterations: 4
Simulation Time: 93.83 s | dt: 0.2182 s

Step: Actuate |   Increment: 406 | Iterations: 4
Simulation Time: 94.04 s | dt: 0.2182 s

Step: Actuate |   Increment: 407 | Iterations: 4
Simulation Time: 94.26 s | dt: 0.2182 s

Step: Actuate |   Increment: 408 | Iterations: 4
Simulation Time: 94.48 s | dt: 0.2182 s

Step: Actuate |   Increment: 409 | Iterations: 4
Simulation Time: 94.7 s | dt: 0.2182 s

Step: Actuate |   Increment: 410 | Iterations: 4
Simulation Time: 94.92 s | dt: 0.2182 s

Step: Actuate |   Increment: 411 | Iterations: 4
Simulation Time: 95.14 s | dt: 0.2182 s

Step: Actuate |   Increment: 412 | Iterations: 4
Simulation Time: 95.35 s | dt: 0.2182 s

Step: Actuate |   Increment: 413 | Iterations: 4
Simulation Time: 95.57 s | dt: 0.2182 s

Step: Actuate |   Increment: 414 | Iterations: 4
Simulation Time: 95.79 s | dt: 0.2182 s

Step: Actuate |   Increment: 415 | Iterations: 4
Simulation Time: 96.01 s | dt: 0.2182 s

Step: Actuate |   Increment: 416 | Iterations: 4
Simulation Time: 96.23 s | dt: 0.2182 s

Step: Actuate |   Increment: 417 | Iterations: 4
Simulation Time: 96.44 s | dt: 0.2182 s

Step: Actuate |   Increment: 418 | Iterations: 4
Simulation Time: 96.66 s | dt: 0.2182 s

Step: Actuate |   Increment: 419 | Iterations: 4
Simulation Time: 96.88 s | dt: 0.2182 s

Step: Actuate |   Increment: 420 | Iterations: 4
Simulation Time: 97.1 s | dt: 0.2182 s

Step: Actuate |   Increment: 421 | Iterations: 4
Simulation Time: 97.32 s | dt: 0.2182 s

Step: Actuate |   Increment: 422 | Iterations: 4
Simulation Time: 97.54 s | dt: 0.2182 s

Step: Actuate |   Increment: 423 | Iterations: 4
Simulation Time: 97.75 s | dt: 0.2182 s

Step: Actuate |   Increment: 424 | Iterations: 4
Simulation Time: 97.97 s | dt: 0.2182 s

Step: Actuate |   Increment: 425 | Iterations: 4
Simulation Time: 98.19 s | dt: 0.2182 s

Step: Actuate |   Increment: 426 | Iterations: 4
Simulation Time: 98.41 s | dt: 0.2182 s

Step: Actuate |   Increment: 427 | Iterations: 4
Simulation Time: 98.63 s | dt: 0.2182 s

Step: Actuate |   Increment: 428 | Iterations: 4
Simulation Time: 98.84 s | dt: 0.2182 s

Step: Actuate |   Increment: 429 | Iterations: 4
Simulation Time: 99.06 s | dt: 0.2182 s

Step: Actuate |   Increment: 430 | Iterations: 4
Simulation Time: 99.28 s | dt: 0.2182 s

Step: Actuate |   Increment: 431 | Iterations: 4
Simulation Time: 99.5 s | dt: 0.2182 s

Step: Actuate |   Increment: 432 | Iterations: 4
Simulation Time: 99.72 s | dt: 0.2182 s

Step: Actuate |   Increment: 433 | Iterations: 4
Simulation Time: 99.94 s | dt: 0.2182 s

Step: Actuate |   Increment: 434 | Iterations: 4
Simulation Time: 100.15 s | dt: 0.2182 s

Step: Actuate |   Increment: 435 | Iterations: 4
Simulation Time: 100.37 s | dt: 0.2182 s

Step: Actuate |   Increment: 436 | Iterations: 4
Simulation Time: 100.59 s | dt: 0.2182 s

Step: Actuate |   Increment: 437 | Iterations: 4
Simulation Time: 100.81 s | dt: 0.2182 s

Step: Actuate |   Increment: 438 | Iterations: 4
Simulation Time: 101.03 s | dt: 0.2182 s

Step: Actuate |   Increment: 439 | Iterations: 4
Simulation Time: 101.25 s | dt: 0.2182 s

Step: Actuate |   Increment: 440 | Iterations: 4
Simulation Time: 101.46 s | dt: 0.2182 s

Step: Actuate |   Increment: 441 | Iterations: 4
Simulation Time: 101.68 s | dt: 0.2182 s

Step: Actuate |   Increment: 442 | Iterations: 4
Simulation Time: 101.9 s | dt: 0.2182 s

Step: Actuate |   Increment: 443 | Iterations: 4
Simulation Time: 102.12 s | dt: 0.2182 s

Step: Actuate |   Increment: 444 | Iterations: 4
Simulation Time: 102.34 s | dt: 0.2182 s

Step: Actuate |   Increment: 445 | Iterations: 4
Simulation Time: 102.55 s | dt: 0.2182 s

Step: Actuate |   Increment: 446 | Iterations: 4
Simulation Time: 102.77 s | dt: 0.2182 s

Step: Actuate |   Increment: 447 | Iterations: 4
Simulation Time: 102.99 s | dt: 0.2182 s

Step: Actuate |   Increment: 448 | Iterations: 4
Simulation Time: 103.21 s | dt: 0.2182 s

Step: Actuate |   Increment: 449 | Iterations: 4
Simulation Time: 103.43 s | dt: 0.2182 s

Step: Actuate |   Increment: 450 | Iterations: 4
Simulation Time: 103.65 s | dt: 0.2182 s

Step: Actuate |   Increment: 451 | Iterations: 4
Simulation Time: 103.86 s | dt: 0.2182 s

Step: Actuate |   Increment: 452 | Iterations: 4
Simulation Time: 104.08 s | dt: 0.2182 s

Step: Actuate |   Increment: 453 | Iterations: 4
Simulation Time: 104.3 s | dt: 0.2182 s

Step: Actuate |   Increment: 454 | Iterations: 4
Simulation Time: 104.52 s | dt: 0.2182 s

Step: Actuate |   Increment: 455 | Iterations: 4
Simulation Time: 104.74 s | dt: 0.2182 s

Step: Actuate |   Increment: 456 | Iterations: 4
Simulation Time: 104.95 s | dt: 0.2182 s

Step: Actuate |   Increment: 457 | Iterations: 4
Simulation Time: 105.17 s | dt: 0.2182 s

Step: Actuate |   Increment: 458 | Iterations: 4
Simulation Time: 105.39 s | dt: 0.2182 s

Step: Actuate |   Increment: 459 | Iterations: 4
Simulation Time: 105.61 s | dt: 0.2182 s

Step: Actuate |   Increment: 460 | Iterations: 4
Simulation Time: 105.83 s | dt: 0.2182 s

Step: Actuate |   Increment: 461 | Iterations: 4
Simulation Time: 106.05 s | dt: 0.2182 s

Step: Actuate |   Increment: 462 | Iterations: 4
Simulation Time: 106.26 s | dt: 0.2182 s

Step: Actuate |   Increment: 463 | Iterations: 4
Simulation Time: 106.48 s | dt: 0.2182 s

Step: Actuate |   Increment: 464 | Iterations: 4
Simulation Time: 106.7 s | dt: 0.2182 s

Step: Actuate |   Increment: 465 | Iterations: 4
Simulation Time: 106.92 s | dt: 0.2182 s

Step: Actuate |   Increment: 466 | Iterations: 4
Simulation Time: 107.14 s | dt: 0.2182 s

Step: Actuate |   Increment: 467 | Iterations: 4
Simulation Time: 107.35 s | dt: 0.2182 s

Step: Actuate |   Increment: 468 | Iterations: 4
Simulation Time: 107.57 s | dt: 0.2182 s

Step: Actuate |   Increment: 469 | Iterations: 4
Simulation Time: 107.79 s | dt: 0.2182 s

Step: Actuate |   Increment: 470 | Iterations: 4
Simulation Time: 108.01 s | dt: 0.2182 s

Step: Actuate |   Increment: 471 | Iterations: 4
Simulation Time: 108.23 s | dt: 0.2182 s

Step: Actuate |   Increment: 472 | Iterations: 4
Simulation Time: 108.45 s | dt: 0.2182 s

Step: Actuate |   Increment: 473 | Iterations: 4
Simulation Time: 108.66 s | dt: 0.2182 s

Step: Actuate |   Increment: 474 | Iterations: 4
Simulation Time: 108.88 s | dt: 0.2182 s

Step: Actuate |   Increment: 475 | Iterations: 4
Simulation Time: 109.1 s | dt: 0.2182 s

Step: Actuate |   Increment: 476 | Iterations: 4
Simulation Time: 109.32 s | dt: 0.2182 s

Step: Actuate |   Increment: 477 | Iterations: 4
Simulation Time: 109.54 s | dt: 0.2182 s

Step: Actuate |   Increment: 478 | Iterations: 4
Simulation Time: 109.75 s | dt: 0.2182 s

Step: Actuate |   Increment: 479 | Iterations: 4
Simulation Time: 109.97 s | dt: 0.2182 s

Step: Actuate |   Increment: 480 | Iterations: 4
Simulation Time: 110.19 s | dt: 0.2182 s

Step: Actuate |   Increment: 481 | Iterations: 4
Simulation Time: 110.41 s | dt: 0.2182 s

Step: Actuate |   Increment: 482 | Iterations: 4
Simulation Time: 110.63 s | dt: 0.2182 s

Step: Actuate |   Increment: 483 | Iterations: 4
Simulation Time: 110.85 s | dt: 0.2182 s

Step: Actuate |   Increment: 484 | Iterations: 4
Simulation Time: 111.06 s | dt: 0.2182 s

Step: Actuate |   Increment: 485 | Iterations: 4
Simulation Time: 111.28 s | dt: 0.2182 s

Step: Actuate |   Increment: 486 | Iterations: 4
Simulation Time: 111.5 s | dt: 0.2182 s

Step: Actuate |   Increment: 487 | Iterations: 4
Simulation Time: 111.72 s | dt: 0.2182 s

Step: Actuate |   Increment: 488 | Iterations: 4
Simulation Time: 111.94 s | dt: 0.2182 s

Step: Actuate |   Increment: 489 | Iterations: 4
Simulation Time: 112.16 s | dt: 0.2182 s

Step: Actuate |   Increment: 490 | Iterations: 4
Simulation Time: 112.37 s | dt: 0.2182 s

Step: Actuate |   Increment: 491 | Iterations: 4
Simulation Time: 112.59 s | dt: 0.2182 s

Step: Actuate |   Increment: 492 | Iterations: 4
Simulation Time: 112.81 s | dt: 0.2182 s

Step: Actuate |   Increment: 493 | Iterations: 4
Simulation Time: 113.03 s | dt: 0.2182 s

Step: Actuate |   Increment: 494 | Iterations: 4
Simulation Time: 113.25 s | dt: 0.2182 s

Step: Actuate |   Increment: 495 | Iterations: 4
Simulation Time: 113.46 s | dt: 0.2182 s

Step: Actuate |   Increment: 496 | Iterations: 4
Simulation Time: 113.68 s | dt: 0.2182 s

Step: Actuate |   Increment: 497 | Iterations: 4
Simulation Time: 113.9 s | dt: 0.2182 s

Step: Actuate |   Increment: 498 | Iterations: 4
Simulation Time: 114.12 s | dt: 0.2182 s

Step: Actuate |   Increment: 499 | Iterations: 4
Simulation Time: 114.34 s | dt: 0.2182 s

Step: Actuate |   Increment: 500 | Iterations: 4
Simulation Time: 114.56 s | dt: 0.2182 s

Step: Actuate |   Increment: 501 | Iterations: 4
Simulation Time: 114.77 s | dt: 0.2182 s

Step: Actuate |   Increment: 502 | Iterations: 4
Simulation Time: 114.99 s | dt: 0.2182 s

Step: Actuate |   Increment: 503 | Iterations: 5
Simulation Time: 115.21 s | dt: 0.1091 s
old dt: 0.2182 s | new dt: 0.1091 s

Step: Actuate |   Increment: 504 | Iterations: 4
Simulation Time: 115.32 s | dt: 0.1091 s

Step: Actuate |   Increment: 505 | Iterations: 4
Simulation Time: 115.43 s | dt: 0.1091 s

Step: Actuate |   Increment: 506 | Iterations: 4
Simulation Time: 115.54 s | dt: 0.1091 s

Step: Actuate |   Increment: 507 | Iterations: 4
Simulation Time: 115.65 s | dt: 0.1091 s

Step: Actuate |   Increment: 508 | Iterations: 4
Simulation Time: 115.76 s | dt: 0.1091 s

Step: Actuate |   Increment: 509 | Iterations: 4
Simulation Time: 115.86 s | dt: 0.1091 s

Step: Actuate |   Increment: 510 | Iterations: 4
Simulation Time: 115.97 s | dt: 0.1091 s

Step: Actuate |   Increment: 511 | Iterations: 4
Simulation Time: 116.08 s | dt: 0.1091 s

Step: Actuate |   Increment: 512 | Iterations: 4
Simulation Time: 116.19 s | dt: 0.1091 s

Step: Actuate |   Increment: 513 | Iterations: 4
Simulation Time: 116.3 s | dt: 0.1091 s

Step: Actuate |   Increment: 514 | Iterations: 4
Simulation Time: 116.41 s | dt: 0.1091 s

Step: Actuate |   Increment: 515 | Iterations: 4
Simulation Time: 116.52 s | dt: 0.1091 s

Step: Actuate |   Increment: 516 | Iterations: 4
Simulation Time: 116.63 s | dt: 0.1091 s

Step: Actuate |   Increment: 517 | Iterations: 4
Simulation Time: 116.74 s | dt: 0.1091 s

Step: Actuate |   Increment: 518 | Iterations: 4
Simulation Time: 116.85 s | dt: 0.1091 s

Step: Actuate |   Increment: 519 | Iterations: 4
Simulation Time: 116.96 s | dt: 0.1091 s

Step: Actuate |   Increment: 520 | Iterations: 4
Simulation Time: 117.06 s | dt: 0.1091 s

Step: Actuate |   Increment: 521 | Iterations: 4
Simulation Time: 117.17 s | dt: 0.1091 s

Step: Actuate |   Increment: 522 | Iterations: 4
Simulation Time: 117.28 s | dt: 0.1091 s

Step: Actuate |   Increment: 523 | Iterations: 4
Simulation Time: 117.39 s | dt: 0.1091 s

Step: Actuate |   Increment: 524 | Iterations: 4
Simulation Time: 117.5 s | dt: 0.1091 s

Step: Actuate |   Increment: 525 | Iterations: 4
Simulation Time: 117.61 s | dt: 0.1091 s

Step: Actuate |   Increment: 526 | Iterations: 4
Simulation Time: 117.72 s | dt: 0.1091 s

Step: Actuate |   Increment: 527 | Iterations: 4
Simulation Time: 117.83 s | dt: 0.1091 s

Step: Actuate |   Increment: 528 | Iterations: 4
Simulation Time: 117.94 s | dt: 0.1091 s

Step: Actuate |   Increment: 529 | Iterations: 4
Simulation Time: 118.05 s | dt: 0.1091 s

Step: Actuate |   Increment: 530 | Iterations: 4
Simulation Time: 118.16 s | dt: 0.1091 s

Step: Actuate |   Increment: 531 | Iterations: 4
Simulation Time: 118.26 s | dt: 0.1091 s

Step: Actuate |   Increment: 532 | Iterations: 4
Simulation Time: 118.37 s | dt: 0.1091 s

Step: Actuate |   Increment: 533 | Iterations: 4
Simulation Time: 118.48 s | dt: 0.1091 s

Step: Actuate |   Increment: 534 | Iterations: 4
Simulation Time: 118.59 s | dt: 0.1091 s

Step: Actuate |   Increment: 535 | Iterations: 5
Simulation Time: 118.7 s | dt: 0.0546 s
old dt: 0.1091 s | new dt: 0.0546 s

Step: Actuate |   Increment: 536 | Iterations: 4
Simulation Time: 118.76 s | dt: 0.0546 s

Step: Actuate |   Increment: 537 | Iterations: 4
Simulation Time: 118.81 s | dt: 0.0546 s

Step: Actuate |   Increment: 538 | Iterations: 4
Simulation Time: 118.86 s | dt: 0.0546 s

Step: Actuate |   Increment: 539 | Iterations: 4
Simulation Time: 118.92 s | dt: 0.0546 s

Step: Actuate |   Increment: 540 | Iterations: 4
Simulation Time: 118.97 s | dt: 0.0546 s

Step: Actuate |   Increment: 541 | Iterations: 4
Simulation Time: 119.03 s | dt: 0.0546 s

Step: Actuate |   Increment: 542 | Iterations: 4
Simulation Time: 119.08 s | dt: 0.0546 s

Step: Actuate |   Increment: 543 | Iterations: 4
Simulation Time: 119.14 s | dt: 0.0546 s

Step: Actuate |   Increment: 544 | Iterations: 4
Simulation Time: 119.19 s | dt: 0.0546 s

Step: Actuate |   Increment: 545 | Iterations: 5
Simulation Time: 119.25 s | dt: 0.0273 s
old dt: 0.0546 s | new dt: 0.0273 s

Step: Actuate |   Increment: 546 | Iterations: 4
Simulation Time: 119.27 s | dt: 0.0273 s

Step: Actuate |   Increment: 547 | Iterations: 4
Simulation Time: 119.3 s | dt: 0.0273 s

Step: Actuate |   Increment: 548 | Iterations: 4
Simulation Time: 119.33 s | dt: 0.0273 s

Step: Actuate |   Increment: 549 | Iterations: 4
Simulation Time: 119.36 s | dt: 0.0273 s

Step: Actuate |   Increment: 550 | Iterations: 4
Simulation Time: 119.38 s | dt: 0.0273 s

Step: Actuate |   Increment: 551 | Iterations: 4
Simulation Time: 119.41 s | dt: 0.0273 s

Step: Actuate |   Increment: 552 | Iterations: 4
Simulation Time: 119.44 s | dt: 0.0273 s

Step: Actuate |   Increment: 553 | Iterations: 5
Simulation Time: 119.46 s | dt: 0.0136 s
old dt: 0.0273 s | new dt: 0.0136 s

Step: Actuate |   Increment: 554 | Iterations: 4
Simulation Time: 119.48 s | dt: 0.0136 s

Step: Actuate |   Increment: 555 | Iterations: 4
Simulation Time: 119.49 s | dt: 0.0136 s

Step: Actuate |   Increment: 556 | Iterations: 4
Simulation Time: 119.51 s | dt: 0.0136 s

Step: Actuate |   Increment: 557 | Iterations: 4
Simulation Time: 119.52 s | dt: 0.0136 s

Step: Actuate |   Increment: 558 | Iterations: 4
Simulation Time: 119.53 s | dt: 0.0136 s

Step: Actuate |   Increment: 559 | Iterations: 4
Simulation Time: 119.55 s | dt: 0.0136 s

Step: Actuate |   Increment: 560 | Iterations: 4
Simulation Time: 119.56 s | dt: 0.0136 s

Step: Actuate |   Increment: 561 | Iterations: 4
Simulation Time: 119.57 s | dt: 0.0136 s

Step: Actuate |   Increment: 562 | Iterations: 4
Simulation Time: 119.59 s | dt: 0.0136 s

Step: Actuate |   Increment: 563 | Iterations: 4
Simulation Time: 119.6 s | dt: 0.0136 s

Step: Actuate |   Increment: 564 | Iterations: 4
Simulation Time: 119.61 s | dt: 0.0136 s

Step: Actuate |   Increment: 565 | Iterations: 4
Simulation Time: 119.63 s | dt: 0.0136 s

Step: Actuate |   Increment: 566 | Iterations: 4
Simulation Time: 119.64 s | dt: 0.0136 s

Step: Actuate |   Increment: 567 | Iterations: 4
Simulation Time: 119.66 s | dt: 0.0136 s

Step: Actuate |   Increment: 568 | Iterations: 4
Simulation Time: 119.67 s | dt: 0.0136 s

Step: Actuate |   Increment: 569 | Iterations: 4
Simulation Time: 119.68 s | dt: 0.0136 s

Step: Actuate |   Increment: 570 | Iterations: 4
Simulation Time: 119.7 s | dt: 0.0136 s

Step: Actuate |   Increment: 571 | Iterations: 4
Simulation Time: 119.71 s | dt: 0.0136 s

Step: Actuate |   Increment: 572 | Iterations: 4
Simulation Time: 119.72 s | dt: 0.0136 s

Step: Actuate |   Increment: 573 | Iterations: 4
Simulation Time: 119.74 s | dt: 0.0136 s

Step: Actuate |   Increment: 574 | Iterations: 4
Simulation Time: 119.75 s | dt: 0.0136 s

Step: Actuate |   Increment: 575 | Iterations: 4
Simulation Time: 119.76 s | dt: 0.0136 s

Step: Actuate |   Increment: 576 | Iterations: 4
Simulation Time: 119.78 s | dt: 0.0136 s

Step: Actuate |   Increment: 577 | Iterations: 4
Simulation Time: 119.79 s | dt: 0.0136 s

Step: Actuate |   Increment: 578 | Iterations: 4
Simulation Time: 119.81 s | dt: 0.0136 s

Step: Actuate |   Increment: 579 | Iterations: 4
Simulation Time: 119.82 s | dt: 0.0136 s

Step: Actuate |   Increment: 580 | Iterations: 4
Simulation Time: 119.83 s | dt: 0.0136 s

Step: Actuate |   Increment: 581 | Iterations: 4
Simulation Time: 119.85 s | dt: 0.0136 s

Step: Actuate |   Increment: 582 | Iterations: 4
Simulation Time: 119.86 s | dt: 0.0136 s

Step: Actuate |   Increment: 583 | Iterations: 4
Simulation Time: 119.87 s | dt: 0.0136 s

Step: Actuate |   Increment: 584 | Iterations: 4
Simulation Time: 119.89 s | dt: 0.0136 s

Step: Actuate |   Increment: 585 | Iterations: 4
Simulation Time: 119.9 s | dt: 0.0136 s

Step: Actuate |   Increment: 586 | Iterations: 4
Simulation Time: 119.91 s | dt: 0.0136 s

Step: Actuate |   Increment: 587 | Iterations: 4
Simulation Time: 119.93 s | dt: 0.0136 s

Step: Actuate |   Increment: 588 | Iterations: 4
Simulation Time: 119.94 s | dt: 0.0136 s

Step: Actuate |   Increment: 589 | Iterations: 4
Simulation Time: 119.96 s | dt: 0.0136 s

Step: Actuate |   Increment: 590 | Iterations: 4
Simulation Time: 119.97 s | dt: 0.0136 s

Step: Actuate |   Increment: 591 | Iterations: 4
Simulation Time: 119.98 s | dt: 0.0136 s

Step: Actuate |   Increment: 592 | Iterations: 4
Simulation Time: 120.0 s | dt: 0.0136 s

Step: Actuate |   Increment: 593 | Iterations: 4
Simulation Time: 120.01 s | dt: 0.0136 s

Step: Actuate |   Increment: 594 | Iterations: 4
Simulation Time: 120.02 s | dt: 0.0136 s

Step: Actuate |   Increment: 595 | Iterations: 4
Simulation Time: 120.04 s | dt: 0.0136 s

Step: Actuate |   Increment: 596 | Iterations: 4
Simulation Time: 120.05 s | dt: 0.0136 s

Step: Actuate |   Increment: 597 | Iterations: 4
Simulation Time: 120.06 s | dt: 0.0136 s

Step: Actuate |   Increment: 598 | Iterations: 4
Simulation Time: 120.08 s | dt: 0.0136 s

Step: Actuate |   Increment: 599 | Iterations: 4
Simulation Time: 120.09 s | dt: 0.0136 s

Step: Actuate |   Increment: 600 | Iterations: 4
Simulation Time: 120.11 s | dt: 0.0136 s

Step: Actuate |   Increment: 601 | Iterations: 4
Simulation Time: 120.12 s | dt: 0.0136 s

Step: Actuate |   Increment: 602 | Iterations: 4
Simulation Time: 120.13 s | dt: 0.0136 s

Step: Actuate |   Increment: 603 | Iterations: 4
Simulation Time: 120.15 s | dt: 0.0136 s

Step: Actuate |   Increment: 604 | Iterations: 4
Simulation Time: 120.16 s | dt: 0.0136 s

Step: Actuate |   Increment: 605 | Iterations: 4
Simulation Time: 120.17 s | dt: 0.0136 s

Step: Actuate |   Increment: 606 | Iterations: 4
Simulation Time: 120.19 s | dt: 0.0136 s

Step: Actuate |   Increment: 607 | Iterations: 4
Simulation Time: 120.2 s | dt: 0.0136 s

Step: Actuate |   Increment: 608 | Iterations: 4
Simulation Time: 120.21 s | dt: 0.0136 s

Step: Actuate |   Increment: 609 | Iterations: 4
Simulation Time: 120.23 s | dt: 0.0136 s

Step: Actuate |   Increment: 610 | Iterations: 4
Simulation Time: 120.24 s | dt: 0.0136 s

Step: Actuate |   Increment: 611 | Iterations: 4
Simulation Time: 120.26 s | dt: 0.0136 s

Step: Actuate |   Increment: 612 | Iterations: 4
Simulation Time: 120.27 s | dt: 0.0136 s

Step: Actuate |   Increment: 613 | Iterations: 4
Simulation Time: 120.28 s | dt: 0.0136 s

Step: Actuate |   Increment: 614 | Iterations: 4
Simulation Time: 120.3 s | dt: 0.0136 s

Step: Actuate |   Increment: 615 | Iterations: 4
Simulation Time: 120.31 s | dt: 0.0136 s

Step: Actuate |   Increment: 616 | Iterations: 4
Simulation Time: 120.32 s | dt: 0.0136 s

Step: Actuate |   Increment: 617 | Iterations: 4
Simulation Time: 120.34 s | dt: 0.0136 s

Step: Actuate |   Increment: 618 | Iterations: 4
Simulation Time: 120.35 s | dt: 0.0136 s

Step: Actuate |   Increment: 619 | Iterations: 4
Simulation Time: 120.36 s | dt: 0.0136 s

Step: Actuate |   Increment: 620 | Iterations: 4
Simulation Time: 120.38 s | dt: 0.0136 s

Step: Actuate |   Increment: 621 | Iterations: 4
Simulation Time: 120.39 s | dt: 0.0136 s

Step: Actuate |   Increment: 622 | Iterations: 4
Simulation Time: 120.41 s | dt: 0.0136 s

Step: Actuate |   Increment: 623 | Iterations: 4
Simulation Time: 120.42 s | dt: 0.0136 s

Step: Actuate |   Increment: 624 | Iterations: 4
Simulation Time: 120.43 s | dt: 0.0136 s

Step: Actuate |   Increment: 625 | Iterations: 4
Simulation Time: 120.45 s | dt: 0.0136 s

Step: Actuate |   Increment: 626 | Iterations: 4
Simulation Time: 120.46 s | dt: 0.0136 s

Step: Actuate |   Increment: 627 | Iterations: 4
Simulation Time: 120.47 s | dt: 0.0136 s

Step: Actuate |   Increment: 628 | Iterations: 4
Simulation Time: 120.49 s | dt: 0.0136 s

Step: Actuate |   Increment: 629 | Iterations: 4
Simulation Time: 120.5 s | dt: 0.0136 s

Step: Actuate |   Increment: 630 | Iterations: 4
Simulation Time: 120.51 s | dt: 0.0136 s

Step: Actuate |   Increment: 631 | Iterations: 4
Simulation Time: 120.53 s | dt: 0.0136 s

Step: Actuate |   Increment: 632 | Iterations: 4
Simulation Time: 120.54 s | dt: 0.0136 s

Step: Actuate |   Increment: 633 | Iterations: 4
Simulation Time: 120.56 s | dt: 0.0136 s

Step: Actuate |   Increment: 634 | Iterations: 4
Simulation Time: 120.57 s | dt: 0.0136 s

Step: Actuate |   Increment: 635 | Iterations: 4
Simulation Time: 120.58 s | dt: 0.0136 s

Step: Actuate |   Increment: 636 | Iterations: 4
Simulation Time: 120.6 s | dt: 0.0136 s

Step: Actuate |   Increment: 637 | Iterations: 4
Simulation Time: 120.61 s | dt: 0.0136 s

Step: Actuate |   Increment: 638 | Iterations: 4
Simulation Time: 120.62 s | dt: 0.0136 s

Step: Actuate |   Increment: 639 | Iterations: 4
Simulation Time: 120.64 s | dt: 0.0136 s

Step: Actuate |   Increment: 640 | Iterations: 4
Simulation Time: 120.65 s | dt: 0.0136 s

Step: Actuate |   Increment: 641 | Iterations: 4
Simulation Time: 120.66 s | dt: 0.0136 s

Step: Actuate |   Increment: 642 | Iterations: 4
Simulation Time: 120.68 s | dt: 0.0136 s

Step: Actuate |   Increment: 643 | Iterations: 4
Simulation Time: 120.69 s | dt: 0.0136 s

Step: Actuate |   Increment: 644 | Iterations: 4
Simulation Time: 120.71 s | dt: 0.0136 s

Step: Actuate |   Increment: 645 | Iterations: 4
Simulation Time: 120.72 s | dt: 0.0136 s

Step: Actuate |   Increment: 646 | Iterations: 4
Simulation Time: 120.73 s | dt: 0.0136 s

Step: Actuate |   Increment: 647 | Iterations: 4
Simulation Time: 120.75 s | dt: 0.0136 s

Step: Actuate |   Increment: 648 | Iterations: 4
Simulation Time: 120.76 s | dt: 0.0136 s

Step: Actuate |   Increment: 649 | Iterations: 4
Simulation Time: 120.77 s | dt: 0.0136 s

Step: Actuate |   Increment: 650 | Iterations: 4
Simulation Time: 120.79 s | dt: 0.0136 s

Step: Actuate |   Increment: 651 | Iterations: 4
Simulation Time: 120.8 s | dt: 0.0136 s

Step: Actuate |   Increment: 652 | Iterations: 4
Simulation Time: 120.81 s | dt: 0.0136 s

Step: Actuate |   Increment: 653 | Iterations: 4
Simulation Time: 120.83 s | dt: 0.0136 s

Step: Actuate |   Increment: 654 | Iterations: 4
Simulation Time: 120.84 s | dt: 0.0136 s

Step: Actuate |   Increment: 655 | Iterations: 4
Simulation Time: 120.86 s | dt: 0.0136 s

Step: Actuate |   Increment: 656 | Iterations: 4
Simulation Time: 120.87 s | dt: 0.0136 s

Step: Actuate |   Increment: 657 | Iterations: 4
Simulation Time: 120.88 s | dt: 0.0136 s

Step: Actuate |   Increment: 658 | Iterations: 4
Simulation Time: 120.9 s | dt: 0.0136 s

Step: Actuate |   Increment: 659 | Iterations: 4
Simulation Time: 120.91 s | dt: 0.0136 s

Step: Actuate |   Increment: 660 | Iterations: 4
Simulation Time: 120.92 s | dt: 0.0136 s

Step: Actuate |   Increment: 661 | Iterations: 4
Simulation Time: 120.94 s | dt: 0.0136 s

Step: Actuate |   Increment: 662 | Iterations: 4
Simulation Time: 120.95 s | dt: 0.0136 s

Step: Actuate |   Increment: 663 | Iterations: 5
Simulation Time: 120.96 s | dt: 0.0068 s
old dt: 0.0136 s | new dt: 0.0068 s

Step: Actuate |   Increment: 664 | Iterations: 4
Simulation Time: 120.97 s | dt: 0.0068 s

Step: Actuate |   Increment: 665 | Iterations: 5
Simulation Time: 120.98 s | dt: 0.0034 s
old dt: 0.0068 s | new dt: 0.0034 s

Step: Actuate |   Increment: 666 | Iterations: 4
Simulation Time: 120.98 s | dt: 0.0034 s

Step: Actuate |   Increment: 667 | Iterations: 4
Simulation Time: 120.99 s | dt: 0.0034 s

Step: Actuate |   Increment: 668 | Iterations: 4
Simulation Time: 120.99 s | dt: 0.0034 s

Step: Actuate |   Increment: 669 | Iterations: 5
Simulation Time: 120.99 s | dt: 0.0017 s
old dt: 0.0034 s | new dt: 0.0017 s

Step: Actuate |   Increment: 670 | Iterations: 4
Simulation Time: 120.99 s | dt: 0.0017 s

Step: Actuate |   Increment: 671 | Iterations: 5
Simulation Time: 121.0 s | dt: 0.0009 s
old dt: 0.0017 s | new dt: 0.0009 s

Step: Actuate |   Increment: 672 | Iterations: 4
Simulation Time: 121.0 s | dt: 0.0009 s

Step: Actuate |   Increment: 673 | Iterations: 4
Simulation Time: 121.0 s | dt: 0.0009 s

Step: Actuate |   Increment: 674 | Iterations: 5
Simulation Time: 121.0 s | dt: 0.0004 s
old dt: 0.0009 s | new dt: 0.0004 s

Step: Actuate |   Increment: 675 | Iterations: 4
Simulation Time: 121.0 s | dt: 0.0004 s

Step: Actuate |   Increment: 676 | Iterations: 5
Simulation Time: 121.0 s | dt: 0.0002 s
old dt: 0.0004 s | new dt: 0.0002 s

Step: Actuate |   Increment: 677 | Iterations: 4
Simulation Time: 121.0 s | dt: 0.0002 s

Step: Actuate |   Increment: 678 | Iterations: 4
Simulation Time: 121.0 s | dt: 0.0002 s

Step: Actuate |   Increment: 679 | Iterations: 5
Simulation Time: 121.0 s | dt: 0.0001 s
old dt: 0.0002 s | new dt: 0.0001 s

Not converged, this was attempt 1
Step: Actuate | Increment: 679 | Iterations: 15
dt: 0.0001 | Simulation Time: 120.9997 s | Percent of total time: 69.3168%
old dt: 0.0001 | new dt 0.0001

Ended early due to an excessively small time increment
-----------------------------------------
End computation
------------------------------------------
Elapsed real time:  0:53:25.742556
------------------------------------------

2024-12-07 03:44:49.322 (3210.829s) [main            ]       NewtonSolver.cpp:270   WARN| Newton solver did not converge.

Plot results

# set plot font to size 18
font = {'size'   : 18}
plt.rc('font', **font)

# Get array of default plot colors
prop_cycle = plt.rcParams['axes.prop_cycle']
colors = prop_cycle.by_key()['color']


# Only plot as far as we have time history data
ind = np.argmax(timeHist0) + 1


time = timeHist0[0:ind]
normVolts = timeHist1[0:ind]/(thickness * np.sqrt(float(Geq_0)/float(vareps))) 
delta = timeHist2[0:ind]/thickness



fig = plt.figure()
plt.plot( time, normVolts, color=colors[0], linewidth=2.0)
plt.grid(linestyle="--", linewidth=0.5, color='b')
plt.xlabel('Time (s)')
plt.ylabel(r'Normalized potential, $\frac{\phi/T_0}{\sqrt{G_0/\varepsilon}}$')


fig = plt.figure()
plt.plot( normVolts, delta, color=colors[0], linewidth=2.0)
plt.grid(linestyle="--", linewidth=0.5, color='b')
plt.xlabel(r'Normalized potential, $\frac{\phi/T_0}{\sqrt{G_0/\varepsilon}}$')
plt.ylabel('$u_2/T_0$')

plt.text(normVolts[-1],delta[-1], r'X', color='k',\
           horizontalalignment='center',verticalalignment='center')



# # Two-axis plotting
# fig, (ax1, ax2) = plt.subplots(2,1, sharex='col')

# ax1.plot(timeHist0[0:ind], normVolts[0:ind], c=colors[0], linewidth=2.0)
# ax1.grid(linestyle="--", linewidth=0.5, color='b')
# ax1.set_ylabel('Normalized electric potential (kV)')
# # ax1.set_xlim([0,5])
# from matplotlib.ticker import AutoMinorLocator,FormatStrFormatter
# ax1.xaxis.set_minor_locator(AutoMinorLocator())
# ax1.yaxis.set_minor_locator(AutoMinorLocator())

# ax2.plot(timeHist0[0:ind], np.abs(timeHist2[0:ind]-timeHist3[0:ind])/height, c=colors[0], linewidth=2.0)
# ax2.grid(linestyle="--", linewidth=0.5, color='b')
# ax2.set_xlabel('Time (s)')
# ax2.set_ylabel('$\delta$')
# from matplotlib.ticker import AutoMinorLocator,FormatStrFormatter
# ax2.xaxis.set_minor_locator(AutoMinorLocator())
# ax2.yaxis.set_minor_locator(AutoMinorLocator())


fig = plt.gcf()
fig.set_size_inches(7,5)
plt.tight_layout()
plt.savefig("results/electro-viscoelastic-diaphram.png", dpi=600)

np.savetxt('diaphramRate1e-1.csv', np.vstack((time,normVolts,delta)).T, delimiter=',')

# retrieve data from prior runs
rate1m3 = np.genfromtxt('diaphramRate1e-3.csv', delimiter=',')
rate1m2 = np.genfromtxt('diaphramRate1e-2.csv', delimiter=',')
rate1m1 = np.genfromtxt('diaphramRate1e-1.csv', delimiter=',')


fig = plt.figure()
plt.plot(rate1m3[:,1],rate1m3[:,2], c=colors[0], linewidth=2.0, label=r'$10^{-3}$/s')
plt.plot(rate1m2[:,1],rate1m2[:,2], c=colors[1], linewidth=2.0, label=r'$10^{-2}$/s')
plt.plot(rate1m1[:,1],rate1m1[:,2], c=colors[2], linewidth=2.0, label=r'$10^{-1}$/s')
plt.grid(linestyle="--", linewidth=0.5, color='b')
plt.legend(loc="upper left")
ax = plt.gca()
#
ax.set_xlabel(r'Normalized potential, $\frac{\phi/T_0}{\sqrt{G_0/\varepsilon}}$',size=18)
ax.set_ylabel(r'$u_2/T_0$')
ax.set_ylim([0.0,60.0])
ax.set_xlim([0.0,1.1])


plt.text(rate1m3[-1,1],rate1m3[-1,2], r'X', color='k',\
           horizontalalignment='center',verticalalignment='center')
plt.text(rate1m2[-1,1],rate1m2[-1,2], r'X', color='k',\
           horizontalalignment='center',verticalalignment='center')
plt.text(rate1m1[-1,1],rate1m1[-1,2], r'X', color='k',\
           horizontalalignment='center',verticalalignment='center')


fig = plt.gcf()
fig.set_size_inches(7,5)
plt.tight_layout()
plt.savefig("results/electro-viscoelastic-BlisterRateSweep.png", dpi=600)




fig = plt.figure()
plt.plot(rate1m3[:,1],rate1m3[:,2], c=colors[0], linewidth=2.0, label=r'$10^{-3}$/s')
plt.plot(rate1m2[:,1],rate1m2[:,2], c=colors[1], linewidth=2.0, label=r'$10^{-2}$/s')
plt.plot(rate1m1[:,1],rate1m1[:,2], c=colors[2], linewidth=2.0, label=r'$10^{-1}$/s')
plt.grid(linestyle="--", linewidth=0.5, color='b')
plt.legend(loc="upper left")
ax = plt.gca()
#
ax.set_xlabel(r'Normalized potential, $\frac{\phi/T_0}{\sqrt{G_0/\varepsilon}}$',size=18)
ax.set_ylabel(r'$u_2/T_0$')
ax.set_ylim([0.0,10.0])
ax.set_xlim([0.0,0.2])

fig = plt.gcf()
fig.set_size_inches(7,5)
plt.tight_layout()
plt.savefig("results/electro-viscoelastic-BlisterRateSweepZoom.png", dpi=600)