pygeodesy 24.5.15__py2.py3-none-any.whl → 24.6.1__py2.py3-none-any.whl

pygeodesy/datums.py

@@ -73,8 +73,7 @@ from pygeodesy.constants import R_M, _float as _F, _0_0, _1_0, _2_0, _8_0, _3600
 #                                          LatLonEllipsoidalBase as _LLEB  # MODS
 from pygeodesy.ellipsoids import a_f2Tuple, Ellipsoid, Ellipsoid2, Ellipsoids, _EWGS84, \
                                  Vector3Tuple
-from pygeodesy.errors import _IsnotError, _TypeError, _xattr, _xellipsoidall, _xkwds, \
-                             _xkwds_pop2
+from pygeodesy.errors import _IsnotError, _TypeError, _xellipsoidall, _xkwds, _xkwds_pop2
 from pygeodesy.fmath import fdot, fmean,  Fmt, _operator
 from pygeodesy.internals import _passarg, _under
 from pygeodesy.interns import NN, _a_, _Airy1830_, _AiryModified_, _BAR_, _Bessel1841_, \
@@ -84,7 +83,8 @@ from pygeodesy.interns import NN, _a_, _Airy1830_, _AiryModified_, _BAR_, _Besse
                              _PLUS_, _Sphere_, _spherical_, _transform_, _UNDER_, \
                              _WGS72_, _WGS84_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _NamedEnum, _NamedEnumItem, _lazyNamedEnumItem as _lazy
+from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _name2__, _NamedEnum, \
+                                _NamedEnumItem
 # from pygeodesy.namedTuples import Vector3Tuple  # from .ellipsoids
 from pygeodesy.props import Property_RO, property_RO
 # from pygeodesy.streprs import Fmt  # from .fmath
@@ -94,7 +94,7 @@ from pygeodesy.units import _isRadius, Radius_,  radians
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.datums
-__version__ = '24.05.14'
+__version__ = '24.05.21'
 
 _a_ellipsoid_ = _UNDER_(_a_, _ellipsoid_)
 _BD72_        = 'BD72'
@@ -204,15 +204,15 @@ class Transform(_NamedEnumItem):
     def __neg__(self):
         return self.inverse()
 
-    def inverse(self, name=NN):
+    def inverse(self, **name):
         '''Return the inverse of this transform.
 
            @kwarg name: Optional, unique name (C{str}).
 
            @return: Inverse (L{Transform}), unregistered.
         '''
-        r = type(self)(**dict(self.items(inverse=True)))
-        n = name or _negastr(self.name)
+        r =  type(self)(**dict(self.items(inverse=True)))
+        n = _name__(**name) or _negastr(self.name)
         if n:
             r.name = n  # unregistered
         return r
@@ -248,16 +248,17 @@ class Transform(_NamedEnumItem):
         self.s  = s = (s1 - _1_0) / _S1_S
         return s
 
-    def toStr(self, prec=5, fmt=Fmt.g, name=NN, **unused):  # PYCHOK expected
+    def toStr(self, prec=5, fmt=Fmt.g, **name):  # PYCHOK expected
         '''Return this transform as a string.
 
            @kwarg prec: Number of (decimal) digits, unstripped (C{int}).
            @kwarg fmt: Optional C{float} format (C{letter}).
-           @kwarg name: Override name (C{str}) or C{None} to exclude
-                        this transform's name.
+           @kwarg name: Optional, override C{B{name}=NN} (C{str}) or
+                        C{None} to exclude this transform's name.
 
            @return: Transform attributes (C{str}).
         '''
+        name, _ = _name2__(**name)  # name=None
         return self._instr(name, prec, *_Names11, fmt=fmt)
 
     def transform(self, x, y, z, inverse=False, **Vector_and_kwds):
@@ -378,12 +379,12 @@ class Datum(_NamedEnumItem):
     _ellipsoid = Ellipsoids.WGS84  # default ellipsoid (L{Ellipsoid}, L{Ellipsoid2})
     _transform = Transforms.WGS84  # default transform (L{Transform})
 
