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)