passing: source, structure, time_modulation

Author: yaugenst-flex

tests/test_components/test_source.py

@@ -2,9 +2,9 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
-import pydantic.v1 as pydantic
 import pytest
 import tidy3d as td
+from pydantic import ValidationError
 from tidy3d.components.source.field import CHEB_GRID_WIDTH, DirectionalSource
 from tidy3d.exceptions import SetupError
 
@@ -141,7 +141,7 @@ def test_dipole():
     # p.plot(y=2)
     # plt.close()
 
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.PointDipole(size=(1, 1, 1), source_time=g, center=(1, 2, 3), polarization="Ex")
 
 
@@ -177,11 +177,11 @@ def test_FieldSource():
     # plt.close()
 
     # test that non-planar geometry crashes plane wave and gaussian beams
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.PlaneWave(size=(1, 1, 1), source_time=g, pol_angle=np.pi / 2, direction="+")
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.GaussianBeam(size=(1, 1, 1), source_time=g, pol_angle=np.pi / 2, direction="+")
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.AstigmaticGaussianBeam(
             size=(1, 1, 1),
             source_time=g,
@@ -190,14 +190,14 @@ def test_FieldSource():
             waist_sizes=(0.2, 0.4),
             waist_distances=(0.1, 0.3),
         )
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.ModeSource(size=(1, 1, 1), source_time=g, mode_spec=mode_spec)
 
     tfsf = td.TFSF(size=(1, 1, 1), direction="+", source_time=g, injection_axis=2)
     _ = tfsf.injection_plane_center
 
     # assert that TFSF must be volumetric
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.TFSF(size=(1, 1, 0), direction="+", source_time=g, injection_axis=2)
 
     # s.plot(z=0)
@@ -295,11 +295,11 @@ def check_freq_grid(freq_grid, num_freqs):
     check_freq_grid(freq_grid, num_freqs)
 
     # check validators for num_freqs
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         s = td.GaussianBeam(
             size=(0, 1, 1), source_time=g, pol_angle=np.pi / 2, direction="+", num_freqs=200
         )
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         s = td.AstigmaticGaussianBeam(
             size=(0, 1, 1),
             source_time=g,
@@ -309,7 +309,7 @@ def check_freq_grid(freq_grid, num_freqs):
             waist_distances=(0.1, 0.3),
             num_freqs=100,
         )
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         s = td.ModeSource(
             size=(0, 1, 1),
             direction="+",
@@ -355,7 +355,7 @@ def test_custom_source_time():
     )
     cst = td.CustomSourceTime.from_values(freq0=freq0, fwidth=0.1e12, values=[0, 1], dt=sim.dt)
     source = td.PointDipole(center=(0, 0, 0), source_time=cst, polarization="Ex")
