support writing compute_checks in feature classes

Author: kecnry

phoebe/backend/universe.py

@@ -1246,16 +1246,12 @@ def from_bundle(cls, b, component, compute=None,
 
         features = []
         for feature in b.filter(qualifier='enabled', compute=compute, value=True, **_skip_filter_checks).features:
-            feature_ps = b.get_feature(feature=feature, **_skip_filter_checks)
             if feature_ps.component != component:
                 continue
             if feature_ps.get_value(qualifier='feature_type', **_skip_filter_checks) != 'component':
                 continue
-            if 'custom_code' in feature_ps.qualifiers:
-                feature_cls = feature_ps.get_value(qualifier='custom_code', **_skip_filter_checks)
-            else:
-                feature_cls = getattr(component_features, feature_ps.kind.title())
-            features.append(feature_cls.from_bundle(b, feature_ps))
+            feature_obj = b.get_feature_code(feature=feature)
+            features.append(feature_obj)
 
         if conf.devel:
             mesh_offset_override = kwargs.pop('mesh_offset', None)

phoebe/features/common.py

@@ -6,7 +6,7 @@ def __init__(self, **kwargs):
         self.kwargs = kwargs
 
     @classmethod
-    def create_feature_parameters(self, feature, **kwargs):
+    def create_feature_parameters(self, feature_ps, **kwargs):
         raise NotImplementedError("create_feature_parameters must be implemented in the feature subclass")
 
     @classmethod
@@ -30,5 +30,9 @@ def parse_bundle(cls, b, feature_ps):
         return {}
 
     @classmethod
-    def from_bundle(cls, b, feature_ps):
+    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 [{}]

phoebe/features/component_features.py

@@ -151,8 +151,8 @@ def create_feature_parameters(cls, feature, **kwargs):
         params = []
         params += [FloatParameter(qualifier="colat", value=kwargs.get('colat', 0.0), default_unit=u.deg, description='Colatitude of the center of the spot wrt spin axis')]
         params += [FloatParameter(qualifier="long", value=kwargs.get('long', 0.0), default_unit=u.deg, description='Longitude of the center of the spot wrt spin axis')]
-        params += [FloatParameter(qualifier='radius', value=kwargs.get('radius', 1.0), default_unit=u.deg, description='Angular radius of the spot')]
-        params += [FloatParameter(qualifier='relteff', value=kwargs.get('relteff', 1.0), limits=(0.,None), default_unit=u.dimensionless_unscaled, description='Temperature of the spot relative to the intrinsic temperature')]
+        params += [FloatParameter(qualifier='radius', value=kwargs.get('radius', 1.0), limits=(0, 180), default_unit=u.deg, description='Angular radius of the spot')]
+        params += [FloatParameter(qualifier='relteff', value=kwargs.get('relteff', 1.0), limits=(0, None), default_unit=u.dimensionless_unscaled, description='Temperature of the spot relative to the intrinsic temperature')]
 
         return ParameterSet(params), []
 
@@ -188,6 +188,21 @@ def parse_bundle(cls, b, feature_ps):
 
         return dict(colat=colat, longitude=longitude, rot_dlongdt=rot_dlongdt, radius=radius, relteff=relteff, t0=t0)
 
+    @classmethod
+    def run_checks_compute(cls, b, feature_ps, compute_ps):
+        items = []
+        relteff_param = feature_ps.get_parameter(qualifier='relteff', **_skip_filter_checks)
+        radius_param = feature_ps.get_parameter(qualifier='radius', **_skip_filter_checks)
+        if relteff_param.get_value(**_skip_filter_checks) == 1:
+            items += [{'msg': 'relteff of spot is 1.0 which will have no affect',
+                       'params': [relteff_param],
+                       'is_error': False}]
+        if radius_param.get_value(**_skip_filter_checks) == 0:
+            items += [{'msg': 'radius of spot is 0.0 which will have no affect',
+                       'params': [radius_param],
+                       'is_error': False}]
+        return items
+
     def instantaneous_position(self, s, time):
         """
         s is the spin vector in roche coordinates

phoebe/frontend/bundle.py

@@ -3175,19 +3175,20 @@ def run_checks(self, raise_logger_warning=False, raise_error=False, **kwargs):
         Arguments
         -----------
         * `compute` (string or list of strings, optional, default=None): the
-            compute options to use  when running checks.  If None (or not provided),
+            compute options to use when running checks.  If None (or not provided),
             the compute options in the 'run_checks_compute@setting' parameter
             will be used (which defaults to all available compute options).
+            All enabled features in `compute` will also be checked.
         * `solver` (string or list of strings, optional, default=None): the
-            solver options to use  when running checks.  If None (or not provided),
+            solver options to use when running checks.  If None (or not provided),
             the compute options in the 'run_checks_solver@setting' parameter
             will be used (which defaults to all available solver options).
         * `solution` (string or list of strings, optional, default=None): the
-            solutions to use  when running checks.  If None (or not provided),
+            solutions to use when running checks.  If None (or not provided),
             the compute options in the 'run_checks_solution@setting' parameter
             will be used (which defaults to no solutions, if not set).
         * `figure` (string or list of strings, optional, default=None): the
-            figures to use  when running checks.  If None (or not provided),
+            figures to use when running checks.  If None (or not provided),
             the compute options in the 'run_checks_figure@setting' parameter
             will be used (which defaults to no figures, if not set).
         * `allow_skip_constraints` (bool, optional, default=False): whether
@@ -4034,10 +4035,12 @@ def _get_surf_area(comp):
 
 
         for compute in computes:
-            compute_kind = self.get_compute(compute=compute, **_skip_filter_checks).kind
+            compute_ps = self.get_compute(compute=compute, **_skip_filter_checks)
+            compute_kind = compute_ps.kind
 
             gps = self.filter(kind=['gp_celerite2','gp_sklearn'], context='feature', **_skip_filter_checks).features
             compute_enabled_gps = self.filter(qualifier='enabled', compute=compute, feature=gps, value=True, **_skip_filter_checks).features
+            compute_enabled_features = self.filter(qualifier='enabled', compute=compute, value=True, **_skip_filter_checks).features
             compute_enabled_datasets = self.filter(qualifier='enabled', dataset=self.datasets, value=True, **_skip_filter_checks).datasets
             compute_enabled_datasets_with_gps = [ds for ds in self.filter(feature=compute_enabled_gps, **_skip_filter_checks).datasets if ds in compute_enabled_datasets]
 
@@ -4118,6 +4121,16 @@ def _get_surf_area(comp):
                 else:
                     raise ValueError("{} could not be found in distributions or solutions".format(dist_or_solution))
 
+            for feature in compute_enabled_features:
+                feature_ps = self.get_feature(feature=feature, **_skip_filter_checks)
+                feature_cls = self.get_feature_code(feature=feature, instantiate=False)
+                for item in feature_cls.run_checks_compute(b=self, feature_ps=feature_ps, compute_ps=compute_ps):
+                    report.add_item(self,
+                                    item.get('msg'),
+                                    item.get('params', []),
+                                    item.get('is_error', False),
+                                    'run_compute')
+
             if len(compute_enabled_gps):
                 # check for time-dependency issues with GPs
                 # then if we're using compute_times/phases, compute_times must cover the range of the dataset times
@@ -5711,16 +5724,18 @@ def get_feature(self, feature=None, **kwargs):
         kwargs['context'] = 'feature'
         return self.filter(**kwargs)
 
-    def get_feature_code(self, feature=None, **kwargs):
+    def get_feature_code(self, feature=None, instantiate=True, **kwargs):
         """
-        Get the instantiated object containing the logic to run a feature.
+        Get the instantiated object (or non-instantiated class) containing the logic to run a feature.
 
         See also:
         * <phoebe.frontend.bundle.Bundle.get_feature>
 
         Arguments
         ---------
         * `feature`: (string, optional, default=None): the name of the feature
+        * `instantiate`: (bool, optional, default=True): whether to intstantiate the object
+            or return the class
         * `**kwargs`: any other tags to do the filtering (excluding feature and context)
 
         Returns:
@@ -5731,7 +5746,10 @@ def get_feature_code(self, feature=None, **kwargs):
             cls = feature_ps.get_value(qualifier='custom_code', check_visible=False, check_default=False)
         else:
             cls = _feature._feature_classes.get(feature_ps.kind)
-        return cls.from_bundle(self, feature_ps)
+        if instantiate:
+            return cls._from_bundle(self, feature_ps)
+        else:
+            return cls
 
     @send_if_client
     def remove_feature(self, feature=None, return_changes=False, **kwargs):