def test_constructor(self):
"""
Test the `NetworkSet()` constructor.
"""
# NetworkSet without input parameter is an empty NetworkSet
self.assertEqual(rf.NetworkSet(), rf.NetworkSet([]))
# the required parameter must be a list
self.assertRaises(ValueError, rf.NetworkSet, 0)
self.assertRaises(ValueError, rf.NetworkSet, 'wrong')
self.assertRaises(ValueError, rf.NetworkSet, False)
# all elements should be of Network type
self.assertRaises(TypeError, rf.NetworkSet, [self.ntwk1, 0])
self.assertRaises(TypeError, rf.NetworkSet, [self.ntwk1, 'wrong'])
# all Networks should share the same Frequency
self.assertRaises(ValueError, rf.NetworkSet, [self.ntwk_freq1_1p, self.ntwk_freq2_1p])
# all Networks should share the same number of ports
self.assertRaises(ValueError, rf.NetworkSet, [self.ntwk_freq1_1p, self.ntwk_freq1_2p])
# expected situations: same number of ports and frequencies
ntwk_set1 = rf.NetworkSet([self.ntwk_freq1_1p, self.ntwk_freq1_1p])
ntwk_set2 = rf.NetworkSet([self.ntwk_freq2_1p, self.ntwk_freq2_1p])
def test_constructor(self):
"""
Test the `NetworkSet()` constructor.
"""
# NetworkSet requires at least one parameter
self.assertRaises(TypeError, rf.NetworkSet)
# the required parameter must be a list
self.assertRaises(ValueError, rf.NetworkSet, 0)
self.assertRaises(ValueError, rf.NetworkSet, 'wrong')
self.assertRaises(ValueError, rf.NetworkSet, False)
# the list (or dict) must not be empty
self.assertRaises(ValueError, rf.NetworkSet, [])
self.assertRaises(ValueError, rf.NetworkSet, {})
# all elements should be of Network type
self.assertRaises(TypeError, rf.NetworkSet, [self.ntwk1, 0])
self.assertRaises(TypeError, rf.NetworkSet, [self.ntwk1, 'wrong'])
# all Networks should share the same Frequency
self.assertRaises(ValueError, rf.NetworkSet, [self.ntwk_freq1_1p, self.ntwk_freq2_1p])
# all Networks should share the same number of ports
self.assertRaises(ValueError, rf.NetworkSet, [self.ntwk_freq1_1p, self.ntwk_freq1_2p])
# expected situations: same number of ports and frequencies
ntwk_set1 = rf.NetworkSet([self.ntwk_freq1_1p, self.ntwk_freq1_1p])
ntwk_set2 = rf.NetworkSet([self.ntwk_freq2_1p, self.ntwk_freq2_1p])
def setUp(self):
"""
Initialize tests.
"""
# Touchstone files
self.test_dir = os.path.dirname(os.path.abspath(__file__))+'/'
self.ntwk1 = rf.Network(os.path.join(self.test_dir, 'ntwk1.s2p'))
self.ntwk2 = rf.Network(os.path.join(self.test_dir, 'ntwk2.s2p'))
self.ntwk3 = rf.Network(os.path.join(self.test_dir, 'ntwk3.s2p'))
self.ntwk4 = rf.Network(os.path.join(self.test_dir, 'ntwk4.s2p'))
# dummy networks of various frequency and port shapes
self.freq1 = rf.Frequency(75, 110, 101, 'ghz')
self.freq2 = rf.Frequency(75, 110, 201, 'ghz')
self.ntwk_freq1_1p = rf.Network(frequency=self.freq1)
self.ntwk_freq1_1p.s = np.random.rand(len(self.freq1), 1, 1)
self.ntwk_freq1_2p = rf.Network(frequency=self.freq1)
self.ntwk_freq1_2p.s = np.random.rand(len(self.freq1), 2, 2)
self.ntwk_freq2_1p = rf.Network(frequency=self.freq2)
self.ntwk_freq2_1p.s = np.random.rand(len(self.freq2), 1, 1)
self.ntwk_freq2_2p = rf.Network(frequency=self.freq2)
self.ntwk_freq2_2p.s = np.random.rand(len(self.freq2), 2, 2)
# dummy networks with associated parameters
# total number of different networks
self.params = [
{'a':0, 'X':10, 'c':'A'},
{'a':1, 'X':10, 'c':'A'},
{'a':2, 'X':10, 'c':'A'},
{'a':1, 'X':20, 'c':'A'},
{'a':0, 'X':20, 'c':'A'},
]
# for write_mdif
self.params_datatypes = {'a': 'int', 'X': 'double', 'c': 'string'}
# create M dummy networks
self.ntwks_params = [rf.Network(frequency=self.freq1,
s=np.random.rand(len(self.freq1),2,2),
name=f'ntwk_{m}',
comment=f'ntwk_{m}',
params=params) \
for (m, params) in enumerate(self.params) ]
# Test nominal
self.ns = rf.NetworkSet([self.ntwk1, self.ntwk2, self.ntwk3])
# Create NetworkSet from a list of Network containing a .params dict parameters
self.ns_params = rf.NetworkSet(self.ntwks_params)
def setUp(self):
self.n_ports = 2
self.wg = rf.RectangularWaveguide(rf.F(75, 100, 3),
a=100 * rf.mil,
z0=50)
wg = self.wg
wg.frequency = rf.F.from_f([100])
self.X = wg.random(n_ports=2, name='X')
self.Y = wg.random(n_ports=2, name='Y')
self.gamma_f = wg.random(n_ports=1, name='gamma_f')
self.gamma_r = wg.random(n_ports=1, name='gamma_r')
ideals = [
wg.short(nports=2, name='short'),
wg.open(nports=2, name='open'),
wg.match(nports=2, name='load'),
wg.thru(name='thru'),
]
measured_sets = []
for ideal in ideals:
ns = rf.NetworkSet([self.measure(ideal) for k in range(3)])
measured_sets.append(ns)
self.calset = Dot(cal_class=EightTerm,
ideals=ideals,
measured_sets=measured_sets,
switch_terms=(self.gamma_f, self.gamma_r))
def setUp(self):
"""
Initialize tests.
"""
# Touchstone files
self.test_dir = os.path.dirname(os.path.abspath(__file__))+'/'
self.ntwk1 = rf.Network(os.path.join(self.test_dir, 'ntwk1.s2p'))
self.ntwk2 = rf.Network(os.path.join(self.test_dir, 'ntwk2.s2p'))
self.ntwk3 = rf.Network(os.path.join(self.test_dir, 'ntwk3.s2p'))
self.ntwk4 = rf.Network(os.path.join(self.test_dir, 'ntwk4.s2p'))
# dummy networks of various frequency and port shapes
self.freq1 = rf.Frequency(75, 110, 101, 'ghz')
self.freq2 = rf.Frequency(75, 110, 201, 'ghz')
self.ntwk_freq1_1p = rf.Network(frequency=self.freq1)
self.ntwk_freq1_1p.s = np.random.rand(len(self.freq1), 1, 1)
self.ntwk_freq1_2p = rf.Network(frequency=self.freq1)
self.ntwk_freq1_2p.s = np.random.rand(len(self.freq1), 2, 2)
self.ntwk_freq2_1p = rf.Network(frequency=self.freq2)
self.ntwk_freq2_1p.s = np.random.rand(len(self.freq2), 1, 1)
self.ntwk_freq2_2p = rf.Network(frequency=self.freq2)
self.ntwk_freq2_2p.s = np.random.rand(len(self.freq2), 2, 2)
# Test nominal
self.ns = rf.NetworkSet([self.ntwk1, self.ntwk2, self.ntwk3])
def test_filter(self):
"""
Test the `filter` method.
"""
ns_unfiltered = rf.NetworkSet([self.ntwk2, self.ntwk1, self.ntwk3])
ns_filtered = ns_unfiltered.filter('ntwk2')
self.assertEqual(len(ns_filtered), 1)
self.assertEqual(ns_filtered[0], self.ntwk2)
def test_copy(self):
"""
Test the `copy()`method and the equality of two NetworkSets
"""
copy = self.ns.copy()
self.assertEqual(copy, self.ns)
copy_inversed = rf.NetworkSet([self.ntwk3, self.ntwk2, self.ntwk1])
self.assertNotEqual(copy_inversed, self.ns)
def test_sort(self):
"""
Test the `sort` method.
"""
ns_unsorted = rf.NetworkSet([self.ntwk2, self.ntwk1, self.ntwk3])
# not inplace sorting
ns_sorted = ns_unsorted.sort(inplace=False)
for (idx, ntwk) in enumerate(ns_sorted):
self.assertEqual(ntwk.name, f'ntwk{idx+1}')
# inplace sorting
ns_unsorted.sort()
for (idx, ntwk) in enumerate(ns_unsorted):
self.assertEqual(ntwk.name, f'ntwk{idx+1}')
# sorting with respect to a property
self.ntwk1.dummy = 100
self.ntwk2.dummy = 10
self.ntwk3.dummy = 40
ns_unsorted = rf.NetworkSet([self.ntwk2, self.ntwk1, self.ntwk3])
ns_unsorted.sort(key=lambda x: x.dummy) # dummy -> 10, 40, 100
self.assertEqual(ns_unsorted,
rf.NetworkSet([self.ntwk2, self.ntwk3, self.ntwk1]))
def test_sel(self):
""" Tests associated to the .sel method """
# passing nothing or empty dict returns the complete NetworkSet
self.assertEqual(self.ns_params.sel(), self.ns_params)
self.assertEqual(self.ns_params.sel({}), self.ns_params)
# should pass a dictionnary
self.assertRaises(TypeError, self.ns_params.sel, 'wrong')
self.assertRaises(TypeError, self.ns_params.sel, 1)
# searching for a parameter which do not exist returns empty networkset
self.assertEqual(self.ns.sel({'a': 1}), rf.NetworkSet())
self.assertEqual(self.ns_params.sel({'ho ho': 1}), rf.NetworkSet())
self.assertEqual(self.ns_params.sel({'a': 10}), rf.NetworkSet())
# there is two times the param key/value 'a':1
self.assertEqual(len(self.ns_params.sel({'a': 1})), 2)
# Iterable values
self.assertEqual(len(self.ns_params.sel({'a': [0,1]})), 4)
self.assertEqual(len(self.ns_params.sel({'a': range(0,2)})), 4)
# Multiple parameters
self.assertEqual(len(self.ns_params.sel({'a': 0, 'X': 10})), 1)
self.assertEqual(len(self.ns_params.sel({'a': 0, 'X': [10,20]})), 2)
self.assertEqual(len(self.ns_params.sel({'a': [0,1], 'X': [10,20]})), 4)
def setUp(self):
self.wg = rf.RectangularWaveguide(rf.F(75, 100, 11),
a=100 * rf.mil,
z0=50)
wg = self.wg
self.n_ports = 1
self.E = wg.random(n_ports=2, name='E')
ideals = [
wg.short(name='short'),
wg.delay_short(45., 'deg', name='ew'),
wg.delay_short(90., 'deg', name='qw'),
wg.match(name='load'),
]
measured_sets = []
for ideal in ideals:
ns = rf.NetworkSet([self.measure(ideal) for k in range(3)])
measured_sets.append(ns)
self.calset = Dot(cal_class=OnePort,
ideals=ideals,
measured_sets=measured_sets,
is_reciprocal=True)
def test_interpolate_from_params(self):
""" Tests associated to the .interpolate_from_params method """
## error handling
# param does not exist
self.assertRaises(ValueError, self.ns_params.interpolate_from_params, 'duh!', 0)
# param values should be bounded by bounded by existing param values
self.assertRaises(ValueError, self.ns_params.interpolate_from_params, 'a', -1, {'X': 10})
self.assertRaises(ValueError, self.ns_params.interpolate_from_params, 'a', 100, {'X': 10})
# cannot interpolate string-valued param
self.assertRaises(ValueError, self.ns_params.interpolate_from_params, 'c', 'duh!', {'X': 10})
# ambiguity: could interpolate a for X=10 or X=20...
self.assertRaises(ValueError, self.ns_params.interpolate_from_params, 'a', 0.5)
## working cases
# returns a Network ?
self.assertIsInstance(self.ns_params.interpolate_from_params('a', 0.5, {'X':10}), rf.Network)
# test interpolated values
f1 = rf.Frequency(1, 1, 1)
ntwk0 = rf.Network(frequency=f1, s=[[0]], params={'s': 0})
ntwk1 = rf.Network(frequency=f1, s=[[1]], params={'s': 1})
ns2 = rf.NetworkSet([ntwk0, ntwk1])
self.assertTrue(np.all(ns2.interpolate_from_params('s', 0.3).s == 0.3))
import pylab
import skrf as rf
ro_set = rf.NetworkSet(\
rf.load_all_touchstones('.',contains='ro').values(),\
name = 'Radiating Open')
pylab.figure()
pylab.title('Uncertainty in Phase')
ro_set.plot_uncertainty_bounds_s_deg()
pylab.figure()
pylab.title('Uncertainty in Magnitude')
ro_set.plot_uncertainty_bounds_s_db()
pylab.show()
# import dc data taken during sparameter measurements
dcfile = dutname + '_DC.csv'
df = pd.read_csv(rf.data.pwd + '/' + dcfile)
# add column for fT/fmax data
df['FT'] = ""
# set line / marker styles
if sim_string_id in dutname:
sym = '-'
s_or_m = 'Simu'
else:
sym = 'o'
s_or_m = 'Meas'
# Read all the rf data in the directory
npn_data = rf.read_all(rf.data.pwd)
npn_ns = rf.NetworkSet(npn_data)
for rfnw in npn_ns:
dev = mdl.rfnpn(rfnw)
if sim_string_id in dutname:
pass
else:
dev = dev.d4s() # Perform 4 step deembedding
h21 = dev.h21()
fT = np.absolute(h21[np.where(dev.f == spotf)]) * spotf # calculate ft
# extract bias info from dev name. Needs to be modified based on naming scheme.
vbs = re.findall("VB_\d*\.?\d*", dev.name)
vbs = re.findall("\d*\.?\d*", str(vbs))
# find first nonempty string in list
vb = next(v for v in vbs if v)