-    def __init__(self, ellipsoid, transform=None, name=NN):
+    def __init__(self, ellipsoid, transform=None, **name):
         '''New L{Datum}.
 
            @arg ellipsoid: The ellipsoid (L{Ellipsoid} or L{Ellipsoid2}).
            @kwarg transform: Optional transform (L{Transform}).
-           @kwarg name: Optional, unique name (C{str}).
+           @kwarg name: Optional, unique C{B{name}=NN} (C{str}).
 
            @raise NameError: Datum with that B{C{name}} already exists.
 
@@ -397,7 +398,8 @@ class Datum(_NamedEnumItem):
         self._transform = transform or Datum._transform
         _xinstanceof(Transform, transform=self.transform)
 
-        self._register(Datums, name or self.transform.name or self.ellipsoid.name)
+        self._register(Datums, _name__(name) or self.transform.name
+                                             or self.ellipsoid.name)
 
     def __eq__(self, other):
         '''Compare this and an other datum.
@@ -474,15 +476,16 @@ class Datum(_NamedEnumItem):
         '''
         return self.ellipsoid.isSpherical
 
-    def toStr(self, sep=_COMMASPACE_, name=NN, **unused):  # PYCHOK expected
+    def toStr(self, sep=_COMMASPACE_, **name):  # PYCHOK expected
         '''Return this datum as a string.
 
            @kwarg sep: Separator to join (C{str}).
-           @kwarg name: Override name (C{str}) or C{None} to exclude
-                        this datum's name.
+           @kwarg name: Optional, override C{B{name}=NN} (C{str}) or
+                        C{None} to exclude this datum's name.
 
            @return: Datum attributes (C{str}).
         '''
+        name, _ = _name2__(**name)  # name=None
         t = [] if name is None else \
             [Fmt.EQUAL(name=repr(name or self.named))]
         for a in (_ellipsoid_, _transform_):
@@ -497,7 +500,7 @@ class Datum(_NamedEnumItem):
         return self._transform
 
 
-def _earth_datum(inst, a_earth, f=None, name=NN, raiser=_a_ellipsoid_):  # in .karney, .trf, ...
+def _earth_datum(inst, a_earth, f=None, raiser=_a_ellipsoid_, **name):  # in .karney, .trf, ...
     '''(INTERNAL) Set C{inst._datum} from C{(B{a_..}, B{f})} or C{B{.._ellipsoid}}
        (L{Ellipsoid}, L{Ellipsoid2}, L{Datum}, C{a_f2Tuple} or C{scalar} earth radius).
 
@@ -520,12 +523,12 @@ def _earth_datum(inst, a_earth, f=None, name=NN, raiser=_a_ellipsoid_):  # in .k
     inst._datum = D
 
 
-def _earth_ellipsoid(earth, *name_raiser):
+def _earth_ellipsoid(earth, **name_raiser):
     '''(INTERAL) Return the ellipsoid for the given C{earth} model.
     '''
     return Ellipsoids.Sphere if earth is  R_M else (
           _EWGS84            if earth is _EWGS84 or earth is _WGS84 else
-          _spherical_datum(earth, *name_raiser).ellipsoid)
+          _spherical_datum(earth, **name_raiser).ellipsoid)
 
 
 def _ED2(radius, name):
@@ -534,13 +537,13 @@ def _ED2(radius, name):
     D = Datums.Sphere
     E = D.ellipsoid
     if name or radius != E.a:  # != E.b
-        n = _under(name)
+        n = _under(_name__(name, _or_nameof=D))
         E =  Ellipsoid(radius, radius, name=n)
         D =  Datum(E, transform=Transforms.Identity, name=n)
     return E, D
 
 
