User-defined features

phoebe/__init__.py

@@ -384,6 +384,7 @@ def progressbars(self):
 from . import dynamics as dynamics
 from . import distortions as distortions
 from . import algorithms as algorithms
+from . import features as features
 import libphoebe
 
 # Shortcut to building logger
@@ -882,7 +883,6 @@ def add_distl_docstring(obj):
 add_distl_docstring(uniform_around)
 add_distl_docstring(gaussian_around)
 
-
 # expose available "kinds" per-context
 def _get_phoebe_funcs(module, devel=False):
     ignore = ['_empty_array', 'deepcopy', 'fnmatch',
@@ -949,7 +949,7 @@ def list_available_features(devel=False):
     ---------
     * (list of strings)
     """
-    return _get_phoebe_funcs(feature, devel=devel)
+    return list(feature._feature_classes.keys())
 
 def list_available_datasets(devel=False):
     """

phoebe/backend/backends.py

@@ -1173,12 +1173,7 @@ def _run_single_time(self, b, i, time, infolist, **kwargs):
                                          kind=kind,
                                          components=info['component'])
 
-                    rv = obs['rv'] + b.get_value(qualifier='rv_offset',
-                                                 component=info['component'],
-                                                 dataset=info['dataset'],
-                                                 context='dataset',
-                                                unit=u.solRad/u.d,
-                                                 **_skip_filter_checks)
+                    rv = obs['rv']
                 else:
                     # then rv_method == 'dynamical'
                     rv = -1*vzi[cind]
@@ -1608,13 +1603,6 @@ def mqtf(value, direction=None):
             phb1.setpar(proximity_par, rv_method=='flux-weighted')
 
             rvs = np.array(rv_call(tuple(info['times'].tolist()), rvind))
-            rvs += b.get_value(qualifier='rv_offset',
-                               component=info['component'],
-                               dataset=info['dataset'],
-                               context='dataset',
-                               unit=u.km/u.s,
-                               **_skip_filter_checks)
-
             packetlist.append(_make_packet('rvs',
                                            rvs*u.km/u.s,
                                            None,

phoebe/backend/mesh.py

@@ -1320,6 +1320,7 @@ def _place_in_orbit(self, pos, vel, euler, euler_vel, rotation_vel=(0,0,0), comp
         # let's store the position.  This is both useful for "undoing" the
         # orbit-offset, and also eventually to allow incremental changes.
         self._pos = pos
+        self._vel = vel
         if component_com_x is not None and component_com_x != 0.0:
             self._pos_center = transform_position_array(np.array([component_com_x, 0.0, 0.0]), pos, euler, False)
         else:

phoebe/features/__init__.py

@@ -0,0 +1,2 @@
+from .dataset_features import *
+from .component_features import *

phoebe/features/common.py

@@ -0,0 +1,44 @@
+import logging
+logger = logging.getLogger("FEATURES")
+logger.addHandler(logging.NullHandler())
+
+
+__all__ = ['BaseFeature']
+
+
+class BaseFeature:
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        self.logger = logger
+
+    @classmethod
+    def create_feature_parameters(self, feature_ps, **kwargs):
+        raise NotImplementedError("create_feature_parameters must be implemented in the feature subclass")
+
+    @classmethod
+    def parse_from_feature_ps(cls, b, feature_ps, param_list):
+        _skip_filter_checks = {'check_default': False,
+                               'check_visible': False,
+                               'check_advanced': False}
+
+        def item_to_kwargs(item):
+            if isinstance(item, str):
+                item = {'qualifier': item}
+            if not isinstance(item, dict):
+                raise TypeError("items in param_list must be qualifiers or dictionaries")
+            return item
+
+        kws = [item_to_kwargs(item) for item in param_list]
+        return {kw['qualifier']: feature_ps.get_value(**kw, **_skip_filter_checks) for kw in kws}
+
+    @classmethod
+    def parse_bundle(cls, b, feature_ps):
+        return {}
+
+    @classmethod
+    def _from_bundle(cls, b, feature_ps):
+        return cls(**cls.parse_bundle(b, feature_ps))
+
+    @classmethod
+    def run_checks_compute(cls, b, feature_ps, compute_ps):
+        return [{}]