def test_jump_by_cluster(setup_NGC6440E):
"""
Compare selection by MJD with selection by cluster (which by default selects TOAs by 2h gaps)
"""
m_copy = copy.deepcopy(setup_NGC6440E.m)
setup_NGC6440E.m.add_component(PhaseJump(), validate=False)
cp = setup_NGC6440E.m.components["PhaseJump"]
par = p.maskParameter(name="JUMP",
key="mjd",
value=0.2,
key_value=[54099, 54100],
units=u.s)
# this should be the last group of any TOAs
cp.add_param(par, setup=True)
# add clusters to the TOAs
clusters = setup_NGC6440E.t.get_clusters(2 * u.hr, add_column=False)
for i, v in zip(np.arange(len(setup_NGC6440E.t)), clusters):
setup_NGC6440E.t.table[i]["flags"]["toacluster"] = str(v)
m_copy.add_component(PhaseJump(), validate=False)
cp_copy = m_copy.components["PhaseJump"]
par_copy = p.maskParameter(name="JUMP",
key="-toacluster",
value=0.2,
key_value=41,
units=u.s)
# this should be identical to the cluster above
cp_copy.add_param(par_copy, setup=True)
assert set(cp.JUMP1.select_toa_mask(setup_NGC6440E.t)) == set(
cp_copy.JUMP1.select_toa_mask(setup_NGC6440E.t))
def __init__(self, ):
super().__init__()
self.introduces_correlated_errors = False
self.add_param(
maskParameter(
name="EFAC",
units="",
aliases=["T2EFAC", "TNEF"],
description="A multiplication factor on"
" the measured TOA uncertainties,",
))
self.add_param(
maskParameter(
name="EQUAD",
units="us",
aliases=["T2EQUAD"],
description="An error term added in "
"quadrature to the scaled (by"
" EFAC) TOA uncertainty.",
))
self.add_param(
maskParameter(
name="TNEQ",
units=u.LogUnit(physical_unit=u.second),
description="An error term added in "
"quadrature to the scaled (by"
" EFAC) TOA uncertainty in "
" the unit of log10(second).",
))
self.covariance_matrix_funcs += [self.sigma_scaled_cov_matrix]
self.scaled_toa_sigma_funcs += [self.scale_toa_sigma]
def __init__(self,):
super(ScaleDmError, self).__init__()
self.introduces_correlated_errors = False
self.add_param(
maskParameter(
name="DMEFAC",
units="",
description="A multiplication factor on"
" the measured DM uncertainties,",
)
)
self.add_param(
maskParameter(
name="DMEQUAD",
units="pc / cm ^ 3",
description="An error term added in "
"quadrature to the scaled (by"
" EFAC) TOA uncertainty.",
)
)
self.dm_covariance_matrix_funcs_component = [self.dm_sigma_scaled_cov_matrix]
self.scaled_dm_sigma_funcs += [self.scale_dm_sigma]
self._paired_DMEFAC_DMEQUAD = None
def add_jump_and_flags(self, toa_table):
"""Add jump object to PhaseJump and appropriate flags to TOA tables.
Helper function for pintk. Primarily to be used when applying a jump through
pintk to TOAs - since these jumps don't have keys that match to preexisting
flags in the TOA tables, we must add the flags when adding the jump.
Parameters
----------
toa_table: list object
The TOA table which must be modified. In pintk (pulsar.py), this will
be all_toas.table["flags"][selected]
"""
ind = None # index of jump
name = None # name of jump
# check if this is first jump added
if len(self.jumps) == 0 or (len(self.jumps) == 1
and getattr(self, "JUMP1").key is None):
param = maskParameter(
name="JUMP",
index=1,
key="-gui_jump",
key_value="1",
value=0.0,
units="second",
frozen=False,
)
# otherwise add on jump with next index
else:
# first, search for TOAs already jumped in inputted selection
# - pintk does not allow jumps added through GUI to overlap
# with existing jumps
for d in toa_table:
if "gui_jump" in d.keys():
log.warning(
"The selected toa(s) overlap an existing jump."
"Remove all interfering jumps before attempting to jump these toas."
)
return None
param = maskParameter(
name="JUMP",
index=len(self.jumps) + 1,
key="-gui_jump",
key_value=str(len(self.jumps) + 1),
value=0.0,
units="second",
frozen=False,
)
self.add_param(param)
ind = param.index
name = param.name
self.setup()
for dict1 in toa_table:
dict1["jump"] = str(ind)
dict1["gui_jump"] = str(ind)
return name
def test_compare_key_value():
par1 = maskParameter(name="Test1", key="-k1", key_value="kv1")
par2 = maskParameter(name="Test2", key="-k1", key_value="kv1")
par3 = maskParameter(name="Test3", key="-k2", key_value="kv1")
par4 = maskParameter(name="Test4", key="-k1", key_value="kv2")
assert par1.compare_key_value(par2)
assert par2.compare_key_value(par1)
assert not par1.compare_key_value(par3)
assert not par1.compare_key_value(par4)
assert not par2.compare_key_value(par3)
assert not par2.compare_key_value(par4)
def jump_flags_to_params(self, toas):
"""convert jump flags in toas.table["flags"] to jump parameters in the model"""
from . import jump
for flag_dict in toas.table["flags"]:
if "jump" in flag_dict.keys():
break
else:
log.info("No jump flags to process")
return None
jump_nums = [
flag_dict["jump"] if "jump" in flag_dict.keys() else np.nan
for flag_dict in toas.table["flags"]
]
if "PhaseJump" not in self.components:
log.info("PhaseJump component added")
a = jump.PhaseJump()
a.setup()
self.add_component(a)
self.remove_param("JUMP1")
for num in np.arange(1, np.nanmax(jump_nums) + 1):
if "JUMP" + str(int(num)) not in self.params:
param = maskParameter(
name="JUMP",
index=int(num),
key="jump",
key_value=int(num),
value=0.0,
units="second",
uncertainty=0.0,
)
self.add_param_from_top(param, "PhaseJump")
getattr(self, param.name).frozen = False
if 0 in jump_nums:
for flag_dict in toas.table["flags"]:
if "jump" in flag_dict.keys() and flag_dict["jump"] == 0:
flag_dict["jump"] = int(np.nanmax(jump_nums) + 1)
param = maskParameter(
name="JUMP",
index=int(np.nanmax(jump_nums) + 1),
key="jump",
key_value=int(np.nanmax(jump_nums) + 1),
value=0.0,
units="second",
uncertainty=0.0,
)
self.add_param_from_top(param, "PhaseJump")
getattr(self, param.name).frozen = False
self.components["PhaseJump"].setup()
def test_add_component(self):
tm = TimingModel(
"TestTimingModel", [BinaryELL1(), AstrometryEquatorial(), Spindown()]
)
tm.add_component(DelayJump(), validate=False)
# Test link
# TODO may be add a get_component function
cp = tm.components["DelayJump"]
assert cp._parent == tm
# Test order
cp_pos = tm.DelayComponent_list.index(cp)
assert cp_pos == 2
print(cp.params)
print(cp.get_prefix_mapping_component("JUMP"))
print(id(cp), "test")
add_jumps = [
("JUMP", {"value": 0.1, "key": "mjd", "key_value": [55000, 56000]}),
("JUMP", {"value": 0.2, "key": "freq", "key_value": [1440, 2000]}),
("JUMP", {"value": 0.3, "key": "tel", "key_value": "ao"}),
]
for jp in add_jumps:
p_name = jp[0]
print("test1", p_name)
p_vals = jp[1]
par = p.maskParameter(
name=p_name,
key=p_vals["key"],
value=p_vals["value"],
key_value=p_vals["key_value"],
units=u.s,
)
print("test", par.name)
cp.add_param(par, setup=True)
# TODO add test component setup function. use jump1 right now, this
# should be updated in the future.
assert hasattr(cp, "JUMP1")
assert hasattr(cp, "JUMP2")
assert hasattr(cp, "JUMP3")
assert hasattr(tm, "JUMP1")
assert hasattr(tm, "JUMP2")
assert hasattr(tm, "JUMP3")
jump1 = getattr(tm, "JUMP1")
jump2 = getattr(tm, "JUMP2")
jump3 = getattr(tm, "JUMP3")
assert jump1.key == "mjd"
assert jump2.key == "freq"
assert jump3.key == "tel"
# Check jump value
assert jump1.value == 0.1
assert jump2.value == 0.2
assert jump3.value == 0.3
# Check jump key value
assert jump1.key_value == [55000, 56000]
assert jump2.key_value == [1440, 2000]
assert jump3.key_value == ["ao"]
assert tm.jumps == ["JUMP1", "JUMP2", "JUMP3"]
def test_jump_params_to_flags(setup_NGC6440E):
""" Check jump_params_to_flags function. """
setup_NGC6440E.m.add_component(PhaseJump(), validate=False)
cp = setup_NGC6440E.m.components["PhaseJump"]
par = p.maskParameter(
name="JUMP", key="freq", value=0.2, key_value=[1440, 1700], units=u.s
) # TOAs indexed 48, 49, 54 in NGC6440E are within this frequency range
cp.add_param(par, setup=True)
# sanity check - ensure no jump flags from initialization
for i in range(setup_NGC6440E.t.ntoas):
assert "jump" not in setup_NGC6440E.t.table["flags"][i]
# add flags based off jumps added to model
setup_NGC6440E.m.jump_params_to_flags(setup_NGC6440E.t)
# index to affected TOAs and ensure appropriate flags set
toa_indeces = [48, 49, 54]
for i in toa_indeces:
assert "jump" in setup_NGC6440E.t.table["flags"][i]
assert setup_NGC6440E.t.table["flags"][i]["jump"][0] == "1"
# ensure no extraneous flags added to unaffected TOAs
for i in range(setup_NGC6440E.t.ntoas):
if i not in toa_indeces:
assert "jump" not in setup_NGC6440E.t.table["flags"][i]
# check case where multiple calls are performed (no-ops)
old_table = setup_NGC6440E.t.table
setup_NGC6440E.m.jump_params_to_flags(setup_NGC6440E.t)
assert all(old_table) == all(setup_NGC6440E.t.table)
# check that adding overlapping jump works
par2 = p.maskParameter(
name="JUMP", key="freq", value=0.2, key_value=[1600, 1900], units=u.s
) # frequency range overlaps with par, 2nd jump will have common TOAs w/ 1st
cp.add_param(par2, setup=True)
# add flags based off jumps added to model
setup_NGC6440E.m.jump_params_to_flags(setup_NGC6440E.t)
mask2 = par2.select_toa_mask(setup_NGC6440E.t)
intersect = np.intersect1d(toa_indeces, mask2)
assert intersect is not []
for i in mask2:
assert "2" in setup_NGC6440E.t.table["flags"][i]["jump"]
for i in toa_indeces:
assert "1" in setup_NGC6440E.t.table["flags"][i]["jump"]
def __init__(self):
super().__init__()
self.add_param(
maskParameter(
name="JUMP",
units="second",
description="Amount to jump the selected TOAs by.",
))
self.phase_funcs_component += [self.jump_phase]
def setup(self):
super().setup()
# Get all the EFAC parameters and EQUAD
self.EFACs = {}
self.EQUADs = {}
self.TNEQs = {}
for mask_par in self.get_params_of_type("maskParameter"):
if mask_par.startswith("EFAC"):
par = getattr(self, mask_par)
self.EFACs[mask_par] = (par.key, par.key_value)
elif mask_par.startswith("EQUAD"):
par = getattr(self, mask_par)
self.EQUADs[mask_par] = (par.key, par.key_value)
elif mask_par.startswith("TNEQ"):
par = getattr(self, mask_par)
self.TNEQs[mask_par] = (par.key, par.key_value)
else:
continue
# convert all the TNEQ to EQUAD
for tneq in self.TNEQs:
tneq_par = getattr(self, tneq)
if tneq_par.key is None:
continue
if self.TNEQs[tneq] in list(self.EQUADs.values()):
log.warning("'%s %s %s' is provided by parameter EQUAD, using"
" EQUAD instead. " %
(tneq, tneq_par.key, tneq_par.key_value))
else:
EQUAD_name = "EQUAD" + str(tneq_par.index)
if EQUAD_name in list(self.EQUADs.keys()):
EQUAD_par = getattr(self, EQUAD_name)
EQUAD_par.key = tneq_par.key
EQUAD_par.key_value = tneq_par.key_value
EQUAD_par.quantity = tneq_par.quantity.to(u.us)
else:
self.add_param(
maskParameter(
name="EQUAD",
units="us",
index=tneq_par.index,
aliases=["T2EQUAD"],
description="An error term "
" added in quadrature to the"
" scaled (by EFAC) TOA uncertainty.",
))
EQUAD_par = getattr(self, EQUAD_name)
EQUAD_par.key = tneq_par.key
EQUAD_par.key_value = tneq_par.key_value
EQUAD_par.quantity = tneq_par.quantity.to(u.us)
for pp in self.params:
if pp.startswith("EQUAD"):
par = getattr(self, pp)
self.EQUADs[pp] = (par.key, par.key_value)
def __init__(self):
super(DispersionJump, self).__init__()
self.dm_value_funcs += [self.jump_dm]
self.add_param(
maskParameter(
name="DMJUMP",
units="pc cm^-3",
value=None,
description="DM value offset.",
))
def __init__(self):
super().__init__()
self.dm_value_funcs += [self.jump_dm]
# Dispersion jump only model the dm values.
self.add_param(
maskParameter(
name="DMJUMP",
units="pc cm^-3",
value=None,
description="DM value offset.",
))
def __init__(self, ):
super().__init__()
self.introduces_correlated_errors = True
self.add_param(
maskParameter(
name="ECORR",
units="us",
aliases=["TNECORR"],
description="An error term added that"
" correlated all TOAs in an"
" observing epoch.",
))
self.covariance_matrix_funcs += [self.ecorr_cov_matrix]
self.basis_funcs += [self.ecorr_basis_weight_pair]
def test_compare_key_value_list():
par1 = maskParameter(name="Test1", key="-k1", key_value=["k", "q"])
par2 = maskParameter(name="Test2", key="-k1", key_value=["q", "k"])
par3 = maskParameter(name="Test3", key="-k1", key_value=["k", "q"])
assert par1.compare_key_value(par2)
assert par2.compare_key_value(par1)
assert par3.compare_key_value(par1)
par4 = maskParameter(name="Test4", key="-k1", key_value=[2000, 3000])
par5 = maskParameter(name="Test5", key="-k1", key_value=[3000, 2000])
assert par4.compare_key_value(par5)
assert par5.compare_key_value(par4)
par6 = maskParameter(name="Test6",
key="-k1",
key_value=["430", "guppi", "puppi"])
par7 = maskParameter(name="Test7",
key="-k1",
key_value=["puppi", "guppi", "430"])
assert par6.compare_key_value(par7)
assert par7.compare_key_value(par6)
def test_multijump_toa(setup_NGC6440E):
setup_NGC6440E.m.add_component(PhaseJump(), validate=False)
cp = setup_NGC6440E.m.components["PhaseJump"]
par = p.maskParameter(
name="JUMP", key="freq", value=0.2, key_value=[1440, 1700], units=u.s
) # TOAs indexed 48, 49, 54 in NGC6440E are within this frequency range
selected_toa_ind = [48, 49, 54]
cp.add_param(par, setup=True)
# check that one can still add "gui jumps" to model-jumped TOAs
cp.add_jump_and_flags(setup_NGC6440E.t.table["flags"][selected_toa_ind])
# add flags based off jumps added to model
setup_NGC6440E.m.jump_params_to_flags(setup_NGC6440E.t)
for dict in setup_NGC6440E.t.table["flags"][selected_toa_ind]:
assert dict["jump"] in ["1,2", "2,1"]
assert dict["gui_jump"] == "2"
assert len(cp.jumps) == 2
setup_NGC6440E.m.delete_jump_and_flags(setup_NGC6440E.t.table["flags"], 2)
for dict in setup_NGC6440E.t.table["flags"][selected_toa_ind]:
assert "jump" in dict
assert len(cp.jumps) == 1
assert "JUMP1" in cp.jumps
def __init__(self):
super(PhaseJump, self).__init__()
self.add_param(maskParameter(name="JUMP", units="second"))
self.phase_funcs_component += [self.jump_phase]
def __init__(self):
super(DelayJump, self).__init__()
# TODO: In the future we should have phase jump as well.
self.add_param(maskParameter(name="JUMP", units="second"))
self.delay_funcs_component += [self.jump_delay]
def __init__(self):
super(DelayJump, self).__init__()
self.add_param(maskParameter(name="JUMP", units="second"))
self.delay_funcs_component += [self.jump_delay]
assert par2.compare_key_value(par1)
assert par3.compare_key_value(par1)
par4 = maskParameter(name="Test4", key="-k1", key_value=[2000, 3000])
par5 = maskParameter(name="Test5", key="-k1", key_value=[3000, 2000])
assert par4.compare_key_value(par5)
assert par5.compare_key_value(par4)
par6 = maskParameter(name="Test6",
key="-k1",
key_value=["430", "guppi", "puppi"])
par7 = maskParameter(name="Test7",
key="-k1",
key_value=["puppi", "guppi", "430"])
assert par6.compare_key_value(par7)
assert par7.compare_key_value(par6)
@pytest.mark.parametrize(
"p",
[
boolParameter(name="FISH"),
intParameter(name="FISH"),
strParameter(name="FISH"),
pytest.param(maskParameter(name="JUMP"), ),
pytest.param(prefixParameter(name="F0"), ),
pairParameter(name="WEAVE"),
AngleParameter(name="BEND"),
],
)
def test_parameter_can_be_pickled(p):
pickle.dumps(p)
