def alter_dndm(self, val):
        """
        A model for empirical recalibration of the HMF.

        :type: None, str, or :class`WDMRecalibrateMF` subclass.
        """
        if not np.issubclass_(val, WDMRecalibrateMF) and val is not None and not np.issubclass_(val, basestring):
            raise TypeError("alter_dndm must be a WDMRecalibrateMF subclass, string, or None")
        else:
            return val

 def growth(self):
     "The instantiated growth model"
     if np.issubclass_(self.growth_model, gf.GrowthFactor):
         return self.growth_model(self.cosmo, **self.growth_params)
     else:
         return get_model(self.growth_model, "hmf.growth_factor", cosmo=self.cosmo,
                          **self.growth_params)

 def default(self, obj):
     if isinstance(obj, BaseP2GObject):
         mod_str = str(obj.__class__.__module__)
         mod_str = mod_str + "." if mod_str != __name__ else ""
         cls_str = str(obj.__class__.__name__)
         obj = obj.copy(as_dict=True)
         # object should now be a builtin dict
         obj["__class__"] = mod_str + cls_str
         return obj
         # return super(P2GJSONEncoder, self).encode(obj)
     elif isinstance(obj, datetime):
         return obj.isoformat()
     elif numpy.issubclass_(obj, numpy.number) or isinstance(obj, numpy.dtype):
         return dtype_to_str(obj)
     elif hasattr(obj, 'dtype'):
         if obj.size > 1:
             return obj.tolist()
         return int(obj) if numpy.issubdtype(obj, numpy.integer) else float(obj)
     else:
         try:
             return super(P2GJSONEncoder, self).default(obj)
         except TypeError as e:
             print("TypeError:", str(e), type(obj))
             print(obj)
             raise

    def __init__(self, *args, **kwargs):
        self.__enums = dict((f, t) for f, t in self._fields_
                            if issubclass_(t, Enum))
        for field, val in iteritems(self._defaults_):
            setattr(self, field, val)

        Structure.__init__(self, *args, **kwargs)

 def _wdm(self):
     if issubclass_(self.wdm_transfer, WDM):
         return self.wdm_transfer(self.wdm_mass, self.omegac, self.h, self.mean_dens,
                                  **self.wdm_params)
     elif isinstance(self.wdm_transfer, basestring):
         return get_wdm(self.wdm_transfer, mx=self.wdm_mass, omegac=self.omegac,
                        h=self.h, rho_mean=self.mean_dens,
                        **self.wdm_params)

 def replace_dim(self, olddim, newdim):
     if isinstance(olddim, string_types):
         olddim = self.dims_index(olddim)
         olddim = self.dims[olddim]
         if np.issubclass_(newdim, DimBase):
             newdim = newdim(olddim)
     self.dims = replace_dim(self.dims, olddim, newdim)
     return self.dims

 def sd_bias(self):
     """A class containing relevant methods to calculate scale-dependent bias corrections"""
     if self.sd_bias_model is None:
         return None
     elif issubclass_(self.sd_bias_model, bias.ScaleDepBias):
         return self.sd_bias_model(self.corr_mm_base, **self.sd_bias_params)
     else:
         return get_model(self.sd_bias_model, "halomod.bias",
                          xi_dm=self.corr_mm_base, **self.sd_bias_params)

    def exclusion_model(self, val):
        """A string identifier for the type of halo exclusion used (or None)"""
        if val is None:
            val = "NoExclusion"

        if issubclass_(val, Exclusion):
            return val
        else:
            return get_model_(val, "halomod.halo_exclusion")

    def profile_model(self, val):
        """The halo density profile model"""
        if not isinstance(val, basestring) and not issubclass_(val, profiles.Profile):
            raise ValueError("profile_model must be a subclass of profiles.Profile")

        if isinstance(val, basestring):
            return get_model_(val, "halomod.profiles")
        else:
            return val

    def filter_model(self, val):
        """
        A model for the window/filter function.

        :type: str or :class:`hmf.filters.Filter` subclass
        """
        if not issubclass_(val, Filter) and not isinstance(val, basestring):
            raise ValueError("filter must be a Filter or string, got %s" % type(val))
        return val

 def filter(self):
     """
     Instantiated model for filter/window functions.
     """
     if issubclass_(self.filter_model, Filter):
         return self.filter_model(self.k,self._unnormalised_power, **self.filter_params)
     elif isinstance(self.filter_model, basestring):
         return get_model(self.filter_model, "hmf.filters", k=self.k,
                             power=self._unnormalised_power, **self.filter_params)

    def wdm_model(self, val):
        """
        A model for the WDM effect on the transfer function.

        :type: str or :class:`WDM` subclass
        """
        if not np.issubclass_(val, WDM) and not isinstance(val, basestring):
            raise ValueError("wdm_model must be a WDM subclass or string, got %s" % type(val))
        return val

