Ejemplo n.º 1
0
def test_set_params(lines, param, value):
    model = get_model(io.StringIO("\n".join([par_base] + lines)))
    with pytest.raises(KeyError) as e:
        model[param].value = value
    str(e.value).index(param)  # raise exception if not found
    with pytest.raises(AttributeError) as e:
        getattr(model, param).value = value
    str(e.value).index(param)  # raise exception if not found
Ejemplo n.º 2
0
def test_change_dmepoch():
    parfile = os.path.join(datadir, "J2229+2643_dm1.par")
    model = models.get_model(parfile)
    t0 = Time(56000, scale="tdb", format="mjd")
    epoch_diff = (t0.mjd_long - model.DMEPOCH.quantity.mjd_long) * u.day
    DM_at_t0 = model.DM.quantity + model.DM1.quantity * epoch_diff.to(u.s)
    model.change_dmepoch(t0)
    assert np.abs(model.DM.quantity - DM_at_t0) < 1e-8 * u.pc / u.cm ** 3
Ejemplo n.º 3
0
    def test_copy_model_object(self):
        model = get_model("J1614-2230_NANOGrav_12yv3.wb.gls.par")
        model_copy = copy.deepcopy(model)

        assert sys.getsizeof(model) == sys.getsizeof(model_copy)
        assert id(model) != id(model_copy)
        assert len(model.params) == len(model_copy.params)
        assert list(model.components.keys()) == list(model_copy.components.keys())
Ejemplo n.º 4
0
def get_pint_models(psr_name, psr_file_path):
    """Function that returns pint model given a specific pulsar"""
    # will need to add section for J1713 T2 file. gls is not file wanted for this specfic pulsar.
    model_name = "{0}{1}_NANOGrav_11yv1.gls.par".format(
        psr_file_path, psr_name)
    par_model = models.get_model(model_name)

    return par_model
Ejemplo n.º 5
0
def test_dm_barycentered():
    model = get_model(io.StringIO(par_base))
    toas = make_fake_toas(57000, 57900, 10, model, obs="@", freq=np.inf)
    model.free_params = ["F0", "DM"]
    fitter = pint.fitter.WLSFitter(toas, model)
    with pytest.warns(pint.fitter.DegeneracyWarning,
                      match=".*degeneracy.*DM.*"):
        fitter.fit_toas()
Ejemplo n.º 6
0
def test_A1DOT():
    """Should get changed to XDOT for TEMPO/TEMPO2"""
    m = get_model(os.path.join(datadir, "J1600-3053_test.par"))
    assert (("A1DOT" in m.as_parfile()) and not ("XDOT" in m.as_parfile())
            and not ("A1DOT" in m.as_parfile(format="tempo"))
            and ("XDOT" in m.as_parfile(format="tempo"))
            and not ("A1DOT" in m.as_parfile(format="tempo2"))
            and ("XDOT" in m.as_parfile(format="tempo2")))
Ejemplo n.º 7
0
def test_MODE1():
    """Should start TEMPO2"""
    m = get_model(os.path.join(datadir, "B1855+09_NANOGrav_dfg+12_TAI.par"))
    assert (not (m.as_parfile(include_info=False).startswith("MODE 1"))
            and not (m.as_parfile(include_info=False,
                                  format="tempo").startswith("MODE 1"))
            and (m.as_parfile(include_info=False,
                              format="tempo2").startswith("MODE 1")))
Ejemplo n.º 8
0
def test_DMDATA_N():
    """Should be an integer for TEMPO/TEMPO2"""
    m = get_model(os.path.join(datadir, "J0030+0451_post.par"))
    for l in m.as_parfile(format="tempo").split("\n"):
        if "DMDATA" in l:
            # this should be a 0
            dmdata = int(l.split()[-1])
            assert dmdata == 0
Ejemplo n.º 9
0
    def setUpClass(self):
        self.parfileJ1853 = "J1853+1303_NANOGrav_11yv0.gls.par"
        self.timfileJ1853 = "J1853+1303_NANOGrav_11yv0.tim"
        self.toasJ1853 = toa.get_TOAs(self.timfileJ1853,
                                      ephem="DE421",
                                      planets=False)
        self.modelJ1853 = model.get_model(self.parfileJ1853)
        self.ltres, self.ltbindelay = np.genfromtxt(self.parfileJ1853 + \
                                     '.tempo2_test',skip_header=1, unpack=True)

        self.parfileJ0613 = "J0613-0200_NANOGrav_9yv1_ELL1H.gls.par"
        self.timfileJ0613 = "J0613-0200_NANOGrav_9yv1.tim"
        self.modelJ0613 = model.get_model(self.parfileJ0613)
        self.toasJ0613 = toa.get_TOAs(self.timfileJ0613,
                                      ephem="DE421",
                                      planets=False)
        self.parfileJ0613_STIG = "J0613-0200_NANOGrav_9yv1_ELL1H_STIG.gls.par"
        self.modelJ0613_STIG = model.get_model(self.parfileJ0613_STIG)
