def test_indexing():
"Basic test for array indexing"
sim = openmodes.Simulation()
mesh = sim.load_mesh(osp.join(openmodes.geometry_dir, "SRR.geo"))
group1 = sim.place_part()
group2 = sim.place_part()
srr1 = sim.place_part(mesh, parent=group1)
srr2 = sim.place_part(mesh, parent=group1)
srr3 = sim.place_part(mesh, parent=group2)
basis = sim.basis_container[srr1]
basis_len = len(basis)
A = LookupArray(
((group1, sim.basis_container), (group2, sim.basis_container), 5, 3))
assert (A.shape == (2 * basis_len, basis_len, 5, 3))
A[group1, srr3] = 22.5
assert (np.all(A[srr1, :] == 22.5))
assert (np.all(A[srr2] == 22.5))
V = LookupArray((("E", "H"), (sim.parts, sim.basis_container)),
dtype=np.complex128)
V["E", group1] = -4.7 + 22j
V["H", srr1] = 5.2
V["H", srr2] = 6.7
assert (np.all(V["E", group1] == V["E"][group1]))
assert (np.all(V["E", srr1] == -4.7 + 22j))
assert (np.all(V["E", srr2].imag == 22))
def val(self):
"The value of the impedance matrix"
Z = LookupArray(
(self.sources, (self.part_o, self.basis_container), self.unknowns,
(self.part_s, self.basis_container)),
dtype=np.complex128)
Z.simple_view()[:] = self.matrices['Z']
return Z
def val(self):
"The value of the impedance matrix"
s = self.md['s']
Z = LookupArray((self.sources, (self.part_o, self.basis_container),
self.unknowns, (self.part_s, self.basis_container)),
dtype=np.complex128)
Z.simple_view()[:] = self.matrices['S']/s + s*self.matrices['L']
return Z
def val(self):
"The value of the impedance matrix"
s = self.md['s']
alpha = self.md['alpha']
Z = LookupArray(
(self.sources, (self.part_o, self.basis_container), self.unknowns,
(self.part_s, self.basis_container)),
dtype=np.complex128)
Z.simple_view()[:] = (
alpha * (self.matrices['S'] / s + s * self.matrices['L']) +
(1.0 - alpha) * self.matrices['M'])
return Z
def s(self):
res = LookupArray(
(('modes', ), (self.parent_part, self.macro_container)),
dtype=np.complex128)
for part in self.parts:
res[:, part] = self.modes_of_parts[part.unique_id]['s']
return res
def solve(self, vec):
"""Solve the impedance matrix for a source vector. Caches the
factorised matrix for efficiently solving multiple vectors"""
if self.part_o != self.part_s:
raise ValueError("Can only invert a self-impedance matrix")
Z_lu = self.factored()
if isinstance(vec, LookupArray):
vec = vec.simple_view()
lookup = (self.unknowns, (self.part_s, self.basis_container))
if len(vec.shape) > 1:
lookup = lookup + (vec.shape[1], )
I = LookupArray(lookup, dtype=np.complex128)
I_simp = I.simple_view()
I_simp[:] = la.lu_solve(Z_lu, vec)
return I
def solve(self, vec):
"""Solve the impedance matrix for a source vector. Caches the
factorised matrix for efficiently solving multiple vectors"""
if self.part_o != self.part_s:
raise ValueError("Can only invert a self-impedance matrix")
Z_lu = self.factored()
if isinstance(vec, LookupArray):
vec = vec.simple_view()
lookup = (self.unknowns, (self.part_s, self.basis_container))
if len(vec.shape) > 1:
lookup = lookup+(vec.shape[1],)
I = LookupArray(lookup, dtype=np.complex128)
I_simp = I.simple_view()
I_simp[:] = la.lu_solve(Z_lu, vec)
return I
def __init__(self,
part_o,
part_s,
basis_container,
sources,
unknowns,
metadata=None,
matrices=None,
derivatives=None):
self.md = metadata or dict()
self.part_o = part_o
self.part_s = part_s
self.basis_container = basis_container
self.sources = sources
self.unknowns = unknowns
# Note that the internal LookupArray format is different from the
# final format as it excludes the quantity lookup.
self.matrices = {
name: LookupArray(
((part_o, basis_container), (part_s, basis_container)),
dtype=np.complex128)
for name in self.matrix_names
}
if matrices is not None:
# fill out any matrices which are supplied
for name, mat in list(matrices.items()):
self.matrices[name][:] = mat
# create the frequency derivatives of the matrices
if derivatives is None:
self.der = {
name: LookupArray(((
part_o,
basis_container,
), (part_s, basis_container)),
dtype=np.complex128)
for name in self.matrix_names
}
else:
self.der = derivatives
def source_vector(self, source_field, s, parent, extinction_field):
"Calculate the relevant source vector for this operator"
V = LookupArray((("E"), (parent, self.basis_container)),
dtype=np.complex128)
for part in parent.iter_single():
V["E", part] = self.source_single_part(source_field, s, part,
extinction_field)
return V
def gram_matrix(self, part):
"""Create a Gram matrix as a LookupArray"""
G = self.basis_container[part].gram_matrix
Gp = LookupArray(
(self.unknowns, (part, self.basis_container), self.sources,
(part, self.basis_container)),
dtype=G.dtype)
Gp[:] = 0.0
for unknown, source in zip(self.unknowns, self.sources):
Gp[unknown, :, source, :] = G
return Gp
def source_vector(self, source_field, s, parent, extinction_field=False):
"Calculate the relevant source vector for this operator"
if extinction_field:
return super(CfieOperator,
self).source_vector(source_field, s, parent, True)
fields = ("E", "nxH")
V = LookupArray((fields, (parent, self.basis_container)),
dtype=np.complex128)
# define the functions to interpolate over the mesh
def elec_func(r):
return source_field.electric_field(s, r)
def mag_func(r):
return source_field.magnetic_field(s, r)
for field in fields:
if field == "E":
field_func = elec_func
source_cross = False
elif field == "nxH":
field_func = mag_func
source_cross = True
for part in parent.iter_single():
basis = self.basis_container[part]
V[field,
part] = basis.weight_function(field_func,
self.integration_rule,
part.nodes, source_cross)
V_final = LookupArray((self.sources, (parent, self.basis_container)),
dtype=np.complex128)
V_final[:] = self.alpha * V["E"] + (1.0 - self.alpha) * V["nxH"]
return V_final
def vr(self):
"The right eigenvectors"
res = LookupArray(
(self.operator.unknowns, (self.parent_part, self.orig_container),
('modes', ), (self.parent_part, self.macro_container)),
dtype=np.complex128)
res[:] = 0.0
for part in self.parts:
res[:, part, :,
part] = self.modes_of_parts[part.unique_id]['vr'].reshape(
res[:, part, :, part].shape)
return res
def test_list_indexing():
"List mucks up LookupArrays, which is now warned about"
sim = openmodes.Simulation()
mesh = sim.load_mesh(osp.join(openmodes.geometry_dir, "SRR.geo"))
srr1 = sim.place_part(mesh)
srr2 = sim.place_part(mesh)
res = LookupArray((sim.operator.unknowns, (sim.parts, sim.basis_container),
('modes', ), (srr2, sim.basis_container)),
dtype=np.complex128)
with pytest.warns(UserWarning):
res[0, :, 0, [2]]
def empty_array(self, part=None, extra_dims=()):
"""
Create an empty array of the appropriate size to contain solutions for
all of the parts, or a single part and its sub-parts
Parameters
----------
part : Part, optional
The part for which to create the vector. If not specified, all
parts in the full simulation
extra_dims : tuple, optional
This can give the sizes of additional dimensions
"""
part = part or self.parts
return LookupArray((self.operator.unknowns,
(part, self.basis_container)) + extra_dims,
dtype=np.complex128)
def val(self):
"The value of the impedance matrix"
s = self.md['s']
D_i = s * self.matrices['L_i'] + self.matrices['S_i'] / s
D_o = s * self.matrices['L_o'] + self.matrices['S_o'] / s
K_i = self.matrices['K_i']
K_o = self.matrices['K_o']
eta_o = self.md['eta_o']
eta_i = self.md['eta_i']
w_EFIE_i = self.md['w_EFIE_i']
w_EFIE_o = self.md['w_EFIE_o']
w_MFIE_i = self.md['w_MFIE_i']
w_MFIE_o = self.md['w_MFIE_o']
Z = LookupArray((("E", "H"), (self.part_o, self.basis_container),
("J", "M"), (self.part_s, self.basis_container)),
dtype=np.complex128)
# first calculate the external problem contributions
Z["E", :, "J"] = eta_o * D_o * w_EFIE_o
Z["E", :, "M"] = -K_o * w_EFIE_o
Z["H", :, "J"] = K_o * w_MFIE_o
Z["H", :, "M"] = D_o / eta_o * w_MFIE_o
# The internal contributions are only for self-terms
for part_o in self.part_o.iter_single():
for part_s in self.part_s.iter_single():
if part_o == part_s:
Z["E", :, "J"][part_o, part_s] += eta_i[part_s] * D_i[
part_o, part_s] * w_EFIE_i[part_s]
Z["E", :,
"M"][part_o,
part_s] -= K_i[part_o, part_s] * w_EFIE_i[part_s]
Z["H", :,
"J"][part_o,
part_s] += K_i[part_o, part_s] * w_MFIE_i[part_s]
Z["H", :, "M"][part_o, part_s] += D_i[
part_o, part_s] / eta_i[part_s] * w_MFIE_i[part_s]
return Z
def source_vector(self, source_field, s, parent, extinction_field=False):
"Calculate the relevant source vector for this operator"
if extinction_field:
fields = self.extinction_fields
else:
fields = self.sources
V = LookupArray((fields, (parent, self.basis_container)),
dtype=np.complex128)
# define the functions to interpolate over the mesh
def elec_func(r):
return source_field.electric_field(s, r)
def mag_func(r):
return source_field.magnetic_field(s, r)
for field in fields:
if field in ("E", "nxE"):
field_func = elec_func
source_cross = field == "nxE"
elif field in ("H", "nxH"):
field_func = mag_func
source_cross = field == "nxH"
else:
raise ValueError(field)
for part in parent.iter_single():
basis = self.basis_container[part]
V[field,
part] = basis.weight_function(field_func,
self.integration_rule,
part.nodes, source_cross)
return V
