def vt_array(self):
if not hasattr(self, 'aux_connection'):
self._vt_array = []
return self._vt_array
if not hasattr(self, '_vt_array'):
self._vt_array = []
for key in self.aux_connection:
if len(self._vt_array) > key:
continue
sidx = str(key)
data = [
("oprt1_" + sidx,
VtableElement(
"oprt1_" + sidx,
type='any',
guilabel="operator1",
default="",
tip="oprator (horizontal)",
)),
("oprt2_" + sidx,
VtableElement(
"oprt2_" + sidx,
type='any',
guilabel="operator2",
default="",
tip="oprator (vertical)",
)),
]
vt = Vtable(data)
self._vt_array.append(vt)
return self._vt_array
def vt(self):
root_phys = self.get_root_phys()
if not isinstance(root_phys, PhysModule):
data = (('esse_value',
VtableElement(None,
type="array",
guilabel="dummy",
default="0.0",
tip="dummy")), )
return Vtable(data)
dep_vars = self.get_root_phys().dep_vars
if not hasattr(self, '_dep_var_bk'):
self._dep_var_bk = ""
if self._dep_var_bk != dep_vars:
dep_var = dep_vars[0]
data = (('esse_value',
VtableElement("esse_value",
type="array",
guilabel=dep_var,
default="0.0",
tip="Reference for disance measurement")), )
vt = Vtable(data)
self._vt1 = vt
self._dep_var_bk = dep_vars
self.update_attribute_set()
else:
vt = self._vt1
return vt
def import_panel_value(self, obj, v):
obj.use_3_points = False
obj.use_face_parallel = False
if v[0] == 'Face parallel and point':
setattr(obj, 'use_m_'+self.name, False)
obj.use_face_parallel = True
obj.face_parallel_txt1 = v[4][0]
obj.face_parallel_txt2 = v[4][1]
elif v[0] == 'By 3 points':
setattr(obj, 'use_m_'+self.name, False)
obj.use_3_points = True
obj.by_3_points_txt1 = v[3][0]
obj.by_3_points_txt2 = v[3][1]
obj.by_3_points_txt3 = v[3][2]
else:
VtableElement.import_panel_value(self, obj, v)
def add_attribute(self, v):
v = VtableElement.add_attribute(self, v)
v['use_face_parallel'] = False
v['face_parallel_txt1'] = ''
v['face_parallel_txt2'] = ''
v['use_3_points'] = False
v['by_3_points_txt1'] = ''
v['by_3_points_txt2'] = ''
v['by_3_points_txt3'] = ''
return v
def vt(self):
root_phys = self.get_root_phys()
if not isinstance(root_phys, PhysModule):
data = (('esse_value',
VtableElement(None,
type="array",
guilabel="dummy",
default="0.0",
tip="dummy")), )
return Vtable(data)
dep_vars = self.get_root_phys().dep_vars
if not hasattr(self, '_dep_var_bk'):
self._dep_var_bk = ""
if self._dep_var_bk != dep_vars:
dep_var = dep_vars[0]
data = (
('esse_value',
VtableElement("esse_value",
type="array",
guilabel=dep_var,
default="0.0",
tip="Essentail BC")),
(
'esse_vdim',
VtableElement(
"esse_vdim",
type="string",
guilabel="vdim (0-base)",
default="all",
#readonly = True,
tip="vdim (not supported)")),
)
vt = Vtable(data)
self._vt1 = vt
self._dep_var_bk = dep_vars
self.update_attribute_set()
else:
vt = self._vt1
return vt
def import_panel_value(self, obj, v):
obj.use_normal = False
obj.use_normalp = False
obj.use_fromto_points = False
if v[0] == 'Normal':
setattr(obj, 'use_m_'+self.name, False)
obj.use_normal = True
obj.reverse_dir_normal = v[4][0]
elif v[0] == 'Normal to point':
setattr(obj, 'use_m_'+self.name, False)
obj.use_normalp = True
obj.normalp_dest = v[5][0]
obj.reverse_dir_normalp = v[5][1]
elif v[0] == 'By two points':
setattr(obj, 'use_m_'+self.name, False)
obj.use_fromto_points = True
obj.fromto_points_txt1 = v[3][0]
obj.fromto_points_txt2 = v[3][1]
obj.fromto_points_use_dist = v[3][2]
obj.reverse_dir_fromto = v[3][3]
else:
VtableElement.import_panel_value(self, obj, v)
def _add_vt_array(self, sidx):
data = [
("oprt1_" + sidx,
VtableElement(
"oprt1_" + sidx,
type='any',
guilabel="operator1",
default="",
tip="oprator (horizontal)",
)),
("oprt2_" + sidx,
VtableElement(
"oprt2_" + sidx,
type='any',
guilabel="operator2",
default="",
tip="oprator (vertical)",
)),
]
vt = Vtable(data)
self._vt_array.append(vt)
vt.preprocess_params(self)
def make_value_or_expression(self, obj):
ret = VtableElement.make_value_or_expression(self, obj)
if obj.use_face_parallel:
ret = ['face_parallel',
obj.face_parallel_txt1,
obj.face_parallel_txt2]
elif obj.use_3_points:
ret = ['3_points',
obj.by_3_points_txt1,
obj.by_3_points_txt2,
obj.by_3_points_txt3,]
else:
ret = ['by_abc', ret]
return ret
def add_attribute(self, v):
v = VtableElement.add_attribute(self, v)
v['use_normal'] = False
v['use_fromto_points'] = False
v['fromto_points_txt1'] = ''
v['fromto_points_txt2'] = ''
v['fromto_points_use_dist'] = False
v['reverse_dir_normal'] = False
v['reverse_dir_fromto'] = False
v['use_normalp'] = False
v['normalp_dest'] = ''
v['reverse_dir_normalp'] = False
return v
def panel_param(self, obj, validator = None):
ret = VtableElement.panel_param(self, obj, validator = validator)
ret[3] = list(ret[3])
ret[3][0]['choices'].append('By 3 points')
ret[3][0]['choices'].append('Face parallel and point')
elp3 = [["Point 1", None, 0, {}],
["Point 2", None, 0, {}],
["Point 3", None, 0, {}],]
elp4 = [["Face", None, 0, {}],
["Point", None, 0, {}],]
ret[3].append({'elp': elp3})
ret[3].append({'elp': elp4})
return ret
def make_value_or_expression(self, obj):
ret = VtableElement.make_value_or_expression(self, obj)
if obj.use_normal:
ret = ['normal', obj.reverse_dir_normal]
elif obj.use_normalp:
ret = ['normalp', obj.normalp_dest, obj.reverse_dir_normalp]
elif obj.use_fromto_points:
ret = ['fromto_points',
obj.fromto_points_txt1,
obj.fromto_points_txt2,
obj.fromto_points_use_dist,
obj.reverse_dir_normal]
else:
pass
return ret
def get_panel_value(self, obj):
ret = VtableElement.get_panel_value(self, obj)
if obj.use_face_parallel:
ret[0] = 'Face parallel and point'
elif obj.use_3_points:
ret[0] = 'By 3 points'
else:
pass
ret.append([obj.by_3_points_txt1,
obj.by_3_points_txt2,
obj.by_3_points_txt3,])
ret.append([obj.face_parallel_txt1,
obj.face_parallel_txt2,])
return ret
def vt3(self):
names = self.get_root_phys().dep_vars_base
names2 = [n + '_init' for n in names]
data = []
if hasattr(self, '_vt3'):
vt3 = self._vt3
if vt3.keys() == names2: return vt3
data = [(n + '_init',
VtableElement(n + '_init',
type='float',
guilabel=n + '(init)',
default=0.0,
tip="initial value",
chkbox=True)) for n in names]
self._vt3 = Vtable(data)
self.update_attribute_set()
return self._vt3
def panel_param(self, obj, validator = None):
ret = VtableElement.panel_param(self, obj, validator = validator)
ret[3] = list(ret[3])
ret[3][0]['choices'].append('By two points')
ret[3][0]['choices'].append('Normal')
ret[3][0]['choices'].append('Normal to point')
elp3 = [["Point(from)", None, 0, {}],
["Point(to)", None, 0, {}],
[None, True, 3, {"text": "Use distance between points"}],
[None, True, 3, {"text": "Reverse direction"}],]
elp4 = [ [None, True, 3, {"text": "Reverse direction"}],
[None, "(Note) Face must be flat-plane", 2, {}],]
elp5 = [ ["Point(to)", None, 0, {}],
[None, True, 3, {"text": "Reverse direction"}],
[None, "(Note) Face must be flat-plane. Length below is mulitplier", 2, {}],]
ret[3].append({'elp': elp3})
ret[3].append({'elp': elp4})
ret[3].append({"elp": elp5})
return ret
def get_panel_value(self, obj):
ret = VtableElement.get_panel_value(self, obj)
if obj.use_normal:
ret[0] = 'Normal'
elif obj.use_fromto_points:
ret[0] = 'By two points'
elif obj.use_normalp:
ret[0] = 'Normal to point'
else:
pass
ret.append([obj.fromto_points_txt1,
obj.fromto_points_txt2,
obj.fromto_points_use_dist,
obj.reverse_dir_fromto])
ret.append([obj.reverse_dir_normal,
'(Note) Face must be flat-plane',])
ret.append([obj.normalp_dest,
obj.reverse_dir_normalp,
'(Note) Face must be flat-plane. Distance below is ignored',])
return ret
assert False, "entity id field must be text"
return values
def eval_enitity_id(self, *text):
if len(text) == 1:
return self._eval_enitity_id(text[0])
return [self._eval_enitity_id(x) for x in text]
data = (
('clmax',
VtableElement('clmax',
type='float',
guilabel='Max size(def)',
default_txt='',
default=1e20,
tip="CharacteristicLengthMax")),
('clmin',
VtableElement('clmin',
type='float',
guilabel='Min size(def)',
default_txt='',
default=0.0,
tip="CharacteristicLengthMin")),
)
class GmshMesh(GMeshTop, Vtable_mixin):
has_2nd_panel = False
isMeshGroup = True
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,
tip="y")),
('s_delta',
VtableElement('s_delta',
type='array',
guilabel='scale',
default=1.0,
tip="scale")),
)
class Coeff2D_PointSource(Coeff2D_Point):
vt = Vtable(data)
_sel_index = [-1]
from petram.phys.em3d.em3d_base import EM3D_Bdry, EM3D_Domain
from petram.phys.vtable import VtableElement, Vtable
data = (('label1',
VtableElement(None,
guilabel='Perfect Magnetic Conductor',
default="Ht = 0",
tip="this is a natural BC")), )
class EM3D_PMC(EM3D_Bdry):
is_essential = False
nlterms = []
vt = Vtable(data)
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)
v = 1j * self.omega * v
if self.real: return v.real
else: return v.imag
class EM3D_ExtJ(EM3D_Domain):
import traceback
import petram.debug
dprint1, dprint2, dprint3 = petram.debug.init_dprints('Projection(PP)')
from petram.phys.vtable import VtableElement, Vtable, Vtable_mixin
from petram.postprocess.pp_model import PostProcessBase
data = [("coeff_lambda",
VtableElement(
"coeff_lambda",
type='array',
guilabel="expression",
default=0.0,
tip="expression",
))]
class DerivedValue(PostProcessBase, Vtable_mixin):
has_2nd_panel = True
vt_coeff = Vtable(data)
def attribute_set(self, v):
v = super(DerivedValue, self).attribute_set(v)
v["projection_name"] = 'derived'
v["element"] = 'H1_FECollection'
v["is_complex_valued"] = False
v["order"] = 1
v["sdim"] = 2
v['sel_index'] = ['all']
2) an weighting to evaulate mode amplutude from the E field
on a boundary
TEM Mode
E is parallel to the periodic edge
Mode number is ignored (of course)
About sign of port phasing.
positive phasing means the incoming wave appears later (phase delay)
at the port
'''
from petram.phys.vtable import VtableElement, Vtable
data = (
('inc_amp',
VtableElement('inc_amp',
type='complex',
guilabel='incoming amp',
default=1.0,
tip="amplitude of incoming wave")),
('inc_phase',
VtableElement('inc_phase',
type='float',
guilabel='incoming phase (deg)',
default=0.0,
tip="phase of incoming wave")),
('epsilonr',
VtableElement('epsilonr',
type='complex',
guilabel='epsilonr',
default=1.0,
tip="relative permittivity")),
('mur',
'''
import numpy as np
import traceback
from petram.model import Domain, Bdry, Pair
from petram.phys.phys_model import Phys, PhysModule
from petram.phys.em2da.em2da_base import EM2Da_Bdry
from petram.phys.em2da.em2da_vac import EM2Da_Vac
txt_predefined = 'freq, e0, mu0'
from petram.phys.vtable import VtableElement, Vtable
data2 = (('label1', VtableElement(None,
guilabel = 'Default Bdry (PMC)',
default = "Ht = 0",
tip = "this is a natural BC" )),)
class EM2Da_DefDomain(EM2Da_Vac):
can_delete = False
nlterms = []
#vt = Vtable(data1)
#do not use vtable here, since we want to use
#vtable defined in EM3D_Vac in add_bf_conttribution
def __init__(self, **kwargs):
super(EM2Da_DefDomain, self).__init__(**kwargs)
def panel1_param(self):
return [['Default Domain (Vac)', "eps_r=1, mu_r=1, sigma=0", 2, {}],]
def get_panel1_value(self):
return None
def import_panel1_value(self, v):
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',
dprint1, dprint2, dprint3 = debug.init_dprints('EM3D_PML')
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 = (
('stretch',
VtableElement(
'stretch',
type='complex',
guilabel='stretch',
default=1.0,
no_func=True,
tip=
"real: shorten wavelength (>0), imag: damping (>0 forward, <0 backward)"
)),
('s_order',
VtableElement('s_order',
type='float',
guilabel='order',
default=1.0,
no_func=True,
tip="streach order")),
)
from petram.phys.coefficient import CC_Matrix
from petram.phys.em3d.em3d_const import mu0, epsilon0
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 []
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',
type='complex',
guilabel='epsilonr',
default=1.0,
tip="relative permittivity")),
('mur',
VtableElement('mur',
type='complex',
guilabel='mur',
default=1.0,
tip="relative permeability")),
('sigma',
VtableElement('sigma',
type='complex',
guilabel='sigma',
default=0.0,
tip="contuctivity")),
('kz',
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]))
if self.real: val = v.real
else: val = v.imag
return val
class Einit_z(PhysCoefficient):
dprint1, dprint2, dprint3 = petram.debug.init_dprints('Integration(PP)')
from petram.phys.vtable import VtableElement, Vtable, Vtable_mixin
from petram.postprocess.pp_model import PostProcessBase
from petram.phys.weakform import get_integrators
bilinintegs = get_integrators('BilinearOps')
linintegs = get_integrators('LinearOps')
data = [("coeff_lambda",
VtableElement(
"coeff_lambda",
type='array',
guilabel="lambda",
default=0.0,
tip="coefficient",
))]
data = [("coeff_lambda",
VtableElement(
"coeff_lambda",
type='array',
guilabel="lambda",
default='1.0',
tip="coefficient",
))]
class WeakformIntegrator(PostProcessBase, Vtable_mixin):
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):
Bdry.attribute_set(self, v)
import petram.debug as debug
dprint1, dprint2, dprint3 = debug.init_dprints('EM3D_Z')
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
data1 = (('impedance',
VtableElement('impedance',
type='complex',
guilabel='Z(w)',
default=1.0,
tip="impedance ")), )
data2 = (
('epsilonr_bnd',
VtableElement('epsilonr_bnd',
type='complex',
guilabel='epsilonr(bnd)',
default=1.0,
tip="boundary relative permittivity")),
('mur_bnd',
VtableElement('mur_bnd',
type='complex',
guilabel='mur',
default=1.0,
tip="boundary relative permeability")),