Ejemplo n.º 10
0
def test_unset_other_epochs_dm1(caplog):
    caplog.set_level(logging.WARNING)
    with warnings.catch_warnings():
        warnings.simplefilter("error")
        m = models.get_model(io.StringIO("\n".join([test_par, "DM1 1e-10"])))
        assert m.PEPOCH.quantity is not None
        assert m.DMEPOCH.quantity == m.PEPOCH.quantity
        assert m.POSEPOCH.quantity is None
    assert not caplog.records
Ejemplo n.º 11
0
def test_solar_wind_delays_positive():
    model = get_model(StringIO("\n".join([par, "NE_SW 1"])))
    toas = make_fake_toas_uniform(54000,
                                  54000 + year,
                                  13,
                                  model=model,
                                  obs="gbt")
    assert np.all(
        model.components["SolarWindDispersion"].solar_wind_dm(toas) > 0)
Ejemplo n.º 12
0
def test_merge_indices():
    m = get_model(StringIO(simplepar))
    fakes = [
        toa.make_fake_toas(55000, 55500, 5, model=m, obs="ao"),
        toa.make_fake_toas(56000, 56500, 10, model=m, obs="gbt"),
        toa.make_fake_toas(57000, 57500, 15, model=m, obs="@"),
    ]
    toas = toa.merge_TOAs(fakes)
    assert len(set(toas.table["index"])) == len(toas)
def test_unused_noise_model_parameter(param, value):
    model = get_model(io.StringIO("\n".join([par_base, f"{param} TEL ao {value}"])))
    toas = make_fake_toas_uniform(
        58000, 58900, 10, model, obs="barycenter", freq=np.inf
    )
    model.free_params = ["F0"]
    fitter = pint.fitter.GLSFitter(toas, model)
    with pytest.warns(UserWarning, match=param):
        fitter.fit_toas()
Ejemplo n.º 14
0
def test_H3_and_H4_non_zero(toasJ0613):
    """Testing if the different H3, H4 combination breaks the fitting. the
    fitting result will not be checked here.
    """
    simple_model = get_model(StringIO(simple_par))

    test_toas = toasJ0613[::20]
    f = ff.WLSFitter(test_toas, simple_model)
    f.fit_toas()
Ejemplo n.º 15
0
def test_unset_other_epochs(caplog, par):
    caplog.set_level(logging.WARNING)
    with warnings.catch_warnings():
        warnings.simplefilter("error")
        m = models.get_model(io.StringIO(par))
        assert m.PEPOCH.quantity is not None
        assert m.DMEPOCH.quantity is None
        assert m.POSEPOCH.quantity is None
    assert not caplog.records
Ejemplo n.º 16
0
def test_zero_H4(toasJ0613):
    H4_zero_model = get_model(StringIO(simple_par))
    H4_zero_model.H4.value = 0.0
    H4_zero_model.H4.frozen = False
    assert H4_zero_model.H3.value != 0.0
    H4_zero_model.H3.frozen = False
    test_toas = toasJ0613[::20]
    f = ff.WLSFitter(test_toas, H4_zero_model)
    f.fit_toas()
Ejemplo n.º 17
0
def test_zero_H3(toasJ0613):
    H3_zero_model = get_model(StringIO(simple_par))
    H3_zero_model.H3.value = 0.0
    H3_zero_model.H3.frozen = False
    assert H3_zero_model.H4.value != 0.0
    H3_zero_model.H4.frozen = False
    test_toas = toasJ0613[::20]
    with pytest.raises(ValueError):
        ff.WLSFitter(test_toas, H3_zero_model)
