def test_ftest_nb():
"""Test for narrowband fitter class F-test."""
m = tm.get_model(os.path.join(datadir, "B1855+09_NANOGrav_9yv1.gls.par"))
t = toa.get_TOAs(os.path.join(datadir, "B1855+09_NANOGrav_9yv1.tim"))
f = fitter.WLSFitter(toas=t, model=m)
f.fit_toas()
# Test adding parameters
FD4 = param.prefixParameter(parameter_type="float",
name="FD4",
value=0.0,
units=u.s,
frozen=False)
ft = f.ftest(FD4, "FD", remove=False)
assert isinstance(ft["ft"], float) or isinstance(ft["ft"], bool)
# Test return the full output
Ftest_dict = f.ftest(FD4, "FD", remove=False, full_output=True)
assert isinstance(Ftest_dict["ft"], float) or isinstance(
Ftest_dict["ft"], bool)
# Test removing parameter
FD3 = param.prefixParameter(parameter_type="float",
name="FD3",
value=0.0,
units=u.s,
frozen=False)
ft = f.ftest(FD3, "FD", remove=True)
assert isinstance(ft["ft"], float) or isinstance(ft["ft"], bool)
Ftest_dict = f.ftest(FD3, "FD", remove=True, full_output=True)
assert isinstance(Ftest_dict["ft"], float) or isinstance(
Ftest_dict["ft"], bool)
def test_ftest_nb():
"""Test for narrowband fitter class F-test."""
m = tm.get_model(os.path.join(datadir, "J0023+0923_ell1_simple.par"))
t = toa.make_fake_toas(56000.0, 56001.0, 10, m, freq=1400.0, obs="AO")
f = fitter.WLSFitter(toas=t, model=m)
f.fit_toas()
# Test adding parameters
F2 = param.prefixParameter(
parameter_type="float",
name="F2",
value=0.0,
units=u.Hz / u.s / u.s,
frozen=False,
)
ft = f.ftest(F2, "Spindown", remove=False)
assert isinstance(ft["ft"], float) or isinstance(ft["ft"], bool)
# Test return the full output
Ftest_dict = f.ftest(F2, "Spindown", remove=False, full_output=True)
assert isinstance(Ftest_dict["ft"], float) or isinstance(Ftest_dict["ft"], bool)
# Test removing parameter
F1 = param.prefixParameter(
parameter_type="float", name="F1", value=0.0, units=u.Hz / u.s, frozen=False
)
ft = f.ftest(F1, "Spindown", remove=True)
assert isinstance(ft["ft"], float) or isinstance(ft["ft"], bool)
Ftest_dict = f.ftest(F1, "Spindown", remove=True, full_output=True)
assert isinstance(Ftest_dict["ft"], float) or isinstance(Ftest_dict["ft"], bool)
def __init__(self):
super(Spindown, self).__init__()
self.add_param(
floatParameter(
name="F0",
value=0.0,
units="Hz",
description="Spin-frequency",
long_double=True,
))
self.add_param(
prefixParameter(
name="F1",
value=0.0,
units="Hz/s^1",
description="Spindown-rate",
unit_template=self.F_unit,
description_template=self.F_description,
type_match="float",
long_double=True,
))
self.add_param(
MJDParameter(
name="PEPOCH",
description="Reference epoch for spin-down",
time_scale="tdb",
))
self.phase_funcs_component += [self.spindown_phase]
self.phase_derivs_wrt_delay += [self.d_spindown_phase_d_delay]
def __init__(self):
super(DispersionDM, self).__init__()
self.add_param(
floatParameter(
name="DM",
units="pc cm^-3",
value=0.0,
description="Dispersion measure",
long_double=True,
))
self.add_param(
prefixParameter(
name="DM1",
value=0.0,
units="pc cm^-3/yr^1",
description=
"First order time derivative of the dispersion measure",
unit_template=self.DM_dervative_unit,
description_template=self.DM_dervative_description,
type_match="float",
long_double=True,
))
self.add_param(
MJDParameter(name="DMEPOCH",
description="Epoch of DM measurement",
time_scale="tdb"))
self.dm_value_funcs += [self.base_dm]
self.delay_funcs_component += [self.constant_dispersion_delay]
def __init__(self):
super(Wave, self).__init__()
self.add_param(
floatParameter(
name="WAVE_OM",
description="Base frequency of wave solution",
units="1/d",
)
)
self.add_param(
prefixParameter(
name="WAVE1",
units="s",
description="Wave components",
type_match="pair",
long_double=True,
parameter_type="pair",
)
)
self.add_param(
MJDParameter(
name="WAVEEPOCH",
description="Reference epoch for wave solution",
time_scale="tdb",
)
)
self.phase_funcs_component += [self.wave_phase]
def __init__(self):
super(DispersionDMX, self).__init__()
# DMX is for info output right now
self.add_param(
floatParameter(
name="DMX",
units="pc cm^-3",
value=0.0,
description="Dispersion measure",
)
)
self.add_param(
prefixParameter(
name="DMX_0001",
units="pc cm^-3",
value=0.0,
unit_template=lambda x: "pc cm^-3",
description="Dispersion measure variation",
description_template=lambda x: "Dispersion measure",
paramter_type="float",
)
)
self.add_param(
prefixParameter(
name="DMXR1_0001",
units="MJD",
unit_template=lambda x: "MJD",
description="Beginning of DMX interval",
description_template=lambda x: "Beginning of DMX interval",
parameter_type="MJD",
time_scale="utc",
)
)
self.add_param(
prefixParameter(
name="DMXR2_0001",
units="MJD",
unit_template=lambda x: "MJD",
description="End of DMX interval",
description_template=lambda x: "End of DMX interval",
parameter_type="MJD",
time_scale="utc",
)
)
self.dm_value_funcs += [self.dmx_dm]
self.set_special_params(["DMX_0001", "DMXR1_0001", "DMXR2_0001"])
self.delay_funcs_component += [self.DMX_dispersion_delay]
def __init__(self):
super(FD, self).__init__()
self.add_param(
prefixParameter(
name="FD1",
units="second",
value=0.0,
descriptionTplt=lambda x: ("%d term of frequency"
" dependent coefficients" % x),
unitTplt=lambda x: "second",
type_match="float",
))
self.delay_funcs_component += [self.FD_delay]
def __init__(self):
super(IFunc, self).__init__()
self.add_param(
floatParameter(name="SIFUNC",
description="Type of interpolation",
units=""))
self.add_param(
prefixParameter(
name="IFUNC1",
units="s",
description="Interpolation Components (MJD+delay)",
type_match="pair",
long_double=True,
parameter_type="pair",
))
self.phase_funcs_component += [self.ifunc_phase]
def test_pickle_prefixparameter():
parfile = pint.config.examplefile("NGC6440E.par")
m = get_model(parfile)
modelcomponent = m.components["Spindown"]
p = param.prefixParameter(
parameter_type="float",
name="F2",
value=0,
units=modelcomponent.F_unit(2),
uncertainty=0,
description=modelcomponent.F_description(2),
longdouble=True,
frozen=False,
)
modelcomponent.add_param(p, setup=True)
m.validate()
s = pickle.dumps(m)
def __init__(self):
super().__init__()
self.add_param(
prefixParameter(
name="FD1",
units="second",
value=0.0,
description=
"Coefficient of delay as a polynomial function of log-frequency",
# descriptionTplt=lambda x: (
# "%d term of frequency" " dependent coefficients" % x
# ),
descriptionTplt=self._description_template,
# unitTplt=lambda x: "second",
type_match="float",
))
self.delay_funcs_component += [self.FD_delay]
def test_grid_3param_prefix_multiprocessor():
parfile = pint.config.examplefile("NGC6440E.par")
timfile = pint.config.examplefile("NGC6440E.tim")
m, t = get_model_and_toas(parfile, timfile)
# add a F2 to the model
modelcomponent = m.components["Spindown"]
p = param.prefixParameter(
parameter_type="float",
name="F2",
value=0,
units=modelcomponent.F_unit(2),
uncertainty=0,
description=modelcomponent.F_description(2),
longdouble=True,
frozen=False,
)
modelcomponent.add_param(p, setup=True)
m.validate()
f = WLSFitter(t, m)
f.fit_toas()
bestfit = f.resids.chi2
F0 = np.linspace(
f.model.F0.quantity - 3 * f.model.F0.uncertainty,
f.model.F0.quantity + 3 * f.model.F0.uncertainty,
3,
)
F1 = np.linspace(
f.model.F1.quantity - 3 * f.model.F1.uncertainty,
f.model.F1.quantity + 3 * f.model.F1.uncertainty,
7,
)
F2 = np.linspace(
f.model.F2.quantity - 3 * f.model.F2.uncertainty,
f.model.F2.quantity + 3 * f.model.F2.uncertainty,
5,
)
chi2grid, _ = pint.gridutils.grid_chisq(f, ("F0", "F1", "F2"),
(F0, F1, F2),
ncpu=ncpu)
assert np.isclose(bestfit, chi2grid.min())
def __init__(self):
super(Glitch, self).__init__()
self.add_param(
prefixParameter(
name="GLPH_1",
units="pulse phase",
value=0.0,
descriptionTplt=lambda x: "Phase change for glitch %d" % x,
unitTplt=lambda x: "pulse phase",
type_match="float",
)
)
# FIXME: should this be long double?
self.add_param(
prefixParameter(
name="GLEP_1",
units="day",
descriptionTplt=lambda x: "Epoch of glitch %d" % x,
unitTplt=lambda x: "day",
type_match="MJD",
time_scale="tdb",
)
)
self.add_param(
prefixParameter(
name="GLF0_1",
units="Hz",
value=0.0,
descriptionTplt=lambda x: "Permanent frequency change"
" for glitch %d" % x,
unitTplt=lambda x: "Hz",
type_match="float",
)
)
self.add_param(
prefixParameter(
name="GLF1_1",
units="Hz/s",
value=0.0,
descriptionTplt=lambda x: "Permanent frequency-"
"derivative change for glitch"
" %d " % x,
unitTplt=lambda x: "Hz/s",
)
)
self.add_param(
prefixParameter(
name="GLF2_1",
units="Hz/s^2",
value=0.0,
descriptionTplt=lambda x: "Permanent second frequency-"
"derivative change for glitch"
" %d " % x,
unitTplt=lambda x: "Hz/s^2",
)
)
self.add_param(
prefixParameter(
name="GLF0D_1",
units="Hz",
value=0.0,
descriptionTplt=lambda x: "Decaying frequency change "
"for glitch %d " % x,
unitTplt=lambda x: "Hz",
type_match="float",
)
)
self.add_param(
prefixParameter(
name="GLTD_1",
units="day",
value=0.0,
descriptionTplt=lambda x: "Decay time constant for" " glitch %d" % x,
unitTplt=lambda x: "day",
type_match="float",
)
)
self.phase_funcs_component += [self.glitch_phase]
def __init__(self):
super().__init__()
self.add_param(
prefixParameter(
name="GLPH_1",
units="pulse phase",
value=0.0,
description_template=self._description_glitch_phase,
type_match="float",
))
self.add_param(
prefixParameter(
name="GLEP_1",
units="MJD",
description_template=self._description_glitch_epoch,
parameter_type="MJD",
time_scale="tdb",
))
self.add_param(
prefixParameter(
name="GLF0_1",
units="Hz",
value=0.0,
description_template=self._description_glitch_frequencychange,
type_match="float",
))
self.add_param(
prefixParameter(
name="GLF1_1",
units="Hz/s",
value=0.0,
description_template=self.
_description_glitch_frequencyderivativechange,
))
self.add_param(
prefixParameter(
name="GLF2_1",
units="Hz/s^2",
value=0.0,
description_template=self.
_description_glitch_frequencysecondderivativechange,
))
self.add_param(
prefixParameter(
name="GLF0D_1",
units="Hz",
value=0.0,
description_template=self.
_description_decaying_frequencychange,
type_match="float",
))
self.add_param(
prefixParameter(
name="GLTD_1",
units="day",
value=0.0,
description_template=self._description_decaytimeconstant,
type_match="float",
))
self.phase_funcs_component += [self.glitch_phase]
def add_DMX_range(self,
mjd_start,
mjd_end,
index=None,
dmx=0,
frozen=True):
"""Add DMX range to a dispersion model with specified start/end MJDs and DMX.
Parameters
----------
mjd_start : float
MJD for beginning of DMX event.
mjd_end : float
MJD for end of DMX event.
index : int, None
Integer label for DMX event. If None, will increment largest used index by 1.
dmx : float
Change in DM during DMX event.
frozen : bool
Indicates whether DMX will be fit.
Returns
-------
index : int
Index that has been assigned to new DMX event.
"""
#### Setting up the DMX title convention. If index is None, want to increment the current max DMX index by 1.
if index is None:
dct = self.get_prefix_mapping_component("DMX_")
index = np.max(list(dct.keys())) + 1
i = f"{int(index):04d}"
if mjd_end is not None and mjd_start is not None:
if mjd_end < mjd_start:
raise ValueError("Starting MJD is greater than ending MJD.")
elif mjd_start != mjd_end:
raise ValueError("Only one MJD bound is set.")
if int(index) in self.get_prefix_mapping_component("DMX_"):
raise ValueError(
"Index '%s' is already in use in this model. Please choose another."
% index)
self.add_param(
prefixParameter(
name="DMX_" + i,
units="pc cm^-3",
value=dmx,
description="Dispersion measure variation",
parameter_type="float",
frozen=frozen,
))
self.add_param(
prefixParameter(
name="DMXR1_" + i,
units="MJD",
description="Beginning of DMX interval",
parameter_type="MJD",
time_scale="utc",
value=mjd_start,
))
self.add_param(
prefixParameter(
name="DMXR2_" + i,
units="MJD",
description="End of DMX interval",
parameter_type="MJD",
time_scale="utc",
value=mjd_end,
))
self.setup()
self.validate()
return index
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)
#
# Note, `Component` class also has the attribute `params`, which is only for the parameters in the component.
# %%
print(tm.components["DispersionDMX"].params)
# %% [markdown]
# ### Add DMX parameters
#
# Since we already have DMX_0001, we will add DMX_0003, just want to show that for DMX model, DMX index('0001' part) does not have to follow the consecutive order.
#
# The prefix type of parameters have to use `prefixParameter` class from `pint.models.parameter` module.
# %%
# Add prefix parameters
dmx_0003 = p.prefixParameter(parameter_type="float",
name="DMX_0003",
value=None,
units=u.pc / u.cm**3)
tm.components["DispersionDMX"].add_param(dmx_0003, setup=True)
# tm.add_param_from_top(dmx_0003, "DispersionDMX", setup=True)
# # Component should given by its name string. use setup=True make sure new parameter get registered.
# %% [markdown]
# ### Check if the parameter and component setup correctly.
# %%
display(tm.params)
display(
tm.delay_deriv_funcs.keys()) # the derivative function should be added.
# %% [markdown]
def __init__(self):
super().__init__()
self.add_param(
prefixParameter(
name="PWSTART_1",
units="MJD",
description_template=self._description_solution_epochstart,
parameter_type="MJD",
time_scale="tdb",
))
self.add_param(
prefixParameter(
name="PWSTOP_1",
units="MJD",
description_template=self._description_solution_epochstop,
parameter_type="MJD",
time_scale="tdb",
))
self.add_param(
prefixParameter(
name="PWEP_1",
units="MJD",
description_template=self._description_solution_epoch,
parameter_type="MJD",
time_scale="tdb",
))
self.add_param(
prefixParameter(
name="PWPH_1",
units="",
value=0.0,
description_template=self._description_solution_startphase,
type_match="float",
uncertainty=1,
))
self.add_param(
prefixParameter(
name="PWF0_1",
units="Hz",
value=0.0,
description_template=self._description_solution_frequency,
type_match="float",
))
self.add_param(
prefixParameter(
name="PWF1_1",
units="Hz/s",
value=0.0,
description_template=self.
_description_solution_frequencyderivative,
))
self.add_param(
prefixParameter(
name="PWF2_1",
units="Hz/s^2",
value=0.0,
description_template=self.
_description_solution_secondfrequencyderivative,
))
self.phase_funcs_component += [self.piecewise_phase]
def __init__(self,):
super(PulsarBinary, self).__init__()
self.binary_model_name = None
self.barycentric_time = None
self.binary_model_class = None
self.add_param(
floatParameter(
name="PB", units=u.day, description="Orbital period", long_double=True
)
)
self.add_param(
floatParameter(
name="PBDOT",
units=u.day / u.day,
description="Orbital period derivitve respect to time",
unit_scale=True,
scale_factor=1e-12,
scale_threshold=1e-7,
)
)
self.add_param(
floatParameter(
name="A1", units=ls, description="Projected semi-major axis, a*sin(i)"
)
)
# NOTE: the DOT here takes the value and times 1e-12, tempo/tempo2 can
# take both.
self.add_param(
floatParameter(
name="A1DOT",
aliases=["XDOT"],
units=ls / u.s,
description="Derivative of projected semi-major axis, da*sin(i)/dt",
unit_scale=True,
scale_factor=1e-12,
scale_threshold=1e-7,
)
)
self.add_param(
floatParameter(
name="ECC", units="", aliases=["E"], description="Eccentricity"
)
)
self.add_param(
floatParameter(
name="EDOT",
units="1/s",
description="Eccentricity derivitve respect to time",
unit_scale=True,
scale_factor=1e-12,
scale_threshold=1e-7,
)
)
self.add_param(
MJDParameter(
name="T0", description="Epoch of periastron passage", time_scale="tdb"
)
)
self.add_param(
floatParameter(
name="OM",
units=u.deg,
description="Longitude of periastron",
long_double=True,
)
)
self.add_param(
floatParameter(
name="OMDOT",
units="deg/year",
description="Longitude of periastron",
long_double=True,
)
)
self.add_param(
floatParameter(
name="M2",
units=u.M_sun,
description="Mass of companian in the unit Sun mass",
)
)
self.add_param(
floatParameter(
name="SINI", units="", description="Sine of inclination angle"
)
)
self.add_param(
prefixParameter(
name="FB0",
value=None,
units="1/s^1",
description="0th time derivative of frequency of orbit",
unit_template=self.FBX_unit,
aliases=["FB"],
description_template=self.FBX_description,
type_match="float",
long_double=True,
)
)
self.interal_params = []
self.warn_default_params = ["ECC", "OM"]
# Set up delay function
self.delay_funcs_component += [self.binarymodel_delay]
def __init__(self):
super(PiecewiseSpindown, self).__init__()
self.add_param(
prefixParameter(
name="PWSTART_1",
units="MJD",
unit_template=lambda x: "MJD",
description_template=lambda x: "Epoch of solution piece %d" %
x,
parameter_type="MJD",
time_scale="tdb",
))
self.add_param(
prefixParameter(
name="PWSTOP_1",
units="MJD",
unit_template=lambda x: "MJD",
description_template=lambda x: "Epoch of solution piece %d" %
x,
parameter_type="MJD",
time_scale="tdb",
))
self.add_param(
prefixParameter(
name="PWEP_1",
units="MJD",
unit_template=lambda x: "MJD",
description_template=lambda x: "Epoch of solution piece %d" %
x,
parameter_type="MJD",
time_scale="tdb",
))
self.add_param(
prefixParameter(
name="PWPH_1",
units="",
value=0.0,
description_template=lambda x:
"Starting phase of solution piece %d" % x,
unit_template=lambda x: "",
type_match="float",
uncertainty=1,
))
self.add_param(
prefixParameter(
name="PWF0_1",
units="Hz",
value=0.0,
description_template=lambda x: "Frequency of solution piece %d"
% x,
unit_template=lambda x: "Hz",
type_match="float",
))
self.add_param(
prefixParameter(
name="PWF1_1",
units="Hz/s",
value=0.0,
description_template=lambda x:
"Frequency-derivative of solution piece"
" %d " % x,
unit_template=lambda x: "Hz/s",
))
self.add_param(
prefixParameter(
name="PWF2_1",
units="Hz/s^2",
value=0.0,
description_template=lambda x: "Second frequency-"
"derivative of solution piece"
" %d " % x,
unit_template=lambda x: "Hz/s^2",
))
self.phase_funcs_component += [self.piecewise_phase]
