def test_2DmultiRegion(verbose=0):
"""Test for loading gmsh mesh through PUMI with multiple-regions"""
testDir = os.path.dirname(os.path.abspath(__file__))
Model = testDir + '/TwoQuads.dmg'
Mesh = testDir + '/TwoQuads.smb'
domain = Domain.PUMIDomain(
dim=2, manager=MeshAdapt.AdaptManager()) #initialize the domain
domain.AdaptManager.reconstructedFlag = 0 #this is used to indicate that no mesh reconstruction is being done.
domain.AdaptManager.PUMIAdapter.loadModelAndMesh(bytes(Model, 'utf-8'),
bytes(Mesh, 'utf-8'))
domain.faceList = [[14], [12], [11], [13], [15], [16]]
domain.boundaryLabels = [1, 2, 3, 4, 5, 6]
domain.regList = [[41], [42]]
mesh = MeshTools.TriangularMesh()
mesh.cmesh = cmeshTools.CMesh()
comm = Comm.init()
mesh.convertFromPUMI(domain,
domain.AdaptManager.PUMIAdapter,
domain.faceList,
domain.regList,
parallel=comm.size() > 1,
dim=domain.nd)
ok(mesh.elementMaterialTypes[0] == 1)
ok(mesh.elementMaterialTypes[-1] == 2)
def init_mpi_petsc(opts):
log("Initializing MPI")
if opts.petscOptions != None:
petsc_argv = sys.argv[:1]+opts.petscOptions.split()
log("PETSc options from commandline")
log(str(petsc_argv))
else:
petsc_argv=sys.argv[:1]
if opts.petscOptionsFile != None:
petsc_argv=[sys.argv[0]]
petsc_argv += open(opts.petscOptionsFile).read().split()
log("PETSc options from commandline")
log(str(petsc_argv))
return Comm.init(argv=petsc_argv)
def init_mpi_petsc(opts, log):
log("Initializing MPI")
if opts.petscOptions != None:
petsc_argv = sys.argv[:1]+opts.petscOptions.split()
log("PETSc options from commandline")
log(str(petsc_argv))
else:
petsc_argv=sys.argv[:1]
if opts.petscOptionsFile != None:
petsc_argv=[sys.argv[0]]
petsc_argv += open(opts.petscOptionsFile).read().split()
log("PETSc options from commandline")
log(str(petsc_argv))
return Comm.init(argv=petsc_argv)
def test_parallelLoadPUMI(verbose=0):
"""Test to load parallel PUMI model and mesh"""
comm = Comm.init()
eq(comm.size(),2)
testDir=os.path.dirname(os.path.abspath(__file__))
domain = Domain.PUMIDomain()
Model=testDir+ '/Prism.dmg'
Mesh=testDir + '/Prism.smb'
domain.PUMIMesh=MeshAdaptPUMI.MeshAdaptPUMI()
domain.PUMIMesh.loadModelAndMesh(Model, Mesh)
mesh = MeshTools.TetrahedralMesh()
mesh.cmesh = cmeshTools.CMesh()
mesh.convertFromPUMI(domain.PUMIMesh, domain.faceList, parallel = comm.size() > 1, dim = domain.nd)
eq(mesh.nElements_global,8148)
eq(mesh.nNodes_global,1880)
eq(mesh.nEdges_global,11001)
eq(mesh.nElementBoundaries_global,17270)
def test_3DparallelLoadPUMI(verbose=0):
"""Test to load 3D parallel PUMI model and mesh"""
comm = Comm.init()
eq(comm.size(),2)
testDir=os.path.dirname(os.path.abspath(__file__))
domain = Domain.PUMIDomain()
Model=testDir+ '/Prism.dmg'
Mesh=testDir + '/Prism.smb'
domain.PUMIMesh=MeshAdaptPUMI.MeshAdaptPUMI()
domain.PUMIMesh.loadModelAndMesh(Model, Mesh)
mesh = MeshTools.TetrahedralMesh()
mesh.cmesh = cmeshTools.CMesh()
mesh.convertFromPUMI(domain.PUMIMesh, domain.faceList, domain.regList,parallel = comm.size() > 1, dim = domain.nd)
eq(mesh.nElements_global,8148)
eq(mesh.nNodes_global,1880)
eq(mesh.nEdges_global,11001)
eq(mesh.nElementBoundaries_global,17270)
def test_2DparallelLoadPUMI(verbose=0):
"""Test to load 2D parallel PUMI model and mesh"""
comm = Comm.init()
eq(comm.size(),2)
testDir=os.path.dirname(os.path.abspath(__file__))
domain = Domain.PUMIDomain(dim=2)
Model=testDir+ '/Rectangle.dmg'
Mesh=testDir + '/Rectangle.smb'
domain.PUMIMesh=MeshAdaptPUMI.MeshAdaptPUMI()
domain.PUMIMesh.loadModelAndMesh(Model, Mesh)
mesh = MeshTools.TriangularMesh()
mesh.cmesh = cmeshTools.CMesh()
mesh.convertFromPUMI(domain.PUMIMesh, domain.faceList, domain.regList,parallel = comm.size() > 1, dim = domain.nd)
eq(mesh.nElements_global,8)
eq(mesh.nNodes_global,10)
eq(mesh.nEdges_global,17)
eq(mesh.nElementBoundaries_global,17)
def test_2DmultiRegion(verbose=0):
"""Test for loading gmsh mesh through PUMI with multiple-regions"""
testDir=os.path.dirname(os.path.abspath(__file__))
Model=testDir + '/TwoQuads.dmg'
Mesh=testDir + '/TwoQuads.smb'
domain = Domain.PUMIDomain(dim=2) #initialize the domain
domain.PUMIMesh=MeshAdaptPUMI.MeshAdaptPUMI()
domain.PUMIMesh.loadModelAndMesh(Model, Mesh)
domain.faceList=[[14],[12],[11],[13],[15],[16]]
domain.regList=[[41],[42]]
mesh = MeshTools.TriangularMesh()
mesh.cmesh = cmeshTools.CMesh()
comm = Comm.init()
mesh.convertFromPUMI(domain.PUMIMesh, domain.faceList,domain.regList, parallel = comm.size() > 1, dim = domain.nd)
ok(mesh.elementMaterialTypes[0]==1)
ok(mesh.elementMaterialTypes[-1]==2)
def test_wdot():
"""
test_wdot
Verifies that the proteus.LinearAlgebraTools.wdot computes dot product correctly.
"""
import numpy as np
import numpy.testing as npt
from proteus.LinearAlgebraTools import wDot
from proteus import Comm
comm = Comm.init()
x = np.array([-1, 2, 3])
y = np.array([5, 6, 10])
h = np.array([0.5, 1.2, 6.0])
t1 = 191.9
t2 = wDot(x, y, h)
test = npt.assert_almost_equal
test.description = 'test_wdot'
assert t1 == approx(t2)
def test_wdot():
"""
test_wdot
Verifies that the proteus.LinearAlgebraTools.wdot computes dot product correctly.
"""
import numpy as np
import numpy.testing as npt
from proteus.LinearAlgebraTools import wDot
from proteus import Comm
comm = Comm.init()
x = np.array([-1, 2, 3])
y = np.array([5, 6, 10])
h = np.array([0.5, 1.2, 6.0])
t1 = 191.9
t2 = wDot(x, y, h)
test = npt.assert_almost_equal
test.description = 'test_wdot'
assert t1 == approx(t2)
def test_2DparallelLoadPUMI(verbose=0):
"""Test to load 2D parallel PUMI model and mesh"""
comm = Comm.init()
eq(comm.size(), 2)
testDir = os.path.dirname(os.path.abspath(__file__))
domain = Domain.PUMIDomain(dim=2)
Model = testDir + '/Rectangle.dmg'
Mesh = testDir + '/Rectangle.smb'
domain.PUMIMesh = MeshAdaptPUMI.MeshAdaptPUMI()
domain.PUMIMesh.loadModelAndMesh(Model, Mesh)
mesh = MeshTools.TriangularMesh()
mesh.cmesh = cmeshTools.CMesh()
mesh.convertFromPUMI(domain.PUMIMesh,
domain.faceList,
domain.regList,
parallel=comm.size() > 1,
dim=domain.nd)
eq(mesh.nElements_global, 8)
eq(mesh.nNodes_global, 10)
eq(mesh.nEdges_global, 17)
eq(mesh.nElementBoundaries_global, 17)
def test_2DmultiRegion(verbose=0):
"""Test for loading gmsh mesh through PUMI with multiple-regions"""
testDir = os.path.dirname(os.path.abspath(__file__))
Model = testDir + '/TwoQuads.dmg'
Mesh = testDir + '/TwoQuads.smb'
domain = Domain.PUMIDomain(dim=2) #initialize the domain
domain.PUMIMesh = MeshAdaptPUMI.MeshAdaptPUMI()
domain.PUMIMesh.loadModelAndMesh(Model, Mesh)
domain.faceList = [[14], [12], [11], [13], [15], [16]]
domain.regList = [[41], [42]]
mesh = MeshTools.TriangularMesh()
mesh.cmesh = cmeshTools.CMesh()
comm = Comm.init()
mesh.convertFromPUMI(domain.PUMIMesh,
domain.faceList,
domain.regList,
parallel=comm.size() > 1,
dim=domain.nd)
ok(mesh.elementMaterialTypes[0] == 1)
ok(mesh.elementMaterialTypes[-1] == 2)
def test_poiseuilleError(verbose=0):
"""Test for loading gmsh mesh through PUMI, estimating error for
a Poiseuille flow case. The estimated error should be larger than the
exact error in the seminorm"""
testDir = os.path.dirname(os.path.abspath(__file__))
Model = testDir + '/Couette.null'
Mesh = testDir + '/Couette.msh'
domain = Domain.PUMIDomain() #initialize the domain
domain.PUMIMesh = MeshAdaptPUMI.MeshAdaptPUMI(hmax=0.01,
hmin=0.008,
numIter=1,
sfConfig='ERM',
maType='isotropic',
logType='off')
domain.PUMIMesh.loadModelAndMesh(Model, Mesh)
domain.faceList = [[80], [76], [42], [24], [82], [78]]
mesh = MeshTools.TetrahedralMesh()
mesh.cmesh = cmeshTools.CMesh()
comm = Comm.init()
nElements_initial = mesh.nElements_global
mesh.convertFromPUMI(domain.PUMIMesh,
domain.faceList,
domain.regList,
parallel=comm.size() > 1,
dim=domain.nd)
domain.PUMIMesh.transferFieldToPUMI("coordinates", mesh.nodeArray)
rho = numpy.array([998.2, 998.2])
nu = numpy.array([1.004e-6, 1.004e-6])
g = numpy.asarray([0.0, 0.0, 0.0])
deltaT = 1.0 #dummy number
domain.PUMIMesh.transferPropertiesToPUMI(rho, nu, g, deltaT)
#Poiseuille Flow
Ly = 0.2
Lz = 0.05
Re = 100
Umax = Re * nu[0] / Lz
def vOfX(x):
return 4 * Umax / (Lz**2) * (x[2]) * (Lz - x[2])
def dvOfXdz(x):
return 4 * Umax / (Lz**2) * (Lz - 2 * x[2])
#hard code solution
vector = numpy.zeros((mesh.nNodes_global, 3), 'd')
dummy = numpy.zeros(mesh.nNodes_global)
vector[:, 0] = dummy
vector[:, 1] = 4 * Umax / (Lz**2) * (mesh.nodeArray[:, 2]) * (
Lz - mesh.nodeArray[:, 2]) #v-velocity
vector[:, 2] = dummy
domain.PUMIMesh.transferFieldToPUMI("velocity", vector)
scalar = numpy.zeros((mesh.nNodes_global, 1), 'd')
domain.PUMIMesh.transferFieldToPUMI("p", scalar)
scalar[:, 0] = mesh.nodeArray[:, 2]
domain.PUMIMesh.transferFieldToPUMI("phi", scalar)
del scalar
scalar = numpy.zeros((mesh.nNodes_global, 1), 'd') + 1.0
domain.PUMIMesh.transferFieldToPUMI("vof", scalar)
errorTotal = domain.PUMIMesh.get_local_error()
# load the femspace with linear basis and get the quadrature points on a reference element
elementQuadrature = Quadrature.SimplexGaussQuadrature(domain.nd, 3)
ok(mesh.nNodes_element == 4) #confirm all of the elements have 4 nodes
#hard code computation for H1 seminorm; ideally will be reformatted using the classes within proteus
derivativeArrayRef = [[1, 0, 0], [0, 1, 0], [0, 0, 1], [-1, -1, -1]]
error = 0
for eID in range(mesh.nElements_global):
nodes = mesh.elementNodesArray[eID]
coords = []
for i in range(mesh.nNodes_element):
coords.append(mesh.nodeArray[nodes[i]])
J = numpy.matrix([[
coords[0][0] - coords[3][0], coords[1][0] - coords[3][0],
coords[2][0] - coords[3][0]
],
[
coords[0][1] - coords[3][1],
coords[1][1] - coords[3][1],
coords[2][1] - coords[3][1]
],
[
coords[0][2] - coords[3][2],
coords[1][2] - coords[3][2],
coords[2][2] - coords[3][2]
]])
invJ = J.I
detJ = numpy.linalg.det(J)
gradPhi_h = 0
for k in range(len(elementQuadrature.points)):
tempQpt = 0
zCoord = elementQuadrature.points[k][0]*coords[0][2] \
+elementQuadrature.points[k][1]*coords[1][2] \
+elementQuadrature.points[k][2]*coords[2][2] \
+(1-elementQuadrature.points[k][0]-elementQuadrature.points[k][1]-elementQuadrature.points[k][2])*coords[3][2]
for i in range(mesh.nNodes_element):
temp = 0
for j in range(domain.nd):
temp = temp + derivativeArrayRef[i][j] * invJ[j, 2]
tempQpt = tempQpt + vector[nodes[i]][1] * temp
exactgradPhi = dvOfXdz([0, 0, zCoord])
gradPhi_h = gradPhi_h + tempQpt
error = error + (exactgradPhi - gradPhi_h
)**2 * elementQuadrature.weights[k] * abs(detJ)
error = sqrt(error)
ok(error < errorTotal)
ns = NumericalSolution.NS_base(so,pList,nList,so.sList,opts)
ns.calculateSolution('poisson_2d_c0p1')
#test load vector calculation in a crude way
#see if sum over test functions of residual is same as the sum over the test functions of the load vector
#should be if have strong bc's and no other terms in residual besides stiffness and load
#transport model on the final grid
finest_model = ns.modelList[0].levelModelList[-1]
#cheating a little bit to get the global test space dimension from the global trial space
nr = finest_model.u[0].femSpace.dim
import numpy as np
r = np.zeros((nr,),'d')
f = np.zeros((nr,),'d')
utmp = np.zeros((nr,),'d')
finest_model.getResidual(utmp,r)
finest_model.getLoadVector(f)
return r,f
def test_load_vector():
for name,use_num_flux in zip(['Strong_Dir','Weak_Dir'],[False,True]):
r,f = compute_load_vector(use_num_flux)
test = npt.assert_almost_equal
test.descrption = 'test_load_vector_{}'.format(name)
yield test,r,f
if __name__ == '__main__':
from proteus import Comm
comm = Comm.init()
import nose
nose.main()
def test_2DgmshLoadAndAdapt(verbose=0):
"""Test for loading gmsh mesh through PUMI, estimating error and adapting for
a 2D Couette flow case"""
testDir=os.path.dirname(os.path.abspath(__file__))
Model=testDir + '/Couette2D.null'
Mesh=testDir + '/Couette2D.msh'
domain = Domain.PUMIDomain(dim=2) #initialize the domain
domain.PUMIMesh=MeshAdaptPUMI.MeshAdaptPUMI(hmax=0.01, hmin=0.008, numIter=1,sfConfig=b'ERM',maType=b'isotropic',targetError=1)
domain.PUMIMesh.loadModelAndMesh(bytes(Model,'utf-8'), bytes(Mesh,'utf-8'))
domain.faceList=[[14],[12],[11],[13]]
domain.boundaryLabels=[1,2,3,4]
mesh = MeshTools.TriangularMesh()
mesh.cmesh = cmeshTools.CMesh()
comm = Comm.init()
nElements_initial = mesh.nElements_global
mesh.convertFromPUMI(domain,domain.PUMIMesh, domain.faceList,domain.regList, parallel = comm.size() > 1, dim = domain.nd)
domain.PUMIMesh.transferFieldToPUMI(b"coordinates",mesh.nodeArray)
rho = numpy.array([998.2,998.2])
nu = numpy.array([1.004e-6, 1.004e-6])
g = numpy.asarray([0.0,0.0])
deltaT = 1.0 #dummy number
epsFact = 1.0 #dummy number
domain.PUMIMesh.transferPropertiesToPUMI(rho,nu,g,deltaT,epsFact)
#Couette Flow
Lz = 0.05
Uinf = 2e-3
#hard code solution
vector=numpy.zeros((mesh.nNodes_global,3),'d')
dummy = numpy.zeros(mesh.nNodes_global);
vector[:,0] = Uinf*mesh.nodeArray[:,1]/Lz #v-velocity
vector[:,1] = dummy
vector[:,2] = dummy
domain.PUMIMesh.transferFieldToPUMI(b"velocity", vector)
del vector
del dummy
scalar=numpy.zeros((mesh.nNodes_global,1),'d')
domain.PUMIMesh.transferFieldToPUMI(b"p", scalar)
scalar[:,0] = mesh.nodeArray[:,1]
domain.PUMIMesh.transferFieldToPUMI(b"phi", scalar)
del scalar
scalar = numpy.zeros((mesh.nNodes_global,1),'d')+1.0
domain.PUMIMesh.transferFieldToPUMI(b"vof", scalar)
errorTotal=domain.PUMIMesh.get_local_error()
ok(errorTotal<1e-14)
#ok(domain.PUMIMesh.willAdapt(),1)
domain.PUMIMesh.adaptPUMIMesh()
mesh = MeshTools.TriangularMesh()
mesh.convertFromPUMI(domain,domain.PUMIMesh,
domain.faceList,
domain.regList,
parallel = comm.size() > 1,
dim = domain.nd)
nElements_final = mesh.nElements_global
ok(nElements_final>nElements_initial)
petsc_argv = [sys.argv[0]]
with open(opts.petscOptionsFile) as petsc_file:
data = petsc_file.readlines()
def strip_comments(line):
if '#' in line:
line = line[:line.index('#')]
return line
stripped_data = [strip_comments(line) for line in data]
petsc_argv += '\n'.join(stripped_data).split()
log("PETSc options from commandline")
log(str(petsc_argv))
Comm.argv = petsc_argv
comm = Comm.init()
Profiling.procID = comm.rank()
if opts.logLevel > 0:
#mwf looks like just gets .py.log if no sso file given
#Profiling.openLog(args[0][-3:]+".log",opts.logLevel)
if len(args) == 0:
Profiling.openLog("proteus.log", opts.logLevel)
elif len(args[0].split(' ')) == 1:
Profiling.openLog(args[0].split('.')[0] + ".log", opts.logLevel)
else:
Profiling.openLog(args[0][-3:] + ".log", opts.logLevel)
if opts.logAllProcesses:
Profiling.logAllProcesses = True
#blanket import statements can go below here now that petsc4py should be initialized
from proteus import *
def test_gmshLoadAndAdapt(verbose=0):
"""Test for loading gmsh mesh through PUMI, estimating error and adapting for
a Couette flow case"""
testDir = os.path.dirname(os.path.abspath(__file__))
Model = testDir + '/Couette.null'
Mesh = testDir + '/Couette.msh'
domain = Domain.PUMIDomain() #initialize the domain
domain.PUMIMesh = MeshAdaptPUMI.MeshAdaptPUMI(hmax=0.01,
hmin=0.008,
numIter=1,
sfConfig='ERM',
maType='isotropic')
domain.PUMIMesh.loadModelAndMesh(Model, Mesh)
domain.faceList = [[80], [76], [42], [24], [82], [78]]
mesh = MeshTools.TetrahedralMesh()
mesh.cmesh = cmeshTools.CMesh()
comm = Comm.init()
nElements_initial = mesh.nElements_global
mesh.convertFromPUMI(domain.PUMIMesh,
domain.faceList,
parallel=comm.size() > 1,
dim=domain.nd)
domain.PUMIMesh.transferFieldToPUMI("coordinates", mesh.nodeArray)
rho = numpy.array([998.2, 998.2])
nu = numpy.array([1.004e-6, 1.004e-6])
g = numpy.asarray([0.0, 0.0, 0.0])
domain.PUMIMesh.transferPropertiesToPUMI(rho, nu, g)
#Couette Flow
Lz = 0.05
Uinf = 2e-3
#hard code solution
vector = numpy.zeros((mesh.nNodes_global, 3), 'd')
dummy = numpy.zeros(mesh.nNodes_global)
vector[:, 0] = dummy
vector[:, 1] = Uinf * mesh.nodeArray[:, 2] / Lz #v-velocity
vector[:, 2] = dummy
domain.PUMIMesh.transferFieldToPUMI("velocity", vector)
del vector
del dummy
scalar = numpy.zeros((mesh.nNodes_global, 1), 'd')
domain.PUMIMesh.transferFieldToPUMI("p", scalar)
scalar[:, 0] = mesh.nodeArray[:, 2]
domain.PUMIMesh.transferFieldToPUMI("phi", scalar)
del scalar
scalar = numpy.zeros((mesh.nNodes_global, 1), 'd') + 1.0
domain.PUMIMesh.transferFieldToPUMI("vof", scalar)
errorTotal = domain.PUMIMesh.get_local_error()
ok(errorTotal < 1e-14)
ok(domain.PUMIMesh.willAdapt(), 1)
domain.PUMIMesh.adaptPUMIMesh()
mesh = MeshTools.TetrahedralMesh()
mesh.convertFromPUMI(domain.PUMIMesh,
domain.faceList,
parallel=comm.size() > 1,
dim=domain.nd)
nElements_final = mesh.nElements_global
ok(nElements_final > nElements_initial)
"""
convenience script to generate xdmf and vtk output from tetgen files
"""
from proteus import Comm
Comm.init()
comm = Comm.get()
def refine_uniform_from_tetgen(filebase,refinementLevels,index_base=0,EB=False):
from proteus import MeshTools,Archiver
mesh = MeshTools.TetrahedralMesh()
mesh.generateFromTetgenFiles(filebase,index_base,skipGeometricInit=False)
MLMesh = MeshTools.MultilevelTetrahedralMesh(0,0,0,skipInit=True)
MLMesh.generateFromExistingCoarseMesh(mesh,refinementLevels)
MLMesh.meshList[-1].writeTetgenFiles(filebase+'_out',index_base)
ar = Archiver.XdmfArchive('.',filebase+'_out')
import xml.etree.ElementTree as ElementTree
ar.domain = ElementTree.SubElement(ar.tree.getroot(),"Domain")
mesh.writeMeshXdmf(ar,'mesh_coarse'+'_out',init=True,EB=EB,tCount=0)
MLMesh.meshList[-1].writeMeshXdmf(ar,'mesh_fine'+'_out',init=True,EB=EB,tCount=1)
ar.close()
def refine_uniform_from_triangle(filebase,refinementLevels,index_base=0,EB=False):
from proteus import MeshTools,Archiver
mesh = MeshTools.TriangularMesh()
mesh.generateFromTriangleFiles(filebase,index_base)
MLMesh = MeshTools.MultilevelTriangularMesh(0,0,0,skipInit=True)
def test_gmshLoadAndAdapt(verbose=0):
"""Test for loading gmsh mesh through PUMI, estimating error and adapting for
a Couette flow case"""
testDir = os.path.dirname(os.path.abspath(__file__))
Model = testDir + '/Couette.null'
Mesh = testDir + '/Couette.msh'
domain = Domain.PUMIDomain(
manager=MeshAdapt.AdaptManager()) #initialize the domain
domain.AdaptManager.modelDict = {'flow': 0}
domain.AdaptManager.sizeInputs = [b'error_erm']
domain.AdaptManager.adapt = 1
domain.AdaptManager.hmax = 0.01
domain.AdaptManager.hmin = 0.008
domain.AdaptManager.hphi = 0.008
domain.AdaptManager.numIterations = 1
domain.AdaptManager.targetError = 1
domain.AdaptManager.PUMIAdapter.loadModelAndMesh(bytes(Model, 'utf-8'),
bytes(Mesh, 'utf-8'))
domain.AdaptManager.PUMIAdapter.setAdaptProperties(domain.AdaptManager)
domain.faceList = [[80], [76], [42], [24], [82], [78]]
domain.boundaryLabels = [1, 2, 3, 4, 5, 6]
mesh = MeshTools.TetrahedralMesh()
mesh.cmesh = cmeshTools.CMesh()
comm = Comm.init()
nElements_initial = mesh.nElements_global
mesh.convertFromPUMI(domain,
domain.AdaptManager.PUMIAdapter,
domain.faceList,
domain.regList,
parallel=comm.size() > 1,
dim=domain.nd)
domain.AdaptManager.PUMIAdapter.transferFieldToPUMI(
b"coordinates", mesh.nodeArray)
rho = numpy.array([998.2, 998.2])
nu = numpy.array([1.004e-6, 1.004e-6])
g = numpy.asarray([0.0, 0.0, 0.0])
deltaT = 1.0 #dummy number
epsFact = 1.0 #dummy number
domain.AdaptManager.PUMIAdapter.transferPropertiesToPUMI(
rho, nu, g, deltaT, deltaT, deltaT, epsFact)
#Couette Flow
Lz = 0.05
Uinf = 2e-3
#hard code solution
vector = numpy.zeros((mesh.nNodes_global, 3), 'd')
dummy = numpy.zeros(mesh.nNodes_global)
vector[:, 0] = dummy
vector[:, 1] = Uinf * mesh.nodeArray[:, 2] / Lz #v-velocity
vector[:, 2] = dummy
domain.AdaptManager.PUMIAdapter.transferFieldToPUMI(b"velocity", vector)
del vector
del dummy
scalar = numpy.zeros((mesh.nNodes_global, 1), 'd')
domain.AdaptManager.PUMIAdapter.transferFieldToPUMI(b"p", scalar)
scalar[:, 0] = mesh.nodeArray[:, 2]
domain.AdaptManager.PUMIAdapter.transferFieldToPUMI(b"phi", scalar)
del scalar
scalar = numpy.zeros((mesh.nNodes_global, 1), 'd') + 1.0
domain.AdaptManager.PUMIAdapter.transferFieldToPUMI(b"vof", scalar)
errorTotal = domain.AdaptManager.PUMIAdapter.get_local_error()
ok(errorTotal < 1e-14)
#ok(domain.AdaptManager.willAdapt(),1)
domain.AdaptManager.PUMIAdapter.adaptPUMIMesh(b"")
mesh = MeshTools.TetrahedralMesh()
mesh.convertFromPUMI(domain,
domain.AdaptManager.PUMIAdapter,
domain.faceList,
domain.regList,
parallel=comm.size() > 1,
dim=domain.nd)
nElements_final = mesh.nElements_global
ok(nElements_final > nElements_initial)
log = Profiling.logEvent
log("Initializing MPI")#this won't show up unless logAllProcesses=True because we don't know our procID yet
if opts.petscOptions != None:
petsc_argv = sys.argv[:1]+opts.petscOptions.split()
log("PETSc options from commandline")
log(str(petsc_argv))
else:
petsc_argv=sys.argv[:1]
if opts.petscOptionsFile != None:
petsc_argv=[sys.argv[0]]
petsc_argv += open(opts.petscOptionsFile).read().split()
log("PETSc options from commandline")
log(str(petsc_argv))
comm = Comm.init(argv=petsc_argv)
#blanket import statements can go below here now that petsc4py should be initialized
Profiling.procID=comm.rank()
log("Initialized MPI")
if opts.viewer is not False:
from proteusGraphical import *
from proteus import *
log("Adding "+str(opts.probDir)+" to path for loading modules")
probDir = str(opts.probDir)
if probDir not in sys.path:
sys.path.insert(0,probDir)
pList = []
nList = []
sList = []
def test_2DgmshLoadAndAdapt(verbose=0):
"""Test for loading gmsh mesh through PUMI, estimating error and adapting for
a 2D Couette flow case"""
testDir=os.path.dirname(os.path.abspath(__file__))
Model=testDir + '/Couette2D.null'
Mesh=testDir + '/Couette2D.msh'
domain = Domain.PUMIDomain(dim=2) #initialize the domain
domain.PUMIMesh=MeshAdaptPUMI.MeshAdaptPUMI(hmax=0.01, hmin=0.008, numIter=1,sfConfig='ERM',maType='isotropic',targetError=1)
domain.PUMIMesh.loadModelAndMesh(Model, Mesh)
domain.faceList=[[14],[12],[11],[13]]
mesh = MeshTools.TriangularMesh()
mesh.cmesh = cmeshTools.CMesh()
comm = Comm.init()
nElements_initial = mesh.nElements_global
mesh.convertFromPUMI(domain.PUMIMesh, domain.faceList,domain.regList, parallel = comm.size() > 1, dim = domain.nd)
domain.PUMIMesh.transferFieldToPUMI("coordinates",mesh.nodeArray)
rho = numpy.array([998.2,998.2])
nu = numpy.array([1.004e-6, 1.004e-6])
g = numpy.asarray([0.0,0.0])
deltaT = 1.0 #dummy number
domain.PUMIMesh.transferPropertiesToPUMI(rho,nu,g,deltaT)
#Couette Flow
Lz = 0.05
Uinf = 2e-3
#hard code solution
vector=numpy.zeros((mesh.nNodes_global,3),'d')
dummy = numpy.zeros(mesh.nNodes_global);
vector[:,0] = Uinf*mesh.nodeArray[:,1]/Lz #v-velocity
vector[:,1] = dummy
vector[:,2] = dummy
domain.PUMIMesh.transferFieldToPUMI("velocity", vector)
del vector
del dummy
scalar=numpy.zeros((mesh.nNodes_global,1),'d')
domain.PUMIMesh.transferFieldToPUMI("p", scalar)
scalar[:,0] = mesh.nodeArray[:,1]
domain.PUMIMesh.transferFieldToPUMI("phi", scalar)
del scalar
scalar = numpy.zeros((mesh.nNodes_global,1),'d')+1.0
domain.PUMIMesh.transferFieldToPUMI("vof", scalar)
errorTotal=domain.PUMIMesh.get_local_error()
ok(errorTotal<1e-14)
ok(domain.PUMIMesh.willAdapt(),1)
domain.PUMIMesh.adaptPUMIMesh()
mesh = MeshTools.TriangularMesh()
mesh.convertFromPUMI(domain.PUMIMesh,
domain.faceList,
domain.regList,
parallel = comm.size() > 1,
dim = domain.nd)
nElements_final = mesh.nElements_global
ok(nElements_final>nElements_initial)
#import sys
#from proteus import Comm
import os
import sys
import socket
import cPickle
import numpy
import proteus
#remove blankent import statements until after Comm initialized for petsc4py
# from proteus import *
from proteus import Profiling,Comm
from warnings import *
import optparse
import sys
import pstats
import pdb
import petsc4py
Profiling.openLog("proteus.log",7)
print sys.argv[:1]
comm = Comm.init(argv=sys.argv[:1])
comm = Comm.init(argv=sys.argv[:1])
#petsc4py.init(sys.argv[:1])
print comm.rank(),comm.size()
print "Hellow World from",comm.rank()
from proteus import *
Profiling.procID=comm.rank()
def test_poiseuilleError(verbose=0):
"""Test for loading gmsh mesh through PUMI, estimating error for
a Poiseuille flow case. The estimated error should be larger than the
exact error in the seminorm"""
testDir=os.path.dirname(os.path.abspath(__file__))
Model=testDir + '/Couette.null'
Mesh=testDir + '/Couette.msh'
domain = Domain.PUMIDomain() #initialize the domain
domain.PUMIMesh=MeshAdaptPUMI.MeshAdaptPUMI(hmax=0.01, hmin=0.008, numIter=1,sfConfig='ERM',maType='isotropic',logType='off')
domain.PUMIMesh.loadModelAndMesh(Model, Mesh)
domain.faceList=[[80],[76],[42],[24],[82],[78]]
mesh = MeshTools.TetrahedralMesh()
mesh.cmesh = cmeshTools.CMesh()
comm = Comm.init()
nElements_initial = mesh.nElements_global
mesh.convertFromPUMI(domain.PUMIMesh, domain.faceList, domain.regList,parallel = comm.size() > 1, dim = domain.nd)
domain.PUMIMesh.transferFieldToPUMI("coordinates",mesh.nodeArray)
rho = numpy.array([998.2,998.2])
nu = numpy.array([1.004e-6, 1.004e-6])
g = numpy.asarray([0.0,0.0,0.0])
deltaT = 1.0 #dummy number
domain.PUMIMesh.transferPropertiesToPUMI(rho,nu,g,deltaT)
#Poiseuille Flow
Ly=0.2
Lz = 0.05
Re = 100
Umax = Re*nu[0]/Lz
def vOfX(x):
return 4*Umax/(Lz**2)*(x[2])*(Lz-x[2])
def dvOfXdz(x):
return 4*Umax/(Lz**2)*(Lz-2*x[2])
#hard code solution
vector=numpy.zeros((mesh.nNodes_global,3),'d')
dummy = numpy.zeros(mesh.nNodes_global);
vector[:,0] = dummy
vector[:,1] = 4*Umax/(Lz**2)*(mesh.nodeArray[:,2])*(Lz-mesh.nodeArray[:,2]) #v-velocity
vector[:,2] = dummy
domain.PUMIMesh.transferFieldToPUMI("velocity", vector)
scalar=numpy.zeros((mesh.nNodes_global,1),'d')
domain.PUMIMesh.transferFieldToPUMI("p", scalar)
scalar[:,0] = mesh.nodeArray[:,2]
domain.PUMIMesh.transferFieldToPUMI("phi", scalar)
del scalar
scalar = numpy.zeros((mesh.nNodes_global,1),'d')+1.0
domain.PUMIMesh.transferFieldToPUMI("vof", scalar)
errorTotal=domain.PUMIMesh.get_local_error()
# load the femspace with linear basis and get the quadrature points on a reference element
elementQuadrature = Quadrature.SimplexGaussQuadrature(domain.nd,3)
ok(mesh.nNodes_element==4) #confirm all of the elements have 4 nodes
#hard code computation for H1 seminorm; ideally will be reformatted using the classes within proteus
derivativeArrayRef = [[1,0,0],[0,1,0],[0,0,1],[-1,-1,-1]]
error = 0
for eID in range(mesh.nElements_global):
nodes=mesh.elementNodesArray[eID]
coords=[];
for i in range(mesh.nNodes_element):
coords.append(mesh.nodeArray[nodes[i]])
J = numpy.matrix([[coords[0][0]-coords[3][0],coords[1][0]-coords[3][0],coords[2][0]-coords[3][0]],
[coords[0][1]-coords[3][1],coords[1][1]-coords[3][1],coords[2][1]-coords[3][1]],
[coords[0][2]-coords[3][2],coords[1][2]-coords[3][2],coords[2][2]-coords[3][2]]])
invJ = J.I
detJ = numpy.linalg.det(J)
gradPhi_h = 0
for k in range(len(elementQuadrature.points)):
tempQpt = 0
zCoord = elementQuadrature.points[k][0]*coords[0][2] \
+elementQuadrature.points[k][1]*coords[1][2] \
+elementQuadrature.points[k][2]*coords[2][2] \
+(1-elementQuadrature.points[k][0]-elementQuadrature.points[k][1]-elementQuadrature.points[k][2])*coords[3][2]
for i in range(mesh.nNodes_element):
temp = 0
for j in range(domain.nd):
temp = temp + derivativeArrayRef[i][j]*invJ[j,2]
tempQpt = tempQpt + vector[nodes[i]][1]*temp
exactgradPhi = dvOfXdz([0,0,zCoord])
gradPhi_h = gradPhi_h + tempQpt
error = error + (exactgradPhi-gradPhi_h)**2*elementQuadrature.weights[k]*abs(detJ)
error = sqrt(error)
ok(error<errorTotal)