Ejemplo n.º 18
0
    def _gen_polyco(self, parfile, MJD_start, segLength = 60.0, ncoeff = 15, \
                       maxha=12.0, method="TEMPO", numNodes=20, usePINT = True):
        """
        This will be a convenience function to generate polycos and subsequent parameters to replace the values in a 
        PSRFITS file header. The default way to do this will be to use PINT (usePINT = True), with other methods
        currently unsupported. The input values are:
        parfile [string] : path to par file used to generate the polycos. The observing frequency, and observatory will 
                            come from the par file
        MJD_start [float] : Start MJD of the polyco. Should start no later than the beginning of the observation
        segLength [float] : Length in minutes of the range covered by the polycos generated. Default is 60 minutes
        ncoeff [int] : number of polyco coeffeicients to generate. Default is 15, the same as in the PSRFITS file
        maxha [float] : max hour angle needed by PINT. Default is 12.0
        method [string] : Method PINT uses to generate the polyco. Currently only TEMPO is supported.
        numNodes [int] : Number of nodes PINT will use to fit the polycos. Must be larger than ncoeff
        usePINT [bool] : Method used to generate polycos. Currently only PINT is supported.
        """
        if usePINT:
            # Define dictionary to put parameters into
            polyco_dict = {'NSPAN': segLength, 'NCOEF': ncoeff}
            # load parfile to PINT model object
            m = models.get_model(parfile)
            # Determine MJD_end based on segLength
            MJD_end = MJD_start + np.double(
                make_quant(segLength, 'min').to('day').value)  # MJD
            # Determine obseratory and observing frequency
            obsFreq = m.TZRFRQ.value  # in MHz
            polyco_dict['REF_FREQ'] = obsFreq
            obs = m.TZRSITE.value  # string
            polyco_dict['NSITE'] = obs.encode(
                'utf-8')  # observatory code needs to be in binary
            # Get pulsar frequency
            polyco_dict['REF_F0'] = m.F0.value
            # get the polycos
            pcs = polycos.Polycos()
            pcs.generate_polycos(m, MJD_start, MJD_end, obs, segLength, ncoeff, obsFreq, maxha=12.0, method="TEMPO", \
                                     numNodes=20)
            coeffs = pcs.polycoTable['entry'][-1].coeffs
            polyco_dict['COEFF'] = coeffs
            # Now we need to determine the reference MJD, and phase
            REF_MJD = np.double(pcs.polycoTable['tmid'][-1])
            polyco_dict['REF_MJD'] = REF_MJD
            # Now find the phase difference
            tmid_toa = toa.get_TOAs_list(
                [toa.TOA(REF_MJD, obs=obs, freq=obsFreq)])
            ref_phase = m.phase(tmid_toa)
            # Need to force positive value
            if ref_phase.frac.value[0] < 0.0:
                ref_frac_phase = 1.0 - abs(ref_phase.frac.value[0])
            else:
                ref_frac_phase = ref_phase.frac.value[0]
            polyco_dict['REF_PHS'] = ref_frac_phase

            return polyco_dict

        else:
            print("Only PINT is currently supported for generating polycos")
            raise NotImplementedError()
Ejemplo n.º 19
0
def test_merge_indices():
    m = get_model(StringIO(simplepar))
    fakes = [
        toa.make_fake_toas(55000, 55500, 5, model=m, obs="ao"),
        toa.make_fake_toas(56000, 56500, 10, model=m, obs="gbt"),
        toa.make_fake_toas(57000, 57500, 15, model=m, obs="@"),
    ]
    toas = toa.merge_TOAs(fakes)
    check_indices_contiguous(toas)
Ejemplo n.º 20
0
def test_renumber_subset():
    m = get_model(StringIO(simplepar))
    toas = toa.make_fake_toas(55000, 55500, 10, model=m, obs="ao")

    sub = toas[1:-1]
    assert 0 not in sub.table["index"]

    sub.renumber()
    assert np.all(sub.table["index"] == np.arange(len(sub)))
Ejemplo n.º 21
0
def test_STIGMA():
    """Should get changed to VARSIGMA for TEMPO/TEMPO2"""
    m = get_model(
        os.path.join(datadir, "J0613-0200_NANOGrav_9yv1_ELL1H_STIG.gls.par"))
    assert (("STIGMA" in m.as_parfile()) and not ("VARSIGMA" in m.as_parfile())
            and not ("STIGMA" in m.as_parfile(format="tempo"))
            and ("VARSIGMA" in m.as_parfile(format="tempo"))
            and not ("STIGMA" in m.as_parfile(format="tempo2"))
            and ("VARSIGMA" in m.as_parfile(format="tempo2")))
