def test_scalar_product(self):
field1 = make_vector_field("x", "y", "z")
field2 = make_vector_field("-y", "x", "z")
field = SvExVectorFieldsScalarProduct(field1, field2)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
r = field.evaluate_grid(xs, ys, zs)
expected = np.array([9, 16])
self.assert_numpy_arrays_equal(r, expected)
def test_average(self):
field1 = make_vector_field("x", "y", "z")
field2 = make_vector_field("-x", "-y", "-z")
field = SvExAverageVectorField([field1, field2])
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
rxs, rys, rzs = field.evaluate_grid(xs, ys, zs)
expected_x = np.array([0, 0])
expected_y = np.array([0, 0])
expected_z = np.array([0, 0])
self.assert_numpy_arrays_equal(rxs, expected_x)
self.assert_numpy_arrays_equal(rys, expected_y)
self.assert_numpy_arrays_equal(rzs, expected_z)
def test_cross_product(self):
field1 = make_vector_field("-y", "x", "z")
field2 = make_vector_field("-y", "x", "z")
field = SvExVectorFieldCrossProduct(field1, field2)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
rxs, rys, rzs = field.evaluate_grid(xs, ys, zs)
expected_x = np.array([0, 0])
expected_y = np.array([0, 0])
expected_z = np.array([0, 0])
self.assert_numpy_arrays_equal(rxs, expected_x)
self.assert_numpy_arrays_equal(rys, expected_y)
self.assert_numpy_arrays_equal(rzs, expected_z)
def test_lerp(self):
field1 = make_vector_field("-x", "y", "z")
field2 = make_vector_field("x", "-y", "z")
scalar = SvExConstantScalarField(0.5)
field = SvExVectorFieldsLerp(field1, field2, scalar)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
rxs, rys, rzs = field.evaluate_grid(xs, ys, zs)
expected_x = np.array([0, 0])
expected_y = np.array([0, 0])
expected_z = np.array([3, 4])
self.assert_numpy_arrays_equal(rxs, expected_x)
self.assert_numpy_arrays_equal(rys, expected_y)
self.assert_numpy_arrays_equal(rzs, expected_z)
def test_sph_rho(self):
field1 = make_vector_field("x", "y", "z")
field = SvExVectorFieldDecomposed(field1, 'SPH', 0)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
r = field.evaluate_grid(xs, ys, zs)
expected = np.array([3.742, 5.385])
self.assert_numpy_arrays_equal(r, expected, precision=3)
def test_cyl_phi(self):
field1 = make_vector_field("x", "y", "z")
field = SvExVectorFieldDecomposed(field1, 'CYL', 1)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
r = field.evaluate_grid(xs, ys, zs)
expected = np.array([1.107, 0.983])
self.assert_numpy_arrays_equal(r, expected, precision=3)
def test_z(self):
field1 = make_vector_field("2*x", "3*y", "4*z")
field = SvExVectorFieldDecomposed(field1, 'XYZ', 2)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
r = field.evaluate_grid(xs, ys, zs)
expected = np.array([12, 16])
self.assert_numpy_arrays_equal(r, expected)
def test_divergence(self):
field1 = make_vector_field("x", "y", "z")
field = SvExVectorFieldDivergence(field1, 0.0001)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
r = field.evaluate_grid(xs, ys, zs)
expected = np.array([3, 3])
self.assert_numpy_arrays_equal(r, expected, precision=3)
def test_lambda(self):
field = make_vector_field("-y", "x", "z")
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
rxs, rys, rzs = field.evaluate_grid(xs, ys, zs)
expected_x = np.array([-2, -3])
expected_y = np.array([1, 2])
expected_z = np.array([3, 4])
self.assert_numpy_arrays_equal(rxs, expected_x)
self.assert_numpy_arrays_equal(rys, expected_y)
self.assert_numpy_arrays_equal(rzs, expected_z)
def test_rotor_one(self):
field1 = make_vector_field("-y", "x", "z")
field = SvExVectorFieldRotor(field1, 0.0001)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
rxs, rys, rzs = field.evaluate_grid(xs, ys, zs)
expected_x = np.array([0, 0])
expected_y = np.array([0, 0])
expected_z = np.array([2, 2])
self.assert_numpy_arrays_equal(rxs, expected_x, precision=4)
self.assert_numpy_arrays_equal(rys, expected_y, precision=4)
self.assert_numpy_arrays_equal(rzs, expected_z, precision=4)
def test_abs(self):
field1 = make_vector_field("x", "y", "z")
field = SvExRelativeVectorField(field1)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
rxs, rys, rzs = field.evaluate_grid(xs, ys, zs)
expected_x = np.array([0, 0])
expected_y = np.array([0, 0])
expected_z = np.array([0, 0])
self.assert_numpy_arrays_equal(rxs, expected_x, precision=3)
self.assert_numpy_arrays_equal(rys, expected_y, precision=3)
self.assert_numpy_arrays_equal(rzs, expected_z, precision=3)
def test_multiply_by_scalar(self):
field1 = make_vector_field("x", "y", "z")
scalar = SvExConstantScalarField(2)
field = SvExVectorFieldMultipliedByScalar(field1, scalar)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
rxs, rys, rzs = field.evaluate_grid(xs, ys, zs)
expected_x = np.array([2, 4])
expected_y = np.array([4, 6])
expected_z = np.array([6, 8])
self.assert_numpy_arrays_equal(rxs, expected_x)
self.assert_numpy_arrays_equal(rys, expected_y)
self.assert_numpy_arrays_equal(rzs, expected_z)
def test_cotangent(self):
v = np.array([1, 0, 0])
field1 = make_vector_field("x", "y", "z")
field2 = SvExConstantVectorField(v)
field = SvExVectorFieldCotangent(field1, field2)
xs = np.array([1, 2])
ys = np.array([2, 3])
zs = np.array([3, 4])
rxs, rys, rzs = field.evaluate_grid(xs, ys, zs)
expected_x = np.array([0, 0])
expected_y = np.array([2, 3])
expected_z = np.array([3, 4])
self.assert_numpy_arrays_equal(rxs, expected_x)
self.assert_numpy_arrays_equal(rys, expected_y)
self.assert_numpy_arrays_equal(rzs, expected_z)
