__author__ = "Andrea Tramacere"
from .model_parameters import ModelParameterArray, ModelParameter
from .utils import get_nested_attr, set_nested_attr
#from .utils import safe_run, get_nested_attr, set_nested_attr
import numpy as np
__all__=['JetParameter','JetModelDictionaryPar','JetModelParameterArray']
[docs]
class JetModelDictionaryPar(object):
"""Declarative parameter specification used to build jet parameters.
Notes
-----
Stores metadata (bounds, units, default value, kernel binding and flags)
that are later converted into concrete :class:`JetParameter` instances.
"""
def __init__(self,
ptype=None,
vmin=None,
vmax=None,
punit=None,
froz=False,
log=False,
val=None,
jetkernel_par_name=None,
is_in_jetkernel=True,
allowed_values=None ):
"""Create a new `JetModelDictionaryPar` instance.
Parameters
----------
ptype : object, optional
Parameter controlling ptype.
vmin : object, optional
Lower bound/control for vmin.
vmax : object, optional
Upper bound/control for vmax.
punit : object, optional
Parameter controlling punit.
froz : bool, optional
Parameter controlling froz.
log : bool, optional
Parameter controlling log.
val : object, optional
Value to assign.
jetkernel_par_name : object, optional
Parameter controlling jetkernel par name.
is_in_jetkernel : bool, optional
Boolean flag controlling in jetkernel.
allowed_values : object, optional
Lower bound/control for allowed values.
"""
self.ptype =ptype
self.val=val
self.vmin =vmin
self.vmax =vmax
self.punit =punit
self.froz =froz
self.log =log
self.jetkernel_par_name = jetkernel_par_name
self.is_in_jetkernel=is_in_jetkernel
self.allowed_values =allowed_values
[docs]
class JetParameter(ModelParameter):
"""JetParameter class."""
def __init__(self,
model,
jetkernel_struct_name,
jetkernel_parameter_name,
is_in_jetkernel=True,
**keywords):
"""This class is a subclass of the :class:`.ModelParameter` class,
extending the base class to handles SSC/EC parameters,
overriding the :meth:`.ModelParameter.set` in order to propagate the
parameter value to the BlazarSED object instance
Parameters
----------
model : object
Model instance.
jetkernel_struct_name : object
Parameter controlling jetkernel struct name.
jetkernel_parameter_name : object
Parameter controlling jetkernel parameter name.
is_in_jetkernel : bool, optional
Boolean flag controlling in jetkernel.
**keywords : dict
Parameter controlling keywords.
"""
self._model = model
#self._jetkernel_attr_name = jetkernel_attr_name
self._jetkernel_parameter_name= jetkernel_parameter_name
self._jetkernel_struct_name = jetkernel_struct_name
_allowed_par_types = ['scaling_factor',
'acceleration_time',
'cooling_time',
'escape_time',
'gamma_grid',
'time_grid',
'accelerator_width',
'fp_coeff_index',
'turbulence_scale',
'inj_luminosity',
'acc_energy',
'time_ev_output',
'exp_start_time',
'L_inj',
'emitters_density',
'target_density',
'cold_p_to_rel_e_ratio',
'Disk',
'BLR',
'DT',
'Star',
'region_size',
'radius_expansion_index',
'region_position',
'beta_expansion',
'jet_base_height',
'electron_energy',
'LE_spectral_slope',
'HE_spectral_slope',
'high-energy-cut-off',
'low-energy-cut-off',
'spectral_curvature',
'turn-over-energy',
'magnetic_field',
'magnetic_field_index',
'jet_opening_angle',
'beaming',
'jet-viewing-angle',
'jet-bulk-factor',
'redshift']
self._is_in_jetkernel=is_in_jetkernel
super(JetParameter,self).__init__(allowed_par_types=_allowed_par_types, **keywords)
if 'val' in keywords.keys():
val=keywords['val']
self.assign_val_to_jetkernel(self.name,val)
#@safe_run
[docs]
def set(self,**keywords):
"""Set.
Parameters
----------
**keywords : dict
Additional keyword arguments.
"""
super(JetParameter,self).set(**keywords )
if 'val' in keywords.keys():
self.assign_val_to_jetkernel(self.name,keywords['val'])
#This instruction is not requested since it is performed in
#parent class
#if self._depending_par is not None:
# self._depending_par.set(val = self._depending_par._func(self._val.val))
[docs]
def assign_val_to_jetkernel(self, name, val):
"""Assign val to jetkernel.
Parameters
----------
name : object
Name identifier.
val : object
Value to assign.
"""
if self._jetkernel_parameter_name is not None:
name=self._jetkernel_parameter_name
#_jetkernel = getattr(self._model, self._jetkernel_attr)
_jetkernel_struct = getattr(self._model, self._jetkernel_struct_name)
if self._is_in_jetkernel is True:
if '.' in name:
b = get_nested_attr(_jetkernel_struct, name)
elif hasattr(_jetkernel_struct,name):
b=getattr(_jetkernel_struct,name)
else:
b = None
if b is not None:
if type(b)==int:
if self._val.islog is True:
val=10**val
val=int(val)
elif type(b)==float:
if self._val._islog is True:
val=10**val
val=float(val)
elif type(b)==str:
val=val
if '.' in name:
set_nested_attr(_jetkernel_struct, name, val)
else:
setattr(_jetkernel_struct,name,val)
[docs]
class JetModelParameterArray(ModelParameterArray):
"""Parameter-array helper for jet models and kernel-backed parameters.
Notes
-----
Extends :class:`~jetset.model_parameters.ModelParameterArray` with methods
that instantiate parameters from JetSeT dictionary specifications and bind
them to jetkernel structures.
"""
def __init__(self,model=None):
"""Create a new `JetModelParameterArray` instance.
Parameters
----------
model : object, optional
Model instance.
"""
super(JetModelParameterArray, self).__init__(model=model)
[docs]
def add_par_from_dict(self,
model_dic,
model ,
struct_name,
parameter_class):
"""Add par from dict.
Parameters
----------
model_dic : object
Model-parameter dictionary specification.
model : object
Model instance.
struct_name : object
Name of the bound jetkernel structure.
parameter_class : object
Parameter class used to instantiate entries.
"""
#print('--->',model_dic)
for key in model_dic.keys():
pname = key
jetkernel_par_name = model_dic[key].jetkernel_par_name
if jetkernel_par_name is None:
jetkernel_par_name=pname
p_test = self.get_par_by_name(pname)
_jetkernel_struct=getattr(model,struct_name)
if p_test is None:
if model_dic[key].is_in_jetkernel is True:
if '.' in jetkernel_par_name:
try:
pval = get_nested_attr(_jetkernel_struct, jetkernel_par_name)
except Exception:
pval = None
elif hasattr(_jetkernel_struct, jetkernel_par_name):
pval = getattr(_jetkernel_struct, jetkernel_par_name)
else:
pval = None
if pval is None:
if model_dic[key].val is not None:
pval = model_dic[key].val
else:
raise RuntimeError('par', pname, 'not found in jetkernel and model dict')
elif model_dic[key].val is not None:
pval = model_dic[key].val
else:
raise RuntimeError('par', pname, 'not found in jetkernel and model dict')
log = model_dic[key].log
allowed_values = model_dic[key].allowed_values
# IMPORTANT
# This has to stay here, because the parameter, even if log, is stored as linear
if log is True:
pval = np.log10(pval)
ptype = model_dic[key].ptype
vmin = model_dic[key].vmin
vmax = model_dic[key].vmax
punit = model_dic[key].punit
froz = model_dic[key].froz
is_in_jetkernel = model_dic[key].is_in_jetkernel
if (hasattr(model_dic[key],'_is_dependent')):
_is_dependent=model_dic[key]._is_dependent
else:
_is_dependent=False
if (hasattr(model_dic[key],'_depending_pars')):
_depending_pars=model_dic[key]._depending_pars
else:
_depending_pars=[]
if (hasattr(model_dic[key],'_func')):
_func=model_dic[key]._func
else:
_func=None
if (hasattr(model_dic[key],'_master_pars')):
_master_pars=model_dic[key]._master_pars
else:
_master_pars=[]
#print('==>, p',pname,'log_val',log,pval)
self.add_par(parameter_class(model,
struct_name,
jetkernel_par_name,
name=pname,
par_type=ptype,
val=pval,
val_min=vmin,
val_max=vmax,
units=punit,
frozen=froz,
log=log,
is_in_jetkernel=is_in_jetkernel,
allowed_values=model_dic[key].allowed_values,
_is_dependent=_is_dependent,
_depending_pars= _depending_pars,
_func=_func,
_master_pars=_master_pars))