Ejemplo n.º 22
0
 def setup(self):
     self.model = get_model("J1614-2230_NANOGrav_12yv3.wb.gls.par")
     self.toas = get_TOAs(
         "J1614-2230_NANOGrav_12yv3.wb.tim", ephem="DE436", bipm_version="BIPM2015"
     )
     self.fit_data_name = ["toa", "dm"]
     self.fit_params_lite = ["F0", "F1", "ELONG", "ELAT", "DMJUMP1", "DMX_0022"]
     self.tempo_res = np.genfromtxt(
         "J1614-2230_NANOGrav_12yv3.wb.tempo_test", comments="#"
     )
Ejemplo n.º 23
0
 def setup(self):
     self.model = get_model("J1614-2230_NANOGrav_12yv3.wb.gls.par")
     self.toas = get_TOAs("J1614-2230_NANOGrav_12yv3.wb.tim")
     toa_backends, valid_flags = self.toas.get_flag_value("fe")
     self.toa_backends = np.array(toa_backends)
     self.dm_jump_params = [
         getattr(self.model, x)
         for x in self.model.params
         if (x.startswith("DMJUMP"))
     ]
Ejemplo n.º 24
0
def test_no_H3_H4(toasJ0613):
    """Test no H3 and H4 in model."""
    no_H3_H4 = simple_par.replace("H4 2.0262048E-7  1       1.1276173E-7", "")
    no_H3_H4 = no_H3_H4.replace("H3 2.7507208E-7  1       1.5114416E-7", "")
    no_H3_H4_model = get_model(StringIO(no_H3_H4))
    assert no_H3_H4_model.H3.value is None
    assert no_H3_H4_model.H4.value is None
    test_toas = toasJ0613[::20]
    f = ff.WLSFitter(test_toas, no_H3_H4_model)
    f.fit_toas()
Ejemplo n.º 25
0
def main(argv=None):
    parser = argparse.ArgumentParser(
        description="PINT tool for command-line parfile format conversions",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
    )
    parser.add_argument("input", help="Input parfile", type=str)

    parser.add_argument(
        "-f",
        "--format",
        help=("Format for output"),
        choices=_parfile_formats,
        default="pint",
    )
    parser.add_argument(
        "-o",
        "--out",
        help=("Output filename [default=stdout]"),
        default=None,
    )
    parser.add_argument(
        "--log-level",
        type=str,
        choices=("TRACE", "DEBUG", "INFO", "WARNING", "ERROR"),
        default="WARNING",
        help="Logging level",
        dest="loglevel",
    )
    args = parser.parse_args(argv)
    log.remove()
    log.add(
        sys.stderr,
        level=args.loglevel,
        colorize=True,
        format=pint.logging.format,
        filter=pint.logging.LogFilter(),
    )

    if not os.path.exists(args.input):
        log.error(f"Cannot open '{args.input}' for reading")
        return

    log.info(f"Reading '{args.input}'")
    model = get_model(args.input)
    output = model.as_parfile(format=args.format)
    if args.out is None:
        # just output to STDOUT
        print(output)
    else:
        with open(args.out, "w") as outfile:
            outfile.write(output)
        log.info(f"Wrote to '{args.out}'")

    return
Ejemplo n.º 26
0
def test_wave():
    parfile = 'J1513-5908_PKS_alldata_white.par'
    timfile = 'J1744-1134.Rcvr1_2.GASP.8y.x.tim'
    t = toa.get_TOAs(timfile, usepickle=False)

    m = tm.get_model(parfile)
    log.info("model.as_parfile():\n%s"%m.as_parfile())

    print(m.as_parfile())
    print(m)
    print(m.delay(t))
Ejemplo n.º 27
0
def test_zero_H3_H4_fit_H3(toasJ0613):
    H3H4_zero2_model = get_model(StringIO(simple_par))
    H3H4_zero2_model.H3.value = 0.0
    H3H4_zero2_model.H3.frozen = False
    H3H4_zero2_model.H4.value = 0.0
    H3H4_zero2_model.H4.frozen = True
    test_toas = toasJ0613[::20]
    f = ff.WLSFitter(test_toas, H3H4_zero2_model)
    # This should work
    f.fit_toas()
    assert f.model.H3.value > 0.0
Ejemplo n.º 28
0
def test_ECL():
    """Should be only IERS2003 for TEMPO2"""
    m = get_model(os.path.join(datadir, "J0613-0200_NANOGrav_9yv1.gls.par"))
    for l in m.as_parfile().split("\n"):
        if "ECL" in l:
            assert l.split()[-1] == "IERS2010"
    for l in m.as_parfile(format="tempo").split("\n"):
        if "ECL" in l:
            assert l.split()[-1] == "IERS2010"
    for l in m.as_parfile(format="tempo2").split("\n"):
        if "ECL" in l:
            assert l.split()[-1] == "IERS2003"
