Beispiel #1
0
      ex14p.py -m amr-quad.mesh -rs 3
      ex14p.py -m amr-hex.mesh
'''
import sys
from mfem.common.arg_parser import ArgParser
from os.path import expanduser, join
import numpy as np

from mfem import path
import mfem.par as mfem
from mpi4py import MPI

num_procs = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank

parser = ArgParser(description='Ex14p')
parser.add_argument('-m',
                    '--mesh',
                    default='star.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument(
    '-rs',
    '--refine-serial',
    action='store',
    default=-1,
    type=int,
    help="Number of times to refine the mesh uniformly before parallel")
parser.add_argument(
    '-rp',
Beispiel #2
0
   Description:  This example code demonstrates the use of MFEM to define a
                 simple finite element discretization of the Laplace problem
                 -Delta u = 1 with homogeneous Dirichlet boundary conditions.

'''

import sys
from os.path import expanduser, join
import numpy as np

from mfem.common.arg_parser import ArgParser
from mfem import path
import mfem.ser as mfem

parser = ArgParser(description='Ex1 (Laplace Problem)')
parser.add_argument('-m',
                    '--mesh',
                    default='star.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument('-vis',
                    '--visualization',
                    action='store_true',
                    help='Enable GLVis visualization')
parser.add_argument(
    '-o',
    '--order',
    action='store',
    default=1,
Beispiel #3
0
        u_coeff = mfem.GridFunctionCoefficient(u_alpha_gf)
        self.K.AddDomainIntegrator(mfem.DiffusionIntegrator(u_coeff))
        self.K.Assemble(0)
        self.K.FormSystemMatrix(self.ess_tdof_list, self.Kmat)
        self.T = None


class InitialTemperature(mfem.PyCoefficient):
    def EvalValue(self, x):
        xx = np.array(x)
        norm2 = float(np.sum(xx**2))
        if norm2 < 0.5: return 2.0
        return 1.0


parser = ArgParser(description='Ex16p')
parser.add_argument('-m',
                    '--mesh',
                    default='star.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument(
    '-rs',
    '--refine-serial',
    action='store',
    default=2,
    type=int,
    help="Number of times to refine the mesh uniformly in serial")
parser.add_argument(
    '-rp',
Beispiel #4
0
      ex12p.py -m beam-quad-nurbs.mesh
      ex12p.py -m beam-hex-nurbs.mesh
'''
import sys
from os.path import expanduser, join
import numpy as np

from mfem import path
from mfem.common.arg_parser import ArgParser
import mfem.par as mfem
from mpi4py import MPI

num_procs = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank

parser = ArgParser(description='Ex12 (linear elastisity)')
parser.add_argument('-m',
                    '--mesh',
                    default='beam-tri.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument('-o',
                    '--order',
                    action='store',
                    default=1,
                    type=int,
                    help="Finite element order (polynomial degree)")
parser.add_argument("-n",
                    "--num-eigs",
                    action='store',
Beispiel #5
0
    def initialize(self, inMeshObj=None, inMeshFile=None):
        # 2. Problem initialization
        self.parser = ArgParser(description='Based on MFEM Ex16p')
        self.parser.add_argument('-m',
                                 '--mesh',
                                 default='beam-tet.mesh',
                                 action='store',
                                 type=str,
                                 help='Mesh file to use.')
        self.parser.add_argument('-rs',
                                 '--refine-serial',
                                 action='store',
                                 default=1,
                                 type=int,
                                 help="Number of times to refine the mesh \
                    uniformly in serial")
        self.parser.add_argument('-rp',
                                 '--refine-parallel',
                                 action='store',
                                 default=0,
                                 type=int,
                                 help="Number of times to refine the mesh \
            uniformly in parallel")
        self.parser.add_argument('-o',
                                 '--order',
                                 action='store',
                                 default=1,
                                 type=int,
                                 help="Finite element order (polynomial \
                    degree)")
        self.parser.add_argument(
            '-s',
            '--ode-solver',
            action='store',
            default=3,
            type=int,
            help='\n'.join([
                "ODE solver: 1 - Backward Euler, 2 - SDIRK2, \
              3 - SDIRK3", "\t\t 11 - Forward Euler, \
              12 - RK2, 13 - RK3 SSP, 14 - RK4."
            ]))
        self.parser.add_argument('-t',
                                 '--t-final',
                                 action='store',
                                 default=20.,
                                 type=float,
                                 help="Final time; start time is 0.")
        self.parser.add_argument("-dt",
                                 "--time-step",
                                 action='store',
                                 default=5e-3,
                                 type=float,
                                 help="Time step.")
        self.parser.add_argument("-v",
                                 "--viscosity",
                                 action='store',
                                 default=0.00,
                                 type=float,
                                 help="Viscosity coefficient.")
        self.parser.add_argument('-L',
                                 '--lmbda',
                                 action='store',
                                 default=1.e0,
                                 type=float,
                                 help='Lambda of Hooks law')
        self.parser.add_argument('-mu',
                                 '--shear-modulus',
                                 action='store',
                                 default=1.e0,
                                 type=float,
                                 help='Shear modulus for Hooks law')
        self.parser.add_argument('-rho',
                                 '--density',
                                 action='store',
                                 default=1.0,
                                 type=float,
                                 help='mass density')
        self.parser.add_argument('-vis',
                                 '--visualization',
                                 action='store_true',
                                 help='Enable GLVis visualization')
        self.parser.add_argument('-vs',
                                 '--visualization-steps',
                                 action='store',
                                 default=25,
                                 type=int,
                                 help="Visualize every n-th timestep.")
        args = self.parser.parse_args()
        self.ser_ref_levels = args.refine_serial
        self.par_ref_levels = args.refine_parallel
        self.order = args.order
        self.dt = args.time_step
        self.visc = args.viscosity
        self.t_final = args.t_final
        self.lmbda = args.lmbda
        self.mu = args.shear_modulus
        self.rho = args.density
        self.visualization = args.visualization
        self.ti = 1
        self.vis_steps = args.visualization_steps
        self.ode_solver_type = args.ode_solver
        self.t = 0.0
        self.last_step = False
        if self.myId == 0: self.parser.print_options(args)

        # 3. Reading mesh
        if inMeshObj is None:
            self.meshFile = inMeshFile
            if self.meshFile is None:
                self.meshFile = args.mesh
            self.mesh = mfem.Mesh(self.meshFile, 1, 1)
        else:
            self.mesh = inMeshObj
        self.dim = self.mesh.Dimension()
        print("Mesh dimension: %d" % self.dim)
        print("Number of vertices in the mesh: %d " % self.mesh.GetNV())
        print("Number of elements in the mesh: %d " % self.mesh.GetNE())

        # 4. Define the ODE solver used for time integration.
        #    Several implicit singly diagonal implicit
        #    Runge-Kutta (SDIRK) methods, as well as
        #    explicit Runge-Kutta methods are available.
        if self.ode_solver_type == 1:
            self.ode_solver = BackwardEulerSolver()
        elif self.ode_solver_type == 2:
            self.ode_solver = mfem.SDIRK23Solver(2)
        elif self.ode_solver_type == 3:
            self.ode_solver = mfem.SDIRK33Solver()
        elif self.ode_solver_type == 11:
            self.ode_solver = ForwardEulerSolver()
        elif self.ode_solver_type == 12:
            self.ode_solver = mfem.RK2Solver(0.5)
        elif self.ode_solver_type == 13:
            self.ode_solver = mfem.RK3SSPSolver()
        elif self.ode_solver_type == 14:
            self.ode_solver = mfem.RK4Solver()
        elif self.ode_solver_type == 22:
            self.ode_solver = mfem.ImplicitMidpointSolver()
        elif self.ode_solver_type == 23:
            self.ode_solver = mfem.SDIRK23Solver()
        elif self.ode_solver_type == 24:
            self.ode_solver = mfem.SDIRK34Solver()
        else:
            print("Unknown ODE solver type: " + str(self.ode_solver_type))
            exit

        # 5. Refine the mesh in serial to increase the
        #    resolution. In this example we do
        #    'ser_ref_levels' of uniform refinement, where
        #    'ser_ref_levels' is a command-line parameter.
        for lev in range(self.ser_ref_levels):
            self.mesh.UniformRefinement()

        # 6. Define a parallel mesh by a partitioning of
        #    the serial mesh. Refine this mesh further
        #    in parallel to increase the resolution. Once the
        #    parallel mesh is defined, the serial mesh can
        #    be deleted.
        self.pmesh = mfem.ParMesh(MPI.COMM_WORLD, self.mesh)
        for lev in range(self.par_ref_levels):
            self.pmesh.UniformRefinement()

        # 7. Define the vector finite element space
        #    representing the current and the
        #    initial temperature, u_ref.
        self.fe_coll = mfem.H1_FECollection(self.order, self.dim)
        self.fespace = mfem.ParFiniteElementSpace(self.pmesh, self.fe_coll,
                                                  self.dim)
        self.fe_size = self.fespace.GlobalTrueVSize()
        if self.myId == 0:
            print("FE Number of unknowns: " + str(self.fe_size))
        true_size = self.fespace.TrueVSize()
        self.true_offset = mfem.intArray(3)
        self.true_offset[0] = 0
        self.true_offset[1] = true_size
        self.true_offset[2] = 2 * true_size
        self.vx = mfem.BlockVector(self.true_offset)
        self.v_gf = mfem.ParGridFunction(self.fespace)
        self.v_gfbnd = mfem.ParGridFunction(self.fespace)
        self.x_gf = mfem.ParGridFunction(self.fespace)
        self.x_gfbnd = mfem.ParGridFunction(self.fespace)
        self.x_ref = mfem.ParGridFunction(self.fespace)
        self.pmesh.GetNodes(self.x_ref)

        # 8. Set the initial conditions for u.
        #self.velo = InitialVelocity(self.dim)
        self.velo = velBCs(self.dim)
        #self.deform =  InitialDeformation(self.dim)
        self.deform = defBCs(self.dim)
        self.v_gf.ProjectCoefficient(self.velo)
        self.v_gfbnd.ProjectCoefficient(self.velo)
        self.x_gf.ProjectCoefficient(self.deform)
        self.x_gfbnd.ProjectCoefficient(self.deform)
        #self.v_gf.GetTrueDofs(self.vx.GetBlock(0));
        #self.x_gf.GetTrueDofs(self.vx.GetBlock(1));

        # setup boundary-conditions
        self.xess_bdr = mfem.intArray(
            self.fespace.GetMesh().bdr_attributes.Max())
        self.xess_bdr.Assign(0)
        self.xess_bdr[0] = 1
        self.xess_bdr[1] = 1
        self.xess_tdof_list = intArray()
        self.fespace.GetEssentialTrueDofs(self.xess_bdr, self.xess_tdof_list)
        #print('True x essential BCs are')
        #self.xess_tdof_list.Print()

        self.vess_bdr = mfem.intArray(
            self.fespace.GetMesh().bdr_attributes.Max())
        self.vess_bdr.Assign(0)
        self.vess_bdr[0] = 1
        self.vess_bdr[1] = 1
        self.vess_tdof_list = intArray()
        self.fespace.GetEssentialTrueDofs(self.vess_bdr, self.vess_tdof_list)
        #print('True v essential BCs are')
        #self.vess_tdof_list.Print()

        # 9. Initialize the stiffness operator
        self.oper = StiffnessOperator(self.fespace, self.lmbda, self.mu,
                                      self.rho, self.visc, self.vess_tdof_list,
                                      self.vess_bdr, self.xess_tdof_list,
                                      self.xess_bdr, self.v_gfbnd,
                                      self.x_gfbnd, self.deform, self.velo,
                                      self.vx)

        # 10. Setting up file output
        self.smyid = '{:0>2d}'.format(self.myId)

        # initializing ode solver
        self.ode_solver.Init(self.oper)
Beispiel #6
0
import mfem.par as mfem

from mfem.common.arg_parser import ArgParser
from os.path import expanduser, join
import numpy as np
from numpy import sqrt, pi, cos, sin, hypot, arctan2
from scipy.special import erfc

from mfem import path
from mfem.par import intArray, add_vector
from mpi4py import MPI

num_procs = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank

parser = ArgParser(description='Ex10p')
parser.add_argument('-m',
                    '--mesh',
                    default='beam-quad.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument(
    '-rs',
    '--refine-serial',
    action='store',
    default=2,
    type=int,
    help="Number of times to refine the mesh uniformly before parallel")
parser.add_argument(
    '-rp',
Beispiel #7
0
        self.output.flush()

    def send_solution(self, mesh, x):
        if self.output is None: return
        self.output.send_solution(mesh, x)

    def send_text(self, x):
        if self.output is None: return
        self.output.send_text(x)

    def flush(self):
        if self.output is None: return
        self.output.flush()


parser = ArgParser(description='Ex17')
parser.add_argument('-m',
                    '--mesh',
                    default='beam-tri.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument(
    '-rs',
    '--refine-serial',
    action='store',
    default=-1,
    type=int,
    help="Number of times to refine the mesh uniformly before parallel")
parser.add_argument(
    '-rp',
Beispiel #8
0
                   str(self.win_y + self.stride_y*(sid/self.win_nx)) +
                   ' ' +  str(self.win_w) +  ' ' +  str(self.win_h))
        self.output.send_text(command)
        self.output.flush()

    def send_solution(self, mesh, x):
        if self.output is None: return        
        self.output.send_solution(mesh, x)
    def send_text(self, x):
        if self.output is None: return        
        self.output.send_text(x)
    def flush(self):        
        if self.output is None: return        
        self.output.flush()
        
parser = ArgParser(description='Ex17')
parser.add_argument('-m', '--mesh',
                    default = 'beam-tri.mesh',
                    action = 'store', type = str,
                    help='Mesh file to use.')
parser.add_argument('-r', '--refine',
                    action = 'store', default = -1, type=int,
       help = "Number of times to refine the mesh uniformly, -1 for auto.")
parser.add_argument('-o', '--order',
                    action = 'store', default = 1, type=int,
                    help = "Finite element order (polynomial degree)");
parser.add_argument('-a', '--alpha',
                    action = 'store', default = -1.0, type=float,
       help = '\n'.join(["One of the two DG penalty parameters, typically +1/-1."
                         " See the documentation of class DGElasticityIntegrator."]))
parser.add_argument('-k', '--kappa',
Beispiel #9
0
    # 11. Recover the solution as a finite element grid function.
    a.RecoverFEMSolution(X, b, x)
    # 12. Save the refined mesh and the solution. This output can be viewed later
    #     using GLVis: "glvis -m refined.mesh -g sol.gf".
    mesh.Print('refined.mesh', 8)
    x.Save('sol.gf', 8)

    #13. Send the solution by socket to a GLVis server.
    if (visualization):
        sol_sock = mfem.socketstream("localhost", 19916)
        sol_sock.precision(8)
        sol_sock.send_solution(mesh, x)


if __name__ == "__main__":
    parser = ArgParser(description='Ex1 (Laplace Problem)')
    parser.add_argument('-m',
                        '--mesh',
                        default='star.mesh',
                        action='store',
                        type=str,
                        help='Mesh file to use.')
    parser.add_argument('-vis',
                        '--visualization',
                        action='store_true',
                        help='Enable GLVis visualization')
    parser.add_argument(
        '-o',
        '--order',
        action='store',
        default=1,
Beispiel #10
0
      ex2p.py -m beam-tri.mesh -o 2 -sys   
      ex2p.py -m beam-quad.mesh -o 3 -elast
      ex2p.py -m beam-quad.mesh -o 3 -sc
'''
from mfem import path
from mfem.common.arg_parser import ArgParser
import mfem.par as mfem
from mpi4py import MPI
num_procs = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank

import sys
from os.path import expanduser, join
import numpy as np

parser = ArgParser(description='Ex2 (linear elastisity)')
parser.add_argument('-m',
                    '--mesh',
                    default='beam-tri.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument('-vis',
                    '--visualization',
                    action='store_true',
                    help='Enable GLVis visualization')
parser.add_argument(
    '-o',
    '--order',
    action='store',
    default=1,
Beispiel #11
0
      refinement loop. 
      See c++ version in the MFEM library for more detail 
'''
from mfem import path
from mfem.common.arg_parser import ArgParser
import mfem.ser as mfem
from mfem.ser import intArray
from os.path import expanduser, join
import numpy as np
from numpy import sqrt, pi, cos, sin, hypot, arctan2
from scipy.special import erfc

# Equation constant parameters.(using globals to share them with ex18_common)
import ex18_common

parser = ArgParser(description='Ex18')
parser.add_argument('-m',
                    '--mesh',
                    default='periodic-square.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument(
    '-p',
    '--problem',
    action='store',
    default=1,
    type=int,
    help='Problem setup to use. See options in velocity_function().')
parser.add_argument('-r',
                    '--refine',
Beispiel #12
0
      ex4p.py -m amr-hex.mesh -o 2 -hb
      ex4p.py -m star-surf.mesh -o 3 -hb
'''
from mfem import path
from mfem.common.arg_parser import ArgParser
import mfem.par as mfem
from mpi4py import MPI
num_procs = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank

import sys
from os.path import expanduser, join
import numpy as np
from numpy import sin, array, cos

parser = ArgParser(description='Ex4 ')
parser.add_argument('-m',
                    '--mesh',
                    default='star.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument('-o',
                    '--order',
                    action='store',
                    default=1,
                    type=int,
                    help="Finite element order (polynomial degree)")
parser.add_argument('-no-bc',
                    '--dont-impose-bc',
                    action='store_false',
Beispiel #13
0
      ex11p.py -m mobius-strip.mesh -n 8
      ex11p.py -m klein-bottle.mesh -n 10
'''
import sys
from os.path import expanduser, join
import numpy as np

from mfem import path
from mfem.common.arg_parser import ArgParser
import mfem.par as mfem
from mpi4py import MPI

num_procs = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank

parser = ArgParser(description='Ex2 (linear elastisity)')
parser.add_argument('-m',
                    '--mesh',
                    default='beam-tri.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument(
    '-rs',
    '--refine-serial',
    default=2,
    action='store',
    type=int,
    help="Number of times to refine the mesh uniformly in serial.")

parser.add_argument(
Beispiel #14
0
      ex8p.py -m star-surf.mesh -o 2
'''
import sys
from os.path import expanduser, join
import numpy as np
from numpy import sin, cos, exp, sqrt

from mfem.common.arg_parser import ArgParser

from mfem import path
import mfem.par as mfem
from mpi4py import MPI
num_procs = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank

parser = ArgParser(description='Ex8p')
parser.add_argument('-m',
                    '--mesh',
                    default='star.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument('-o',
                    '--order',
                    action='store',
                    default=1,
                    type=int,
                    help="Finite element order (polynomial degree)")
parser.add_argument('-vis',
                    '--visualization',
                    action='store_true',
Beispiel #15
0
from mfem import path

import mfem.par as mfem
from mfem.par import intArray, add_vector, Add
from os.path import expanduser, join
import numpy as np
from numpy import sqrt, pi, cos, sin, hypot, arctan2
from scipy.special import erfc

# 1. Initialize MPI.from mpi4py import MPI

from mpi4py import MPI
num_procs = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank

parser = ArgParser(description='Ex19p')
parser.add_argument('-m',
                    '--mesh',
                    default='beam-hex.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument(
    '-rs',
    '--refine-serial',
    action='store',
    default=0,
    type=int,
    help="Number of times to refine the mesh uniformly in serial")
parser.add_argument(
    '-rp',
Beispiel #16
0
'''

import sys
from mfem.common.arg_parser import ArgParser
from os.path import expanduser, join
import numpy as np
from numpy import cos, sin, pi, exp, sqrt, arctan
from mfem import path

import mfem.par as mfem
from mpi4py import MPI
num_procs = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank

parser = ArgParser(description='Ex15p')
parser.add_argument('-m',
                    '--mesh',
                    default='star-hilbert.mesh',
                    action='store',
                    type=str,
                    help='Mesh file to use.')
parser.add_argument(
    "-p",
    "--problem",
    action='store',
    default=0,
    type=int,
    help="Problem setup to use: 0 = spherical front, 1 = ball.")
parser.add_argument("-n",
                    "--nfeatures",
Beispiel #17
0
    names = [os.path.join(example_dir, x) for x in names]    
    names = [x for x in names if os.access(x, os.X_OK)]

    pairs = [(num, name) for num, name in zip(nums, names)]
    names = [name  for num, name in sorted(pairs)]

    return names

def print_help(self):
    print("python test.py -np -v")

if __name__=="__main__":
    script_path = sys.path[0]  # the location of this file
    
    from mfem.common.arg_parser import ArgParser
    parser = ArgParser(description='test')
    parser.add_argument('-np', default = 2,
                        action = 'store', type = int,
                    help='Number of processes for MPI')
    parser.add_argument('-verbose', 
                        action = 'store_true', default = False,
                        help='Verbose print out')
    parser.add_argument('-parallel', 
                        action = 'store_true', 
                        help='Test parallel version')
    parser.add_argument('-serial', 
                        action = 'store_true', 
                        help='Test serial version')
    parser.add_argument('-clean', 
                        action = 'store_true', default = False,
                        help='Test serial version')
Beispiel #18
0
    pairs = [(num, name) for num, name in zip(nums, names)]
    names = [name for num, name in sorted(pairs)]

    return names


def print_help(self):
    print("python test.py -np -v")


if __name__ == "__main__":
    script_path = sys.path[0]  # the location of this file

    from mfem.common.arg_parser import ArgParser
    parser = ArgParser(description='test')
    parser.add_argument('-np',
                        default=2,
                        action='store',
                        type=long,
                        help='Number of processes for MPI')
    parser.add_argument('-verbose',
                        action='store_true',
                        default=False,
                        help='Verbose print out')
    parser.add_argument('-parallel',
                        action='store',
                        default=True,
                        help='Test parallel version')
    parser.add_argument('-serial',
                        action='store',
Beispiel #19
0
class mfemSim(object):
    def __init__(self, desc=''):
        # 1. Object initialization
        self.desc = desc
        self.myId = MPI.COMM_WORLD.rank
        self.nProc = MPI.COMM_WORLD.size

    def __del__(self):
        # do nothing for now
        self.finalize()
        print('MFEM problem is deleted')

    # problem initialization
    def initialize(self, inMeshObj=None, inMeshFile=None):
        # 2. Problem initialization
        self.parser = ArgParser(description='Based on MFEM Ex16p')
        self.parser.add_argument('-m',
                                 '--mesh',
                                 default='beam-tet.mesh',
                                 action='store',
                                 type=str,
                                 help='Mesh file to use.')
        self.parser.add_argument('-rs',
                                 '--refine-serial',
                                 action='store',
                                 default=1,
                                 type=int,
                                 help="Number of times to refine the mesh \
                    uniformly in serial")
        self.parser.add_argument('-rp',
                                 '--refine-parallel',
                                 action='store',
                                 default=0,
                                 type=int,
                                 help="Number of times to refine the mesh \
            uniformly in parallel")
        self.parser.add_argument('-o',
                                 '--order',
                                 action='store',
                                 default=1,
                                 type=int,
                                 help="Finite element order (polynomial \
                    degree)")
        self.parser.add_argument(
            '-s',
            '--ode-solver',
            action='store',
            default=3,
            type=int,
            help='\n'.join([
                "ODE solver: 1 - Backward Euler, 2 - SDIRK2, \
              3 - SDIRK3", "\t\t 11 - Forward Euler, \
              12 - RK2, 13 - RK3 SSP, 14 - RK4."
            ]))
        self.parser.add_argument('-t',
                                 '--t-final',
                                 action='store',
                                 default=20.,
                                 type=float,
                                 help="Final time; start time is 0.")
        self.parser.add_argument("-dt",
                                 "--time-step",
                                 action='store',
                                 default=5e-3,
                                 type=float,
                                 help="Time step.")
        self.parser.add_argument("-v",
                                 "--viscosity",
                                 action='store',
                                 default=0.00,
                                 type=float,
                                 help="Viscosity coefficient.")
        self.parser.add_argument('-L',
                                 '--lmbda',
                                 action='store',
                                 default=1.e0,
                                 type=float,
                                 help='Lambda of Hooks law')
        self.parser.add_argument('-mu',
                                 '--shear-modulus',
                                 action='store',
                                 default=1.e0,
                                 type=float,
                                 help='Shear modulus for Hooks law')
        self.parser.add_argument('-rho',
                                 '--density',
                                 action='store',
                                 default=1.0,
                                 type=float,
                                 help='mass density')
        self.parser.add_argument('-vis',
                                 '--visualization',
                                 action='store_true',
                                 help='Enable GLVis visualization')
        self.parser.add_argument('-vs',
                                 '--visualization-steps',
                                 action='store',
                                 default=25,
                                 type=int,
                                 help="Visualize every n-th timestep.")
        args = self.parser.parse_args()
        self.ser_ref_levels = args.refine_serial
        self.par_ref_levels = args.refine_parallel
        self.order = args.order
        self.dt = args.time_step
        self.visc = args.viscosity
        self.t_final = args.t_final
        self.lmbda = args.lmbda
        self.mu = args.shear_modulus
        self.rho = args.density
        self.visualization = args.visualization
        self.ti = 1
        self.vis_steps = args.visualization_steps
        self.ode_solver_type = args.ode_solver
        self.t = 0.0
        self.last_step = False
        if self.myId == 0: self.parser.print_options(args)

        # 3. Reading mesh
        if inMeshObj is None:
            self.meshFile = inMeshFile
            if self.meshFile is None:
                self.meshFile = args.mesh
            self.mesh = mfem.Mesh(self.meshFile, 1, 1)
        else:
            self.mesh = inMeshObj
        self.dim = self.mesh.Dimension()
        print("Mesh dimension: %d" % self.dim)
        print("Number of vertices in the mesh: %d " % self.mesh.GetNV())
        print("Number of elements in the mesh: %d " % self.mesh.GetNE())

        # 4. Define the ODE solver used for time integration.
        #    Several implicit singly diagonal implicit
        #    Runge-Kutta (SDIRK) methods, as well as
        #    explicit Runge-Kutta methods are available.
        if self.ode_solver_type == 1:
            self.ode_solver = BackwardEulerSolver()
        elif self.ode_solver_type == 2:
            self.ode_solver = mfem.SDIRK23Solver(2)
        elif self.ode_solver_type == 3:
            self.ode_solver = mfem.SDIRK33Solver()
        elif self.ode_solver_type == 11:
            self.ode_solver = ForwardEulerSolver()
        elif self.ode_solver_type == 12:
            self.ode_solver = mfem.RK2Solver(0.5)
        elif self.ode_solver_type == 13:
            self.ode_solver = mfem.RK3SSPSolver()
        elif self.ode_solver_type == 14:
            self.ode_solver = mfem.RK4Solver()
        elif self.ode_solver_type == 22:
            self.ode_solver = mfem.ImplicitMidpointSolver()
        elif self.ode_solver_type == 23:
            self.ode_solver = mfem.SDIRK23Solver()
        elif self.ode_solver_type == 24:
            self.ode_solver = mfem.SDIRK34Solver()
        else:
            print("Unknown ODE solver type: " + str(self.ode_solver_type))
            exit

        # 5. Refine the mesh in serial to increase the
        #    resolution. In this example we do
        #    'ser_ref_levels' of uniform refinement, where
        #    'ser_ref_levels' is a command-line parameter.
        for lev in range(self.ser_ref_levels):
            self.mesh.UniformRefinement()

        # 6. Define a parallel mesh by a partitioning of
        #    the serial mesh. Refine this mesh further
        #    in parallel to increase the resolution. Once the
        #    parallel mesh is defined, the serial mesh can
        #    be deleted.
        self.pmesh = mfem.ParMesh(MPI.COMM_WORLD, self.mesh)
        for lev in range(self.par_ref_levels):
            self.pmesh.UniformRefinement()

        # 7. Define the vector finite element space
        #    representing the current and the
        #    initial temperature, u_ref.
        self.fe_coll = mfem.H1_FECollection(self.order, self.dim)
        self.fespace = mfem.ParFiniteElementSpace(self.pmesh, self.fe_coll,
                                                  self.dim)
        self.fe_size = self.fespace.GlobalTrueVSize()
        if self.myId == 0:
            print("FE Number of unknowns: " + str(self.fe_size))
        true_size = self.fespace.TrueVSize()
        self.true_offset = mfem.intArray(3)
        self.true_offset[0] = 0
        self.true_offset[1] = true_size
        self.true_offset[2] = 2 * true_size
        self.vx = mfem.BlockVector(self.true_offset)
        self.v_gf = mfem.ParGridFunction(self.fespace)
        self.v_gfbnd = mfem.ParGridFunction(self.fespace)
        self.x_gf = mfem.ParGridFunction(self.fespace)
        self.x_gfbnd = mfem.ParGridFunction(self.fespace)
        self.x_ref = mfem.ParGridFunction(self.fespace)
        self.pmesh.GetNodes(self.x_ref)

        # 8. Set the initial conditions for u.
        #self.velo = InitialVelocity(self.dim)
        self.velo = velBCs(self.dim)
        #self.deform =  InitialDeformation(self.dim)
        self.deform = defBCs(self.dim)
        self.v_gf.ProjectCoefficient(self.velo)
        self.v_gfbnd.ProjectCoefficient(self.velo)
        self.x_gf.ProjectCoefficient(self.deform)
        self.x_gfbnd.ProjectCoefficient(self.deform)
        #self.v_gf.GetTrueDofs(self.vx.GetBlock(0));
        #self.x_gf.GetTrueDofs(self.vx.GetBlock(1));

        # setup boundary-conditions
        self.xess_bdr = mfem.intArray(
            self.fespace.GetMesh().bdr_attributes.Max())
        self.xess_bdr.Assign(0)
        self.xess_bdr[0] = 1
        self.xess_bdr[1] = 1
        self.xess_tdof_list = intArray()
        self.fespace.GetEssentialTrueDofs(self.xess_bdr, self.xess_tdof_list)
        #print('True x essential BCs are')
        #self.xess_tdof_list.Print()

        self.vess_bdr = mfem.intArray(
            self.fespace.GetMesh().bdr_attributes.Max())
        self.vess_bdr.Assign(0)
        self.vess_bdr[0] = 1
        self.vess_bdr[1] = 1
        self.vess_tdof_list = intArray()
        self.fespace.GetEssentialTrueDofs(self.vess_bdr, self.vess_tdof_list)
        #print('True v essential BCs are')
        #self.vess_tdof_list.Print()

        # 9. Initialize the stiffness operator
        self.oper = StiffnessOperator(self.fespace, self.lmbda, self.mu,
                                      self.rho, self.visc, self.vess_tdof_list,
                                      self.vess_bdr, self.xess_tdof_list,
                                      self.xess_bdr, self.v_gfbnd,
                                      self.x_gfbnd, self.deform, self.velo,
                                      self.vx)

        # 10. Setting up file output
        self.smyid = '{:0>2d}'.format(self.myId)

        # initializing ode solver
        self.ode_solver.Init(self.oper)

    # stepping in time
    def step(self, nStep):
        # initialization
        self.last_step = False
        tFinal = self.t + self.dt * nStep
        if (self.t + self.dt >= tFinal - self.dt / 2):
            self.last_step = True
        # loop for time stepping
        while not self.last_step:
            if (self.t + self.dt >= tFinal - self.dt / 2):
                self.last_step = True
            # update BCs
            self.deform.SetTime(self.t)
            self.velo.SetTime(self.t)
            # step in time
            self.t, self.dt = self.ode_solver.Step(self.vx, self.t, self.dt)
            # writing to output
            if (self.last_step or (self.ti % self.vis_steps) == 0):
                if self.myId == 0:
                    print("Running step " + str(self.ti) + ", t = " +
                          str(self.t))
                self.oper.SetBCs()
                self.v_gf.Distribute(self.vx.GetBlock(0))
                self.x_gf.Distribute(self.vx.GetBlock(1))
                self.solToFile()
            # preparing for the next time step
            self.ti = self.ti + 1
            self.oper.SetBCs()

    # sets up simulation agent after a major update
    # such as mass matrix or stiffness matrix
    def postUpdate(self):
        self.oper.RecoverSln(self.v_gf, self.x_gf)

    # finalize the simulation
    def finalize(self):
        print('mfem simulation is finalizing')

    # writes solution to file
    def solToFile(self):
        # print mesh to vtk format
        sol_name   =  "fe-sol-" + self.smyid \
        + '-' + str(self.ti).zfill(6) + '.vtu'
        #sol_name   =  "fe-sol-" + self.smyid \
        #+ '-' + str(self.ti).zfill(6)
        #self.vtkStream = open(sol_name+'.vtk', 'w')
        #self.pmesh.PrintVTK(self.vtkStream, 1, 1)
        fieldName = 'V'
        #self.v_gf.SaveVTK(self.vtkStream, str(fieldName), 1)
        fieldName = 'U'
        #self.x_gf.SaveVTK(self.vtkStream, str(fieldName), 1)
        #self.vtkStream.close()
        meshToVtu(self.pmesh, sol_name, (self.v_gf, self.x_gf), ('V', 'U'))

    # get solution vector
    def getSolVec(self, name):
        ret = []
        name = name.lower()
        if name == 'displacement':
            sz = self.vx.GetBlock(1).Size()
            ret = np.zeros(sz, np.double)
            for i in range(sz):
                ret[i] = self.vx.GetBlock(1)[i]
        elif name == 'velocity':
            sz = self.vx.GetBlock(0).Size()
            ret = np.zeros(sz, np.double)
            for i in range(sz):
                ret[i] = self.vx.GetBlock(0)[i]
        else:
            raise ValueError('Requested solution is invalid.')
        return (ret)