476539530

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/GeoStat-Framework/GSTools/commit/<a class=hub.com/GeoStat-Framework/GSTools/commit/2d8fb84efa405a8251c13d2359192ed93da21ae4">2d8fb84ef<a href="https://github.com/GeoStat-Framework/GSTools/commit/2d8fb84efa405a8251c13d2359192ed93da21ae4">">Merge </a><a class="double-link" href="https://github.com/GeoStat-Framework/GSTools/commit/<a class="double-link" href="https://github.com/GeoStat-Framework/GSTools/commit/e5af2bb7c64ebbc8d4e684eac6cd28076b39489c">e5af2bb7c</a>">e5af2bb7c</a><a href="https://github.com/GeoStat-Framework/GSTools/commit/2d8fb84efa405a8251c13d2359192ed93da21ae4"> into e28b00c95">e28b00c95</a>

Pull Request Pull Request #113: Add support for geographical coordinates

Run Details

87 of 87 new or added lines in 8 files covered. (100.0%)

2108 of 2319 relevant lines covered (90.9%)

13.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.71

/gstools/field/base.py

# -*- coding: utf-8 -*-
"""
GStools subpackage providing a base class for spatial fields.

.. currentmodule:: gstools.field.base

The following classes are provided

.. autosummary::
   Field
"""
# pylint: disable=C0103

from functools import partial

import numpy as np
import meshio

from gstools.covmodel.base import CovModel
from gstools.tools.geometric import format_struct_pos_dim, gen_mesh
from gstools.tools.export import to_vtk, vtk_export


__all__ = ["Field"]