Ejemplo n.º 29
0
def test_T2CMETHOD():
    """Should be commented out in TEMPO2"""
    m = get_model(os.path.join(datadir, "B1855+09_NANOGrav_dfg+12_TAI.par"))
    for l in m.as_parfile().split("\n"):
        if "T2CMETHOD" in l:
            assert not (l.startswith("#"))
    for l in m.as_parfile(format="tempo").split("\n"):
        if "T2CMETHOD" in l:
            assert not (l.startswith("#"))
    for l in m.as_parfile(format="tempo2").split("\n"):
        if "T2CMETHOD" in l:
            assert l.startswith("#")
Ejemplo n.º 30
0
    def setUpClass(cls):
        os.chdir(datadir)
        cls.parfileJ1853 = "J1853+1303_NANOGrav_11yv0.gls.par"
        cls.timfileJ1853 = "J1853+1303_NANOGrav_11yv0.tim"
        cls.toasJ1853 = toa.get_TOAs(cls.timfileJ1853,
                                     ephem="DE421",
                                     planets=False)
        cls.modelJ1853 = model.get_model(cls.parfileJ1853)
        cls.ltres, cls.ltbindelay = np.genfromtxt(cls.parfileJ1853 +
                                                  ".tempo2_test",
                                                  skip_header=1,
                                                  unpack=True)

        cls.parfileJ0613 = "J0613-0200_NANOGrav_9yv1_ELL1H.gls.par"
        cls.timfileJ0613 = "J0613-0200_NANOGrav_9yv1.tim"
        cls.modelJ0613 = model.get_model(cls.parfileJ0613)
        cls.toasJ0613 = toa.get_TOAs(cls.timfileJ0613,
                                     ephem="DE421",
                                     planets=False)
        cls.parfileJ0613_STIG = "J0613-0200_NANOGrav_9yv1_ELL1H_STIG.gls.par"
        cls.modelJ0613_STIG = model.get_model(cls.parfileJ0613_STIG)
Ejemplo n.º 31
0
def get_orbital_correction_from_ephemeris_file(mjdstart, mjdstop, parfile,
                                               ntimes=1000, ephem="DE405",
                                               return_pint_model=False):
    """Get a correction for orbital motion from pulsar parameter file.

    Parameters
    ----------
    mjdstart, mjdstop : float
        Start and end of the time interval where we want the orbital solution
    parfile : str
        Any parameter file understood by PINT (Tempo or Tempo2 format)

    Other parameters
    ----------------
    ntimes : int
        Number of time intervals to use for interpolation. Default 1000

    Returns
    -------
    correction_sec : function
        Function that accepts in input an array of times in seconds and a
        floating-point MJDref value, and returns the deorbited times
    correction_mjd : function
        Function that accepts times in MJDs and returns the deorbited times.
    """
    from scipy.interpolate import interp1d
    from astropy import units
    simon("Assuming events are already referred to the solar system "
          "barycenter (timescale is TDB)")
    if not HAS_PINT:
        raise ImportError("You need the optional dependency PINT to use this "
                          "functionality: github.com/nanograv/pint")

    mjds = np.linspace(mjdstart, mjdstop, ntimes)
    toalist = _load_and_prepare_TOAs(mjds, ephem=ephem)
    m = get_model(parfile)
    delays = m.delay(toalist)
    correction_mjd = \
        interp1d(mjds,
                 (toalist.table['tdbld'] * units.d - delays).to(units.d).value)

    def correction_sec(times, mjdref):
        deorb_mjds = correction_mjd(times / 86400 + mjdref)
        return np.array((deorb_mjds - mjdref) * 86400)

    retvals = [correction_sec, correction_mjd]
    if return_pint_model:
        retvals.append(m)
    return retvals
Ejemplo n.º 32
0
    def loadparfile(self, parfile):
        """
        Load a parfile with pint

        :param parfile:
            Name of the parfile
        """

        self.model = pm.get_model(parfile)
        log.info("model.as_parfile():\n%s"%self.model.as_parfile())

        try:
            self.planets = self.model.PLANET_SHAPIRO.value
        except AttributeError:
            self.planets = False

        self._readparams()
