from .solver_model import LinearSolverModel, LinearSolver
import numpy as np
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('GMRESModel')
from petram.mfem_config import use_parallel
if use_parallel:
from petram.helper.mpi_recipes import *
from mfem.common.parcsr_extra import *
import mfem.par as mfem
default_kind = 'hypre'
from mpi4py import MPI
num_proc = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank
smyid = '{:0>6d}'.format(myid)
from mfem.common.mpi_debug import nicePrint
else:
import mfem.ser as mfem
default_kind = 'scipy'
from petram.solver.mumps_model import MUMPSPreconditioner
SparseSmootherCls = {
"Jacobi": (mfem.DSmoother, 0),
"l1Jacobi": (mfem.DSmoother, 1),
"lumpedJacobi": (mfem.DSmoother, 2),
"GS": (mfem.GSSmoother, 0),
"forwardGS": (mfem.GSSmoother, 1),
"backwardGS": (mfem.GSSmoother, 2),
Coeff2D_Zero : zero essential (default)
Coeff2D_Esse : general essential
Point:
Coeff2D_PointEsse: point essential (default)
'''
model_basename = 'Coeff2D'
import numpy as np
from petram.model import Domain, Bdry, Point, Pair
from petram.phys.phys_model import Phys, PhysModule
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('Coeff2D_Model')
txt_predefined = ''
class Coeff2D_DefDomain(Domain, Phys):
can_delete = False
def __init__(self, **kwargs):
super(Coeff2D_DefDomain, self).__init__(**kwargs)
def get_panel1_value(self):
return None
def import_panel1_value(self, v):
pass
from __future__ import print_function
import numpy as np
from os.path import dirname, basename, isfile, join
import warnings
import glob
import types
import parser
import numbers
import petram
from petram.model import Model, Bdry, Domain
from petram.namespace_mixin import NS_mixin
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('Phys')
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
else:
import mfem.ser as mfem
from petram.helper.variables import Variable, eval_code
from petram.helper.variables import NativeCoefficientGenBase, CoefficientVariable
# not that PyCoefficient return only real number array
class PhysConstant(mfem.ConstantCoefficient):
def __init__(self, value):
self.value = value
mfem.ConstantCoefficient.__init__(self, value)
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('EM1D_PEC')
from petram.phys.phys_model import PhysConstant
from petram.phys.em1d.em1d_base import EM1D_Bdry, EM1D_Domain
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
else:
import mfem.ser as mfem
from petram.phys.vtable import VtableElement, Vtable
data = (('label1', VtableElement(None,
guilabel = 'Perfect Electric Conductor',
default = "Ey=0 and Ez=0",
tip = "Essential Homogenous BC" )),)
class EM1D_PEC(EM1D_Bdry):
has_essential = True
nlterms = []
vt = Vtable(data)
def get_essential_idx(self, kfes):
if kfes == 1:
return self._sel_index
elif kfes == 2:
return self._sel_index
else:
return []
import os
import numpy as np
from petram.model import Model
from .solver_model import Solver
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('StdSolver')
rprint = debug.regular_print('StdSolver')
class StdSolver(Solver):
can_delete = True
has_2nd_panel = False
def attribute_set(self, v):
v['clear_wdir'] = False
v['init_only'] = False
v['assemble_real'] = False
v['save_parmesh'] = False
v['phys_model'] = ''
v['init_setting'] = ''
super(StdSolver, self).attribute_set(v)
return v
def panel1_param(self):
return [
[
"Initial value setting",
self.init_setting,
0,
{},
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('MeshExtension')
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
from mfem.common.mpi_debug import nicePrint
else:
def nicePrint(x):
print(x)
class MeshExtInfo(dict):
def __init__(self, *args, **kwargs):
cut = set(kwargs.pop('cut', []))
sel = set(kwargs.pop('sel', []))
dim = kwargs.pop('dim', 1)
base = kwargs.pop('base', 0)
self['cut'] = cut
self['sel'] = sel
self['dim'] = dim
self['base'] = base
dict.__init__(self, *args, **kwargs)
def set_dim(self, dim):
self['dim'] = dim
def set_selection(self, sel):
from __future__ import print_function
import os
import numpy as np
from petram.model import Model
from .solver_model import Solver
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints("TimeDomainSolver")
rprint = debug.regular_print('TimeDependentSolver')
from petram.solver.std_solver_model import StdSolver
class DerivedValue(StdSolver):
def allocate_instance(self, engine):
from petram.solver.std_solver_model import StandardSolver
instance = StandardSolver(self, engine)
instance.set_blk_mask()
return instance
class TimeStep():
def __init__(self, data):
self.data = list(np.atleast_1d(data))
def __call__(self, i):
if i >= len(self.data):
return self.data[-1]
from petram.mfem_config import use_parallel
from .solver_model import LinearSolverModel, LinearSolver
from petram.helper.matrix_file import write_matrix, write_vector, write_coo_matrix
import os
import numpy as np
import scipy
import weakref
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('MUMPSModel')
def convert2float(txt):
try:
return float(txt)
except BaseException:
assert False, "can not convert to float. Input text is " + txt
def convert2int(txt):
try:
return int(txt)
except BaseException:
assert False, "can not convert to float. Input text is " + txt
class MUMPSBase(LinearSolverModel):
has_2nd_panel = False
accept_complex = True
is_iterative = False
2016 5/20 first version only TE modes
'''
import numpy as np
from petram.model import Bdry
from petram.phys.phys_model import Phys
from petram.phys.em3d.em3d_base import EM3D_Bdry, EM3D_Domain
from petram.helper.geom import connect_pairs
from petram.helper.geom import find_circle_center_radius
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('EM3D_Port')
from .em3d_const import epsilon0, mu0
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
from mfem.common.mpi_debug import nicePrint
'''
from mpi4py import MPI
num_proc = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank
'''
else:
import mfem.ser as mfem
nicePrint = dprint1
import traceback
import numpy as np
from petram.model import Domain, Bdry, Edge, Point, Pair
from petram.phys.phys_model import VectorPhysCoefficient, PhysCoefficient
from petram.phys.weakform import WeakLinIntegration, WeakBilinIntegration
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('WF_Constraints')
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
else:
import mfem.ser as mfem
# define variable for this BC.
from petram.phys.vtable import VtableElement, Vtable
'''
class InitValue(PhysCoefficient):
def EvalValue(self, x):
v = super(InitValue, self).EvalValue(x)
if self.real: val = v.real
else: val = v.imag
return val
'''
'''
class InitValueV(VectorPhysCoefficient):
def EvalValue(self, x):
v = super(InitValueV, self).EvalValue(x)
'''
BlcokPreconditioner Model.
'''
from petram.solver.mumps_model import MUMPSPreconditioner
from petram.mfem_config import use_parallel
import numpy as np
from petram.debug import flush_stdout
from petram.namespace_mixin import NS_mixin
from .solver_model import LinearSolverModel, LinearSolver
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('BlockSmoother')
if use_parallel:
from petram.helper.mpi_recipes import *
from mfem.common.parcsr_extra import *
import mfem.par as mfem
default_kind = 'hypre'
from mpi4py import MPI
num_proc = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank
smyid = '{:0>6d}'.format(myid)
from mfem.common.mpi_debug import nicePrint
else:
import mfem.ser as mfem
default_kind = 'scipy'
IterativeSolver)
from petram.solver.solver_model import SolverInstance
from petram.model import Model
from petram.solver.solver_model import Solver, SolverInstance
from petram.solver.std_solver_model import StdSolver
from petram.mfem_config import use_parallel
if use_parallel:
from petram.helper.mpi_recipes import *
import mfem.par as mfem
else:
import mfem.ser as mfem
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('MGSolver')
rprint = debug.regular_print('MGSolver')
class CoarseSolver:
pass
class FineSolver:
pass
class CoarseIterative(Iterative, CoarseSolver):
@classmethod
def fancy_menu_name(self):
return 'Iterative'
import numpy as np
from petram.solver.parametric_scanner import DefaultParametricScanner
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('PortScanner')
dprint0 = debug.regular_print('PortScanner', True)
format_memory_usage = debug.format_memory_usage
class PortScanner(DefaultParametricScanner):
'''
Scanner for port BC amplitude
PortScan([1,2,3], amplitude=1, phase=0.0)
# user need to load this in the global namelist
'''
def __init__(self, *args, **kwargs):
amplitude = kwargs.pop("amplitude", 1)
self.phase = kwargs.pop("phase", 0.0)
if len(args) != 1:
assert False, "port id must be specified"
self.port = [int(x) for x in args[0]]
data = []
for i in range(len(self.port)):
amp = np.array([0] * len(self.port))
amp[i] = amplitude
data.append(amp)
Selectable: define a panel with pull down menu
(('Z_param', VtableElement('Z_param',
type = 'selectable'
choices= ('Impedance', 'e/m/s'),
vtables = (vt1, vt2)
default = 'Impedance')),)
'''
import six
import numpy as np
import itertools
from collections import OrderedDict
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('Vtable')
def dummy():
pass
dummy.__repr__ = lambda: '"1"'
class VtableElement(object):
def __init__(self,
name,
type='',
size=(1, ),
suffix=None,
from __future__ import print_function
import tempfile
import os
import subprocess
import tempfile
import weakref
import numpy as np
import traceback
import time
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('GeomModel')
from petram.mesh.mesh_model import Mesh
from petram.phys.vtable import VtableElement, Vtable, Vtable_mixin
debug = True
class GMesh(Mesh):
def onItemSelChanged(self, evt):
'''
GUI response when model object is selected in
the dlg_edit_model
'''
geom_root = self.geom_root
if not geom_root.is_finalized:
geom_root.onBuildAll(evt)
if geom_root.is_finalized:
if geom_root.geom_timestamp != self.geom_timestamp:
'''
Model Tree to stroe MFEM model parameters
'''
from petram.namespace_mixin import NS_mixin
import numpy as np
from petram.model import Model
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('MFEMModel')
class MFEM_GeneralRoot(Model, NS_mixin):
can_delete = False
has_2nd_panel = True
def __init__(self, *args, **kwargs):
Model.__init__(self, *args, **kwargs)
NS_mixin.__init__(self, *args, **kwargs)
def get_info_str(self):
return NS_mixin.get_info_str(self)
def attribute_set(self, v):
v['debug_level'] = 1
v['dwc_object_name'] = ''
v['mesh_gen'] = ''
v['geom_gen'] = ''
v['diagpolicy'] = 'one'
v['partitioning'] = 'auto'
'''
Vacuum region:
However, can have arbitrary scalar epsilon_r, mu_r, sigma
'''
import numpy as np
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('EM2D_Vac')
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
else:
import mfem.ser as mfem
from petram.phys.coefficient import PyComplexPowCoefficient as ComplexPow
from petram.phys.coefficient import PyComplexProductCoefficient as ComplexProduct
from petram.phys.coefficient import PyComplexSumCoefficient as ComplexSum
from petram.phys.coefficient import PyComplexMatrixSumCoefficient as ComplexMatrixSum
from petram.phys.coefficient import PyComplexMatrixInvCoefficient as ComplexMatrixInv
from petram.phys.coefficient import PyComplexMatrixSliceCoefficient as ComplexMatrixSlice
from petram.phys.coefficient import PyComplexMatrixProductCoefficient as ComplexMatrixProduct
from petram.phys.coefficient import PyComplexMatrixAdjCoefficient as ComplexMatrixAdj
from petram.phys.vtable import VtableElement, Vtable
data = (
('epsilonr',
VtableElement('epsilonr',
'''
external current source
'''
import numpy as np
from petram.phys.phys_model import Phys, VectorPhysCoefficient
from petram.phys.em3d.em3d_base import EM3D_Bdry, EM3D_Domain
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('EM3D_extJ')
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
else:
import mfem.ser as mfem
from petram.phys.vtable import VtableElement, Vtable
data = (('jext', VtableElement('jext', type='complex',
guilabel = 'External J',
suffix =('x', 'y', 'z'),
default = [0,0,0],
tip = "volumetric external current" )),)
class Jext(VectorPhysCoefficient):
def __init__(self, *args, **kwargs):
self.omega = kwargs.pop('omega', 1.0)
super(Jext, self).__init__(*args, **kwargs)
def EvalValue(self, x):
from .em3d_const import mu0, epsilon0
v = super(Jext, self).EvalValue(x)
import traceback
import numpy as np
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('EM2D_Base')
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
else:
import mfem.ser as mfem
from petram.model import Domain, Bdry, Pair
from petram.phys.phys_model import Phys, PhysModule, VectorPhysCoefficient, PhysCoefficient
# define variable for this BC.
from petram.phys.vtable import VtableElement, Vtable
data = (('Einit',
VtableElement('Einit',
type='float',
guilabel='E(init)',
suffix=('x', 'y', 'z'),
default=np.array([0, 0, 0]),
tip="initial_E",
chkbox=True)), )
class Einit_xy(VectorPhysCoefficient):
def EvalValue(self, x):
v = super(Einit_xy, self).EvalValue(x)
v = np.array((v[0], v[1]))
import numpy as np
from petram.model import Bdry
from petram.phys.phys_model import Phys, VectorPhysCoefficient
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('EM3D_E')
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
else:
import mfem.ser as mfem
class Et(VectorPhysCoefficient):
def EvalValue(self, x):
v = super(Et, self).EvalValue(x)
if self.real: return v.real
else: return v.imag
class EM3D_E(Bdry, Phys):
has_essential = True
def __init__(self, **kwargs):
super(EM3D_E, self).__init__(**kwargs)
Phys.__init__(self)
def attribute_set(self, v):
super(EM3D_E, self).attribute_set(v)
'''
Distance module
physics module to compute distance
'''
import numpy as np
from petram.model import Domain, Bdry, Point, Pair
from petram.phys.phys_model import Phys, PhysModule
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('Distance_Model')
txt_predefined = ''
model_basename = 'Distance'
class Distance_DefDomain(Domain, Phys):
can_delete = False
def __init__(self, **kwargs):
super(Distance_DefDomain, self).__init__(**kwargs)
def get_panel1_value(self):
return None
def import_panel1_value(self, v):
pass
import weakref
import numpy as np
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
from mpi4py import MPI
num_proc = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank
comm = MPI.COMM_WORLD
from mfem.common.mpi_debug import nicePrint
else:
import mfem.ser as mfem
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints("Operators")
rprint = debug.regular_print('Operators')
class Operator(object):
def __repr__(self):
return self.__class__.__name__ + "("+",".join(self.sel)+")"
class Operator(object):
def __init__(self, **kwargs):
self._sel = kwargs.pop("sel", "all")
self._ssel = kwargs.pop("src", "all")
self._sel_mode = kwargs.pop("sel_mode", "domain")
self._fes1 = None
self._fes2 = None
self._engine = None
self._transpose = False
import traceback
import numpy as np
from scipy.sparse import csr_matrix, coo_matrix, lil_matrix
from petram.model import Pair, Bdry
from petram.phys.phys_model import Phys
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('WF_PAIRS')
from petram.mfem_config import use_parallel
if use_parallel:
from mfem.common.parcsr_extra import ToHypreParCSR, get_row_partitioning
import mfem.par as mfem
from mpi4py import MPI
num_proc = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank
from mfem.common.mpi_debug import nicePrint
else:
import mfem.ser as mfem
num_proc = 1
myid = 0
'''
Map DoF from src surface (s1) to dst surface (s2)
'''
def make_mapper(txt, g, indvars):
lns = {}
from mfem.common.mpi_debug import nicePrint
if use_parallel:
from petram.helper.mpi_recipes import *
from mfem.common.parcsr_extra import *
import mfem.par as mfem
default_kind = 'hypre'
else:
import mfem.ser as mfem
default_kind = 'scipy'
from petram.solver.solver_utils import make_numpy_coo_matrix
from petram.helper.matrix_file import write_coo_matrix, write_vector
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('BlockMatrix')
format_memory_usage = debug.format_memory_usage
class One(object):
'''
An identity matrix (used in P and mimic 1*X = X)
'''
def __init__(self, ref):
self._shape = ref.shape
self._is_hypre = False
if hasattr(ref, "GetColPartArray"):
self._cpart = ref.GetColPartArray()
self._is_hypre = True
if hasattr(ref, "GetRowPartArray"):
self._rpart = ref.GetRowPartArray()
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
else:
import mfem.ser as mfem
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('WF_Natrual')
from petram.phys.vtable import VtableElement, Vtable
from petram.model import Domain, Bdry, Edge, Point, Pair
from petram.phys.phys_model import Phys, PhysModule
data = (('label1',
VtableElement(None,
guilabel='Natrual BC',
default="",
tip="this does not constrain the model")), )
class WF_Natural(Bdry, Phys):
has_essential = False
nlterms = []
can_timedpendent = False
has_3rd_panel = True
vt = Vtable(data)
def __init__(self, **kwargs):
super(WF_Natural, self).__init__(**kwargs)
def attribute_set(self, v):
import numpy as np
from petram.debug import flush_stdout
from petram.namespace_mixin import NS_mixin
from .solver_model import LinearSolverModel, LinearSolver
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('IterativeSolverModel')
from petram.mfem_config import use_parallel
if use_parallel:
from petram.helper.mpi_recipes import *
from mfem.common.parcsr_extra import *
import mfem.par as mfem
default_kind = 'hypre'
from mpi4py import MPI
num_proc = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank
smyid = '{:0>6d}'.format(myid)
from mfem.common.mpi_debug import nicePrint
else:
import mfem.ser as mfem
default_kind = 'scipy'
from petram.solver.mumps_model import MUMPSPreconditioner
SparseSmootherCls = {
"Jacobi": (mfem.DSmoother, 0),
"l1Jacobi": (mfem.DSmoother, 1),
"lumpedJacobi": (mfem.DSmoother, 2),
from petram.solver.solver_model import SolverInstance
import os
import numpy as np
from petram.model import Model
from petram.solver.solver_model import Solver
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('DistanceSolver')
rprint = debug.regular_print('DistanceSolver')
class DistanceSolver(Solver):
can_delete = True
has_2nd_panel = False
def attribute_set(self, v):
super(DistanceSolver, self).attribute_set(v)
v["solver_type"] = "heat flow"
v["p_lap_p"] = 20
v["p_lap_iter"] = 50
v["heat_flow_t"] = 1.
v["heat_flow_diffuse_iter"] = 1
v["log_level"] = 1
return v
def panel1_param(self):
return [ # ["Initial value setting", self.init_setting, 0, {},],
[
"physics model",
self.phys_model,
0,
or
u = u0
m, d, a, f, g and h: scalar
alpha, beta and gamma : vector
c : matrix (dim (space) ^2)
'''
import numpy as np
from petram.phys.phys_model import PhysCoefficient, VectorPhysCoefficient
from petram.phys.phys_model import MatrixPhysCoefficient, Coefficient_Evaluator
from petram.phys.coeff2d.coeff2d_base import Coeff2D_Point
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('Coeff2D_Domain')
from petram.mfem_config import use_parallel
if use_parallel:
import mfem.par as mfem
else:
import mfem.ser as mfem
from petram.phys.vtable import VtableElement, Vtable
data = (
('x_delta',
VtableElement('x_delta', type='array', guilabel='x', default=0.0,
tip="x")),
('y_delta',
VtableElement('y_delta', type='array', guilabel='y', default=0.0,
[y_src ] [b1]
A [ ] = [ ]
[y_dest] [b2]
becomes
Pt A P [y_src] = [b1 + Mt b2]
For H1, L2 element M^-1 = M^t,
For ND, and RT, M^-1 needs inversion.
'''
import numpy as np
import scipy
from scipy.sparse import lil_matrix
import petram.debug as debug
debug.debug_default_level = 1
dprint1, dprint2, dprint3 = debug.init_dprints('dof_map')
from petram.helper.matrix_file import write_matrix, write_vector
from petram.mfem_config import use_parallel
if use_parallel:
from mpi4py import MPI
comm = MPI.COMM_WORLD
num_proc = MPI.COMM_WORLD.size
myid = MPI.COMM_WORLD.rank
from petram.helper.mpi_recipes import *
import mfem.par as mfem
from mfem.common.mpi_debug import nicePrint
else:
import numpy as np
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('GmshMeshActions')
from petram.phys.vtable import VtableElement, Vtable
from petram.mesh.gmsh_mesh_model import GmshMeshActionBase
data = (
('geom_id',
VtableElement('geom_id',
type='string',
guilabel='Line#',
default="remaining",
tip="Line ID")),
('num_seg',
VtableElement('num_seg',
type='int',
guilabel='Number of segments',
default=5,
tip="Number of segments")),
('progression',
VtableElement('progression',
type='float',
guilabel='Progression',
default=1.0,
tip="Progression")),
('bump',
VtableElement('bump',
type='float',