-def _ellipsoidal_datum(earth, Error=TypeError, name=NN, raiser=NN):
+def _ellipsoidal_datum(earth, Error=TypeError, raiser=NN, **name):
     '''(INTERNAL) Create a L{Datum} from an L{Ellipsoid} or L{Ellipsoid2},
        C{a_f2Tuple}, 2-tuple or 2-list B{C{earth}} model.
 
@@ -563,29 +566,25 @@ def _ellipsoidal_datum(earth, Error=TypeError, name=NN, raiser=NN):
 def _EnD3(earth, name):
     '''(INTERNAL) Helper for C{_earth_datum} and C{_ellipsoidal_datum}.
     '''
-    D = None
+    D, n = None, _under(_name__(name, _or_nameof=earth))
     if isinstance(earth, (Ellipsoid, Ellipsoid2)):
-        E =  earth
-        n = _under(name or E.name)
+        E = earth
     elif isinstance(earth, Datum):
-        E =  earth.ellipsoid
-        n = _under(name or earth.name)
-        D =  earth
+        E = earth.ellipsoid
+        D = earth
     elif _isRadius(earth):
-        E, D = _ED2(Radius_(earth), name)
-        n =  E.name
+        E, D = _ED2(Radius_(earth), n)
+        n = E.name
     elif isinstance(earth, a_f2Tuple):
-        n = _under(name or earth.name)
-        E =  earth.ellipsoid(name=n)
+        E = earth.ellipsoid(name=n)
     elif islistuple(earth, minum=2):
-        E =  Ellipsoids.Sphere
+        E = Ellipsoids.Sphere
         a, f = earth[:2]
         if f or a != E.a:  # != E.b
-            n = _under(name or _xattr(earth, name=NN))
-            E =  Ellipsoid(a, f=f, name=n)
+            E = Ellipsoid(a, f=f, name=n)
         else:
-            n =  E.name
-            D =  Datums.Sphere
+            n = E.name
+            D = Datums.Sphere
     else:
         E, n = None, NN
     return E, n, D
@@ -624,16 +623,18 @@ def _negastr(name):  # in .trf
     return n.lstrip(p) if n.startswith(p) else NN(m, n)
 
 
-def _spherical_datum(earth, Error=TypeError, name=NN, raiser=NN):
+def _spherical_datum(earth, Error=TypeError, raiser=NN, **name):
     '''(INTERNAL) Create a L{Datum} from an L{Ellipsoid}, L{Ellipsoid2},
        C{a_f2Tuple}, 2-tuple, 2-list B{C{earth}} model or C{scalar} radius.
 
        @kwarg raiser: If not C{NN}, raise an B{C{Error}} if not spherical.
     '''
-    if _isRadius(earth):
+    if isinstance(earth, Datum):
+        D = earth
+    elif _isRadius(earth):
         _, D = _ED2(Radius_(earth, Error=Error), name)
     else:
-        D = _ellipsoidal_datum(earth, Error=Error, name=name)
+        D = _ellipsoidal_datum(earth, Error=Error, **name)
     if raiser and not D.isSpherical:
         raise _IsnotError(_spherical_, Error=Error, **{raiser: earth})
     return D
@@ -643,11 +644,11 @@ class Datums(_NamedEnum):
     '''(INTERNAL) L{Datum} registry, I{must} be a sub-class
        to accommodate the L{_LazyNamedEnumItem} properties.
     '''
-    def _Lazy(self, ellipsoid_name, transform_name, name=NN):
+    def _Lazy(self, ellipsoid_name, transform_name, **name):
         '''(INTERNAL) Instantiate the L{Datum}.
         '''
         return Datum(Ellipsoids.get(ellipsoid_name),
-                     Transforms.get(transform_name), name=name)
+                     Transforms.get(transform_name), **name)
 
 Datums = Datums(Datum)  # PYCHOK singleton
 '''Some pre-defined L{Datum}s, all I{lazily} instantiated.'''

pygeodesy/deprecated/functions.py

@@ -14,7 +14,7 @@ from pygeodesy.props import deprecated_function
 from pygeodesy.units import Number_, Scalar_
 
 __all__ = _ALL_DEPRECATED.deprecated_functions
-__version__ = '24.02.08'
+__version__ = '24.05.25'
 
 _WGS84 = _UTM = object()
 
@@ -109,13 +109,19 @@ def enStr2(easting, northing, prec, *extras):  # PYCHOK no cover
     return _MODS.streprs.enstr2(easting, northing, (int(prec) // 2 - 5), *extras)
 
 
+@deprecated_function
+def equirectangular_(lat1, lon1, lat2, lon2, **options):  # PYCHOK no cover
+    '''DEPRECATED on 2024.05.25, use function L{pygeodesy.equirectangular4}.'''
+    return _MODS.formy.equirectangular4(lat1, lon1, lat2, lon2, **options)
+
+
 @deprecated_function
 def equirectangular3(lat1, lon1, lat2, lon2, **options):  # PYCHOK no cover
-    '''DEPRECATED, use function L{pygeodesy.equirectangular_}.
+    '''DEPRECATED, use function L{pygeodesy.equirectangular4}.
 
        @return: 3-Tuple C{(distance2, delta_lat, delta_lon)}.
     '''