def str_to_dtype(dtype_str):
    if numpy.issubclass_(dtype_str, numpy.number):
        # if they gave us a numpy dtype
        return dtype_str

    try:
        return str2dtype[dtype_str]
    except KeyError:
        raise ValueError("Not a valid data type string: %s" % (dtype_str,))

 def transfer(self):
     """
     The instantiated transfer model
     """
     if np.issubclass_(self.transfer_model, tm.TransferComponent):
         return self.transfer_model(self.cosmo, **self.transfer_params)
     elif isinstance(self.transfer_model, str):
         return get_model(self.transfer_model, "hmf.transfer_models", cosmo=self.cosmo,
                          **self.transfer_params)

    def growth_model(self, val):
        """
        The model to use to calculate the growth function/growth rate.

        :type: str or `hmf.growth_factor.GrowthFactor` subclass
        """
        if not np.issubclass_(val, gf.GrowthFactor) and not isinstance(val, str):
            raise ValueError("growth_model must be a GrowthFactor or string, got %s" % type(val))
        return val

    def hmf_model(self, val):
        """
        A model to use as the fitting function :math:`f(\sigma)`

        :type: str or `hmf.fitting_functions.FittingFunction` subclass
        """
        if not issubclass_(val, ff.FittingFunction) and not isinstance(val, basestring):
            raise ValueError("hmf_model must be a ff.FittingFunction or string, got %s" % type(val))
        return val

    def get_fill_value(self, item, default_dtype=numpy.float32):
        """If the caller of `get_swath_data` doesn't force the output fill value then they need to know what it is now.
        Defaults version expects a 'data_type' attribute in the value returned from `file_type_info`.

            - Unsigned Integers: Highest valid integer (i.e. -1 converted to unsigned integer)
            - Signed Integers: -999
            - Float: NaN

        :raises: RuntimeError if unknown data type
        """
        data_type = self.get_data_type(item, default_dtype=default_dtype)
        if numpy.issubclass_(data_type, numpy.unsignedinteger):
            return data_type(-1)
        elif numpy.issubclass_(data_type, numpy.integer):
            return -999
        elif numpy.issubclass_(data_type, numpy.floating):
            return numpy.nan
        else:
            raise RuntimeError("Unknown data type for %s: %s" % (item, data_type))

 def _unnormalised_lnT(self):
     """
     The un-normalised transfer function
     
     This wraps the individual transfer_fit methods to provide unified access.
     """
     if issubclass_(self.transfer_fit, GetTransfer):
         return self.transfer_fit(self).lnt(self.lnk)
     elif isinstance(self.transfer_fit, basestring):
         return get_transfer(self.transfer_fit, self).lnt(self.lnk)

 def __init__(self, theta, phi, r, w=None, s=0.0, eps=1e-16):
     if np.issubclass_(w, float):
         w = ones(len(theta)) * w
     nt_, tt_, np_, tp_, c, fp, ier = dfitpack.spherfit_smth(theta, phi, r, w=w, s=s, eps=eps)
     if not ier in [0, -1, -2]:
         message = _spherefit_messages.get(ier, "ier=%s" % (ier))
         raise ValueError(message)
     self.fp = fp
     self.tck = tt_[:nt_], tp_[:np_], c[: (nt_ - 4) * (np_ - 4)]
     self.degrees = (3, 3)

    def create_output_from_product(self, gridded_product, output_pattern=None,
                                   data_type=None, inc_by_one=None, fill_value=None, **kwargs):
        inc_by_one = inc_by_one or False
        data_type = data_type or gridded_product["data_type"]
        fill_value = fill_value or gridded_product["fill_value"]
        same_fill = numpy.isnan(fill_value) and numpy.isnan(gridded_product["fill_value"]) or fill_value == gridded_product["fill_value"]
        grid_def = gridded_product["grid_definition"]
        if not output_pattern:
            output_pattern = DEFAULT_OUTPUT_PATTERN
        if "{" in output_pattern:
            # format the filename
            of_kwargs = gridded_product.copy(as_dict=True)
            of_kwargs["data_type"] = data_type
            output_filename = self.create_output_filename(output_pattern,
                                                          grid_name=grid_def["grid_name"],
                                                          rows=grid_def["height"],
                                                          columns=grid_def["width"],
                                                          **of_kwargs)
        else:
            output_filename = output_pattern

        if os.path.isfile(output_filename):
            if not self.overwrite_existing:
                LOG.error("Geotiff file already exists: %s", output_filename)
                raise RuntimeError("Geotiff file already exists: %s" % (output_filename,))
            else:
                LOG.warning("Geotiff file already exists, will overwrite: %s", output_filename)

        # if we have a floating point data type, then scaling doesn't make much sense
        if data_type == gridded_product["data_type"] and same_fill:
            LOG.info("Saving product %s to binary file %s", gridded_product["product_name"], output_filename)
            shutil.copyfile(gridded_product["grid_data"], output_filename)
            return output_filename
        elif numpy.issubclass_(data_type, numpy.floating):
            # we didn't rescale any data, but we need to convert it
            data = gridded_product.get_data_array()
        else:
            try:
                LOG.debug("Scaling %s data to fit data type", gridded_product["product_name"])
                data = self.rescaler.rescale_product(gridded_product, data_type,
                                                     inc_by_one=inc_by_one, fill_value=fill_value)
                data = clip_to_data_type(data, data_type)
            except ValueError:
                if not self.keep_intermediate and os.path.isfile(output_filename):
                    os.remove(output_filename)
                raise

        LOG.info("Saving product %s to binary file %s", gridded_product["product_name"], output_filename)
        data = data.astype(data_type)
        fill_mask = gridded_product.get_data_mask()
        data[fill_mask] = fill_value
        data.tofile(output_filename)

        return output_filename