class Field:
    """A base class for random fields, kriging fields, etc.

    Parameters
    ----------
    model : :any:`CovModel`
        Covariance Model related to the field.
    mean : :class:`float`, optional
        Mean value of the field.
    """

    def __init__(self, model, mean=0.0):
        # initialize attributes
        self.pos = None
        self.mesh_type = None
        self.field = None
        # initialize private attributes
        self._mean = None
        self._model = None
        self.mean = mean
        self.model = model
        self._value_type = None

    def __call__(*args, **kwargs):
        """Generate the field."""
        pass

    def structured(self, *args, **kwargs):
        """Generate a field on a structured mesh.

        See :any:`Field.__call__`
        """
        call = partial(self.__call__, mesh_type="structured")
        return call(*args, **kwargs)

    def unstructured(self, *args, **kwargs):
        """Generate a field on an unstructured mesh.

        See :any:`Field.__call__`
        """
        call = partial(self.__call__, mesh_type="unstructured")
        return call(*args, **kwargs)

    def mesh(
        self, mesh, points="centroids", direction="all", name="field", **kwargs
    ):
        """Generate a field on a given meshio or ogs5py mesh.

        Parameters
        ----------
        mesh : meshio.Mesh or ogs5py.MSH or PyVista mesh
            The given meshio, ogs5py, or PyVista mesh
        points : :class:`str`, optional
            The points to evaluate the field at.
            Either the "centroids" of the mesh cells
            (calculated as mean of the cell vertices) or the "points"
            of the given mesh.
            Default: "centroids"
        direction : :class:`str` or :class:`list`, optional
            Here you can state which direction should be choosen for
            lower dimension. For example, if you got a 2D mesh in xz direction,
            you have to pass "xz". By default, all directions are used.
            One can also pass a list of indices.
            Default: "all"
        name : :class:`str` or :class:`list` of :class:`str`, optional
            Name(s) to store the field(s) in the given mesh as point_data or
            cell_data. If to few names are given, digits will be appended.
            Default: "field"
        **kwargs
            Keyword arguments forwareded to `Field.__call__`.

        Notes
        -----
        This will store the field in the given mesh under the given name,
        if a meshio or PyVista mesh was given.

        See: https://github.com/nschloe/meshio
        See: https://github.com/pyvista/pyvista

        See: :any:`Field.__call__`
        """
        has_pyvista = False
        has_ogs5py = False

        try:
            import pyvista as pv

            has_pyvista = True
        except ImportError:
            pass
        try:
            import ogs5py as ogs

            has_ogs5py = True
        except ImportError:
            pass

        if isinstance(direction, str) and direction == "all":
            select = list(range(self.model.field_dim))
        elif isinstance(direction, str):
            select = _get_select(direction)[: self.model.field_dim]
        else:
            select = direction[: self.model.field_dim]
        if len(select) < self.model.field_dim:
            raise ValueError(
                "Field.mesh: need at least {} direction(s), got '{}'".format(
                    self.model.field_dim, direction
                )
            )
        # convert pyvista mesh
        if has_pyvista and pv.is_pyvista_dataset(mesh):
            if points == "centroids":
                pnts = mesh.cell_centers().points.T[select]
            else:
                pnts = mesh.points.T[select]
            out = self.unstructured(pos=pnts, **kwargs)
            # Deal with the output
            fields = [out] if isinstance(out, np.ndarray) else out
            for f_name, field in zip(_names(name, len(fields)), fields):
                mesh[f_name] = field
        # convert ogs5py mesh
        elif has_ogs5py and isinstance(mesh, ogs.MSH):
            if points == "centroids":
                pnts = mesh.centroids_flat.T[select]
            else:
                pnts = mesh.NODES.T[select]
            out = self.unstructured(pos=pnts, **kwargs)
        # convert meshio mesh
        elif isinstance(mesh, meshio.Mesh):
            if points == "centroids":
                # define unique order of cells
                offset = []
                length = []
                mesh_dim = mesh.points.shape[1]
                if mesh_dim < self.model.field_dim:
                    raise ValueError("Field.mesh: mesh dimension too low!")
                pnts = np.empty((0, mesh_dim), dtype=np.double)
                for cell in mesh.cells:
                    pnt = np.mean(mesh.points[cell[1]], axis=1)
                    offset.append(pnts.shape[0])
                    length.append(pnt.shape[0])
                    pnts = np.vstack((pnts, pnt))
                # generate pos for __call__
                pnts = pnts.T[select]
                out = self.unstructured(pos=pnts, **kwargs)
                fields = [out] if isinstance(out, np.ndarray) else out
                f_lists = []
                for field in fields:
                    f_list = []
                    for of, le in zip(offset, length):
                        f_list.append(field[of : of + le])
                    f_lists.append(f_list)
                for f_name, f_list in zip(_names(name, len(f_lists)), f_lists):
                    mesh.cell_data[f_name] = f_list
            else:
                out = self.unstructured(pos=mesh.points.T[select], **kwargs)
                fields = [out] if isinstance(out, np.ndarray) else out
                for f_name, field in zip(_names(name, len(fields)), fields):
                    mesh.point_data[f_name] = field
        else:
            raise ValueError("Field.mesh: Unknown mesh format!")
        return out

    def pre_pos(self, pos, mesh_type="unstructured"):
        """
        Preprocessing positions and mesh_type.

        Parameters
        ----------
        pos : :any:`iterable`
            the position tuple, containing main direction and transversal
            directions
        mesh_type : :class:`str`, optional
            'structured' / 'unstructured'
            Default: `"unstructured"`

        Returns
        -------
        iso_pos : (d, n), :class:`numpy.ndarray`
            the isometrized position tuple
        shape : :class:`tuple`
            Shape of the resulting field.
        """
        # save mesh-type
        self.mesh_type = mesh_type
        dim = self.model.field_dim
        # save pos tuple
        if mesh_type != "unstructured":
            pos, shape = format_struct_pos_dim(pos, dim)
            self.pos = pos
            pos = gen_mesh(pos)
        else:
            pos = np.array(pos, dtype=np.double).reshape(dim, -1)
            self.pos = pos
            shape = np.shape(pos[0])
        # prepend dimension if we have a vector field
        if self.value_type == "vector":
            shape = (self.model.dim,) + shape
            if self.model.latlon:
                raise ValueError("Field: Vector fields not allowed for latlon")
        # return isometrized pos tuple and resulting field shape
        return self.model.isometrize(pos), shape

    def _to_vtk_helper(
        self, filename=None, field_select="field", fieldname="field"
    ):  # pragma: no cover
        """Create a VTK/PyVista grid of the field or save it as a VTK file.

        This is an internal helper that will handle saving or creating objects

        Parameters
        ----------
        filename : :class:`str`
            Filename of the file to be saved, including the path. Note that an
            ending (.vtr or .vtu) will be added to the name. If ``None`` is
            passed, a PyVista dataset of the appropriate type will be returned.
        field_select : :class:`str`, optional
            Field that should be stored. Can be:
            "field", "raw_field", "krige_field", "err_field" or "krige_var".
            Default: "field"
        fieldname : :class:`str`, optional
            Name of the field in the VTK file. Default: "field"
        """
        if self.value_type is None:
            raise ValueError(
                "Field value type not set! "
                + "Specify 'scalar' or 'vector' before plotting."
            )
        elif self.value_type == "vector":
            if hasattr(self, field_select):
                field = getattr(self, field_select)
            else:
                field = None
            if not (
                self.pos is None or field is None or self.mesh_type is None
            ):
                suf = ["_X", "_Y", "_Z"]
                fields = {}
                for i in range(self.model.dim):
                    fields[fieldname + suf[i]] = field[i]
                if filename is None:
                    return to_vtk(self.pos, fields, self.mesh_type)
                else:
                    return vtk_export(
                        filename, self.pos, fields, self.mesh_type
                    )
        elif self.value_type == "scalar":
            if hasattr(self, field_select):
                field = getattr(self, field_select)
            else:
                field = None
            if not (
                self.pos is None or field is None or self.mesh_type is None
            ):
                if filename is None:
                    return to_vtk(self.pos, {fieldname: field}, self.mesh_type)
                else:
                    return vtk_export(
                        filename, self.pos, {fieldname: field}, self.mesh_type
                    )
            else:
                print("Field.to_vtk: '{}' not available.".format(field_select))
        else:
            raise ValueError(
                "Unknown field value type: {}".format(self.value_type)
            )

    def to_pyvista(
        self, field_select="field", fieldname="field"
    ):  # pragma: no cover
        """Create a VTK/PyVista grid of the stored field.

        Parameters
        ----------
        field_select : :class:`str`, optional
            Field that should be stored. Can be:
            "field", "raw_field", "krige_field", "err_field" or "krige_var".
            Default: "field"
        fieldname : :class:`str`, optional
            Name of the field in the VTK file. Default: "field"
        """
        grid = self._to_vtk_helper(
            filename=None, field_select=field_select, fieldname=fieldname
        )
        return grid

    def vtk_export(
        self, filename, field_select="field", fieldname="field"
    ):  # pragma: no cover
        """Export the stored field to vtk.

        Parameters
        ----------
        filename : :class:`str`
            Filename of the file to be saved, including the path. Note that an
            ending (.vtr or .vtu) will be added to the name.
        field_select : :class:`str`, optional
            Field that should be stored. Can be:
            "field", "raw_field", "krige_field", "err_field" or "krige_var".
            Default: "field"
        fieldname : :class:`str`, optional
            Name of the field in the VTK file. Default: "field"
        """
        if not isinstance(filename, str):
            raise TypeError("Please use a string filename.")
        return self._to_vtk_helper(
            filename=filename, field_select=field_select, fieldname=fieldname
        )

    def plot(self, field="field", fig=None, ax=None):  # pragma: no cover
        """
        Plot the spatial random field.

        Parameters
        ----------
        field : :class:`str`, optional
            Field that should be plotted. Can be:
            "field", "raw_field", "krige_field", "err_field" or "krige_var".
            Default: "field"
        fig : :class:`Figure` or :any:`None`
            Figure to plot the axes on. If `None`, a new one will be created.
            Default: `None`
        ax : :class:`Axes` or :any:`None`
            Axes to plot on. If `None`, a new one will be added to the figure.
            Default: `None`
        """
        # just import if needed; matplotlib is not required by setup
        from gstools.field.plot import plot_field, plot_vec_field

        if self.value_type is None:
            raise ValueError(
                "Field value type not set! "
                + "Specify 'scalar' or 'vector' before plotting."
            )

        elif self.value_type == "scalar":
            r = plot_field(self, field, fig, ax)

        elif self.value_type == "vector":
            if self.model.dim == 2:
                r = plot_vec_field(self, field, fig, ax)
            else:
                raise NotImplementedError(
                    "Streamflow plotting only supported for 2d case."
                )
        else:
            raise ValueError(
                "Unknown field value type: {}".format(self.value_type)
            )

        return r

    @property
    def mean(self):
        """:class:`float`: The mean of the field."""
        return self._mean

    @mean.setter
    def mean(self, mean):
        self._mean = float(mean)

    @property
    def model(self):
        """:any:`CovModel`: The covariance model of the field."""
        return self._model

    @model.setter
    def model(self, model):
        if isinstance(model, CovModel):
            self._model = model
        else:
            raise ValueError(
                "Field: 'model' is not an instance of 'gstools.CovModel'"
            )

    @property
    def value_type(self):
        """:class:`str`: Type of the field values (scalar, vector)."""
        return self._value_type

    def __str__(self):
        """Return String representation."""
        return self.__repr__()

    def __repr__(self):
        """Return String representation."""
        return "Field(model={0}, mean={1:.{p}})".format(
            self.model, self.mean, p=self.model._prec
        )


