def load(cls, info, pdescs):
desc = parseutils.make_basic_desc(cls, 'params')
opts = parseutils.parse_options_for_callable(
info, desc, cls.__init__, fun_ignore_args=['pdescs'])
opts = paramutils.load_params_parameters_conversions(
opts, pdescs, Real, lambda x: x)
return cls(pdescs, **opts)
def load(cls, info, pdescs):
desc = parseutils.make_basic_desc(cls, 'fit params')
opts = parseutils.parse_options_for_callable(
info, desc, cls.__init__, fun_ignore_args=['pdescs'])
opts = paramutils.load_params_parameters_conversions(
opts, pdescs, collections.abc.Mapping, cls.load_param)
return cls(pdescs, **opts)
def load_dmodel_common(cls, info, ndim, dataset, dataset_cls):
desc = parseutils.make_typed_desc(cls, 'dmodel')
info = copy.deepcopy(info)
if dataset:
dataset_desc = parseutils.make_typed_desc(dataset_cls, 'dataset')
if not isinstance(dataset, dataset_cls):
raise RuntimeError(
f"{desc} "
f"is not compatible with "
f"{dataset_desc}")
info.update(dict(
size=dataset.size(),
step=info.get('step', dataset.step()),
rpix=info.get('rpix', dataset.rpix()),
rval=info.get('rval', dataset.rval()),
rota=info.get('rota', dataset.rota()),
dtype=info.get('dtype', str(dataset.dtype))))
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
for attr in ['size', 'step', 'cval', 'scale']:
if attr in opts:
opts[attr] = opts[attr][:ndim]
if 'dtype' in opts:
opts['dtype'] = np.dtype(opts['dtype']).type
if 'psf' in opts:
opts['psf'] = gbkfit.psflsf.psf_parser.load(opts['psf'])
if 'lsf' in opts:
opts['lsf'] = gbkfit.psflsf.lsf_parser.load(opts['lsf'])
return opts
def load(cls, info, step=None, rpix=None, rval=None, rota=None, prefix=''):
desc = parseutils.make_basic_desc(cls, 'data')
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
data_d, header_d, wcs_d = _load_fits(prefix + opts['data'])
data_m = None
data_e = None
if 'mask' in opts:
data_m = _load_fits(prefix + opts['mask'])[0]
if 'error' in opts:
data_e = _load_fits(prefix + opts['error'])[0]
# Local information has higher priority than global
step = opts.get('step', step)
rpix = opts.get('rpix', rpix)
rval = opts.get('rval', rval)
# If no information is provided, use fits header
if step is None:
step = wcs_d.wcs.cdelt # noqa
if rpix is None:
rpix = wcs_d.wcs.crpix # noqa
if rval is None:
rval = wcs_d.wcs.crval # noqa
# todo: deal with rotation (PC Matrix and CROTA (deprecated))
# Build class arguments dict
opts.update(dict(
data=data_d,
mask=data_m,
error=data_e,
step=step,
rpix=rpix,
rval=rval,
rota=0))
return cls(**opts)
def load(cls, info):
desc = parseutils.make_typed_desc(cls, 'gmodel component')
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
opts.update(
dict(rptraits=traits.rpt_parser.load(opts.get('rptraits')),
sptraits=traits.spt_parser.load(opts.get('sptraits')),
wptraits=traits.wpt_parser.load(opts.get('wptraits'))))
return cls(**opts)
def load(cls, info, **kwargs):
info = _parse_min_and_max(info, **kwargs)
desc = parseutils.make_typed_desc(cls, 'prior')
opts = parseutils.parse_options_for_callable(
info, desc, cls.__init__, fun_rename_args=dict(
minimum='min',
maximum='max'))
return cls(**opts)
def load(cls, info):
desc = parseutils.make_basic_desc(cls, 'fit parameter')
opts = parseutils.parse_options_for_callable(
info, desc, cls.__init__, fun_rename_args=dict(
initial_value='value',
initial_scale='scale',
minimum='min',
maximum='max'))
return cls(**opts)
def load(cls, info):
info['prior'] = fitutils.prepare_param_prior_info(info)
info['prior'] = prior_parser.load(info['prior'], param_info=info)
desc = parseutils.make_basic_desc(cls, 'fit parameter')
opts = parseutils.parse_options_for_callable(
info,
desc,
cls.__init__,
fun_rename_args=dict(initial_value='value', initial_width='width'))
return cls(**opts)
def load(cls, info, descs):
desc = parseutils.make_basic_desc(cls, 'fit params')
opts = parseutils.parse_options_for_callable(info,
desc,
cls.__init__,
fun_ignore_args=['descs'])
parameters = load_parameters(opts.get('parameters'), descs,
cls.load_param)
value_conversions = paramparsers.load_params_value_conversions(
opts.get('value_conversions'))
return cls(descs, parameters, value_conversions)
def load(cls, info):
desc = parseutils.make_typed_desc(cls, 'fitter')
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
if 'crossover' in opts:
opts['crossover'] = pymooutils.crossover_parser.load(
opts['crossover'])
if 'mutation' in opts:
opts['mutation'] = pymooutils.mutation_parser.load(
opts['mutation'])
if 'selection' in opts:
opts['selection'] = pymooutils.selection_parser.load(
opts['selection'])
if 'termination' in opts:
opts['termination'] = pymooutils.termination_parser.load(
opts['termination'])
return cls(**opts)
def load(cls, info, descs):
desc = parseutils.make_basic_desc(cls, 'fit parameters')
opts = parseutils.parse_options_for_callable(
info, desc, cls.__init__, fun_ignore_args=['descs'])
infos, exprs = paramutils.parse_param_info(
opts['parameters'], descs)[4:]
for key, val in infos.items():
try:
infos[key] = FitParamPygmo.load(val)
except RuntimeError as e:
raise RuntimeError(
f"could not parse information for parameter '{key}'; "
f"reason: {str(e)}") from e
parameters = infos | exprs
expressions = paramutils.load_param_value_conversions(
opts.get('value_conversions'))
return cls(descs, parameters, expressions)
def load_dataset_common(cls, info, names, **kwargs):
prefix = kwargs.get('prefix', '')
desc = parseutils.make_typed_desc(cls, 'dataset')
opts = parseutils.parse_options_for_callable(
info,
desc,
cls.__init__,
add_optional=['step', 'rpix', 'rval', 'rota'])
step = opts.pop('step', None)
rpix = opts.pop('rpix', None)
rval = opts.pop('rval', None)
rota = opts.pop('rota', None)
for name in names:
if name in opts:
opts[name] = data_parser.load(opts[name],
step,
rpix,
rval,
rota,
prefix=prefix)
return opts
def load(cls, info):
desc = _trait_desc(cls)
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
return cls(**opts)
def load(cls, info):
desc = parseutils.make_typed_desc(cls, 'fitter')
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
opts.update(moves=load_moves_with_weights(opts.get('moves')))
return cls(**opts)
def load(cls, info):
desc = parseutils.make_typed_desc(cls, 'fitter')
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
return cls(**opts)
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 load(cls, info, datasets, drivers, dmodels, gmodels):
desc = parseutils.make_basic_desc(cls, ' goodness objective')
opts = parseutils.parse_options_for_callable(
info, desc, cls.__init__, fun_ignore_args=[
'datasets', 'drivers', 'dmodels', 'gmodels'])
return cls(datasets, drivers, dmodels, gmodels, **opts)
def _load_psf_common(cls, info):
desc = parseutils.make_typed_desc(cls, 'PSF')
return parseutils.parse_options_for_callable(info, desc, cls.__init__)
def load(cls, info):
info['prior'] = fitutils.prepare_param_prior_info(info)
info['prior'] = prior_parser.load(info['prior'], param_info=info)
desc = parseutils.make_basic_desc(cls, 'fit parameter')
opts = parseutils.parse_options_for_callable(info, desc, cls.__init__)
return cls(**opts)