-    return tuple(_MODS.formy.equirectangular_(lat1, lon1, lat2, lon2, **options)[:3])
+    return tuple(_MODS.formy.equirectangular4(lat1, lon1, lat2, lon2, **options)[:3])
 
 
 @deprecated_function

pygeodesy/dms.py

@@ -66,10 +66,11 @@ from pygeodesy.basics import copysign0, isLatLon, isodd, issequence, isstr, map2
 from pygeodesy.constants import _umod_360, _0_0, _0_5, _60_0, _360_0, _3600_0
 from pygeodesy.errors import ParseError, RangeError, _TypeError, _ValueError,\
                             _parseX, rangerrors, _xkwds, _xkwds_get
-from pygeodesy.interns import NN, _arg_, _COMMA_, _d_, _DASH_, _deg_, _degrees_, _DOT_, \
-                             _0_, _e_, _E_, _EW_, _f_, _F_, _g_, _MINUS_, _N_, _NE_, _NS_, \
-                             _NSEW_, _NW_, _of_, _PERCENTDOTSTAR_, _PLUS_, _PLUSMINUS_, \
-                             _QUOTE1_, _QUOTE2_, _radians_, _S_, _SE_, _SPACE_, _SW_, _W_
+from pygeodesy.interns import NN, _arg_, _COMMA_, _d_, _DASH_, _deg_, _degrees_, \
+                             _DOT_, _0_, _e_, _E_, _EW_, _f_, _F_, _g_, _keyword_, \
+                             _MINUS_, _N_, _NE_, _NS_, _NSEW_, _NW_, _of_, \
+                             _PERCENTDOTSTAR_, _PLUS_, _PLUSMINUS_, _QUOTE1_, \
+                             _QUOTE2_, _radians_, _S_, _SE_, _SPACE_, _SW_, _W_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv
 # from pygeodesy.namedTuples import LatLon2Tuple  # _MODS
 # from pygeodesy.props import _throwarning  # _MODS
@@ -84,12 +85,11 @@ except ImportError:  # Python 3+
     from string import ascii_letters as _LETTERS
 
 __all__ = _ALL_LAZY.dms
-__version__ = '24.03.21'
+__version__ = '24.05.18'
 
 _beyond_      = 'beyond'
 _DDDMMSS_     = 'DDDMMSS'
 _deg_min_     = 'deg+min'
-_keyword_     = 'keyword'
 _SDIGITS_     = '-0123456789+'
 _sexagecimal_ = 'sexagecimal'
 _SEXAGECIMUL  =  1.e4  # sexagecimal C{D.MMSSss} into decimal C{DMMSS.ss}

pygeodesy/ecef.py