-    sim = sim.updated_copy(sources=[source])
+    sim = sim.updated_copy(sources=(source,))
     assert np.allclose(cst.amp_time(sim.tmesh[0]), [0], rtol=0, atol=ATOL)
     assert np.allclose(
         cst.amp_time(sim.tmesh[1:]),
@@ -374,18 +374,18 @@ def test_custom_source_time():
     cst = td.CustomSourceTime(source_time_dataset=dataset, freq0=freq0, fwidth=0.1e12)
     source = td.PointDipole(center=(0, 0, 0), source_time=cst, polarization="Ex")
     with AssertLogLevel("WARNING", contains_str="defined over a time range"):
-        sim = sim.updated_copy(sources=[source])
+        sim = sim.updated_copy(sources=(source,))
 
     # test normalization warning
     with AssertLogLevel("WARNING"):
         sim = sim.updated_copy(normalize_index=0)
 
     with AssertLogLevel("WARNING"):
         source = source.updated_copy(source_time=td.ContinuousWave(freq0=freq0, fwidth=0.1e12))
-        sim = sim.updated_copy(sources=[source])
+        sim = sim.updated_copy(sources=(source,))
 
     # test single value validation error
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         vals = td.components.data.data_array.TimeDataArray([1], coords=dict(t=[0]))
         dataset = td.components.data.dataset.TimeDataset(values=vals)
         cst = td.CustomSourceTime(source_time_dataset=dataset, freq0=freq0, fwidth=0.1e12)
@@ -411,7 +411,7 @@ def make_custom_field_source(field_ds):
     with AssertLogLevel(None):
         make_custom_field_source(field_dataset)
 
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         # repeat some entries so data cannot be interpolated
         X2 = [X[0]] + list(X)
         n_data2 = np.vstack((n_data[0, :, :, :].reshape(1, Ny, Nz, Nf), n_data))

tests/test_components/test_structure.py

@@ -2,9 +2,9 @@
 import autograd.numpy as anp
 import gdstk
 import numpy as np
-import pydantic.v1 as pd
 import pytest
 import tidy3d as td
+from pydantic import ValidationError
 
 
 def test_to_gds(tmp_path):
@@ -116,23 +116,23 @@ def test_invalid_polyslab(axis):
     _ = td.Structure(geometry=geo1, medium=medium)
 
     geo2 = ps.rotated(np.pi / 4, i)
-    with pytest.raises(pd.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.Structure(geometry=geo2, medium=medium)
 
     geo3 = ps.rotated(np.pi / 5, j)
-    with pytest.raises(pd.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.Structure(geometry=geo3, medium=medium)
 
     geo4 = ps.rotated(np.pi / 6, (1, 1, 1))
-    with pytest.raises(pd.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.Structure(geometry=geo4, medium=medium)
 
     geo5 = td.GeometryGroup(geometries=[ps]).rotated(np.pi / 2, j)
-    with pytest.raises(pd.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.Structure(geometry=geo5, medium=medium)
 
     geo6 = td.GeometryGroup(geometries=[ps - box]).rotated(np.pi / 2, i)
-    with pytest.raises(pd.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.Structure(geometry=geo6, medium=medium)
 
     geo7 = td.GeometryGroup(geometries=[(ps - box).rotated(np.pi / 4, j)]).rotated(-np.pi / 4, j)
@@ -153,11 +153,11 @@ def test_invalid_polyslab(axis):
     _ = td.Structure(geometry=geo10, medium=medium)
 
     geo11 = ps.reflected(n2)
-    with pytest.raises(pd.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.Structure(geometry=geo11, medium=medium)
 
     geo12 = td.GeometryGroup(geometries=[ps]).reflected(n2)
-    with pytest.raises(pd.ValidationError):
+    with pytest.raises(ValidationError):
         _ = td.Structure(geometry=geo12, medium=medium)
 
     geo13 = td.GeometryGroup(geometries=[(ps - box).reflected(n2)]).reflected(n2)
@@ -236,7 +236,7 @@ def test_validation_of_structures_with_2d_materials():
     ]
 
     for geom in not_allowed_geometries:
-        with pytest.raises(pd.ValidationError):
+        with pytest.raises(ValidationError):
             _ = td.Structure(geometry=geom, medium=med2d)
 
 

tests/test_components/test_time_modulation.py

@@ -3,9 +3,9 @@
 from math import isclose
 
 import numpy as np
-import pydantic.v1 as pydantic
 import pytest
 import tidy3d as td
+from pydantic import ValidationError
 
 from ..utils import cartesian_to_unstructured
 
@@ -112,22 +112,22 @@ def test_space_modulation():
     check_sp_reduction(SP_UNIFORM)
 
     # uniform in phase, but custom in amplitude
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         sp = SP_UNIFORM.updated_copy(amplitude=ARRAY_CMP)
 
     sp = SP_UNIFORM.updated_copy(amplitude=ARRAY)
     assert isclose(sp.max_modulation, np.max(ARRAY))
     check_sp_reduction(sp)
 
     # uniform in amplitude, but custom in phase
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         sp = SP_UNIFORM.updated_copy(phase=ARRAY_CMP)
     sp = SP_UNIFORM.updated_copy(phase=ARRAY)
     assert isclose(sp.max_modulation, 1)
     check_sp_reduction(sp)
 
     # custom in both
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         sp = SP_UNIFORM.updated_copy(phase=ARRAY_CMP, amplitude=ARRAY_CMP)
     sp = SP_UNIFORM.updated_copy(phase=ARRAY, amplitude=ARRAY)
     check_sp_reduction(sp)
@@ -171,7 +171,7 @@ def test_modulated_medium():
     # permittivity modulated
     modulation_spec = MODULATION_SPEC.updated_copy(permittivity=ST)
     # modulated permitivity <= 0
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         medium = td.Medium(modulation_spec=modulation_spec)
     medium = td.Medium(permittivity=2, modulation_spec=modulation_spec)
     assert isclose(medium.n_cfl, np.sqrt(2 - AMP_TIME))
@@ -180,7 +180,7 @@ def test_modulated_medium():
     # conductivity modulated
     modulation_spec = MODULATION_SPEC.updated_copy(conductivity=ST)
     # modulated conductivity <= 0
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         medium = td.Medium(modulation_spec=modulation_spec)
     medium_sometimes_active = td.Medium(modulation_spec=modulation_spec, allow_gain=True)
     medium = td.Medium(conductivity=2, modulation_spec=modulation_spec)
@@ -191,7 +191,7 @@ def test_modulated_medium():
     st_freq2 = ST.updated_copy(
         time_modulation=td.ContinuousWaveTimeModulation(freq0=2e12, amplitude=2)
     )
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         modulation_spec = MODULATION_SPEC.updated_copy(permittivity=ST, conductivity=st_freq2)
     # both modulated, but different space modulation: fine
     st_space2 = ST.updated_copy(space_modulation=td.SpaceModulation(amplitude=0.1))
@@ -209,26 +209,26 @@ def test_unsupported_modulated_medium_types():
     modulation_spec = MODULATION_SPEC.updated_copy(permittivity=ST)
 
     # PEC cannot be modulated
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         td.PECMedium(modulation_spec=modulation_spec)
 
     # For Anisotropic medium, one should modulate the components, not the whole medium
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         td.AnisotropicMedium(
             xx=td.Medium(), yy=td.Medium(), zz=td.Medium(), modulation_spec=modulation_spec
         )
 
     # Modulation to fully Anisotropic medium unsupported
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         td.FullyAnisotropicMedium(modulation_spec=modulation_spec)
 
     # 2D material
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         drude_medium = td.Drude(eps_inf=2.0, coeffs=[(1, 2), (3, 4)])
         td.Medium2D(ss=drude_medium, tt=drude_medium, modulation_spec=modulation_spec)
 
     # together with nonlinear_spec
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         td.Medium(
             permittivity=2,
             nonlinear_spec=td.NonlinearSusceptibility(chi3=1),
@@ -250,10 +250,10 @@ def test_supported_modulated_medium_types(unstructured, z):
     assert mat_p.is_time_modulated
     assert isclose(mat_p.n_cfl, np.sqrt(2 - AMP_TIME))
     # too much modulation resulting in eps_inf < 0
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         mat = mat_p.updated_copy(eps_inf=1.0)
     # conductivity modulation
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         mat = mat_p.updated_copy(modulation_spec=modulation_both_spec)
     mat = mat_p.updated_copy(modulation_spec=modulation_both_spec, allow_gain=True)
     check_med_reduction(mat)
@@ -269,10 +269,10 @@ def test_supported_modulated_medium_types(unstructured, z):
     assert mat_c.is_time_modulated
     assert isclose(mat_c.n_cfl, np.sqrt(2 - AMP_TIME))
     # too much modulation resulting in eps_inf < 0
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         mat = mat_c.updated_copy(permittivity=permittivity * 0.5)
     # conductivity modulation
-    with pytest.raises(pydantic.ValidationError):
+    with pytest.raises(ValidationError):
         mat = mat_c.updated_copy(modulation_spec=modulation_both_spec)
     mat = mat_c.updated_copy(modulation_spec=modulation_both_spec, allow_gain=True)
     check_med_reduction(mat_c)