Ejemplo n.º 33
0
    def __init__(self, parfile=None, timfile=None, testpulsar=False):
        """
        Initialize the pulsar object

        @param parfile:     Filename of par file
        @param timfile:     Filename of tim file
        @param testpulsar:  If true, load J1744 test pulsar
        """

        super(PPulsar, self).__init__()

        # Create a timing-model
        self._interface = "pint"
        #m = pm.StandardTimingModel()
        #m = pm.DDTimingModel()
        
        if testpulsar:
            # Write a test-pulsar, and open that for testing
            parfilename = tempfile.mktemp()
            timfilename = tempfile.mktemp()
            parfile = open(parfilename, 'w')
            timfile = open(timfilename, 'w')
            parfile.write(J1744_parfile_basic)
            timfile.write(J1744_timfile)
            parfile.close()
            timfile.close()
        elif parfile is not None and timfile is not None:
            parfilename = parfile
            timfilename = timfile
        else:
            raise ValueError("No valid pulsar to load")

        # We have a par/tim file. Read them in!
        m = pm.get_model(parfilename)
        #m.read_parfile(parfilename)

        print("model.as_parfile():")
        print(m.as_parfile())

        try:
            planet_ephems = m.PLANET_SHAPIRO.value
        except AttributeError:
            planet_ephems = False

        #t0 = time.time()
        t = toa.get_TOAs(timfilename)
        #time_toa = time.time() - t0
        t.print_summary()

        #sys.stderr.write("Read/corrected TOAs in %.3f sec\n" % time_toa)

        self._mjds = t.get_mjds()
        #d_tdbs = np.array([x.tdb.delta_tdb_tt for x in t.table['mjd']])
        self._toaerrs = t.get_errors()
        resids = np.zeros_like(self._mjds)
        #ss_roemer = np.zeros_like(self._mjds)
        #ss_shapiro = np.zeros_like(self._mjds)

        #sys.stderr.write("Computing residuals...\n")
        #t0 = time.time()
        phases = m.phase(t.table)
        resids = phases.frac

        #for ii, tt in enumerate(t.table):
        #    p = m.phase(tt)
        #    resids[ii] = p.frac
        #    ss_roemer[ii] = m.solar_system_geometric_delay(tt)
        #    ss_shapiro[ii] = m.solar_system_shapiro_delay(tt)

        #time_phase = time.time() - t0
        #sys.stderr.write("Computed phases in %.3f sec\n" % time_phase)

        # resids in (approximate) us:
        self._resids_us = resids / float(m.F0.value) * 1e6
        sys.stderr.write("RMS PINT residuals are %.3f us\n" % self._resids_us.std())

        # Create a dictionary of the fitting parameters
        self.pardict = OrderedDict()
        self.pardict['START'] = tempopar('START')
        self.pardict['FINISH'] = tempopar('FINISH')
        self.pardict['RAJ'] = tempopar('RAJ')
        self.pardict['DECJ'] = tempopar('DECJ')
        self.pardict['PMRA'] = tempopar('PMRA')
        self.pardict['PMDEC'] = tempopar('PMDEC')
        self.pardict['F0'] = tempopar('F0')
        self.pardict['F1'] = tempopar('F1')


        if testpulsar:
            os.remove(parfilename)
            os.remove(timfilename)
Ejemplo n.º 34
0
#! /usr/bin/env python
import sys,os
import pint.models as tm

from pinttestdata import testdir, datadir
datadir = os.path.join(testdir,'datafile')
parfile = os.path.join(datadir,'J1744-1134.basic.par')

m = tm.get_model(parfile)

print("model.param_help():")
m.param_help()
print()

print("calling model.read_parfile():")
m.read_parfile(parfile)
print()

print("print model:")
print(m)
print()

print("model.as_parfile():")
print(m.as_parfile())
print()
Ejemplo n.º 35
0
import pint.models as tm
from pint.phase import Phase
from pint import toa
from pint import fitter

#import matplotlib
#matplotlib.use('TKAgg')
import matplotlib.pyplot as plt

import numpy

from pinttestdata import testdir, datadir

# Get model

m = tm.get_model(os.path.join(datadir,'NGC6440E.par'))

# Get TOAs
t = toa.TOAs(os.path.join(datadir,'NGC6440E.tim'))
t.apply_clock_corrections(include_bipm=False)
t.compute_TDBs()
try:
    planet_ephems = m.PLANET_SHAPIRO.value
except AttributeError:
    planet_ephems = False
t.compute_posvels(planets=planet_ephems)

f=fitter.WlsFitter(toas=t,model=m)

# Print initial chi2
print('chi^2 is initially %0.2f' % f.resids.chi2)