@@ -58,7 +58,7 @@ plane} as opposed to I{geocentric} (ECEF) ones.
 '''
 
 from pygeodesy.basics import copysign0, isscalar, issubclassof, neg, map1, \
-                            _xinstanceof, _xsubclassof
+                            _xinstanceof, _xsubclassof  # _args_kwds_names
 from pygeodesy.constants import EPS, EPS0, EPS02, EPS1, EPS2, EPS_2, INT0, PI, PI_2, \
                                _0_0, _0_0001, _0_01, _0_5, _1_0, _1_0_1T, _N_1_0, \
                                _2_0, _N_2_0, _3_0, _4_0, _6_0, _60_0, _90_0, _N_90_0, \
@@ -73,7 +73,7 @@ from pygeodesy.interns import NN, _a_, _C_, _datum_, _ellipsoid_, _f_, _height_,
                              _lat_, _lon_, _M_, _name_, _singular_, _SPACE_, \
                              _x_, _xyz_, _y_, _z_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _NamedBase, _NamedTuple, _Pass, _xnamed
+from pygeodesy.named import _name__, _name1__, _NamedBase, _NamedTuple, _Pass, _xnamed
 from pygeodesy.namedTuples import LatLon2Tuple, LatLon3Tuple, \
                                   PhiLam2Tuple, Vector3Tuple, Vector4Tuple
 from pygeodesy.props import deprecated_method, Property_RO, property_RO, property_doc_
@@ -86,7 +86,7 @@ from pygeodesy.utily import atan1, atan1d, atan2d, degrees90, degrees180, \
 from math import atan2, cos, degrees, fabs, radians, sqrt
 
 __all__ = _ALL_LAZY.ecef
-__version__ = '24.05.10'
+__version__ = '24.05.31'
 
 _Ecef_    = 'Ecef'
 _prolate_ = 'prolate'
@@ -108,7 +108,7 @@ class _EcefBase(_NamedBase):
     _E     = _EWGS84
     _lon00 =  INT0  # arbitrary, "polar" lon for LocalCartesian, Ltp
 
-    def __init__(self, a_ellipsoid=_EWGS84, f=None, name=NN, lon00=INT0):
+    def __init__(self, a_ellipsoid=_EWGS84, f=None, lon00=INT0, **name):
         '''New C{Ecef*} converter.
 
            @arg a_ellipsoid: A (non-prolate) ellipsoid (L{Ellipsoid}, L{Ellipsoid2},
@@ -117,9 +117,9 @@ class _EcefBase(_NamedBase):
            @kwarg f: C{None} or the ellipsoid flattening (C{scalar}), required
                      for C{scalar} B{C{a_ellipsoid}}, C{B{f}=0} represents a
                      sphere, negative B{C{f}} a prolate ellipsoid.
-           @kwarg name: Optional name (C{str}).
            @kwarg lon00: An arbitrary, I{"polar"} longitude (C{degrees}), see the
-                         methods C{reverse}.
+                         C{reverse} method.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise EcefError: If B{C{a_ellipsoid}} not L{Ellipsoid}, L{Ellipsoid2},
                              L{Datum} or L{a_f2Tuple} or C{scalar} or B{C{f}} not
@@ -136,7 +136,7 @@ class _EcefBase(_NamedBase):
                 raise ValueError  # _invalid_
 
             if E not in (_EWGS84, _WGS84):
-                d = _ellipsoidal_datum(E, name=name)
+                d = _ellipsoidal_datum(E, **name)
                 E =  d.ellipsoid
                 if E.a < EPS or E.f > EPS1:
                     raise ValueError  # _invalid_
@@ -209,9 +209,9 @@ class _EcefBase(_NamedBase):
         m = self._Matrix(sa, ca, sb, cb) if M else None
         return Ecef9Tuple(x * cb, x * sb, z, lat, lon, h,
                                              0, m, self.datum,
-                                             name=name or self.name)
+                                             name=self._name__(name))
 
-    def forward(self, latlonh, lon=None, height=0, M=False, name=NN):
+    def forward(self, latlonh, lon=None, height=0, M=False, **name):
         '''Convert from geodetic C{(lat, lon, height)} to geocentric C{(x, y, z)}.
 
            @arg latlonh: Either a C{LatLon}, an L{Ecef9Tuple} or C{scalar}
@@ -221,7 +221,7 @@ class _EcefBase(_NamedBase):
            @kwarg height: Optional height (C{meter}), vertically above (or below)
                           the surface of the ellipsoid.
            @kwarg M: Optionally, return the rotation L{EcefMatrix} (C{bool}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
                     geocentric C{(x, y, z)} coordinates for the given geodetic ones
@@ -235,10 +235,10 @@ class _EcefBase(_NamedBase):
            @note: Use method C{.forward_} to specify C{lat} and C{lon} in C{radians}
                   and avoid double angle conversions.
         '''
-        llhn = _llhn4(latlonh, lon, height, name=name)
+        llhn = _llhn4(latlonh, lon, height, **name)
         return self._forward(*llhn, M=M)
 
-    def forward_(self, phi, lam, height=0, M=False, name=NN):
+    def forward_(self, phi, lam, height=0, M=False, **name):
         '''Like method C{.forward} except with geodetic lat- and longitude given
            in I{radians}.
 
@@ -247,7 +247,7 @@ class _EcefBase(_NamedBase):
            @kwarg height: Optional height (C{meter}), vertically above (or below)
                           the surface of the ellipsoid.
            @kwarg M: Optionally, return the rotation L{EcefMatrix} (C{bool}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
                     with C{lat} set to C{degrees90(B{phi})} and C{lon} to
@@ -255,8 +255,8 @@ class _EcefBase(_NamedBase):
 
            @raise EcefError: If B{C{phi}} or B{C{lam}} invalid or not C{scalar}.
         '''
