diff --git a/test/test_core.py b/test/test_core.py index 1de6cb6d561eea99790cd4f3ba3a7b44cf53ca22..2684a08b68a911f28b91d91833e163050d51e7ef 100644 --- a/test/test_core.py +++ b/test/test_core.py @@ -51,7 +51,7 @@ class Base_Test(object): merge_list[1].transform(tfields.bases.CYLINDER) merge_list[2].transform(tfields.bases.SPHERICAL) obj = type(self._inst).merged(*merge_list) - self.assertTrue(obj.coordSys == tfields.bases.CARTESIAN) + self.assertTrue(obj.coord_sys == tfields.bases.CARTESIAN) for i in range(len(merge_list)): value = np.allclose(merge_list[0], obj[i * len(self._inst): (i + 1) * @@ -59,7 +59,7 @@ class Base_Test(object): atol=ATOL) self.assertTrue(value) - obj_cs = type(self._inst).merged(*merge_list, coordSys=tfields.bases.CYLINDER) + obj_cs = type(self._inst).merged(*merge_list, coord_sys=tfields.bases.CYLINDER) for i in range(len(merge_list)): value = np.allclose(merge_list[1], obj_cs[i * len(self._inst): (i + 1) * @@ -99,7 +99,7 @@ class TensorFields_Empty_Test(Tensors_Empty_Test): class TensorFields_Copy_Test(TensorFields_Empty_Test): def setUp(self): base = [(-5, 5, 11)] * 3 - self._fields = [tfields.Tensors.grid(*base, coordSys='cylinder'), + self._fields = [tfields.Tensors.grid(*base, coord_sys='cylinder'), tfields.Tensors(range(11**3))] tensors = tfields.Tensors.grid(*base) self._inst = tfields.TensorFields(tensors, *self._fields) @@ -116,7 +116,7 @@ class TensorMaps_Copy_Test(TensorMaps_Empty_Test): def setUp(self): base = [(-1, 1, 3)] * 3 tensors = tfields.Tensors.grid(*base) - self._fields = [tfields.Tensors.grid(*base, coordSys='cylinder'), + self._fields = [tfields.Tensors.grid(*base, coord_sys='cylinder'), tfields.Tensors(range(len(tensors)))] self._maps_tensors = [[[0, 0, 0], [1, 2, 3], diff --git a/tfields/__init__.py b/tfields/__init__.py index b582e438d3441f6f83b1fafb78f8686e19741055..9518a8ec846523af96e0ca5aa08a0d4c0d7faac6 100644 --- a/tfields/__init__.py +++ b/tfields/__init__.py @@ -1,4 +1,4 @@ -__version__ = '0.1.0.dev3' +__version__ = '0.1.0.dev4' __author__ = "Daniel Boeckenhoff" __email__ = "daniel.boeckenhoff@ipp.mpg.de" diff --git a/tfields/bases/bases.py b/tfields/bases/bases.py index a925fbee24d58805b072425bed1d30ffc94d3baa..f66b21f71dc4fd6a25ea8d422d783e2e8c8a1946 100644 --- a/tfields/bases/bases.py +++ b/tfields/bases/bases.py @@ -27,7 +27,7 @@ def get_coord_system(base): if not isinstance(base, sympy.diffgeom.CoordSystem): bse_tpe = type(base) expctd_tpe = type(sympy.diffgeom.CoordSystem) - raise TypeError("Wrong type of coordSystem base {bse_tpe}. " + raise TypeError("Wrong type of coord_system base {bse_tpe}. " "Expected {expctd_tpe}" .format(**locals())) return base diff --git a/tfields/core.py b/tfields/core.py index 0da7482a13b2cf1720959e0dba073f72ef06e63e..607573665bf8d698e640782204a949d5a58fe502 100644 --- a/tfields/core.py +++ b/tfields/core.py @@ -124,7 +124,7 @@ class AbstractNdarray(np.ndarray): >>> from tfields import Tensors, TensorFields >>> scalars = Tensors([0, 1, 2]) >>> vectors = Tensors([[0, 0, 0], [0, 0, 1], [0, -1, 0]]) - >>> scalarField = TensorFields(vectors, scalars, coordSys='cylinder') + >>> scalarField = TensorFields(vectors, scalars, coord_sys='cylinder') Save it and restore it >>> outFile = NamedTemporaryFile(suffix='.pickle') @@ -134,7 +134,7 @@ class AbstractNdarray(np.ndarray): >>> _ = outFile.seek(0) >>> sf = pickle.load(outFile) - >>> sf.coordSys == 'cylinder' + >>> sf.coord_sys == 'cylinder' True >>> sf.fields[0][2] == 2. True @@ -269,7 +269,7 @@ class AbstractNdarray(np.ndarray): else: kwargs[attr] = getattr(self, attr) - np.savez(path, self, **kwargs) + np.savez(path, self, **kwargs) @classmethod def _load_npz(cls, path, **load_kwargs): @@ -305,7 +305,7 @@ class Tensors(AbstractNdarray): True >>> vectors.dim == 3 True - >>> assert vectors.coordSys == 'cartesian' + >>> assert vectors.coord_sys == 'cartesian' Initialize the Levi-Zivita Tensor >>> matrices = tfields.Tensors([[[0, 0, 0], [0, 0, 1], [0, -1, 0]], @@ -319,10 +319,10 @@ class Tensors(AbstractNdarray): True Initializing in different start coordinate system - >>> cyl = tfields.Tensors([[5, np.arctan(4. / 3.), 42]], coordSys='cylinder') - >>> assert cyl.coordSys == 'cylinder' + >>> cyl = tfields.Tensors([[5, np.arctan(4. / 3.), 42]], coord_sys='cylinder') + >>> assert cyl.coord_sys == 'cylinder' >>> cyl.transform('cartesian') - >>> assert cyl.coordSys == 'cartesian' + >>> assert cyl.coord_sys == 'cartesian' >>> cart = cyl >>> assert round(cart[0, 0], 10) == 3. >>> assert round(cart[0, 1], 10) == 4. @@ -331,8 +331,8 @@ class Tensors(AbstractNdarray): Initialize with copy constructor keeps the coordinate system >>> with vectors.tmp_transform('cylinder'): ... vect_cyl = tfields.Tensors(vectors) - ... assert vect_cyl.coordSys == vectors.coordSys - >>> assert vect_cyl.coordSys == 'cylinder' + ... assert vect_cyl.coord_sys == vectors.coord_sys + >>> assert vect_cyl.coord_sys == 'cylinder' You can demand a special dimension. >>> _ = tfields.Tensors([[1, 2, 3]], dim=3) @@ -351,7 +351,7 @@ class Tensors(AbstractNdarray): Tensors([], shape=(0, 7), dtype=float64) """ - __slots__ = ['coordSys'] + __slots__ = ['coord_sys'] __slot_defaults__ = ['cartesian'] __slot_setters__ = [tfields.bases.get_coord_system_name] @@ -364,10 +364,10 @@ class Tensors(AbstractNdarray): if issubclass(type(tensors), Tensors): if dim is not None: dim = tensors.dim - coordSys = kwargs.pop('coordSys', tensors.coordSys) + coord_sys = kwargs.pop('coord_sys', tensors.coord_sys) tensors = tensors.copy() - tensors.transform(coordSys) - kwargs['coordSys'] = coordSys + tensors.transform(coord_sys) + kwargs['coord_sys'] = coord_sys if dtype is None: dtype = tensors.dtype else: @@ -436,10 +436,10 @@ class Tensors(AbstractNdarray): Use of most frequent coordinate system >>> vec_a = tfields.Tensors([[0, 0, 0], [0, 0, 1], [0, -1, 0]]) - >>> vec_b = tfields.Tensors([[5, 4, 1]], coordSys=tfields.bases.cylinder) - >>> vec_c = tfields.Tensors([[4, 2, 3]], coordSys=tfields.bases.cylinder) + >>> vec_b = tfields.Tensors([[5, 4, 1]], coord_sys=tfields.bases.cylinder) + >>> vec_c = tfields.Tensors([[4, 2, 3]], coord_sys=tfields.bases.cylinder) >>> merge = tfields.Tensors.merged(vec_a, vec_b, vec_c, [[2, 0, 1]]) - >>> assert merge.coordSys == 'cylinder' + >>> assert merge.coord_sys == 'cylinder' >>> assert merge.equal([[0, 0, 0], ... [0, 0, 1], ... [1, -np.pi / 2, 0], @@ -450,42 +450,42 @@ class Tensors(AbstractNdarray): Merge also shifts the maps to still refer to the same tensors >>> tm_a = tfields.TensorMaps(merge, maps=[[[0, 1, 2]]]) >>> tm_b = tm_a.copy() - >>> assert tm_a.coordSys == 'cylinder' + >>> assert tm_a.coord_sys == 'cylinder' >>> tm_merge = tfields.TensorMaps.merged(tm_a, tm_b) - >>> assert tm_merge.coordSys == 'cylinder' + >>> assert tm_merge.coord_sys == 'cylinder' >>> assert tm_merge.maps[0].equal([[0, 1, 2], ... list(range(len(merge), ... len(merge) + 3, ... 1))]) - >>> obj_list = [tfields.Tensors([[1, 2, 3]], coordSys=tfields.bases.CYLINDER), + >>> obj_list = [tfields.Tensors([[1, 2, 3]], coord_sys=tfields.bases.CYLINDER), ... tfields.Tensors([[3] * 3]), ... tfields.Tensors([[5, 1, 3]])] - >>> merge2 = tfields.Tensors.merged(*obj_list, coordSys=tfields.bases.CARTESIAN) + >>> merge2 = tfields.Tensors.merged(*obj_list, coord_sys=tfields.bases.CARTESIAN) >>> assert merge2.equal([[-0.41614684, 0.90929743, 3.], ... [3, 3, 3], [5, 1, 3]], atol=1e-8) """ - ''' get most frequent coordSys or predefined coordSys ''' - coordSys = kwargs.get('coordSys', None) + ''' get most frequent coord_sys or predefined coord_sys ''' + coord_sys = kwargs.get('coord_sys', None) dimension = kwargs.get('dim', None) - if coordSys is None: + if coord_sys is None: bases = [] for t in objects: try: - bases.append(t.coordSys) + bases.append(t.coord_sys) except AttributeError: pass if bases: - # get most frequent coordSys - coordSys = sorted(bases, key=Counter(bases).get, reverse=True)[0] - kwargs['coordSys'] = coordSys + # get most frequent coord_sys + coord_sys = sorted(bases, key=Counter(bases).get, reverse=True)[0] + kwargs['coord_sys'] = coord_sys else: - default = cls.__slot_defaults__[cls.__slots__.index('coordSys')] - kwargs['coordSys'] = default + default = cls.__slot_defaults__[cls.__slots__.index('coord_sys')] + kwargs['coord_sys'] = default - ''' transform all raw inputs to cls type with correct coordSys. Also + ''' transform all raw inputs to cls type with correct coord_sys. Also automatically make a copy of those instances that are of the correct type already.''' objects = [cls.__new__(cls, t, **kwargs) for t in objects] @@ -584,10 +584,10 @@ class Tensors(AbstractNdarray): """ return dim(self) - def transform(self, coordSys): + def transform(self, coord_sys): """ Args: - coordSys (str) + coord_sys (str) Examples: >>> import numpy as np @@ -618,7 +618,7 @@ class Tensors(AbstractNdarray): >>> tCart = tfields.Tensors([[3, 4, 42], [1, 0, 0], [0, 1, -1], [-1, 0, 1], [0, 0, 0]]) >>> t_cyl = tCart.copy() >>> t_cyl.transform('cylinder') - >>> assert t_cyl.coordSys == 'cylinder' + >>> assert t_cyl.coord_sys == 'cylinder' R >>> assert t_cyl[0, 0] == 5 @@ -637,40 +637,40 @@ class Tensors(AbstractNdarray): >>> assert t_cyl[2, 2] == -1 >>> t_cyl.transform('cartesian') - >>> assert t_cyl.coordSys == 'cartesian' + >>> assert t_cyl.coord_sys == 'cartesian' >>> assert t_cyl[0, 0] == 3 """ # scalars empty already there - if self.rank == 0 or self.shape[0] == 0 or self.coordSys == coordSys: - self.coordSys = coordSys + if self.rank == 0 or self.shape[0] == 0 or self.coord_sys == coord_sys: + self.coord_sys = coord_sys return - tfields.bases.transform(self, self.coordSys, coordSys) - # self[:] = tfields.bases.transform(self, self.coordSys, coordSys) - self.coordSys = coordSys + tfields.bases.transform(self, self.coord_sys, coord_sys) + # self[:] = tfields.bases.transform(self, self.coord_sys, coord_sys) + self.coord_sys = coord_sys @contextmanager - def tmp_transform(self, coordSys): + def tmp_transform(self, coord_sys): """ - Temporarily change the coordSys to another coordSys and change it back at exit + Temporarily change the coord_sys to another coord_sys and change it back at exit This method is for cleaner code only. No speed improvements go with this. Args: see transform Examples: >>> import tfields - >>> p = tfields.Tensors([[1,2,3]], coordSys=tfields.bases.SPHERICAL) + >>> p = tfields.Tensors([[1,2,3]], coord_sys=tfields.bases.SPHERICAL) >>> with p.tmp_transform(tfields.bases.CYLINDER): - ... assert p.coordSys == tfields.bases.CYLINDER - >>> assert p.coordSys == tfields.bases.SPHERICAL + ... assert p.coord_sys == tfields.bases.CYLINDER + >>> assert p.coord_sys == tfields.bases.SPHERICAL """ - baseBefore = self.coordSys - if baseBefore == coordSys: + baseBefore = self.coord_sys + if baseBefore == coord_sys: yield else: - self.transform(coordSys) + self.transform(coord_sys) yield @@ -716,7 +716,7 @@ class Tensors(AbstractNdarray): def to_segment(self, segment, num_segments, coordinate, periodicity=2 * np.pi, offset=0., - coordSys=None): + coord_sys=None): """ For circular (close into themself after <periodicity>) coordinates at index <coordinate> assume @@ -728,14 +728,14 @@ class Tensors(AbstractNdarray): coordinate (int): coordinate index periodicity (float): after what lenght, the coordiante repeats offset (float): offset in the mapping - coordSys (str or sympy.CoordinateSystem): in which coord sys the + coord_sys (str or sympy.CoordinateSystem): in which coord sys the transformation should be done Examples: >>> import tfields >>> import numpy as np >>> pStart = tfields.Points3D([[6, 2 * np.pi, 1], ... [6, 2 * np.pi / 5 * 3, 1]], - ... coordSys='cylinder') + ... coord_sys='cylinder') >>> p = tfields.Points3D(pStart) >>> p.to_segment(0, 5, 1, offset=-2 * np.pi / 10) >>> assert np.array_equal(p[:, 1], [0, 0]) @@ -748,9 +748,9 @@ class Tensors(AbstractNdarray): if segment > num_segments - 1: raise ValueError("Segment {0} not existent.".format(segment)) - if coordSys is None: - coordSys = self.coordSys - with self.tmp_transform(coordSys): + if coord_sys is None: + coord_sys = self.coord_sys + with self.tmp_transform(coord_sys): # map all values to first segment self[:, coordinate] = \ (self[:, coordinate] - offset) % (periodicity / num_segments) + \ @@ -768,9 +768,9 @@ class Tensors(AbstractNdarray): equal_nan (bool) see numpy.isclose """ - if issubclass(type(other), Tensors) and self.coordSys != other.coordSys: + if issubclass(type(other), Tensors) and self.coord_sys != other.coord_sys: other = other.copy() - other.transform(self.coordSys) + other.transform(self.coord_sys) x, y = np.asarray(self), np.asarray(other) if rtol is None and atol is None: mask = (x == y) @@ -854,7 +854,7 @@ class Tensors(AbstractNdarray): array([2, 3, 4]) """ - with other.tmp_transform(self.coordSys): + with other.tmp_transform(self.coord_sys): # balanced_tree option gives huge speedup! kd_tree = sp.spatial.cKDTree(other, 1000, balanced_tree=False) @@ -863,11 +863,11 @@ class Tensors(AbstractNdarray): return array - def evalf(self, expression=None, coordSys=None): + def evalf(self, expression=None, coord_sys=None): """ Args: expression (sympy logical expression) - coordSys (str): coordSys to evalfuate the expression in. + coord_sys (str): coord_sys to evalfuate the expression in. Returns: np.ndarray: mask of dtype bool with lenght of number of points in self. This array is True, where expression evalfuates True. @@ -897,17 +897,17 @@ class Tensors(AbstractNdarray): """ coords = sympy.symbols('x y z') - with self.tmp_transform(coordSys or self.coordSys): + with self.tmp_transform(coord_sys or self.coord_sys): mask = tfields.evalf(self, expression, coords=coords) return mask - def cut(self, expression, coordSys=None): + def cut(self, expression, coord_sys=None): """ Default cut method for Points3D. Works on a copy. Args: expression (sympy logical expression): logical expression which will be evalfuated. use symbols x, y and z - coordSys (str): coordSys to evalfuate the expression in. + coord_sys (str): coord_sys to evalfuate the expression in. Examples: >>> import tfields >>> import sympy @@ -930,7 +930,7 @@ class Tensors(AbstractNdarray): """ if len(self) == 0: return self.copy() - mask = self.evalf(expression, coordSys=coordSys or self.coordSys) + mask = self.evalf(expression, coord_sys=coord_sys or self.coord_sys) mask.astype(bool) inst = self[mask].copy() return inst @@ -955,9 +955,9 @@ class Tensors(AbstractNdarray): True """ - if issubclass(type(other), Tensors) and self.coordSys != other.coordSys: + if issubclass(type(other), Tensors) and self.coord_sys != other.coord_sys: other = other.copy() - other.transform(self.coordSys) + other.transform(self.coord_sys) return sp.spatial.distance.cdist(self, other, **kwargs) def min_dists(self, other=None, **kwargs): @@ -1139,10 +1139,10 @@ class TensorFields(Tensors): >>> cp = TensorFields(vectorField) >>> assert vectorField.equal(cp) - Copying takes care of coordSys + Copying takes care of coord_sys >>> cp.transform(tfields.bases.CYLINDER) >>> cp_cyl = TensorFields(cp) - >>> assert cp_cyl.coordSys == tfields.bases.CYLINDER + >>> assert cp_cyl.coord_sys == tfields.bases.CYLINDER Copying with changing type >>> tcp = TensorFields(vectorField, dtype=int) @@ -1162,7 +1162,7 @@ class TensorFields(Tensors): >>> assert len(loose) != 1 """ - __slots__ = ['coordSys', 'fields'] + __slots__ = ['coord_sys', 'fields'] def __new__(cls, tensors, *fields, **kwargs): rigid = kwargs.pop('rigid', True) @@ -1280,10 +1280,10 @@ class TensorFields(Tensors): inst = cls.__new__(cls, inst, *fields) return inst - def transform(self, coordSys): - super(TensorFields, self).transform(coordSys) + def transform(self, coord_sys): + super(TensorFields, self).transform(coord_sys) for field in self.fields: - field.transform(coordSys) + field.transform(coord_sys) def equal(self, other, **kwargs): """ @@ -1296,7 +1296,7 @@ class TensorFields(Tensors): if not issubclass(type(other), Tensors): return super(TensorFields, self).equal(other, **kwargs) else: - with other.tmp_transform(self.coordSys): + with other.tmp_transform(self.coord_sys): mask = super(TensorFields, self).equal(other, **kwargs) if issubclass(type(other), TensorFields): if len(self.fields) != len(other.fields): @@ -1325,7 +1325,7 @@ class TensorMaps(TensorFields): tensors: see Tensors class *fields (Tensors): see TensorFields class **kwargs: - coordSys ('str'): see Tensors class + coord_sys ('str'): see Tensors class maps (array-like): indices indicating a connection between the tensors at the respective index positions Examples: @@ -1346,10 +1346,10 @@ class TensorMaps(TensorFields): Copy constructor >>> mesh_copy = tfields.TensorMaps(mesh) - Copying takes care of coordSys + Copying takes care of coord_sys >>> mesh_copy.transform(tfields.bases.CYLINDER) >>> mesh_cp_cyl = tfields.TensorMaps(mesh_copy) - >>> assert mesh_cp_cyl.coordSys == tfields.bases.CYLINDER + >>> assert mesh_cp_cyl.coord_sys == tfields.bases.CYLINDER Raises: >>> import tfields @@ -1359,7 +1359,7 @@ class TensorMaps(TensorFields): ValueError: Incorrect map rank 0 """ - __slots__ = ['coordSys', 'fields', 'maps'] + __slots__ = ['coord_sys', 'fields', 'maps'] def __new__(cls, tensors, *fields, **kwargs): maps = kwargs.pop('maps', []) @@ -1506,7 +1506,7 @@ class TensorMaps(TensorFields): if not issubclass(type(other), Tensors): return super(TensorMaps, self).equal(other, **kwargs) else: - with other.tmp_transform(self.coordSys): + with other.tmp_transform(self.coord_sys): mask = super(TensorMaps, self).equal(other, **kwargs) if issubclass(type(other), TensorMaps): if len(self.maps) != len(other.maps): diff --git a/tfields/mask.py b/tfields/mask.py index 0a7497afba68af730bd7cb773ef70e5d7414edd4..56ce3cce5aa2855850a9330068b1520bb6fa0c88 100644 --- a/tfields/mask.py +++ b/tfields/mask.py @@ -18,7 +18,7 @@ def evalf(array, cutExpression=None, coords=None): Args: array (numpy ndarray) cutExpression (sympy logical expression) - coordSys (str): coordSys to evalfuate the expression in. + coord_sys (str): coord_sys to evalfuate the expression in. Returns: np.array: mask which is True, where cutExpression evalfuates True. Examples: diff --git a/tfields/mesh3D.py b/tfields/mesh3D.py index 758a7bd96a03b5ec91319fa3bec38ce43feab1bb..8d17498bebd84ee319438c3136faa72cbfc877f1 100644 --- a/tfields/mesh3D.py +++ b/tfields/mesh3D.py @@ -462,7 +462,7 @@ class Mesh3D(tfields.TensorMaps): new_points = np.empty((0, 3)) new_faces = np.empty((0, 3)) new_fields = [tfields.Tensors(np.empty((0,) + field.shape[1:]), - coordSys=field.coordSys) + coord_sys=field.coord_sys) for field in inst.fields] new_map_fields = [[] for field in inst.maps[0].fields] new_norm_vectors = [] @@ -524,11 +524,11 @@ class Mesh3D(tfields.TensorMaps): face_map = tfields.TensorFields(faces, *faces_fields, dtype=int, - coordSys=inst.maps[0].coordSys) + coord_sys=inst.maps[0].coord_sys) inst = tfields.Mesh3D(vertices, *fields, maps=[face_map] + inst.maps[1:], - coordSys=inst.coordSys) + coord_sys=inst.coord_sys) mask = np.full(len(inst.maps[0]), True, dtype=bool) for face_idx in range(len(inst.maps[0])): if face_idx in face_delete_indices: @@ -627,7 +627,7 @@ class Mesh3D(tfields.TensorMaps): maps=maps) return inst - def cut(self, expression, coordSys=None, at_intersection=None, + def cut(self, expression, coord_sys=None, at_intersection=None, return_template=False): """ cut method for Mesh3D. @@ -642,7 +642,7 @@ class Mesh3D(tfields.TensorMaps): We use the vertices and maps of the Mesh as the sceleton of the returned mesh. The fields are mapped according to indices in the template.maps[i].fields. - coordSys (coordinate system to cut in): + coord_sys (coordinate system to cut in): at_intersection (str): instruction on what to do, when a cut will intersect a triangle. Options: "remove" (Default) "split" - Create new triangles that make up the old one. @@ -713,7 +713,7 @@ class Mesh3D(tfields.TensorMaps): * optional: template """ - with self.tmp_transform(coordSys or self.coordSys): + with self.tmp_transform(coord_sys or self.coord_sys): if isinstance(expression, Mesh3D): obj = self._cut_template(expression) else: diff --git a/tfields/points3D.py b/tfields/points3D.py index 82e3052e64807ed5b5b4636fdcc55ecfbde3ac76..b9d865b28bd0f3d9eb83b2b380c45a93e23ea793 100644 --- a/tfields/points3D.py +++ b/tfields/points3D.py @@ -18,11 +18,11 @@ class Points3D(tfields.Tensors): Args: points3DInstance -> copy constructor - [points3DInstance1, points3DInstance2, ...] -> coordSys are correctly treated + [points3DInstance1, points3DInstance2, ...] -> coord_sys are correctly treated list of coordinates (see examples) Kwargs: - coordSys (str): + coord_sys (str): Use tfields.bases.CARTESIAN -> x, y, z Use tfields.bases.CYLINDER -> r, phi, z Use tfields.bases.SPHERICAL -> r, phi, theta @@ -55,11 +55,11 @@ class Points3D(tfields.Tensors): [ 8.06225775, 1.05165021, -1. ], [ 9.43398113, 1.01219701, 0. ]]) - Copy constructor with one instance preserves coordSys of instance - >>> assert tfields.Points3D(p2).coordSys == p2.coordSys + Copy constructor with one instance preserves coord_sys of instance + >>> assert tfields.Points3D(p2).coord_sys == p2.coord_sys Unless you specify other: - >>> tfields.Points3D(p2, coordSys=tfields.bases.CARTESIAN) + >>> tfields.Points3D(p2, coord_sys=tfields.bases.CARTESIAN) Points3D([[ 1., 4., 1.], [ 2., 5., 2.], [ 3., 6., -6.], @@ -83,7 +83,7 @@ class Points3D(tfields.Tensors): >>> p1.transform(tfields.bases.CYLINDER) ... unless specified other. Here it is specified - >>> tfields.Points3D.merged(p1, p2, coordSys=tfields.bases.CYLINDER) + >>> tfields.Points3D.merged(p1, p2, coord_sys=tfields.bases.CYLINDER) Points3D([[ 2.23606798, 1.10714872, 3. ], [ 6.40312424, 0.89605538, 6. ], [ 2.23606798, 1.10714872, -6. ], @@ -127,7 +127,7 @@ class Points3D(tfields.Tensors): ... [7.071, -2.356, -5.], ... [1. , 0. , -1.], ... [1. , 1.571, -1.]], - ... coordSys=tfields.bases.CYLINDER), + ... coord_sys=tfields.bases.CYLINDER), ... atol=1e-3) >>> p.transform(tfields.bases.CARTESIAN) >>> assert p.equal(p_cart, atol=1e-15) diff --git a/tfields/triangles3D.py b/tfields/triangles3D.py index 92de96ad5810c3e179466e2c5a5d69b5fa9add2f..c9f22f52b8d955af56b2c05820e544effc5d2854 100644 --- a/tfields/triangles3D.py +++ b/tfields/triangles3D.py @@ -124,7 +124,7 @@ class Triangles3D(tfields.TensorFields): def triangleScalars(self, scalars): self.fields = tfields.scalars_to_fields(scalars) - def evalf(self, expression=None, coordSys=None): + def evalf(self, expression=None, coord_sys=None): """ Triangle3D implementation Examples: @@ -141,12 +141,12 @@ class Triangles3D(tfields.TensorFields): Returns: np.array: mask which is True, where expression evaluates True """ - mask = super(Triangles3D, self).evalf(expression, coordSys=coordSys) + mask = super(Triangles3D, self).evalf(expression, coord_sys=coord_sys) mask = self._to_triangles_mask(mask) mask = np.array([mask] * 3).T.reshape((len(self))) return mask - def cut(self, expression, coordSys=None): + def cut(self, expression, coord_sys=None): """ Default cut method for Triangles3D Examples: @@ -166,7 +166,7 @@ class Triangles3D(tfields.TensorFields): >>> assert np.array_equal(tc2.triangleScalars, np.array([[2.]])) """ - mask = self.evalf(expression, coordSys=coordSys) + mask = self.evalf(expression, coord_sys=coord_sys) inst = self[mask].copy() # inst.triangleScalars = @@ -290,12 +290,12 @@ class Triangles3D(tfields.TensorFields): nT = self.ntriangles() mat = np.ones((1, 3)) / 3.0 # matrix product calculatesq center of all triangles - return tfields.Points3D(np.dot(mat, self.reshape(nT, 3, 3))[0], coordSys=self.coordSys) + return tfields.Points3D(np.dot(mat, self.reshape(nT, 3, 3))[0], coord_sys=self.coord_sys) """ Old version: pointA, pointB, pointC = self.corners() - return Points3D(1. / 3 * (pointA + pointB + pointC)), coordSys=self.coordSys + return Points3D(1. / 3 * (pointA + pointB + pointC)), coord_sys=self.coord_sys This versioin was slightly slower (110 % of new version) Memory usage of new version is better for a factor of 4 or so. Not really reliable method of measurement @@ -549,7 +549,7 @@ class Triangles3D(tfields.TensorFields): return np.empty((tensors.shape[0], 0), dtype=bool) masks = np.zeros((len(tensors), self.ntriangles()), dtype=bool) - with tensors.tmp_transform(self.coordSys): + with tensors.tmp_transform(self.coord_sys): for i, point in enumerate(tensors): # print("Status: {i} points processed. Yet {nP} are found " # "to be in triangles.".format(nP=masks.sum() - 1, **locals()))