def test_5(self):
d = DataBlock()
d.comments = Comments(["Vgs=13", "Ig=14", "Datetime=2011-10-11 20:11:02",
"Vds=-13", "Calibration=SOLT"])
fi = DimSweep("Freq", 3)
gi = DimSweep("g", 4)
d["Vds"] = hfarray([1, 2, 3], dims=(fi,))
d["Id"] = hfarray([1, 2, 3, 4], dims=(gi,))
d.comments.property["Ig"].unit = "mA"
d.guess_units()
d.values_from_property()
self.assertEqual(d.Vds.unit, "V")
self.assertAllclose(d.Vds, [1, 2, 3])
self.assertEqual(d.Id.unit, "A")
self.assertAllclose(d.Id, [1, 2, 3, 4])
self.assertEqual(d.Freq.unit, "Hz")
self.assertEqual(d.comments.property["Vgs"].unit, "V")
self.assertEqual(d.comments.property["Ig"].unit, "mA")
self.assertEqual(d.Ig, 14)
self.assertEqual(d.Vgs, 13)
self.assertEqual(d.Ig.unit, "mA")
self.assertEqual(d.Vgs.unit, "V")
self.assertTrue("Datetime" in d.allvarnames)
def setUp(self):
self.d = DataBlock()
self.fi = DimSweep("Freq", 3)
self.gi = DimSweep("g", 4)
self.hi = DimSweep("h", 4)
self.d["Vds"] = hfarray([1, 2, 3], dims=(self.fi, ))
self.d["Id"] = hfarray([1, 2, 3, 4], dims=(self.gi, ))
def setUp(self):
self.d = DataBlock()
self.fi = DimSweep("Freq", 3)
self.gi = DimSweep("g", 4)
self.hi = DimSweep("h", 4)
self.d["Vds"] = hfarray([1, 2, 3], dims=(self.fi,))
self.d["Id"] = hfarray([1, 2, 3, 4], dims=(self.gi,))
def test_1(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", 3)
gi = DimSweep("g", 4)
dims = (fi,)
d["a"] = hfarray([1, 2, 3], dims=dims,
outputformat="%.5f", unit="V")
d["b"] = hfarray([10, 20, 30], dims=dims,
outputformat="%.7f", unit="A")
d["c"] = hfarray([10, 20, 30, 40], dims=(gi,),
outputformat="%.7f", unit="A")
w = d.filter(d["Freq[Hz]"] <= 1)
self.assertEqual(id(d.comments), id(w.comments))
self.assertEqual(w["Freq[Hz]"].dims, (DimSweep("Freq[Hz]", 2),))
self.assertEqual(w.a.dims, (DimSweep("Freq[Hz]", 2),))
self.assertEqual(w.b.dims, (DimSweep("Freq[Hz]", 2),))
self.assertEqual(w.c.dims, (DimSweep("g", 4),))
self.assertAllclose(w["Freq[Hz]"], [0, 1])
self.assertAllclose(w.a, [1, 2])
self.assertAllclose(w.b, [10, 20])
self.assertAllclose(w.c, [10, 20, 30, 40])
self.assertEqual(w.a.unit, "V")
self.assertEqual(w.b.unit, "A")
self.assertEqual(w.c.unit, "A")
def test_5(self):
d = DataBlock()
d.comments = Comments([
"Vgs=13", "Ig=14", "Datetime=2011-10-11 20:11:02", "Vds=-13",
"Calibration=SOLT"
])
fi = DimSweep("Freq", 3)
gi = DimSweep("g", 4)
d["Vds"] = hfarray([1, 2, 3], dims=(fi, ))
d["Id"] = hfarray([1, 2, 3, 4], dims=(gi, ))
d.comments.property["Ig"].unit = "mA"
d.guess_units()
d.values_from_property()
self.assertEqual(d.Vds.unit, "V")
self.assertAllclose(d.Vds, [1, 2, 3])
self.assertEqual(d.Id.unit, "A")
self.assertAllclose(d.Id, [1, 2, 3, 4])
self.assertEqual(d.Freq.unit, "Hz")
self.assertEqual(d.comments.property["Vgs"].unit, "V")
self.assertEqual(d.comments.property["Ig"].unit, "mA")
self.assertEqual(d.Ig, 14)
self.assertEqual(d.Vgs, 13)
self.assertEqual(d.Ig.unit, "mA")
self.assertEqual(d.Vgs.unit, "V")
self.assertTrue("Datetime" in d.allvarnames)
def test_1(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", 3)
gi = DimSweep("g", 4)
dims = (fi, )
d["a"] = hfarray([1, 2, 3], dims=dims, outputformat="%.5f", unit="V")
d["b"] = hfarray([10, 20, 30],
dims=dims,
outputformat="%.7f",
unit="A")
d["c"] = hfarray([10, 20, 30, 40],
dims=(gi, ),
outputformat="%.7f",
unit="A")
w = d.filter(d["Freq[Hz]"] <= 1)
self.assertEqual(id(d.comments), id(w.comments))
self.assertEqual(w["Freq[Hz]"].dims, (DimSweep("Freq[Hz]", 2), ))
self.assertEqual(w.a.dims, (DimSweep("Freq[Hz]", 2), ))
self.assertEqual(w.b.dims, (DimSweep("Freq[Hz]", 2), ))
self.assertEqual(w.c.dims, (DimSweep("g", 4), ))
self.assertAllclose(w["Freq[Hz]"], [0, 1])
self.assertAllclose(w.a, [1, 2])
self.assertAllclose(w.b, [10, 20])
self.assertAllclose(w.c, [10, 20, 30, 40])
self.assertEqual(w.a.unit, "V")
self.assertEqual(w.b.unit, "A")
self.assertEqual(w.c.unit, "A")
def getvar(db, key):
X = db[key]
dims = []
for x in X.dims:
if len(x):
dimcls = dimrep[cast_unicode(x[0].attrs.get("dimtype",
"DimSweep"))]
dim = dimcls(x[0].name.strip("/"),
x[0][...],
unit=x[0].attrs.get("unit", None))
dims.append(dim)
unit = X.attrs.get("unit", None)
outputformat = X.attrs.get("outputformat", None)
dtype = X.attrs.get("dtype", None)
if len(dims) == len(X.dims):
return hfarray(X.value,
dims=dims,
unit=unit,
dtype=dtype,
outputformat=outputformat)
else:
dimcls = dimrep[X.attrs.get("dimtype", "DimSweep")]
dim = dimcls(X.name.strip("/"), X[...], unit=unit)
return hfarray(X.value,
dims=(dim, ),
unit=unit,
dtype=dtype,
outputformat=outputformat)
def test_copy_2(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", 3)
dims = (fi, )
d.comments = Comments(["Hej=10"])
d["a"] = hfarray([1, 2, 3], dims=dims, outputformat="%.5f", unit="V")
d["b"] = hfarray([10, 20, 30],
dims=dims,
outputformat="%.7f",
unit="A")
c = d.copy()
self.assertEqual(c.allvarnames, d.allvarnames)
self.assertEqual(c.vardata.keys(), d.vardata.keys())
self.assertEqual(c.ivardata.keys(), d.ivardata.keys())
self.assertAllclose(c["Freq[Hz]"], d["Freq[Hz]"])
self.assertAllclose(d.a, [1, 2, 3])
self.assertAllclose(c.a, d.a)
self.assertAllclose(c.b, d.b)
self.assertFalse(id(d.comments) == id(c.comments))
c.a[0] = 7
c.b[0] = 7
self.assertAllclose(c.a, [7, 2, 3])
self.assertAllclose(c.b, [7, 20, 30])
self.assertAllclose(d.a, [1, 2, 3])
self.assertAllclose(d.b, [10, 20, 30])
def test_make_col_from_matrix_1(self):
header = ["S", "P"]
dims = (DimSweep("f", 1), DimMatrix_i("i", 2), DimMatrix_j("j", 2), )
columns = [hfarray([[[11, 12], [21, 22]]], dims=dims),
hfarray([10], dims=dims[:1])]
res = common.make_col_from_matrix(header, columns, "%s%s%s")
self.assertEqual(res, (["S11", "S12", "S21", "S22", "P"],
[11, 12, 21, 22, 10]))
def test_normalize_names_3(self):
db = DataBlock()
db.b = hfarray(1)
db["a1/a2 raw"] = hfarray(1)
db["a12"] = hfarray(2)
res = common.normalize_names(db)
self.assertTrue("a1/a2 raw" in res.vardata)
self.assertTrue("a12" in res.vardata)
def setUp(self):
self.db = db = DataBlock()
Sdims = (DimRep("freq", [1, 2]), DimRep("r", [1]),
DimMatrix_i("i", 2), DimMatrix_j("j", 2))
db.S = hfarray(np.array([[11, 12], [21, 22]])[None, None, :, :] *
np.array([[10], [20]])[..., None, None], dims=Sdims)
db.V = hfarray([1.23], Sdims[1:2])
db.Y = hfarray([1.23], (DimRep("k", [1]),))
def test_normalize_names_3(self):
db = DataBlock()
db.b = hfarray(1)
db["a1/a2 raw"] = hfarray(1)
db["a12"] = hfarray(2)
res = common.normalize_names(db)
self.assertTrue("a1/a2 raw" in res.vardata)
self.assertTrue("a12" in res.vardata)
def setUp(self):
Test_DataBlock.setUp(self)
self.a.P = hfarray([0.5, -.3, .5])
Sdims = (DimMatrix_i("i", 2), DimMatrix_j("j", 2))
self.a.S = hfarray([[11, 12], [21, 22]], dims=Sdims)
Wdims = (DimSweep("g", 1), DimMatrix_i("i", 2), DimMatrix_j("j", 2))
self.a.W = hfarray([[[11, 12], [21, 22]]], dims=Wdims)
self.a.T = hfarray(["Text"], dims=(DimSweep("text_i", ["index0"]),))
def setUp(self):
Test_DataBlock.setUp(self)
self.a.P = hfarray([0.5, -.3, .5])
Sdims = (DimMatrix_i("i", 2), DimMatrix_j("j", 2))
self.a.S = hfarray([[11, 12], [21, 22]], dims=Sdims)
Wdims = (DimSweep("g", 1), DimMatrix_i("i", 2), DimMatrix_j("j", 2))
self.a.W = hfarray([[[11, 12], [21, 22]]], dims=Wdims)
self.a.T = hfarray(["Text"], dims=(DimSweep("text_i", ["index0"]), ))
def read_file(cls,
filename,
make_complex=True,
property_to_vars=True,
guess_unit=True,
normalize=True,
make_matrix=False,
merge=True,
verbose=False,
multiple_files=True,
blockname=None,
**kw):
if multiple_files:
merge = False
obj = cls(make_complex=make_complex,
property_to_vars=property_to_vars,
guess_unit=guess_unit,
normalize=normalize,
make_matrix=make_matrix,
merge=merge,
verbose=verbose,
**kw)
obj.filename = filename
if multiple_files:
filenames = glob(filename)
else:
filenames = [filename]
objs = {}
for idx, fname in enumerate(filenames):
with open(fname) as fil:
res = obj.do_file(fil)
for k, v in res.items():
if isinstance(v, list):
for a in v:
a["FILENAME"] = hfarray(fname)
objs.setdefault(k, []).extend(v)
else:
v["FILENAME"] = hfarray(fname)
objs.setdefault(k, []).append(v)
if multiple_files:
res = {}
for k, v in objs.items():
res[k] = simple_merge_blocks(v)
res[k].guess_units()
else:
res = objs
if blockname:
if blockname in res:
return res[blockname]
else:
msg = "%r not a block in mdif file %r" % (blockname, filename)
MDIFError(msg)
else:
return res
def setUp(self):
self.db = db = DataBlock()
Sdims = (DimRep("freq", [1, 2]), DimRep("r", [1]), DimMatrix_i("i", 2),
DimMatrix_j("j", 2))
db.S = hfarray(np.array([[11, 12], [21, 22]])[None, None, :, :] *
np.array([[10], [20]])[..., None, None],
dims=Sdims)
db.V = hfarray([1.23], Sdims[1:2])
db.Y = hfarray([1.23], (DimRep("k", [1]), ))
def test_intersection_2(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", [10, 20, 30, 40, 50])
gi = DimSweep("g", 4)
dims = (fi, gi)
d["a"] = hfarray([[1, 2, 3, 4]] * 5, dims=dims,
outputformat="%.5f", unit="V")
x = DimSweep("Freq[Hz]", [20, 40])
dres = d.filter(hfarray(x))
self.assertAllclose(dres["Freq[Hz]"], [20, 40])
def proc_info(info, f, data, fn, noisedata):
info_list = info.upper().split()
if len(info_list) == 5:
info = freq_mult, twoporttype, datatype, rtype, z0 = info_list
elif len(info_list) == 3:
info = freq_mult, twoporttype, datatype = info_list
z0 = 1.
else:
msg = ("# format should only have 5 values this one has %d" %
len(info_list))
raise TouchstoneError(msg)
z0 = float(z0)
f = f * freqmultdict[freq_mult]
if fn is not None:
fn = fn * freqmultdict[freq_mult]
convfunc = dict(RI=re_im_to_complex,
DB=dB_angle_to_complex,
MA=mag_angle_to_complex)
if datatype not in convfunc:
pars = datatype
msg = "Unknown dataformat: %s, valid formats: RI, DB, MAG" % pars
raise TouchstoneError(msg)
out = np.empty((data.shape[0], data.shape[1] // 2), dtype=np.complex128)
out[...] = convfunc[datatype](data[:, ::2], data[:, 1::2])
if out.shape[1] == 1:
out.shape = (out.shape[0], 1, 1)
elif out.shape[1] == 4:
out.shape = (out.shape[0], 2, 2)
out = out.transpose(0, 2, 1)
else:
N = int(sqrt(out.shape[1]))
out.shape = (out.shape[0], N, N)
dims = (DimSweep("freq", f, unit="Hz"), )
if fn is not None and len(f) == len(fn) and np.allclose(f, fn):
noisedims = dims
elif fn is None:
noisedims = None
else:
noisedims = (DimSweep("freqn", fn, unit="Hz"), )
out = make_matrix(out, dims)
f = hfarray(f, dims)
db = DataBlock()
db[info[1]] = out
if noisedata is not None:
db.Rn = hfarray(noisedata[..., -1], dims=noisedims) * z0
db.Fmin = 10 ** (hfarray(noisedata[..., 0], dims=noisedims) / 10)
db.Gopt = hfarray(convfunc[datatype](noisedata[:, 1], noisedata[:, 2]),
dims=noisedims)
db.Z0 = hfarray(z0, unit="Ohm")
return db
def proc_info(info, f, data, fn, noisedata):
info_list = info.upper().split()
if len(info_list) == 5:
info = freq_mult, twoporttype, datatype, rtype, z0 = info_list
elif len(info_list) == 3:
info = freq_mult, twoporttype, datatype = info_list
z0 = 1.
else:
msg = ("# format should only have 5 values this one has %d" %
len(info_list))
raise TouchstoneError(msg)
z0 = float(z0)
f = f * freqmultdict[freq_mult]
if fn is not None:
fn = fn * freqmultdict[freq_mult]
convfunc = dict(RI=re_im_to_complex,
DB=dB_angle_to_complex,
MA=mag_angle_to_complex)
if datatype not in convfunc:
pars = datatype
msg = "Unknown dataformat: %s, valid formats: RI, DB, MAG" % pars
raise TouchstoneError(msg)
out = np.empty((data.shape[0], data.shape[1] // 2), dtype=np.complex128)
out[...] = convfunc[datatype](data[:, ::2], data[:, 1::2])
if out.shape[1] == 1:
out.shape = (out.shape[0], 1, 1)
elif out.shape[1] == 4:
out.shape = (out.shape[0], 2, 2)
out = out.transpose(0, 2, 1)
else:
N = int(sqrt(out.shape[1]))
out.shape = (out.shape[0], N, N)
dims = (DimSweep("freq", f, unit="Hz"), )
if fn is not None and len(f) == len(fn) and np.allclose(f, fn):
noisedims = dims
elif fn is None:
noisedims = None
else:
noisedims = (DimSweep("freqn", fn, unit="Hz"), )
out = make_matrix(out, dims)
f = hfarray(f, dims)
db = DataBlock()
db[info[1]] = out
if noisedata is not None:
db.Rn = hfarray(noisedata[..., -1], dims=noisedims) * z0
db.Fmin = 10**(hfarray(noisedata[..., 0], dims=noisedims) / 10)
db.Gopt = hfarray(convfunc[datatype](noisedata[:, 1], noisedata[:, 2]),
dims=noisedims)
db.Z0 = hfarray(z0, unit="Ohm")
return db
def merge_blocks(blocks, hyper=False, indexed=False):
db = DataBlock()
dimpartialgroups = OrderedDict()
for b in blocks:
parts = get_partials(b)
partgroup = dimpartialgroups.setdefault(tuple(parts.keys()), {})
for k, v in parts.items():
partgroup.setdefault(k, []).extend(v)
for idx, dims in enumerate(dimpartialgroups.values(), 1):
for k, v in dims.items():
dims = (DimSweep("INDEX%s" % idx, len(v)),)
db[k] = hfarray([x.data[0] for x in v],
dims=dims, unit=v[0].unit)
varnames = set()
for b in blocks:
for k, v in b.ivardata.items():
if k not in db:
db[k] = v
for k in b.vardata.keys():
varnames.add(k)
for vname in varnames:
v = []
for b in blocks:
if vname not in b:
continue
partials = get_partials(b)
v.append(b[vname])
if v:
k = tuple(partials.keys())
if k:
ri = (db[tuple(dimpartialgroups[k].keys())[0]].dims[0],)
else:
ri = tuple()
value = hfarray(v, dims=ri + v[0].dims, unit=v[0].unit)
if v[0].dims and isinstance(v[0].dims[0], DimSweep):
value = value.reorder_dimensions(v[0].dims[0])
db[vname] = value
cmt = Comments()
for block in blocks:
if block.comments:
cmt.extend(block.comments)
db.comments = cmt
db.blockname = blocks[0].blockname
if hyper:
for vnames in dimpartialgroups.keys():
if vnames:
hyperindex = db[vnames[0]].dims[0]
db = db.hyper(vnames, hyperindex, all=True)
db = db.squeeze()
return db
def merge_blocks(blocks, hyper=False, indexed=False):
db = DataBlock()
dimpartialgroups = OrderedDict()
for b in blocks:
parts = get_partials(b)
partgroup = dimpartialgroups.setdefault(tuple(parts.keys()), {})
for k, v in parts.items():
partgroup.setdefault(k, []).extend(v)
for idx, dims in enumerate(dimpartialgroups.values(), 1):
for k, v in dims.items():
dims = (DimSweep("INDEX%s" % idx, len(v)), )
db[k] = hfarray([x.data[0] for x in v], dims=dims, unit=v[0].unit)
varnames = set()
for b in blocks:
for k, v in b.ivardata.items():
if k not in db:
db[k] = v
for k in b.vardata.keys():
varnames.add(k)
for vname in varnames:
v = []
for b in blocks:
if vname not in b:
continue
partials = get_partials(b)
v.append(b[vname])
if v:
k = tuple(partials.keys())
if k:
ri = (db[tuple(dimpartialgroups[k].keys())[0]].dims[0], )
else:
ri = tuple()
value = hfarray(v, dims=ri + v[0].dims, unit=v[0].unit)
if v[0].dims and isinstance(v[0].dims[0], DimSweep):
value = value.reorder_dimensions(v[0].dims[0])
db[vname] = value
cmt = Comments()
for block in blocks:
if block.comments:
cmt.extend(block.comments)
db.comments = cmt
db.blockname = blocks[0].blockname
if hyper:
for vnames in dimpartialgroups.keys():
if vnames:
hyperindex = db[vnames[0]].dims[0]
db = db.hyper(vnames, hyperindex, all=True)
db = db.squeeze()
return db
def test_2(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", 3)
gi = DimSweep("P[W]", 3)
dims = (fi,)
dims2 = (fi, gi)
dims3 = (gi,)
d["f"] = hfarray([[1, 2, 3]] * 3, dims=dims2)
d["P[W]"] = hfarray([10, 20, 30], dims=dims)
self.assertEqual(d.allvarnames, ["Freq[Hz]", "P[W]", "f"])
self.assertAllclose(d["P[W]"], [10, 20, 30])
def test_2(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", 3)
gi = DimSweep("P[W]", 3)
dims = (fi, )
dims2 = (fi, gi)
dims3 = (gi, )
d["f"] = hfarray([[1, 2, 3]] * 3, dims=dims2)
d["P[W]"] = hfarray([10, 20, 30], dims=dims)
self.assertEqual(d.allvarnames, ["Freq[Hz]", "P[W]", "f"])
self.assertAllclose(d["P[W]"], [10, 20, 30])
def setUp(self):
self.db = db = DataBlock()
fi = DimSweep("freq", [1e9, 2e9, 3e9, 4e9], unit="Hz")
db.y = hfarray([1, 2, 3, 4], dims=(fi, ), unit="V")
db.z = hfarray([1, 2, 3, 4 + 0j], dims=(fi, ), unit="Ohm")
self.fig = plt.figure(1)
self.ax = plt.subplot(111, projection=self.proj)
self.lines = plt.plot(self.db.y)
self.outpath = p = path(basepath / "savetest")
if not p.exists(): # pragma: no cover
p.makedirs()
def setUp(self):
self.db = db = DataBlock()
fi = DimSweep("freq", [1e9, 2e9, 3e9, 4e9], unit="Hz")
db.y = hfarray([1, 2, 3, 4], dims=(fi, ), unit="V")
db.z = hfarray([1, 2, 3, 4 + 0j], dims=(fi, ), unit="Ohm")
self.fig = plt.figure(1)
self.ax = plt.subplot(111, projection=self.proj)
self.lines = plt.plot(self.db.y)
self.outpath = p = path(basepath / "savetest")
if not p.exists(): # pragma: no cover
p.makedirs()
def test_make_matrix_1(self):
a = hfarray([1, 10])
b = hfarray([2, 20])
c = hfarray([3, 30])
d = hfarray([4, 40])
i = DimMatrix_i("i", 2)
j = DimMatrix_j("j", 2)
fi = DimSweep("freq", [0, 1])
matrix = hfmath.make_matrix(a, b, c, d)
self.assertTrue(isinstance(matrix, hfarray))
self.assertEqual(matrix.dims, (fi, i, j))
self.assertAllclose(matrix, [[[1, 2], [3, 4]], [[10, 20], [30, 40]]])
def test_intersection_2(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", [10, 20, 30, 40, 50])
gi = DimSweep("g", 4)
dims = (fi, gi)
d["a"] = hfarray([[1, 2, 3, 4]] * 5,
dims=dims,
outputformat="%.5f",
unit="V")
x = DimSweep("Freq[Hz]", [20, 40])
dres = d.filter(hfarray(x))
self.assertAllclose(dres["Freq[Hz]"], [20, 40])
def test_1(self):
d = DataBlock()
dims = (DimSweep("Freq[Hz]", 3),)
d.P = hfarray([1, 2, 3], dims=dims)
d.L = hfarray([10, 20, 30], dims=dims)
self.assertEqual(d.allvarnames, ["Freq[Hz]", "P", "L"])
d.rename("P", "H")
self.assertEqual(d.allvarnames, ["Freq[Hz]", "H", "L"])
d.rename("Freq[Hz]", "f")
self.assertEqual(d.allvarnames, ["f", "H", "L"])
d.rename("foo", "bar")
self.assertEqual(d.allvarnames, ["f", "H", "L"])
def test_1(self):
d = DataBlock()
dims = (DimSweep("Freq[Hz]", 3), )
d.P = hfarray([1, 2, 3], dims=dims)
d.L = hfarray([10, 20, 30], dims=dims)
self.assertEqual(d.allvarnames, ["Freq[Hz]", "P", "L"])
d.rename("P", "H")
self.assertEqual(d.allvarnames, ["Freq[Hz]", "H", "L"])
d.rename("Freq[Hz]", "f")
self.assertEqual(d.allvarnames, ["f", "H", "L"])
d.rename("foo", "bar")
self.assertEqual(d.allvarnames, ["f", "H", "L"])
def make_block_iterator(data, first=False):
if not data.vardata: # only x-values
sweepvars = ()
head = data.ivardata.keys()[0]
dim = data.ivardata[head]
header = [
head,
]
fmts = (data[head].outputformat, )
columns = (hfarray(dim), )
blockname = data.blockname
comments = data.comments
yield (sweepvars, header, fmts, columns, blockname, comments)
raise StopIteration
d = data.vardata.values()[0]
if ismatrix(d):
dimsnames = [x.name for x in d.dims[:-2]]
else:
dimsnames = [x.name for x in d.dims]
dimsdata = [hfarray(data.ivardata[iname]) for iname in dimsnames]
dimsidx = [range(x.shape[0]) for x in dimsdata]
if first:
if data.comments:
comments = data.comments.copy()
comments.property.clear()
else:
comments = Comments()
else:
comments = Comments()
for enum, idx in enumerate(itertools.product(*dimsidx[1:])):
sweepvars = []
for iname, dim, i in zip(dimsnames[1:], dimsdata[1:], idx):
fmt = getattr(dim, "outputformat", "%.16e")
sweepvars.append((iname, fmt, dim[i]))
if dimsnames:
header = [dimsnames[0]] + data.vardata.keys()
columns = dimsdata[:1] + [
col[(slice(None), ) + idx] for col in data.vardata.values()
]
fmts = [getattr(x, "outputformat", "%.16e") for x in columns]
else:
header = []
columns = []
fmts = []
for k, v in data.vardata.items():
if v.dims == tuple():
comments.property[k] = v
if enum:
comments = Comments()
yield (sweepvars, header, fmts, columns, data.blockname, comments)
def test_wrong_version_1(self):
ia = DimSweep("a", 1, unit="")
d1 = DataBlock()
d1.b = hfarray([2], dims=(ia, ))
d2 = DataBlock()
d2.b = hfarray([3], dims=(ia, ))
fname = testpath / "testdata/hdf5/v02/savetest/res_1.hdf5"
with hdf5context(fname, mode="w") as fil:
save_hdf5_v01(d1, fil)
self.assertRaises(Exception, append_hdf5, d2, fil)
# append_hdf5(d2, fil)
fname.unlink()
def test_11(self):
ia = DimSweep("a", 1)
d = DataBlock()
d.comments = Comments(["Hej=10"])
# import pdb;pdb.set_trace()
d.b = hfarray([u"kalle"], dims=(ia, ), unit="V")
d.c = hfarray(u"kalle")
fname = testpath / "testdata/hdf5/v02/savetest/res_11.hdf5"
self.savefun[0](d, fname)
d2 = readfun(fname)
self.assertEqual(d2.b[0], u"kalle")
self.assertEqual(d2.c, u"kalle")
fname.unlink()
def test_4(self):
d = DataBlock()
fi = DimSweep("Freq", 3)
gi = DimSweep("g", 4)
d["Vds"] = hfarray([1, 2, 3], dims=(fi,))
d["Id"] = hfarray([1, 2, 3, 4], dims=(gi,))
d.guess_units(["Freq", "Vds", "Ig"])
self.assertEqual(d.Vds.unit, "V")
self.assertAllclose(d.Vds, [1, 2, 3])
self.assertEqual(d.Id.unit, None)
self.assertAllclose(d.Id, [1, 2, 3, 4])
self.assertEqual(d.Freq.unit, "Hz")
def test_1(self):
db = DataBlock()
Sdims = (DimRep("freq", [1, 2]) ,DimRep("r", [1]), DimMatrix_i("i", 2), DimMatrix_j("j", 2))
db.S = hfarray(np.array([[11, 12], [21, 22]])[np.newaxis, np.newaxis, :, :] * np.array([[10], [20]])[..., np.newaxis, np.newaxis], dims=Sdims)
db.V = hfarray([1.23], Sdims[1:2])
db.Y = hfarray([1.23], (DimRep("k", [1]),))
out = dset.subset_datablock_by_dims(dset.convert_matrices_to_elements(db), Sdims[:-2])
self.assertTrue("V" in out)
self.assertTrue("S11" in out)
self.assertTrue("S12" in out)
self.assertTrue("S21" in out)
self.assertTrue("S22" in out)
self.assertFalse("Y" in out)
def test_4(self):
d = DataBlock()
fi = DimSweep("Freq", 3)
gi = DimSweep("g", 4)
d["Vds"] = hfarray([1, 2, 3], dims=(fi, ))
d["Id"] = hfarray([1, 2, 3, 4], dims=(gi, ))
d.guess_units(["Freq", "Vds", "Ig"])
self.assertEqual(d.Vds.unit, "V")
self.assertAllclose(d.Vds, [1, 2, 3])
self.assertEqual(d.Id.unit, None)
self.assertAllclose(d.Id, [1, 2, 3, 4])
self.assertEqual(d.Freq.unit, "Hz")
def test_2(self):
d = DataBlock()
fi = DimSweep("Freq", 3, unit="m")
gi = DimSweep("g", 4)
d["Vds"] = hfarray([1, 2, 3], dims=(fi, ), unit="A")
d["Id"] = hfarray([1, 2, 3, 4], dims=(gi, ), unit="V")
d.guess_units()
self.assertEqual(d.Vds.unit, "A")
self.assertAllclose(d.Vds, [1, 2, 3])
self.assertEqual(d.Id.unit, "V")
self.assertAllclose(d.Id, [1, 2, 3, 4])
self.assertEqual(d.Freq.unit, "m")
def test_2(self):
d = DataBlock()
fi = DimSweep("Freq", 3, unit="m")
gi = DimSweep("g", 4)
d["Vds"] = hfarray([1, 2, 3], dims=(fi,), unit="A")
d["Id"] = hfarray([1, 2, 3, 4], dims=(gi,), unit="V")
d.guess_units()
self.assertEqual(d.Vds.unit, "A")
self.assertAllclose(d.Vds, [1, 2, 3])
self.assertEqual(d.Id.unit, "V")
self.assertAllclose(d.Id, [1, 2, 3, 4])
self.assertEqual(d.Freq.unit, "m")
def test_11(self):
ia = DimSweep("a", 1)
d = DataBlock()
d.comments = Comments(["Hej=10"])
# import pdb;pdb.set_trace()
d.b = hfarray([u"kalle"], dims=(ia, ), unit="V")
d.c = hfarray(u"kalle")
fname = testpath / "testdata/hdf5/v02/savetest/res_11.hdf5"
self.savefun[0](d, fname)
d2 = readfun(fname)
self.assertEqual(d2.b[0], u"kalle")
self.assertEqual(d2.c, u"kalle")
fname.unlink()
def test_wrong_version_2(self):
ia = DimSweep("a", 1, unit="")
d1 = DataBlock()
d1.b = hfarray([2], dims=(ia,))
d2 = DataBlock()
d2.b = hfarray([3], dims=(ia,))
fname = testpath / "testdata/hdf5/v02/savetest/res_1.hdf5"
with hdf5context(fname, mode="w") as fil:
save_hdf5_v01(d1, fil)
self.assertRaises(Exception, append_hdf5, d2, fil)
# append_hdf5(d2, fil)
fname.unlink()
def setUp(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", 3)
gi = DimSweep("g", 4)
dims = (fi,)
d["a"] = hfarray([3, 2, 1], dims=dims,
outputformat="%.5f", unit="V")
d["b"] = hfarray([30, 10, 20], dims=dims,
outputformat="%.7f", unit="A")
d["c"] = hfarray([30, 20, 10, 40], dims=(gi,),
outputformat="%.7f", unit="A")
d["ac"] = d.a * d.c
self.d = d
def make_block_iterator(data, first=False):
if not data.vardata: # only x-values
sweepvars = ()
head = data.ivardata.keys()[0]
dim = data.ivardata[head]
header = [head, ]
fmts = (data[head].outputformat,)
columns = (hfarray(dim),)
blockname = data.blockname
comments = data.comments
yield (sweepvars, header, fmts, columns,
blockname, comments)
raise StopIteration
d = data.vardata.values()[0]
if ismatrix(d):
dimsnames = [x.name for x in d.dims[:-2]]
else:
dimsnames = [x.name for x in d.dims]
dimsdata = [hfarray(data.ivardata[iname]) for iname in dimsnames]
dimsidx = [range(x.shape[0]) for x in dimsdata]
if first:
if data.comments:
comments = data.comments.copy()
comments.property.clear()
else:
comments = Comments()
else:
comments = Comments()
for enum, idx in enumerate(itertools.product(*dimsidx[1:])):
sweepvars = []
for iname, dim, i in zip(dimsnames[1:], dimsdata[1:], idx):
fmt = getattr(dim, "outputformat", "%.16e")
sweepvars.append((iname, fmt, dim[i]))
if dimsnames:
header = [dimsnames[0]] + data.vardata.keys()
columns = dimsdata[:1] + [col[(slice(None), ) + idx]
for col in data.vardata.values()]
fmts = [getattr(x, "outputformat", "%.16e") for x in columns]
else:
header = []
columns = []
fmts = []
for k, v in data.vardata.items():
if v.dims == tuple():
comments.property[k] = v
if enum:
comments = Comments()
yield (sweepvars, header, fmts, columns,
data.blockname, comments)
def setUp(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", 3)
gi = DimRep("g", 2)
hi = DimRep("h", 3)
ji = DimRep("j", 4)
dims = (fi, )
d["a"] = hfarray([3, 2, 1], dims=dims, outputformat="%.5f", unit="V")
d["b"] = hfarray([30, 10], dims=(gi, ), outputformat="%.7f", unit="A")
d["c"] = hfarray([[30, 20, 10, 40], [20, 30, 40, 10]],
dims=(gi, hi),
outputformat="%.7f",
unit="A")
self.d = d
def setUp(self):
d = DataBlock()
gi = DimSweep("Index", 6)
ri = DimRep("Rep", 2)
dims = (gi,)
d["a"] = hfarray([1, 1, 2, 2, 3, 3], dims=dims,
outputformat="%.5f", unit="V")
d["b"] = hfarray([10, 20, 10, 20, 10, 20],
dims=(gi,), outputformat="%.7f", unit="A")
d["c"] = hfarray([10.1, 20.1, 10.2, 20.2, 10.3, 20.3],
dims=(gi,), outputformat="%.7f", unit="A")
d["d"] = hfarray([17, 19], dims=(ri,),
outputformat="%.7f", unit="A")
self.d = d
def setUp(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", 3)
gi = DimRep("g", 2)
hi = DimRep("h", 3)
ji = DimRep("j", 4)
dims = (fi,)
d["a"] = hfarray([3, 2, 1], dims=dims,
outputformat="%.5f", unit="V")
d["b"] = hfarray([30, 10], dims=(gi,),
outputformat="%.7f", unit="A")
d["c"] = hfarray([[30, 20, 10, 40], [20, 30, 40, 10]],
dims=(gi, hi), outputformat="%.7f", unit="A")
self.d = d
def test_make_col_from_matrix_1(self):
header = ["S", "P"]
dims = (
DimSweep("f", 1),
DimMatrix_i("i", 2),
DimMatrix_j("j", 2),
)
columns = [
hfarray([[[11, 12], [21, 22]]], dims=dims),
hfarray([10], dims=dims[:1])
]
res = common.make_col_from_matrix(header, columns, "%s%s%s")
self.assertEqual(
res, (["S11", "S12", "S21", "S22", "P"], [11, 12, 21, 22, 10]))
def test_cant_append(self):
i1 = DimSweep("a", 1, unit="s", outputformat="")
i2 = DimSweep("INDEX", 2, unit="s")
iexpand = DimRep("INDEX", 1, unit="s", outputformat="")
d1 = DataBlock()
d1.b = hfarray([2], dims=(i1, ), outputformat="")
d1.c = hfarray(3)
d2 = DataBlock()
d2.b = hfarray([3], dims=(i1, ))
fname = testpath / "testdata/hdf5/v02/savetest/res_1.hdf5"
with hdf5context(fname, mode="w") as fil:
savefun(d1, fil, expandable=True, expanddim=iexpand)
self.assertRaises(ValueError, append_hdf5, d2, fil)
fname.unlink()
def test_1(self):
d = DataBlock()
fi = DimSweep("Freq", 3)
gi = DimSweep("g", 4)
d["Vds"] = hfarray([1, 2, 3], dims=(fi,))
d["Id"] = hfarray([1, 2, 3, 4], dims=(gi,))
d.guess_units()
d.values_from_property()
self.assertEqual(d.Vds.unit, "V")
self.assertAllclose(d.Vds, [1, 2, 3])
self.assertEqual(d.Id.unit, "A")
self.assertAllclose(d.Id, [1, 2, 3, 4])
self.assertEqual(d.Freq.unit, "Hz")
def test_1(self):
d = DataBlock()
fi = DimSweep("Freq", 3)
gi = DimSweep("g", 4)
d["Vds"] = hfarray([1, 2, 3], dims=(fi, ))
d["Id"] = hfarray([1, 2, 3, 4], dims=(gi, ))
d.guess_units()
d.values_from_property()
self.assertEqual(d.Vds.unit, "V")
self.assertAllclose(d.Vds, [1, 2, 3])
self.assertEqual(d.Id.unit, "A")
self.assertAllclose(d.Id, [1, 2, 3, 4])
self.assertEqual(d.Freq.unit, "Hz")
def test_cant_append(self):
i1 = DimSweep("a", 1, unit="s", outputformat="")
i2 = DimSweep("INDEX", 2, unit="s")
iexpand = DimRep("INDEX", 1, unit="s", outputformat="")
d1 = DataBlock()
d1.b = hfarray([2], dims=(i1,), outputformat="")
d1.c = hfarray(3)
d2 = DataBlock()
d2.b = hfarray([3], dims=(i1,))
fname = testpath / "testdata/hdf5/v02/savetest/res_1.hdf5"
with hdf5context(fname, mode="w") as fil:
savefun(d1, fil, expandable=True, expanddim=iexpand)
self.assertRaises(ValueError, append_hdf5, d2, fil)
fname.unlink()
def test_1(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", 3)
gi = DimSweep("P[W]", 3)
dims = (fi, )
dims2 = (fi, gi)
d["f"] = hfarray([[1, 2, 3]] * 3, dims=dims2, outputformat="%.5f")
d["P"] = hfarray([10, 20, 30], dims=dims, outputformat="%.7f")
self.assertEqual(d["f"].outputformat, "%.5f")
self.assertEqual(d["P"].outputformat, "%.7f")
d.outputformat = "%.9f"
for v in d.ivardata.values():
self.assertEqual(v.outputformat, "%.9f")
for v in d.vardata.values():
self.assertEqual(v.outputformat, "%.9f")
def build_meas_state(data):
state_names = data["measstate"][0, 0]["props"][0, 0][0]
state_data = data["measstate"][0, 0]["values"][0, 0][0]
d = DataBlock()
for k, v in zip(state_names, state_data):
if k[0] == "Index":
d["Index"] = DimPartial("Index", v[0])
else:
if v[0].ndim == 1:
d[k[0]] = hfarray(make_real(v[0][0]))
else:
d[k[0]] = hfarray(make_real(v[0]))
if d[k[0]].dtype.name.startswith("unicode"):
d[k[0]] = hfarray(np.char.encode(d[k[0]], "cp1252", errors="replace"), dims=d[k[0]].dims)
return d
def test_1(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", 3)
gi = DimSweep("P[W]", 3)
dims = (fi,)
dims2 = (fi, gi)
d["f"] = hfarray([[1, 2, 3]] * 3, dims=dims2, outputformat="%.5f")
d["P"] = hfarray([10, 20, 30], dims=dims, outputformat="%.7f")
self.assertEqual(d["f"].outputformat, "%.5f")
self.assertEqual(d["P"].outputformat, "%.7f")
d.outputformat = "%.9f"
for v in d.ivardata.values():
self.assertEqual(v.outputformat, "%.9f")
for v in d.vardata.values():
self.assertEqual(v.outputformat, "%.9f")
def test_intersection_1(self):
d = DataBlock()
fi = DimSweep("Freq[Hz]", [10, 20, 30, 40, 50])
gi = DimSweep("g", 4)
dims = (fi, gi)
d["a"] = hfarray([[1, 2, 3, 4]] * 5, dims=dims,
outputformat="%.5f", unit="V")
x = DimSweep("Freq", [20, 40])
reset_hftools_warnings()
self.assertHFToolsWarning(d.filter, hfarray(x))
with warnings.catch_warnings() as log:
warnings.resetwarnings()
warnings.simplefilter("ignore", HFToolsWarning)
d.filter(hfarray(x))
reset_hftools_warnings()
def setUp(self):
self.I = I = DimSweep("I", [1, 2])
self.J = J = DimSweep("J", [10, 20, 30])
self.K = K = DimSweep("K", [100, 200, 300, 400])
self.mi = mi = DimMatrix_i("i", [0, 1])
self.mj = mj = DimMatrix_j("j", [0, 1])
self.i, self.j, self.k = (i, j, k) = list(map(hfarray, (I, J, K)))
self.a = i * j * k
self.b = hfarray(i * j * k, unit="Hz", outputformat="%.3f")
cdims = (DimMatrix_i("i", 2), DimMatrix_j("j", 2))
self.c = hfarray([[11, 12], [21, 22]], dims=cdims)
self.m = hfarray([[[1., 2], [3, 4]]] * 3, dims=(J, mi, mj))
self.m2 = hfarray([[1., 2], [3, 4]], dims=(mi, mj))
def fmt_mdif_block(dims, db):
dimnames = [x.name for x in dims]
fmts = [x.outputformat for x in dims]
for coord in itertools.product(*[x.data for x in dims[1:]]):
for iname, fmt, value in zip(dimnames[1:], fmts[1:], coord):
# import pdb;pdb.set_trace()
yield [("VAR SWEEP.%s(real) = " + fmt) % (iname, value)]
blockname = db.blockname
if blockname is None:
blockname = "DATABLOCK"
yield ["BEGIN %s" % blockname]
attribnames, attribdata = zip(*[(k, v) for (k, v) in db.vardata.items() if v.dims == dims[1:]])
attribheader = format_complex_header(attribnames, attribdata, "%s(real)", "%s(complex)", None, unit_fmt=False)
for name, data in zip(attribheader, attribdata):
yield [("# %s = %s" % (name, data.outputformat)) % data[coord]]
header, columns = zip(*[(k, v) for (k, v) in db.vardata.items() if v.dims == dims])
header = (dims[0].name,) + header
idx = (Ellipsis,) + coord
columns = [col[idx] for col in columns]
columns = [hfarray(dims[0])] + columns
outheader = format_complex_header(header, columns, "%s(real)", "%s(complex)", None, unit_fmt=False)
yield ["% " + " ".join(outheader)]
fmts = [x.outputformat for x in columns]
# import pdb;pdb.set_trace()
for row in zip(*columns):
out = []
for elem, fmt in zip(row, fmts):
out.extend(format_elem(fmt, elem))
yield out
yield ["END"]
def solve_Ab(A, b, squeeze=True):
AA, bb = make_same_dims(A, b)
x = np.linalg.solve(AA, bb)
result = hfarray(x, dims=bb.dims)
if squeeze:
result = result.squeeze()
return result
def check_passive(S):
eig = np.linalg.eigvals
out = []
for s in S:
lambda_max = max(abs(eig(s)))
out.append(lambda_max)
return hfarray(out, dims=S.dims[:1])
def test_8(self):
d = DataBlock()
d.b = hfarray([2], dims=(DimSweep("a", 1), ))
fname = testpath / "testdata/hdf5/v02/savetest/res_8.hdf5"
with h5py.File(fname, mode="w") as fil:
self.savefun[0](d, fil)
fname.unlink()