-        try:  # like function C{_llhn4} above
-            plhn = Phi(phi), Lam(lam), Height(height), name
+        try:  # like function C{_llhn4} below
+            plhn = Phi(phi), Lam(lam), Height(height), _name__(name)
         except (TypeError, ValueError) as x:
             raise EcefError(phi=phi, lam=lam, height=height, cause=x)
         return self._forward(*plhn, M=M, _philam=True)
@@ -390,7 +390,7 @@ class EcefFarrell21(_EcefBase):
 
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    1, None, self.datum,
-                                   name=name or self.name)
+                                   name=self._name__(name))
 
 
 class EcefFarrell22(_EcefBase):
@@ -451,7 +451,7 @@ class EcefFarrell22(_EcefBase):
 
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    1, None, self.datum,
-                                   name=name or self.name)
+                                   name=self._name__(name))
 
 
 class EcefKarney(_EcefBase):
@@ -606,8 +606,7 @@ class EcefKarney(_EcefBase):
         lon = self._polon(sb, cb, R, **name_lon00)
         m   = self._Matrix(sa, ca, sb, cb) if M else None
         return Ecef9Tuple(x, y, z, atan1d(sa, ca), lon, h,
-                                   C, m, self.datum,
-                                   name=name or self.name)
+                                   C, m, self.datum, name=self._name__(name))
 
 
 class EcefSudano(_EcefBase):
@@ -686,7 +685,7 @@ class EcefSudano(_EcefBase):
         # h = (fabs(z) + R - E.a * cos(a + E.e21) * sa / ca) / (ca + sa)
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    i, None, self.datum,  # C=i, M=None
-                                   iteration=i, name=name or self.name)
+                                   iteration=i, name=self._name__(name))
 
     @property_doc_(''' the convergence tolerance (C{float}).''')
     def tolerance(self):
@@ -782,7 +781,7 @@ class EcefVeness(_EcefBase):
         lon = self._polon(y, x, p, **name_lon00)
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    C, None, self.datum,  # M=None
-                                   name=name or self.name)
+                                   name=self._name__(name))
 
 
 class EcefYou(_EcefBase):
@@ -862,7 +861,7 @@ class EcefYou(_EcefBase):
             h = neg(h)  # inside ellipsoid
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    1, None, self.datum,  # C=1, M=None
-                                   name=name or self.name)
+                                   name=self._name__(name))
 
 
 class EcefMatrix(_NamedTuple):
@@ -1160,22 +1159,24 @@ class Ecef9Tuple(_NamedTuple):
             r = self.xyz
         else:
             _xsubclassof(self._CartesianBase, Cartesian=Cartesian)
-            r = Cartesian(self, **_xkwds(Cartesian_kwds, name=self.name))
+            r = Cartesian(self, **_name1__(Cartesian_kwds, _or_nameof=self))
         return r
 
-    def toDatum(self, datum2):
+    def toDatum(self, datum2, **name):
         '''Convert this C{Ecef9Tuple} to an other datum.
 
            @arg datum2: Datum to convert I{to} (L{Datum}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: The converted 9-Tuple (C{Ecef9Tuple}).
 
            @raise TypeError: The B{C{datum2}} is not a L{Datum}.
         '''
+        n = _name__(name, _or_nameof=self)
         if self.datum in (None, datum2):  # PYCHOK _Names_
-            r = self.copy()
+            r = self.copy(name=n)
         else:
-            c = self._CartesianBase(self, datum=self.datum, name=self.name)  # PYCHOK _Names_
+            c = self._CartesianBase(self, datum=self.datum, name=n)  # PYCHOK _Names_
             # c.toLatLon converts datum, x, y, z, lat, lon, etc.
             # and returns another Ecef9Tuple iff LatLon is None
             r = c.toLatLon(datum=datum2, LatLon=None)
