def test_fringes(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument(r".\models\example_2D.dac")
doc.loadTimeStep(doc.getNumberOfTimeSteps() - 1)
gdf = doc.c.plot.gdf.fringes(Enum.P_HEAD, levels=range(11))
# check if levels are correct:
np.testing.assert_almost_equal(
gdf.layer.values,
[0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5],
err_msg="layer mismatch in geodataframe")
np.testing.assert_almost_equal(
gdf["400_min"].values,
[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0],
err_msg="min mismatch in geodataframe")
np.testing.assert_almost_equal(
gdf["400_max"].values,
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0],
err_msg="max mismatch in geodataframe")
# check if areas are equal:
np.testing.assert_almost_equal(gdf.area.values, [
14302.13315203, 20114.86769273, 70707.4589673, 254411.87209667,
155115.96365282, 125447.20580869, 42811.62018617, 42276.8370475,
33731.82795621, 26471.632308
],
err_msg="areas of polygon differs")
doc.closeDocument()
doc = ifm.loadDocument(r".\models\example_3D_mspecies.fem")
gdf = doc.c.plot.gdf.fringes(Enum.P_HEAD)
gdf = doc.c.plot.gdf.fringes(Enum.P_HEAD, levels=range(11))
doc.closeDocument()
def test_elements(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
df = doc.c.mesh.df.elements([Enum.P_TRANS])
self.assertAlmostEqual(df[Enum.P_TRANS].sum(), 741.2000004276633)
doc.c.mesh.df.elements(par=Enum.P_TRANS) # 0
doc.c.mesh.df.elements(par=[Enum.P_TRANS]) # 0
doc.c.mesh.df.elements(par={"Transmissivity": Enum.P_TRANS}) # 0
doc.c.mesh.df.elements(par=[Enum.P_TRANS], expr="elemental_expr_test")
doc.c.mesh.df.elements(par=[Enum.P_TRANS],
expr=["elemental_expr_test"])
doc.c.mesh.df.elements(par=[Enum.P_TRANS],
expr=["elemental_expr_test"],
distr="elemental_test")
doc.c.mesh.df.elements(par=[Enum.P_TRANS],
expr=["elemental_expr_test"],
distr=["elemental_test"])
doc.c.mesh.df.elements(par=[Enum.P_TRANS], layer=1) # 0
doc.c.mesh.df.elements(content=None)
doc.c.mesh.df.elements(content=False)
doc.c.mesh.df.elements(content=True)
doc.c.mesh.df.elements(content=Enum.TOTAL_VOLUME)
doc.c.mesh.df.elements(content=[Enum.TOTAL_VOLUME, Enum.VOID_VOLUME])
doc = ifm.loadDocument("./models/example_partial_unstruct.fem")
df = doc.c.mesh.df.elements()
doc = ifm.loadDocument("./models/example_fully_unstruct.fem")
df = doc.c.mesh.df.elements()
doc = ifm.loadDocument("./models/example_3D.fem")
doc.c.mesh.df.elements(aux="auxLayerThickness")
doc.c.mesh.df.elements(aux=["auxLayerThickness"])
doc.c.mesh.df.elements(aux={"layer_thickness": "auxLayerThickness"})
def test_setFracArea(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
fracid = doc.pdoc.createFracElement(0, 1, Enum.FRAC_1D, Enum.FRAC_A,
Enum.MANNING_LAW)
doc.setFracArea(fracid, 1.0, Enum.ALL_FRAC_TYPES, Enum.ALL_FRAC_MODES,
Enum.ALL_FRAC_LAWS)
def test_nodes(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
doc.c.mesh.df.nodes(par=Enum.P_HEAD) # 0
doc.c.mesh.df.nodes(par=[Enum.P_HEAD]) # 0
doc.c.mesh.df.nodes(par={"Head": Enum.P_HEAD}) # 0
doc.c.mesh.df.nodes(par=[Enum.P_HEAD], expr="nodal_expr_test")
doc.c.mesh.df.nodes(par=[Enum.P_HEAD], expr=["nodal_expr_test"])
doc.c.mesh.df.nodes(par=[Enum.P_HEAD],
expr=["nodal_expr_test"],
distr="nodal_test")
doc.c.mesh.df.nodes(par=[Enum.P_HEAD],
expr=["nodal_expr_test"],
distr=["nodal_test"])
doc.c.mesh.df.nodes(par=[Enum.P_HEAD], slice=1) # 0
# self.assertAlmostEqual(df[Enum.P_TRANS].sum(), 741.2000004276633)
doc = ifm.loadDocument("./models/example_partial_unstruct.fem")
df = doc.c.mesh.df.nodes()
doc = ifm.loadDocument("./models/example_fully_unstruct.fem")
df = doc.c.mesh.df.nodes()
# test nodal budget option
doc = ifm.loadDocument("./models/example_2D.dac")
doc.pdoc.loadTimeStep(1) # t=10.0 days
doc.c.mesh.df.nodes(budget="flow")
doc.c.mesh.df.nodes(budget=["flow"])
doc.c.mesh.df.nodes(budget=True)
df = doc.c.mesh.df.nodes(budget="flow")
self.assertAlmostEqual(df.budget_flow_bc.sum(), -5.2016302997540258)
self.assertAlmostEqual(df.budget_flow_area.sum(), 23.580393938311079)
self.assertAlmostEqual(df.budget_flow_storage.sum(),
-18.378763638890959)
def test_obspoints(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
# should return three observation points
self.assertEqual(3, len(doc.c.obs.gdf.obspoints()))
# should return two observation points
self.assertEqual(2, len(doc.c.obs.gdf.obspoints(filter_by={"label": ["myObsPoint1", "myObsPoint2"]})))
def test_history(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.dac")
# check if all_hist_itemsworks
doc.c.hist.df.all_hist_items()
# test history function
from datetime import datetime
doc.c.hist.df.history("HEAD", reference_time=datetime(2018, 1, 1))
# test depreciated functions
doc.c.hist.df.getDataframe("HEAD", reference_time=datetime(2018, 1, 1))
# should return a certain number of entries
self.assertEqual(46, len(doc.c.hist.df.HEAD))
def test_isolines(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument(r".\models\example_2D.dac")
doc.loadTimeStep(doc.getNumberOfTimeSteps() - 1)
gdf = doc.c.plot.gdf.isolines(Enum.P_HEAD)
gdf = doc.c.plot.gdf.isolines(Enum.P_HEAD, levels=range(11))
#TODO: add tests for distributions and expressions
doc.closeDocument()
ifm.forceLicense("Viewer")
doc = ifm.loadDocument(r".\models\example_3D_mspecies.fem")
doc.loadTimeStep(doc.getNumberOfTimeSteps() - 1)
gdf = doc.c.plot.gdf.isolines(par=Enum.P_HEAD, slice=1)
gdf = doc.c.plot.gdf.isolines(par=Enum.P_HEAD, levels=range(11))
#TODO: add tests for distributions and expressions
doc.closeDocument()
def test_elements(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
gdf = doc.c.mesh.gdf.elements([Enum.P_TRANS])
self.assertAlmostEqual(gdf[Enum.P_TRANS].sum(), 741.2000004276633)
doc.c.mesh.gdf.elements(par=Enum.P_TRANS) # 0
doc.c.mesh.gdf.elements(par=[Enum.P_TRANS]) # 0
doc.c.mesh.gdf.elements(par={"Transmissivity": Enum.P_TRANS}) # 0
doc.c.mesh.gdf.elements(par=[Enum.P_TRANS], expr="elemental_expr_test")
doc.c.mesh.gdf.elements(par=[Enum.P_TRANS], expr=["elemental_expr_test"])
doc.c.mesh.gdf.elements(par=[Enum.P_TRANS], expr=["elemental_expr_test"], distr="elemental_test")
doc.c.mesh.gdf.elements(par=[Enum.P_TRANS], expr=["elemental_expr_test"], distr=["elemental_test"])
doc.c.mesh.gdf.elements(par=[Enum.P_TRANS], layer=1) # 0
doc.c.mesh.gdf.elements(content=None)
doc.c.mesh.gdf.elements(content=False)
doc.c.mesh.gdf.elements(content=True)
doc.c.mesh.gdf.elements(content=Enum.TOTAL_VOLUME)
doc.c.mesh.gdf.elements(content=[Enum.TOTAL_VOLUME, Enum.VOID_VOLUME])
def test_sel_convert_2D(self):
ifm.forceLicense("Viewer")
self.doc = ifm.loadDocument(r".\models\example_2D.fem")
self.assertEqual(self.doc.c.sel.getSelectionType("conversiontest_el"),
1)
self.assertEqual(
self.doc.c.sel.getSelectionType("conversiontest_doesnotexist"), -1)
# -> invalid is not possible
self.assertRaises(ValueError, self.doc.c.sel.convert,
"conversiontest_el", Enum.SEL_INVALID)
# no conversion on equal types
self.assertEqual(
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_ELEMENTAL),
[586, 955])
self.assertEqual(
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_ELEMS),
[586, 955])
# elemental -> nodal
self.assertEqual(
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_NODAL),
[369, 370, 465, 467, 480])
self.assertEqual(
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_NODES),
[369, 370, 465, 467, 480])
# other not yet implemented
with self.assertRaises(NotImplementedError):
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_FACES)
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_FRACS)
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_EDGES)
self.doc.closeDocument()
def test_sel_convert_3D(self):
ifm.forceLicense("Viewer")
self.doc = ifm.loadDocument(r".\models\example_3D_mspecies.fem")
self.assertEqual(self.doc.c.sel.getSelectionType("conversiontest_el"),
1)
self.assertEqual(
self.doc.c.sel.getSelectionType("conversiontest_doesnotexist"), -1)
# -> invalid is not possible
self.assertRaises(ValueError, self.doc.c.sel.convert,
"conversiontest_el", Enum.SEL_INVALID)
# no conversion on equal types
self.assertEqual(
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_ELEMENTAL),
[718, 971])
self.assertEqual(
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_ELEMS),
[718, 971])
# elemental -> nodal
self.assertEqual(
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_NODAL),
[455, 477, 478, 510, 523, 1040, 1062, 1063, 1095, 1108])
self.assertEqual(
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_NODES),
[455, 477, 478, 510, 523, 1040, 1062, 1063, 1095, 1108])
# other not yet implemented
with self.assertRaises(NotImplementedError):
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_FACES)
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_FRACS)
self.doc.c.sel.convert("conversiontest_el", Enum.SEL_EDGES)
self.doc.closeDocument()
def test_get_imatrix2d(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
self.assertEqual(len(doc.c.mesh.get_imatrix2d()), 959)
self.assertEqual(len(doc.c.mesh.get_imatrix2d(ignore_inactive=True)),
904)
self.assertEqual(
len(doc.c.mesh.get_imatrix2d(split_quads_to_triangles=True)), 1088)
self.assertEqual(
len(
doc.c.mesh.get_imatrix2d(ignore_inactive=True,
split_quads_to_triangles=True)),
1088 - 55)
ee = doc.c.mesh.get_imatrix2d(ignore_inactive=True,
return_elements=True)
self.assertEqual(ee[1], [
e for e in range(doc.getNumberOfElements())
if doc.getMatElementActive(e)
])
doc = ifm.loadDocument("./models/example_3D_mspecies.fem")
self.assertEqual(len(doc.c.mesh.get_imatrix2d(slice=1)), 980)
self.assertEqual(len(doc.c.mesh.get_imatrix2d(slice=2)), 980)
self.assertEqual(len(doc.c.mesh.get_imatrix2d(slice=3)), 980)
self.assertEqual(
len(doc.c.mesh.get_imatrix2d(slice=1, ignore_inactive=True)), 807)
self.assertEqual(
len(doc.c.mesh.get_imatrix2d(slice=2, ignore_inactive=True)), 980)
self.assertEqual(
len(
doc.c.mesh.get_imatrix2d(slice=1,
split_quads_to_triangles=True)),
980 + 108)
self.assertEqual(
len(
doc.c.mesh.get_imatrix2d(slice=2,
split_quads_to_triangles=True)),
980 + 108)
self.assertEqual(
len(
doc.c.mesh.get_imatrix2d(slice=1,
ignore_inactive=True,
split_quads_to_triangles=True)),
807 + 81)
self.assertEqual(
len(
doc.c.mesh.get_imatrix2d(slice=2,
ignore_inactive=True,
split_quads_to_triangles=True)),
980 + 108)
ee = doc.c.mesh.get_imatrix2d(ignore_inactive=True,
return_elements=True)
self.assertEqual(ee[1], [
e for e in range(doc.getNumberOfElementsPerLayer())
if doc.getMatElementActive(e)
])
with self.assertRaises(ValueError):
doc.c.mesh.get_imatrix2d(slice=4)
def test_faces(self):
ifm.forceLicense("Viewer")
self.doc = ifm.loadDocument(r".\models\example_2D.dac")
self.doc.c.plot.faces()
def test_obs_labels(self):
ifm.forceLicense("Viewer")
self.doc = ifm.loadDocument(r".\models\example_2D.dac")
self.doc.c.plot.obs_labels()
self.doc.c.plot.obs_labels(
filter_by={"label": ["myObsPoint1", "myObsPoint2"]})
def test_isolines(self):
ifm.forceLicense("Viewer")
self.doc = ifm.loadDocument(r".\models\example_2D.dac")
self.doc.c.plot.isolines(par=Enum.P_HEAD, colors="black")
def test_availableitems(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
doc.c.mesh.df.get_available_items()
def test_createFracElement(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
# doc = ifm.loadDocument("./models/example_3D_mspecies.fem")
doc.createFracElement(0, 1, Enum.FRAC_1D, Enum.FRAC_A, Enum.MANNING_LAW)
def test_getCentroid(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
doc.c.mesh.getCentroid(0)
def test_show_available_aux(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
doc.c.mesh.show_available_aux()
def test_deleteFracElement(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
fracid = doc.pdoc.createFracElement(0, 1, Enum.FRAC_1D, Enum.FRAC_A, Enum.MANNING_LAW)
doc.deleteFracElement(fracid)
def test_continuous(self):
ifm.forceLicense("Viewer")
self.doc = ifm.loadDocument(r".\models\example_2D.dac")
self.doc.c.plot.continuous(par=Enum.P_HEAD)
def test_patches(self):
ifm.forceLicense("Viewer")
self.doc = ifm.loadDocument(
r".\models\example_2D_unconf.fem") # pure triangle mesh
self.doc.c.plot._contours(par=Enum.P_COND, style="patches")
self.doc.c.plot.patches(par=Enum.P_COND)
def test_fringes(self):
ifm.forceLicense("Viewer")
self.doc = ifm.loadDocument(r".\models\example_2D.dac")
self.doc.c.plot.fringes(par=Enum.P_HEAD,
alpha=1,
cmap="feflow_blue_green_red")
def test_mlw(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_3D_mspecies.fem")
doc.c.mesh.df.mlw()
def test_info(self):
ifm.forceLicense("Viewer")
doc = ifm.loadDocument("./models/example_2D.fem")
doc.c.ts.df.info()
