@mean.setter
def mean(self, mean):
self._mean = mean
@property
def std(self):
return self._std
@std.setter
def std(self, std):
self._std = std
def rescale(self, x):
return gbkfit.math.gauss_trunc_1d_ppf(x, self.mean, self.std,
self.minimum, self.maximum)
def prob(self, x):
return gbkfit.math.gauss_trunc_1d_pdf(x, self.mean, self.std,
self.minimum, self.maximum)
def cdf(self, x):
return gbkfit.math.gauss_trunc_1d_cdf(x, self.mean, self.std,
self.minimum, self.maximum)
prior_parser = parseutils.TypedParser(Prior)
prior_parser.register(PriorUniform)
prior_parser.register(PriorGauss)
def enames(self, fixed=True, tied=True, free=True):
return self._interpreter.enames(fixed=fixed, tied=tied, free=free)
def evaluate(self, in_eparams, out_eparams=None, check=True):
return self._interpreter.evaluate(in_eparams, out_eparams, check)
class Fitter(parseutils.TypedParserSupport, abc.ABC):
@staticmethod
@abc.abstractmethod
def load_params(info, desc):
pass
def __init__(self, *args, **kwargs):
pass
def fit(self, objectives, parameters):
if missing := set(objectives.pdescs()).difference(parameters.pdescs()):
raise RuntimeError(
f"fitting cannot start because information for the following "
f"parameters is missing: {missing}")
result = self._fit_impl(objectives, parameters)
return result
@abc.abstractmethod
def _fit_impl(self, objective, params):
pass
fitter_parser = parseutils.TypedParser(Fitter)
def __iter__(self):
return self._pdescs.__iter__()
def __len__(self):
return self._pdescs.__len__()
def __repr__(self):
return self._pdescs.__repr__()
def __str__(self):
return self._pdescs.__str__()
def load_pdescs_dict(info):
pdescs = {}
for key, val in info.items():
pdescs[key] = pdesc_parser.load(dict(name=key) | val)
return pdescs
def dump_pdescs_dict(pdescs):
info = {key: pdesc_parser.dump(val) for key, val in pdescs.items()}
for val in info.values():
del val['name']
return info
pdesc_parser = parseutils.TypedParser(ParamDesc)
pdesc_parser.register(ParamScalarDesc)
pdesc_parser.register(ParamVectorDesc)
from gbkfit.model.core import GModelImage
from gbkfit.utils import iterutils, parseutils
from . import _detail
from .core import DensityComponent2D
from .density_smdisk_2d import DensitySMDisk2D
__all__ = ['GModelIntensity2D']
_dcmp_parser = parseutils.TypedParser(DensityComponent2D)
_dcmp_parser.register(DensitySMDisk2D)
class GModelIntensity2D(GModelImage):
@staticmethod
def type():
return 'intensity_2d'
@classmethod
def load(cls, info):
desc = parseutils.make_typed_desc(cls, 'gmodel')
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
opts.update(components=_dcmp_parser.load(info['components']))
return cls(**opts)
def dump(self):
return dict(type=self.type(), components=_dcmp_parser.dump(self._cmps))
def __init__(self, components):
self._cmps = iterutils.tuplify(components)
self._size = [None, None]
self._wcube = None
from gbkfit.model.core import GModelSCube
from gbkfit.utils import iterutils, parseutils
from . import _detail
from .core import DensityComponent3D, SpectralComponent3D
from .density_mcdisk_3d import DensityMCDisk3D
from .density_smdisk_3d import DensitySMDisk3D
from .spectral_mcdisk_3d import SpectralMCDisk3D
from .spectral_smdisk_3d import SpectralSMDisk3D
__all__ = ['GModelKinematics3D']
_dcmp_parser = parseutils.TypedParser(DensityComponent3D)
_scmp_parser = parseutils.TypedParser(SpectralComponent3D)
_dcmp_parser.register(DensityMCDisk3D)
_dcmp_parser.register(DensitySMDisk3D)
_scmp_parser.register(SpectralMCDisk3D)
_scmp_parser.register(SpectralSMDisk3D)
class GModelKinematics3D(GModelSCube):
@staticmethod
def type():
return 'kinematics_3d'
@classmethod
def load(cls, info):
desc = parseutils.make_typed_desc(cls, 'gmodel')
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
opts.update(components=_scmp_parser.load(info['components']),
tcomponents=_dcmp_parser.load(info.get('tcomponents')))
return cls(**opts)
@staticmethod
def type():
return 'crange'
@staticmethod
def uid():
return JP_TRAIT_UID_CRANGE
def __init__(self, angle):
Trait.__init__(self, angle=angle)
# Density traits (polar) parser
rpt_parser = parseutils.TypedParser(RPTrait, [
RPTraitUniform, RPTraitExponential, RPTraitGauss, RPTraitGGauss,
RPTraitLorentz, RPTraitMoffat, RPTraitSech2, RPTraitMixtureGGauss,
RPTraitMixtureMoffat, RPTraitNWUniform, RPTraitNWHarmonic,
RPTraitNWDistortion
])
# Density traits (height) parser
rht_parser = parseutils.TypedParser(RHTrait, [
RHTraitUniform, RHTraitExponential, RHTraitGauss, RHTraitGGauss,
RHTraitLorentz, RHTraitSech2
])
# Velocity traits (polar) parser
vpt_parser = parseutils.TypedParser(VPTrait, [
VPTraitTanUniform, VPTraitTanArctan, VPTraitTanBoissier, VPTraitTanEpinat,
VPTraitTanLRamp, VPTraitTanTanh, VPTraitTanPolyex, VPTraitTanRix,
VPTraitNWTanUniform, VPTraitNWTanHarmonic, VPTraitNWRadUniform,
VPTraitNWRadHarmonic, VPTraitNWVerUniform, VPTraitNWVerHarmonic,
pass
class GModel(parseutils.TypedParserSupport, abc.ABC):
@abc.abstractmethod
def params(self):
pass
class GModelImage(GModel, abc.ABC):
@abc.abstractmethod
def evaluate_image(
self, driver, params, image, weights, size, step, zero, rota, dtype,
out_extra):
pass
class GModelSCube(GModel, abc.ABC):
@abc.abstractmethod
def evaluate_scube(
self, driver, params, scube, weights, size, step, zero, rota, dtype,
out_extra):
pass
dmodel_parser = parseutils.TypedParser(DModel)
gmodel_parser = parseutils.TypedParser(GModel)
from gbkfit.model.core import GModelSCube
from gbkfit.utils import iterutils, parseutils
from . import _detail
from .core import SpectralComponent2D
from .spectral_smdisk_2d import SpectralSMDisk2D
__all__ = ['GModelKinematics2D']
_scmp_parser = parseutils.TypedParser(SpectralComponent2D)
_scmp_parser.register(SpectralSMDisk2D)
class GModelKinematics2D(GModelSCube):
@staticmethod
def type():
return 'kinematics_2d'
@classmethod
def load(cls, info):
desc = parseutils.make_typed_desc(cls, 'gmodel')
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
opts.update(components=_scmp_parser.load(info['components']))
return cls(**opts)
def dump(self):
return dict(type=self.type(), components=_scmp_parser.dump(self._cmps))
def __init__(self, components):
self._cmps = iterutils.tuplify(components)
self._size = [None, None]
self._wcube = None
pass
@abc.abstractmethod
def dump(self, *args, **kwargs):
pass
def size(self, step, offset=(0, 0)):
size = self._size_impl(step)
return (int(gbkfit.math.roundu_odd(size[0] + offset[0])),
int(gbkfit.math.roundu_odd(size[1] + offset[1])))
def asarray(self, step, size=None, offset=(0, 0)):
if size is None:
size = self.size(step, offset)
if any(gbkfit.math.is_even(s + o) for s, o in zip(size, offset)):
raise RuntimeError(
f"size ({size}) + offset ({offset}) must be odd")
return self._asarray_impl(step, size, offset)
@abc.abstractmethod
def _size_impl(self, step):
pass
@abc.abstractmethod
def _asarray_impl(self, step, size, offset):
pass
lsf_parser = parseutils.TypedParser(LSF)
psf_parser = parseutils.TypedParser(PSF)
return 'mh'
def __init__(self, proposal_function, ndim=None):
super().__init__(emcee.moves.MHMove, copy.deepcopy(locals()))
class FitterEmceeMoveGaussian(FitterEmceeMove):
@staticmethod
def type():
return 'gauss'
def __init__(self, cov, mode='vector', factor=None):
super().__init__(emcee.moves.GaussianMove, copy.deepcopy(locals()))
move_parser = parseutils.TypedParser(FitterEmceeMove)
move_parser.register(FitterEmceeMoveStretch)
move_parser.register(FitterEmceeMoveWalk)
move_parser.register(FitterEmceeMoveKDE)
move_parser.register(FitterEmceeMoveDE)
move_parser.register(FitterEmceeMoveDESnooker)
move_parser.register(FitterEmceeMoveMH)
move_parser.register(FitterEmceeMoveGaussian)
def load_moves_with_weights(info):
moves = iterutils.tuplify(info, False)
weights = [move.pop('weight', 1) for move in moves]
moves = move_parser.load(moves)
return tuple(zip(moves, weights))
@abc.abstractmethod
def math_sum(self, x, out=None):
pass
@abc.abstractmethod
def math_add(self, x1, x2, out=None):
pass
@abc.abstractmethod
def math_sub(self, x1, x2, out=None):
pass
@abc.abstractmethod
def math_mul(self, x1, x2, out=None):
pass
@abc.abstractmethod
def math_div(self, x1, x2, out=None):
pass
@abc.abstractmethod
def math_pow(self, x1, x2, out=None):
pass
@abc.abstractmethod
def backend(self):
pass
driver_parser = parseutils.TypedParser(Driver)