@@ -1197,8 +1198,9 @@ class Ecef9Tuple(_NamedTuple):
            @raise TypeError: Invalid B{C{LatLon}} or B{C{LatLon_kwds}}.
         '''
         lat, lon, D = self.lat, self.lon, self.datum  # PYCHOK Ecef9Tuple
-        kwds = _xkwds(LatLon_kwds, height=self.height, datum=D, name=self.name)  # PYCHOK Ecef9Tuple
-        d = kwds.get(_datum_, LatLon)
+        kwds = _name1__(LatLon_kwds, _or_nameof=self)
+        kwds = _xkwds(kwds, height=self.height, datum=D)  # PYCHOK Ecef9Tuple
+        d    =  kwds.get(_datum_, LatLon)
         if LatLon is None:
             r = LatLon3Tuple(lat, lon, kwds[_height_], name=kwds[_name_])
             if d is not None:
@@ -1242,7 +1244,7 @@ class Ecef9Tuple(_NamedTuple):
            @see: Propertes C{xyz} and C{xyzh}
         '''
         return self.xyz if Vector is None else Vector(
-              *self.xyz, **_xkwds(Vector_kwds, name=self.name))  # PYCHOK Ecef9Tuple
+              *self.xyz, **_name1__(Vector_kwds, _or_nameof=self))  # PYCHOK Ecef9Tuple
 
 #   def _T_x_M(self, T):
 #       '''(INTERNAL) Update M{self.M = T.multiply(self.M)}.
@@ -1272,25 +1274,23 @@ def _4Ecef(this, Ecef):  # in .datums.Datum.ecef, .ellipsoids.Ellipsoid.ecef
     return Ecef(this, name=this.name)
 
 
-def _llhn4(latlonh, lon, height, suffix=NN, Error=EcefError, name=NN):  # in .ltp
+def _llhn4(latlonh, lon, height, suffix=NN, Error=EcefError, **name):  # in .ltp
     '''(INTERNAL) Get a C{(lat, lon, h, name)} 4-tuple.
     '''
     try:
         lat, lon = latlonh.lat, latlonh.lon
         h = _xattr(latlonh, height=_xattr(latlonh, h=height))
-        n = _xattr(latlonh, name=NN)
+        n = _name__(name, _or_nameof=latlonh)  # == latlonh._name__(name)
     except AttributeError:
-        lat, h, n = latlonh, height, NN
-
+        lat, h, n = latlonh, height, _name__(**name)
     try:
-        llhn = Lat(lat), Lon(lon), Height(h), (name or n)
+        return Lat(lat), Lon(lon), Height(h), n
     except (TypeError, ValueError) as x:
         t = _lat_, _lon_, _height_
         if suffix:
             t = (_ + suffix for _ in t)
         d = dict(zip(t, (lat, lon, h)))
         raise Error(cause=x, **d)
-    return llhn
 
 
 def _xEcef(Ecef):  # PYCHOK .latlonBase
@@ -1302,23 +1302,23 @@ def _xEcef(Ecef):  # PYCHOK .latlonBase
 
 
 # kwd lon00 unused but will throw a TypeError if misspelled, etc.
-def _xyzn4(xyz, y, z, Types, Error=EcefError, name=NN,   # PYCHOK unused
-                     _xyz_y_z_names=_xyz_y_z, lon00=0):  # in .ltp
+def _xyzn4(xyz, y, z, Types, Error=EcefError, lon00=0,  # PYCHOK unused
+                     _xyz_y_z_names=_xyz_y_z, **name):  # in .ltp
     '''(INTERNAL) Get an C{(x, y, z, name)} 4-tuple.
     '''
     try:
+        n = _name__(name, _or_nameof=xyz)  # == xyz._name__(name)
         try:
-            t = xyz.x, xyz.y, xyz.z, _xattr(xyz, name=name)
+            t = xyz.x, xyz.y, xyz.z, n
             if not isinstance(xyz, Types):
                 raise _TypesError(_xyz_y_z_names[0], xyz, *Types)
         except AttributeError:
-            t = map1(float, xyz, y, z) + (name,)
-
+            t = map1(float, xyz, y, z) + (n,)
     except (TypeError, ValueError) as x:
         d = dict(zip(_xyz_y_z_names, (xyz, y, z)))
         raise Error(cause=x, **d)
     return t
-# assert _xyz_y_z == _MODS.basics._args_kwds_names(_xyzn4)[:3]
+# assert _xyz_y_z == _args_kwds_names(_xyzn4)[:3]
 
 
 _Ecefs = (EcefKarney, EcefSudano, EcefVeness, EcefYou,