def _names(name, cnt):
    name = [name] if isinstance(name, str) else list(name)[:cnt]
    if len(name) < cnt:
        name += [name[-1] + str(i + 1) for i in range(cnt - len(name))]
    return name


def _get_select(direction):
    select = []
    if not (0 < len(direction) < 4):
        raise ValueError(
            "Field.mesh: need 1 to 3 direction(s), got '{}'".format(direction)
        )
    for axis in direction:
        if axis == "x":
            if 0 in select:
                raise ValueError(
                    "Field.mesh: got duplicate directions {}".format(direction)
                )
            select.append(0)
        elif axis == "y":
            if 1 in select:
                raise ValueError(
                    "Field.mesh: got duplicate directions {}".format(direction)
                )
            select.append(1)
        elif axis == "z":
            if 2 in select:
                raise ValueError(
                    "Field.mesh: got duplicate directions {}".format(direction)
                )
            select.append(2)
        else:
            raise ValueError(
                "Field.mesh: got unknown direction {}".format(axis)
            )
    return select

1	# -- coding: utf-8 --
2	"""	15✔
3	GStools subpackage providing a base class for spatial fields.
4
5	.. currentmodule:: gstools.field.base
6
7	The following classes are provided
8
9	.. autosummary::
10	Field
11	"""
12	# pylint: disable=C0103
13
14	from functools import partial	15✔
15
16	import numpy as np	15✔
17	import meshio	15✔
18
19	from gstools.covmodel.base import CovModel	15✔
20	from gstools.tools.geometric import format_struct_pos_dim, gen_mesh	15✔
21	from gstools.tools.export import to_vtk, vtk_export	15✔
22
23
24	__all__ = ["Field"]	15✔
25
26
27	class Field:	15✔
28	"""A base class for random fields, kriging fields, etc.
29
30	Parameters
31	----------
32	model : :any:`CovModel`
33	Covariance Model related to the field.
34	mean : :class:`float`, optional
35	Mean value of the field.
36	"""
37
38	def __init__(self, model, mean=0.0):	15✔
39	# initialize attributes
40	self.pos = None	15✔
41	self.mesh_type = None	15✔
42	self.field = None	15✔
43	# initialize private attributes
44	self._mean = None	15✔
45	self._model = None	15✔
46	self.mean = mean	15✔
47	self.model = model	15✔
48	self._value_type = None	15✔
49
50	def __call__(args, *kwargs):	15✔
51	"""Generate the field."""
52	pass	×
53
54	def structured(self, args, *kwargs):	15✔
55	"""Generate a field on a structured mesh.
56
57	See :any:`Field.__call__`
58	"""
59	call = partial(self.__call__, mesh_type="structured")	15✔
60	return call(args, *kwargs)	15✔
61
62	def unstructured(self, args, *kwargs):	15✔
63	"""Generate a field on an unstructured mesh.
64
65	See :any:`Field.__call__`
66	"""
67	call = partial(self.__call__, mesh_type="unstructured")	15✔
68	return call(args, *kwargs)	15✔
69
70	def mesh(	15✔
71	self, mesh, points="centroids", direction="all", name="field", **kwargs
72	):
73	"""Generate a field on a given meshio or ogs5py mesh.
74
75	Parameters
76	----------
77	mesh : meshio.Mesh or ogs5py.MSH or PyVista mesh
78	The given meshio, ogs5py, or PyVista mesh
79	points : :class:`str`, optional
80	The points to evaluate the field at.
81	Either the "centroids" of the mesh cells
82	(calculated as mean of the cell vertices) or the "points"
83	of the given mesh.
84	Default: "centroids"
85	direction : :class:`str` or :class:`list`, optional
86	Here you can state which direction should be choosen for
87	lower dimension. For example, if you got a 2D mesh in xz direction,
88	you have to pass "xz". By default, all directions are used.
89	One can also pass a list of indices.
90	Default: "all"
91	name : :class:`str` or :class:`list` of :class:`str`, optional
92	Name(s) to store the field(s) in the given mesh as point_data or
93	cell_data. If to few names are given, digits will be appended.
94	Default: "field"
95	**kwargs
96	Keyword arguments forwareded to `Field.__call__`.
97
98	Notes
99	-----
100	This will store the field in the given mesh under the given name,
101	if a meshio or PyVista mesh was given.
102
103	See: https://github.com/nschloe/meshio
104	See: https://github.com/pyvista/pyvista
105
106	See: :any:`Field.__call__`
107	"""
108	has_pyvista = False	15✔
109	has_ogs5py = False	15✔
110
111	try:	15✔
112	import pyvista as pv	15✔
113
114	has_pyvista = True	×
115	except ImportError:	15✔
116	pass	15✔
117	try:	15✔
118	import ogs5py as ogs	15✔
119
120	has_ogs5py = True	×
121	except ImportError:	15✔
122	pass	15✔
123
124	if isinstance(direction, str) and direction == "all":	15✔
125	select = list(range(self.model.field_dim))	15✔
126	elif isinstance(direction, str):	×
127	select = _get_select(direction)[: self.model.field_dim]	×
128	else:
129	select = direction[: self.model.field_dim]	×
130	if len(select) < self.model.field_dim:	15✔
131	raise ValueError(	×
132	"Field.mesh: need at least {} direction(s), got '{}'".format(
133	self.model.field_dim, direction
134	)
135	)
136	# convert pyvista mesh
137	if has_pyvista and pv.is_pyvista_dataset(mesh):	15✔
138	if points == "centroids":	×
139	pnts = mesh.cell_centers().points.T[select]	×
140	else:
141	pnts = mesh.points.T[select]	×
142	out = self.unstructured(pos=pnts, **kwargs)	×
143	# Deal with the output
144	fields = [out] if isinstance(out, np.ndarray) else out	×
145	for f_name, field in zip(_names(name, len(fields)), fields):	×
146	mesh[f_name] = field	×
147	# convert ogs5py mesh
148	elif has_ogs5py and isinstance(mesh, ogs.MSH):	15✔
149	if points == "centroids":	×
150	pnts = mesh.centroids_flat.T[select]	×
151	else:
152	pnts = mesh.NODES.T[select]	×
153	out = self.unstructured(pos=pnts, **kwargs)	×
154	# convert meshio mesh
155	elif isinstance(mesh, meshio.Mesh):	15✔
156	if points == "centroids":	15✔
157	# define unique order of cells
158	offset = []	15✔
159	length = []	15✔
160	mesh_dim = mesh.points.shape[1]	15✔
161	if mesh_dim < self.model.field_dim:	15✔
162	raise ValueError("Field.mesh: mesh dimension too low!")	×
163	pnts = np.empty((0, mesh_dim), dtype=np.double)	15✔
164	for cell in mesh.cells:	15✔
165	pnt = np.mean(mesh.points[cell[1]], axis=1)	15✔
166	offset.append(pnts.shape[0])	15✔
167	length.append(pnt.shape[0])	15✔
168	pnts = np.vstack((pnts, pnt))	15✔
169	# generate pos for __call__
170	pnts = pnts.T[select]	15✔
171	out = self.unstructured(pos=pnts, **kwargs)	15✔
172	fields = [out] if isinstance(out, np.ndarray) else out	15✔
173	f_lists = []	15✔
174	for field in fields:	15✔
175	f_list = []	15✔
176	for of, le in zip(offset, length):	15✔
177	f_list.append(field[of : of + le])	15✔
178	f_lists.append(f_list)	15✔
179	for f_name, f_list in zip(_names(name, len(f_lists)), f_lists):	15✔
180	mesh.cell_data[f_name] = f_list	15✔
181	else:
182	out = self.unstructured(pos=mesh.points.T[select], **kwargs)	15✔
183	fields = [out] if isinstance(out, np.ndarray) else out	15✔
184	for f_name, field in zip(_names(name, len(fields)), fields):	15✔
185	mesh.point_data[f_name] = field	15✔
186	else:
187	raise ValueError("Field.mesh: Unknown mesh format!")	×
188	return out	15✔
189
190	def pre_pos(self, pos, mesh_type="unstructured"):	15✔
191	"""
192	Preprocessing positions and mesh_type.
193
194	Parameters
195	----------
196	pos : :any:`iterable`
197	the position tuple, containing main direction and transversal
198	directions
199	mesh_type : :class:`str`, optional
200	'structured' / 'unstructured'
201	Default: `"unstructured"`
202
203	Returns
204	-------
205	iso_pos : (d, n), :class:`numpy.ndarray`
206	the isometrized position tuple
207	shape : :class:`tuple`
208	Shape of the resulting field.
209	"""
210	# save mesh-type
211	self.mesh_type = mesh_type	15✔
212	dim = self.model.field_dim	15✔
213	# save pos tuple
214	if mesh_type != "unstructured":	15✔
215	pos, shape = format_struct_pos_dim(pos, dim)	15✔
216	self.pos = pos	15✔
217	pos = gen_mesh(pos)	15✔
218	else:
219	pos = np.array(pos, dtype=np.double).reshape(dim, -1)	15✔
220	self.pos = pos	15✔
221	shape = np.shape(pos[0])	15✔
222	# prepend dimension if we have a vector field
223	if self.value_type == "vector":	15✔
224	shape = (self.model.dim,) + shape	15✔
225	if self.model.latlon:	15✔
226	raise ValueError("Field: Vector fields not allowed for latlon")	×
227	# return isometrized pos tuple and resulting field shape
228	return self.model.isometrize(pos), shape	15✔
229
230	def _to_vtk_helper(
231	self, filename=None, field_select="field", fieldname="field"
232	): # pragma: no cover
233	"""Create a VTK/PyVista grid of the field or save it as a VTK file.
234
235	This is an internal helper that will handle saving or creating objects
236
237	Parameters
238	----------
239	filename : :class:`str`
240	Filename of the file to be saved, including the path. Note that an
241	ending (.vtr or .vtu) will be added to the name. If ``None`` is
242	passed, a PyVista dataset of the appropriate type will be returned.
243	field_select : :class:`str`, optional
244	Field that should be stored. Can be:
245	"field", "raw_field", "krige_field", "err_field" or "krige_var".
246	Default: "field"
247	fieldname : :class:`str`, optional
248	Name of the field in the VTK file. Default: "field"
249	"""
250	if self.value_type is None:
251	raise ValueError(
252	"Field value type not set! "
253	+ "Specify 'scalar' or 'vector' before plotting."
254	)
255	elif self.value_type == "vector":
256	if hasattr(self, field_select):
257	field = getattr(self, field_select)
258	else:
259	field = None
260	if not (
261	self.pos is None or field is None or self.mesh_type is None
262	):
263	suf = ["_X", "_Y", "_Z"]
264	fields = {}
265	for i in range(self.model.dim):
266	fields[fieldname + suf[i]] = field[i]
267	if filename is None:
268	return to_vtk(self.pos, fields, self.mesh_type)
269	else:
270	return vtk_export(
271	filename, self.pos, fields, self.mesh_type
272	)
273	elif self.value_type == "scalar":
274	if hasattr(self, field_select):
275	field = getattr(self, field_select)
276	else:
277	field = None
278	if not (
279	self.pos is None or field is None or self.mesh_type is None
280	):
281	if filename is None:
282	return to_vtk(self.pos, {fieldname: field}, self.mesh_type)
283	else:
284	return vtk_export(
285	filename, self.pos, {fieldname: field}, self.mesh_type
286	)
287	else:
288	print("Field.to_vtk: '{}' not available.".format(field_select))
289	else:
290	raise ValueError(
291	"Unknown field value type: {}".format(self.value_type)
292	)
293
294	def to_pyvista(
295	self, field_select="field", fieldname="field"
296	): # pragma: no cover
297	"""Create a VTK/PyVista grid of the stored field.
298
299	Parameters
300	----------
301	field_select : :class:`str`, optional
302	Field that should be stored. Can be:
303	"field", "raw_field", "krige_field", "err_field" or "krige_var".
304	Default: "field"
305	fieldname : :class:`str`, optional
306	Name of the field in the VTK file. Default: "field"
307	"""
308	grid = self._to_vtk_helper(
309	filename=None, field_select=field_select, fieldname=fieldname
310	)
311	return grid
312
313	def vtk_export(
314	self, filename, field_select="field", fieldname="field"
315	): # pragma: no cover
316	"""Export the stored field to vtk.
317
318	Parameters
319	----------
320	filename : :class:`str`
321	Filename of the file to be saved, including the path. Note that an
322	ending (.vtr or .vtu) will be added to the name.
323	field_select : :class:`str`, optional
324	Field that should be stored. Can be:
325	"field", "raw_field", "krige_field", "err_field" or "krige_var".
326	Default: "field"
327	fieldname : :class:`str`, optional
328	Name of the field in the VTK file. Default: "field"
329	"""
330	if not isinstance(filename, str):
331	raise TypeError("Please use a string filename.")
332	return self._to_vtk_helper(
333	filename=filename, field_select=field_select, fieldname=fieldname
334	)
335
336	def plot(self, field="field", fig=None, ax=None): # pragma: no cover
337	"""
338	Plot the spatial random field.
339
340	Parameters
341	----------
342	field : :class:`str`, optional
343	Field that should be plotted. Can be:
344	"field", "raw_field", "krige_field", "err_field" or "krige_var".
345	Default: "field"
346	fig : :class:`Figure` or :any:`None`
347	Figure to plot the axes on. If `None`, a new one will be created.
348	Default: `None`
349	ax : :class:`Axes` or :any:`None`
350	Axes to plot on. If `None`, a new one will be added to the figure.
351	Default: `None`
352	"""
353	# just import if needed; matplotlib is not required by setup
354	from gstools.field.plot import plot_field, plot_vec_field
355
356	if self.value_type is None:
357	raise ValueError(
358	"Field value type not set! "
359	+ "Specify 'scalar' or 'vector' before plotting."
360	)
361
362	elif self.value_type == "scalar":
363	r = plot_field(self, field, fig, ax)
364
365	elif self.value_type == "vector":
366	if self.model.dim == 2:
367	r = plot_vec_field(self, field, fig, ax)
368	else:
369	raise NotImplementedError(
370	"Streamflow plotting only supported for 2d case."
371	)
372	else:
373	raise ValueError(
374	"Unknown field value type: {}".format(self.value_type)
375	)
376
377	return r
378
379	@property	15✔
380	def mean(self):	6✔
381	""":class:`float`: The mean of the field."""
382	return self._mean	15✔
383
384	@mean.setter	15✔
385	def mean(self, mean):	6✔
386	self._mean = float(mean)	15✔
387
388	@property	15✔
389	def model(self):	6✔
390	""":any:`CovModel`: The covariance model of the field."""
391	return self._model	15✔
392
393	@model.setter	15✔
394	def model(self, model):	6✔
395	if isinstance(model, CovModel):	15✔
396	self._model = model	15✔
397	else:
398	raise ValueError(	×
399	"Field: 'model' is not an instance of 'gstools.CovModel'"
400	)
401
402	@property	15✔
403	def value_type(self):	6✔
404	""":class:`str`: Type of the field values (scalar, vector)."""
405	return self._value_type	15✔
406
407	def __str__(self):
408	"""Return String representation."""
409	return self.__repr__()
410
411	def __repr__(self):
412	"""Return String representation."""
413	return "Field(model={0}, mean={1:.{p}})".format(
414	self.model, self.mean, p=self.model._prec
415	)
416
417
418	def _names(name, cnt):	15✔
419	name = [name] if isinstance(name, str) else list(name)[:cnt]	15✔
420	if len(name) < cnt:	15✔
421	name += [name[-1] + str(i + 1) for i in range(cnt - len(name))]	×
422	return name	15✔
423
424
425	def _get_select(direction):	15✔
426	select = []	×
427	if not (0 < len(direction) < 4):	×
428	raise ValueError(	×
429	"Field.mesh: need 1 to 3 direction(s), got '{}'".format(direction)
430	)
431	for axis in direction:	×
432	if axis == "x":	×
433	if 0 in select:	×
434	raise ValueError(	×
435	"Field.mesh: got duplicate directions {}".format(direction)
436	)
437	select.append(0)	×
438	elif axis == "y":	×
439	if 1 in select:	×
440	raise ValueError(	×
441	"Field.mesh: got duplicate directions {}".format(direction)
442	)
443	select.append(1)	×
444	elif axis == "z":	×
445	if 2 in select:	×
446	raise ValueError(	×
447	"Field.mesh: got duplicate directions {}".format(direction)
448	)
449	select.append(2)	×
450	else:
451	raise ValueError(	×
452	"Field.mesh: got unknown direction {}".format(axis)
453	)
454	return select	×

GeoStat-Framework / GSTools / 476539530

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous