def test_write_tim(self): """ Test writing out the .tim file and then reading it back in. """ self.fakepsr.savetim(str(TMP_DIR / "fakepsr.tim")) self.fakepsrtp.savetim(str(TMP_DIR / "fakepsrtp.tim")) self.assertTrue((TMP_DIR / "fakepsr.tim").exists()) self.assertTrue((TMP_DIR / "fakepsrtp.tim").exists()) t2.purgetim(str(TMP_DIR / "fakepsr.tim")) t2.purgetim(str(TMP_DIR / "fakepsrtp.tim")) newfakepsr = t2.tempopulsar(parfile=self.parfile, timfile=str(TMP_DIR / "fakepsr.tim"), dofit=False) newfakepsrtp = t2.tempopulsar(parfile=self.parfile, timfile=str(TMP_DIR / "fakepsrtp.tim"), dofit=False) self.assertEqual(newfakepsrtp.nobs, len(self.obstimes)) self.assertEqual(newfakepsrtp.nobs, newfakepsr.nobs) self.assertEqual(newfakepsrtp.name, "1909-3744") self.assertEqual(newfakepsr.name, "1909-3744") self.assertTrue(np.all(newfakepsrtp.stoas == self.obstimes)) self.assertTrue(np.all(newfakepsrtp.stoas == self.fakepsrtp.stoas)) self.assertTrue(np.all(newfakepsrtp.toas() == self.fakepsrtp.toas())) self.assertTrue(np.all(newfakepsr.stoas == self.fakepsrtp.stoas)) self.assertTrue(np.all(newfakepsr.toas() == newfakepsrtp.toas())) # check residuals are the same self.assertTrue(np.all(newfakepsrtp.residuals() == self.fakepsrtp.residuals())) self.assertTrue(np.all(newfakepsrtp.phaseresiduals() == self.fakepsrtp.phaseresiduals())) self.assertTrue(np.all(newfakepsrtp.residuals() == newfakepsr.residuals()))
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(LTPulsar, self).__init__() self._interface = "libstempo" 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) timfile.write(J1744_timfile) parfile.close() timfile.close() self._psr = lt.tempopulsar(parfilename, timfilename, dofit=False) os.remove(parfilename) os.remove(timfilename) elif parfile is not None and timfile is not None: self._psr = lt.tempopulsar(parfile, timfile, dofit=False) else: raise ValueError("No valid pulsar to load")
def readArray(partimdir, mindist=0.5, maxdist=2.0): """ Read in a list of ptaPulsar objects from a set of par/tim files. Pulsar distances are randomly drawn between two values @param partimdir: Directory of par/tim files @param mindist: Minimum distance of pulsar @param maxdist: Maximum distance of pulsar @return: list of ptapsrs """ ptapsrs = [] curdir = os.getcwd() os.chdir(partimdir) for ii, infile in enumerate(glob.glob(os.path.join('./', 'J*.par') )): filename = os.path.splitext(infile) basename = os.path.basename(filename[0]) parfile = './' + basename +'.par' timfile = './' + basename +'.tim' psr = lt.tempopulsar(parfile, timfile, dofit=False) dist = mindist + np.random.rand(1) * (maxdist - mindist) ptapsrs.append(ptaPulsar(psr['RAJ'].val, psr['DECJ'].val, psr.name, \ psr.toas(), psr.residuals(), \ psr.toaerrs*1.0e-6, 1000*dist)) os.chdir(curdir) return ptapsrs
def setUpClass(cls): cls.obstimes = np.arange(53000, 54800, 10, dtype=np.float128) cls.toaerr = 1e-3 cls.freq = 1440.0 cls.observatory = "ao" cls.parfile = DATA_PATH + "/J1909-3744_NANOGrav_dfg+12.par" # create a fake pulsar using fakepulsar cls.fakepsr = fakepulsar( parfile=cls.parfile, obstimes=cls.obstimes, toaerr=cls.toaerr, freq=cls.freq, observatory=cls.observatory, iters=0, ) # create a fake pulsar using tempopulsar cls.fakepsrtp = t2.tempopulsar( parfile=cls.parfile, toas=cls.obstimes, toaerrs=cls.toaerr, observatory=cls.observatory, obsfreq=cls.freq, dofit=False, )
def setUpClass(self): self.parfileB1855 = 'B1855+09_NANOGrav_dfg+12_modified.par' self.timB1855 = 'B1855+09_NANOGrav_dfg+12.tim' self.toasB1855 = toa.get_TOAs(self.timB1855, ephem="DE405", planets=False) self.modelB1855 = mb.get_model(self.parfileB1855) self.psrB1855 = lt.tempopulsar(self.parfileB1855, self.timB1855) self.ltres = self.psrB1855.residuals()
def add_gwb(self, gwb, dist, InjectionFile="None", verbose=-1): """ Add GW background on simulated TOAs using a GWB object from libstempo and the pulsar distance in kpc.""" if verbose==-1 : verbose = self.verbose if verbose!=0 : print "Add GWB ..." #### Making libstempo.tempopulsar save in parfile and timfile localverbose=0 if verbose>1 : localverbose=1 self.savepar("TmpIdeal", verbose=localverbose) self.savetim("TmpIdeal",IdealTOAs=True, verbose=localverbose) psr = libstempo.tempopulsar(parfile="TmpIdeal.par",timfile="TmpIdeal.tim",dofit=False) #### Creating GWB data GWBval = gwb.add_gwb(psr,dist) #### Adding data fOut = None if InjectionFile!="None": fOut = open(InjectionFile,'w') fOut.write("#TOAIdeal GWB TOARelBeforeInjection TOARelAfterInjection DiffTOAAft-Bef\n") for itoa in xrange(len(self.timTOAs)) : TOABefInj = self.timTOAs[itoa][0] self.timTOAs[itoa][0] += mp.mpf(np.float64(GWBval[itoa]),n=self.prec) if fOut!=None : fOut.write(mp.nstr(self.timTOAsIdeal[itoa][0],n=self.prec)+" "+repr(GWBval[itoa])+" "\ +mp.nstr(TOABefInj-self.timTOAsIdeal[0][0],n=self.prec)+" "\ +mp.nstr(self.timTOAs[itoa][0]-self.timTOAsIdeal[0][0],n=self.prec)+" "\ +mp.nstr(self.timTOAs[itoa][0]-TOABefInj,n=self.prec)+"\n") if fOut!=None : fOut.close()
def test_DMX(self): print "Testing DMX module." rs = residuals.resids(self.toas, self.DMXm).time_resids.to(u.us).value psr = lt.tempopulsar(self.parf, self.timf) resDiff = rs-psr.residuals() assert np.all(resDiff) < 1e-7, \ "PINT and tempo Residual difference is too big. "
def fit(self, pfile, tfile): #,pfile='test.par',tfile='test.tim'): psr = T.tempopulsar(parfile=pfile, timfile=tfile) # print psr.toas(), psr.residuals() i = N.argsort(psr.toas()) self.toas = psr.toas()[i] self.res = psr.residuals()[i] self.toaerr = psr.toaerrs[i] del (psr)
def produce_libstempo_delays(): """Use simulated data of J1955 with TEMPO2 and test if reproducible""" parfile = 'tests/J1955.par' timfile = 'tests/J1955.tim' toas = toa.get_TOAs(timfile, planets=False, usepickle=False) SECS_PER_DAY = 86400 toasld = toas.table['tdbld'] t0 = toasld[0] toaslds = (toasld - t0) * SECS_PER_DAY newmodel = bt.BT() newmodel.read_parfile(parfile) phases = newmodel.phase(toas.table) #t0 = time.time() delays = newmodel.delay(toas.table) psr = lt.tempopulsar(parfile, timfile) t2resids = psr.residuals() btdelay = psr.binarydelay() bttoasld = psr.toas() btt0 = bttoasld[0] bttoaslds = (bttoasld - btt0) * SECS_PER_DAY # HACK (paulr): Flip sign of btdelay to match what PINT uses. Not sure why this is necessary. Should be figured out. btdelay *= -1.0 with open('tests/J1955_ltdelays.dat', 'w') as fobj: for i in range(len(delays)): print("{:.20} {:.20}".format(toaslds[i], btdelay[i]), file=fobj) plt.figure("Delays") plt.plot(toaslds, delays, label='PINT') plt.scatter(toaslds, delays) plt.plot(bttoaslds, btdelay, label='T2') plt.scatter(bttoaslds, btdelay) plt.legend() plt.xlabel('Time (d)') plt.ylabel('Delay (s)') plt.figure("Diff") plt.plot(toaslds, delays - btdelay) plt.scatter(toaslds, delays - btdelay) plt.legend() plt.xlabel('Time (d)') plt.ylabel('Diff (s)') plt.show()
def gettempo2(pulsarfile,pulsardir='.',timsuffix='',summary=None,debug=False): """Load a pickled archive, or use libstempo.pyx to load pulsar data from tempo2 par and tim files.""" pfile = 'pickles/{0}.pickle'.format(pulsarfile) if os.path.isfile(pfile): if debug: print "Using pickled file %s." % pfile return pulsarfile, getpickle(pfile) pulsarfile, parfile, timfile = findtempo2(pulsarfile,pulsardir=pulsardir,timsuffix=timsuffix,debug=debug) import libstempo as T pulsar = T.tempopulsar(parfile,timfile) meta = N.zeros((1,),dtype=[('name','a32'),('ra','f8'),('dec','f8'),('designpars','i4'),('pars','i4')]) meta['name'] = pulsarfile meta['ra'] = pulsar['RAJ'].val meta['dec'] = pulsar['DECJ'].val meta['designpars'] = 0 # really an offset meta['pars'] = len(pulsar.pars) # get data (will make copies) times_f = N.array(pulsar.toas() - pulsar['PEPOCH'].val,'d') # days resid_f = N.array(pulsar.residuals(),'d') # seconds error_f = N.array(1e-6 * pulsar.toaerrs,'d') # seconds freqs_f = N.array(pulsar.freqs,'d') # MHz # get design matrix desi = pulsar.designmatrix() if desi.shape[1] != meta['pars'] + 1: msg = 'The number of fitting parameters ({0}) and the size of design matrix ({1}x{2}) do not match!'.format( meta['pars'],desi.shape[0],desi.shape[1]) raise ValueError, msg # outlier-removal logic # argout = lambda data,m=2: N.abs(data - N.mean(data)) < m * N.std(data) # kx = argout(resid_f,3) # print "Removing {0} TOAs".format(desi.shape[0] - N.sum(kx)) # desi, times_f, resid_f, error_f = desi[kx,:], times_f[kx], resid_f[kx], error_f[kx] # rescale residuals and errors to units of 100 ns (yes, hardcoded) resid_f = resid_f / 1e-7 error_f = error_f / 1e-7 if summary: summary['parfile'] = parfile summary['timfile'] = timfile return pulsarfile,(meta,desi,times_f,resid_f,error_f,freqs_f)
def fakepulsar(parfile, obstimes, toaerr, freq=1440.0, observatory='AXIS', flags='', iters=3): """Returns a libstempo tempopulsar object corresponding to a noiseless set of observations for the pulsar specified in 'parfile', with observations happening at times (MJD) given in the array (or list) 'obstimes', with measurement errors given by toaerr (us). A new timfile can then be saved with pulsar.savetim(). Re the other parameters: - 'toaerr' needs to be either a common error, or a list of errors of the same length of 'obstimes'; - 'freq' can be either a common observation frequency in MHz, or a list; it defaults to 1440; - 'observatory' can be either a common observatory name, or a list; it defaults to the IPTA MDC 'AXIS'; - 'flags' can be a string (such as '-sys EFF.EBPP.1360') or a list of strings; it defaults to an empty string; - 'iters' is the number of iterative removals of computed residuals from TOAs (which is how the fake pulsar is made...)""" import tempfile outfile = tempfile.NamedTemporaryFile(delete=False) outfile.write(b'FORMAT 1\n') outfile.write(b'MODE 1\n') obsname = 'fake_' + os.path.basename(parfile) if obsname[-4:] == '.par': obsname = obsname[:-4] for i, t in enumerate(obstimes): outfile.write('{0} {1} {2} {3} {4} {5}\n'.format( obsname, _geti(freq, i), t, _geti(toaerr, i), _geti(observatory, i), _geti(flags, i)).encode('ascii')) timfile = outfile.name outfile.close() pulsar = libstempo.tempopulsar(parfile, timfile, dofit=False) for i in range(iters): pulsar.stoas[:] -= pulsar.residuals() / 86400.0 pulsar.formbats() os.remove(timfile) return pulsar
def make_fakes(amp, psrcut): datadir = './data/partim/' ## Get parameter noise dictionary noisedir = os.getcwd() + '/data/noisefiles/' noise_params = {} for filepath in glob.iglob(noisedir + '/*.json'): with open(filepath, 'r') as f: noise_params.update(json.load(f)) # print(noise_params) # import par and tim files into parfiles and timfiles tempopsr = [] print('Importing to libstempo....') for psr in psrcut: parfiles = sorted(glob.glob(datadir + psr.name + '*.par')) timfiles = sorted(glob.glob(datadir + psr.name + '*.tim')) psr = libs.tempopulsar(parfile=parfiles[0], timfile=timfiles[0], maxobs=50000) tempopsr.append(psr) print('adding efac') for psr in tempopsr: LT.make_ideal(psr) LT.add_efac(psr, efac=1.0) print('adding red noise') for psr in tempopsr: # print(psr.name) rednoise_toadd = noise_params[str(psr.name) + '_log10_A'] # print(psr.name) gamma = noise_params[str(psr.name) + '_gamma'] LT.add_rednoise(psr, 10**rednoise_toadd, gamma, components=30) psr.fit() print('adding GWB') LT.createGWB(tempopsr, Amp=amp, gam=13. / 3.) for psr in tempopsr: psr.fit() # save the pulsars pardir = './fakes_gwb/par/' timdir = './fakes_gwb/tim/' if not os.path.exists(pardir): os.makedirs(pardir) os.makedirs(timdir) print('fixing tim files') for psr in tempopsr: psr.savepar(pardir + psr.name + '-sim.par') psr.savetim(timdir + psr.name + '-sim.tim') libs.purgetim(timdir + psr.name + '-sim.tim') # fix the tim files
def test_astropy_array(self): """ Test passing TOAs as an astropy Time array. """ times = Time(self.obstimes, format="mjd", scale="utc") psr = t2.tempopulsar( parfile=self.parfile, toas=times, toaerrs=self.toaerr, observatory=self.observatory, obsfreq=self.freq, ) self.assertEqual(len(self.obstimes), psr.nobs) self.assertTrue(np.all(self.obstimes == self.fakepsr.stoas)) self.assertTrue(np.all(psr.stoas == self.fakepsr.stoas)) self.assertEqual(psr.stoas[0].dtype, np.float128)
def test_single_values(self): """ Test passing single value TOAs. """ psr = t2.tempopulsar( parfile=self.parfile, toas=self.obstimes[0], toaerrs=self.toaerr, observatory=self.observatory, obsfreq=self.freq, ) self.assertEqual(psr.nobs, 1) self.assertEqual(len(psr.stoas), 1) self.assertTrue(np.all(self.fakepsr.stoas[0] == psr.stoas[0])) self.assertEqual(psr.stoas[0].dtype, np.float128)
def __init__(self, parfile, timfile): # initialize libstempo object t2psr = t2.tempopulsar(parfile, timfile, maxobs=30000, ) # get attributes self.name = t2psr.name self.residuals = np.double(t2psr.residuals()) self.toas = np.double(t2psr.toas()*86400) self.toaerrs = np.double(t2psr.toaerrs*1e-6) self.flags = t2psr.flagvals('f') Mmat = np.double(t2psr.designmatrix()) # sort self.isort, self.iisort = utils.argsortTOAs(self.toas, self.flags, which='jitterext', dt=1.0) self.toas = self.toas[self.isort] self.toaerrs = self.toaerrs[self.isort] self.residuals = self.residuals[self.isort] self.flags = self.flags[self.isort] Mmat = Mmat[self.isort, :] u, s, v = np.linalg.svd(Mmat, full_matrices=False) self.Musvd = u self.Mssvd = s # get sky location pars = t2psr.pars() if 'RAJ' not in pars and 'DECJ' not in pars: elong, elat = t2psr['ELONG'].val, t2psr['ELAT'].val ec = ephem.Ecliptic(elong, elat) # check for B name if 'B' in t2psr.name: epoch = '1950' else: epoch = '2000' eq = ephem.Equatorial(ec, epoch=epoch) self.phi = np.double([eq.ra]) self.theta = np.pi/2 - np.double([eq.dec]) else: self.phi = np.double(t2psr['RAJ'].val) self.theta = np.pi/2 - np.double(t2psr['DECJ'].val)
def readRealisations(path): """ Uses the libstempo package to make tempo2 read a set of par/tim files in a specific directory. The package libstempo can be found at: https://github.com/vallis/mc3pta/tree/master/stempo credit: Michele Vallisneri The directory 'path' will be scanned for .par files and similarly named .tim files. @param path: path to the directory with par/tim files """ psrs = [] for infile in glob.glob(os.path.join(path, '*.par')): filename = os.path.splitext(infile) psrs.append(T.tempopulsar(parfile=filename[0]+'.par',timfile=filename[0]+'.tim')) return psrs
def get_tempo2_result(parfile, timfile, general2=None): """This function is to get the results from tempo and write them to a file. Parameter --------- parfile : str The file to read parameters. timfile : str The file to read toas. general2 : list/ None The values required from tempo2 general2 plugin. Return ---------- A file named as parfile name ends with '.tempo2_test' stored residuals in the first column, binary delay in the second column and general2 results if general2 are provided. """ psr = lt.tempopulsar(parfile, timfile) residuals = psr.residuals() binary_delay = psr.binarydelay() outfile = parfile + '.tempo2_test' f = open(outfile, 'w') outstr = 'residuals BinaryDelay ' if general2 is not None and general2 != []: if not has_tempo2_utils: raise ImportError("To get tempo2 general2 results, tempo2_utils are" " required. See page" " https://github.com/demorest/tempo_utils") else: tempo2_vals = t2u.general2(parfile, timfile, general2) for keys in general2: outstr += keys+' ' outstr += '\n' f.write(outstr) for ii in range(len(residuals)): outstr = longdouble2string(residuals[ii]) + ' ' +longdouble2string(binary_delay[ii]) +' ' if general2 is not None: for keys in general2: outstr += longdouble2string(tempo2_vals[keys][ii])+' ' outstr += '\n' f.write(outstr) f.close()
def __init__(self, parfiles, timfiles, ephem='DE436',verbose=True): #### Make a list of libstempo.tempopulsar objects. libs_psrs = [] for p, t in zip(parfiles, timfiles): psr = T2.tempopulsar(p, t, ephem=ephem, maxobs=30000) libs_psrs.append(psr) if verbose: print('\rPSR {0} loaded.'.format(psr_name(p)), flush=True,end='') print('') self.libs_psrs = libs_psrs self.psrs = None self.ephem = ephem self.first_toa = np.amin([p.toas().min() for p in libs_psrs]) self.last_toa = np.amax([p.toas().max() for p in libs_psrs]) self.toa_cuts = [self.last_toa] self.gwb_added = False
def readRealisations(path): """ Uses the libstempo package to make tempo2 read a set of par/tim files in a specific directory. The package libstempo can be found at: https://github.com/vallis/mc3pta/tree/master/stempo credit: Michele Vallisneri The directory 'path' will be scanned for .par files and similarly named .tim files. @param path: path to the directory with par/tim files """ psrs = [] for infile in glob.glob(os.path.join(path, '*.par')): filename = os.path.splitext(infile) psrs.append( T.tempopulsar(parfile=filename[0] + '.par', timfile=filename[0] + '.tim')) return psrs
def fakepulsar(parfile,obstimes,toaerr,freq=1440.0,observatory='AXIS',flags=''): """Returns a libstempo tempopulsar object corresponding to a noiseless set of observations for the pulsar specified in 'parfile', with observations happening at times (MJD) given in the array (or list) 'obstimes', with measurement errors given by toaerr (us). A new timfile can then be saved with pulsar.savetim(). Re the other parameters: - 'toaerr' needs to be either a common error, or a list of errors of the same length of 'obstimes'; - 'freq' can be either a common observation frequency in MHz, or a list; it defaults to 1440; - 'observatory' can be either a common observatory name, or a list; it defaults to the IPTA MDC 'AXIS'; - 'flags' can be a string (such as '-sys EFF.EBPP.1360') or a list of strings; it defaults to an empty string.""" import tempfile outfile = tempfile.NamedTemporaryFile(delete=False) outfile.write('FORMAT 1\n') outfile.write('MODE 1\n') obsname = 'fake_' + os.path.basename(parfile) if obsname[-4:] == '.par': obsname = obsname[:-4] for i,t in enumerate(obstimes): outfile.write('{0} {1} {2} {3} {4} {5}\n'.format( obsname,_geti(freq,i),t,_geti(toaerr,i),_geti(observatory,i),_geti(flags,i) )) timfile = outfile.name outfile.close() pulsar = libstempo.tempopulsar(parfile,timfile,dofit=False) pulsar.stoas[:] -= pulsar.residuals(updatebats=False) / 86400.0 os.remove(timfile) return pulsar
def getBaryCorrs(self): newpar = open('bary.par', 'w') newpar.write("PSRJ J0000+0000\n") newpar.write("RAJ " + str(self.RA) + " 0\n") newpar.write("DECJ " + str(self.Dec) + " 0\n") newpar.write("F0 1.0 0 \n") newpar.write("PEPOCH " + str(self.RefMJD) + "\n") newpar.write("POSEPOCH " + str(self.RefMJD) + "\n") newpar.write("DMEPOCH " + str(self.RefMJD) + "\n") newpar.write("DM " + str(self.DM) + " 0\n") newpar.write("EPHVER 5\n") newpar.write("CLK UNCORR\n") newpar.write("MODE 1\n") newpar.write("EPHEM DE421\n") newpar.close() newtim = open('bary.tim', 'w') tstep = 10.0 start = self.RefMJD stop = self.RefMJD + (self.NSamps * self.TSamp + tstep) / 24 / 60 / 60 N = np.floor((stop - start) * 24 * 60 * 60 / tstep).astype(int) x = np.linspace(start, stop, N) newtim.write("FORMAT 1\n") for i in range(len(x)): newtim.write("barytim " + str(self.LowChan) + " " + str(x[i]) + " 0.1 pks\n") newtim.close() psr = T.tempopulsar(parfile='bary.par', timfile='bary.tim') psr.fit() BCorrs = psr.batCorrs() self.BCorrs = np.zeros([2, len(BCorrs)]) self.BCorrs[0] = (psr.stoas).copy() self.BCorrs[1] = BCorrs.copy() * 24 * 60 * 60 os.remove('bary.par') os.remove('bary.tim')
# module import import pystan import numpy as np import pylab as py import pandas as pd import numpy as np import matplotlib.pyplot as plt import numpy as np from libstempo.libstempo import * import libstempo as T #First load pulsar. We need the sats (separate day/second), and the file names of the archives (FNames) psr = T.tempopulsar(parfile="../TempoNest/Examples/Example2/J0030+0451.par", timfile = "../TempoNest/Examples/Example2/J0030+0451.tim") psr.fit() NToAs = psr.nobs toas=psr.toas() residuals = np.float64(psr.residuals()) errs=psr.toaerrs*(10.0**-6) #Check how many timing model parameters we are fitting for (in addition to phase) numTime=len(psr.pars())+1 redChisq = psr.chisq()/(psr.nobs-len(psr.pars())-1) TempoPriors=np.zeros([numTime,2]).astype(np.float64) TempoPriors[0][0] = 0 TempoPriors[0][1] = 1.0/np.sqrt(np.sum(1.0/(psr.toaerrs*10.0**-6)**2)) for i in range(1,numTime):
def __init__(self,parfile,timfile=None,refpsr=None,verbose=0): """ used to simulate a pulsar from a reference pulsar defined by its parfile OR by a libstempo.tempopulsar . The TOAs are created from existing TOAs (timfile or tempopulsar). """ self.niter = 5 self.prec = 25 mp.mp.dps = self.prec self.verbose = verbose #### Checking parfile if not os.path.isfile(parfile): print "ERROR : No such file",parfile sys.exit(1) #### Checking tempopulsar and timfile. If it's a libstempo.tempopulsar create a local tim file if refpsr!=None : timfile = "Tmp.tim" refpsr.savetim(timfile) else: if not os.path.isfile(timfile): print "ERROR : No such file",timfile sys.exit(1) refpsr = libstempo.tempopulsar(parfile=parfile,timfile=timfile,dofit=False) #### Extracting list of backend self.syslist = refpsr.listsys() self.psrname = refpsr.name if verbose!=0 : print "Pulsar :", self.psrname if verbose!=0 : print "Backend :",self.syslist #### Extracting EFAC, EQUAD, RN and DM from TN parameters in the parfile and remove them from the parfile if verbose!=0 : print "EFAC, EQUAD, RN and DM read in parfile",parfile self.EFAC = np.ones(len(self.syslist)) self.EQUAD = np.zeros(len(self.syslist)) self.RNAmp = 0. self.RNGam = 1.1 self.DMAmp = 0. self.DMGam = 1.1 fIn = open(parfile,'r') lines = fIn.readlines() fIn.close() self.parlines = [] self.parlinesTNEFEEQ = [] self.parlinesTNRNDM = [] for line in lines: w = re.split("\s+",line) if w[0]=="TNEF" or w[0]=="TNEQ" : self.isTNEFEQ = True iSys = -1 for i in xrange(len(self.syslist)): if self.syslist[i]==w[2]: iSys = i if iSys == -1 : print "ERROR : Load TNEF and TNEQ : the sys",w[2],"from",w,"has not been found in",self.syslist sys.exit(1) if w[0]=="TNEF": self.EFAC[iSys] = float(w[3]) if w[0]=="TNEQ": self.EQUAD[iSys] = 10**float(w[3]) if w[0]=="TNRedAmp" : self.RNAmp = 10**float(w[1]) if w[0]=="TNRedGam" : self.RNGam = float(w[1]) if w[0]=="TNDMAmp" : self.DMAmp = 10**float(w[1]) if w[0]=="TNDMGam" : self.DMGam = float(w[1]) if w[0]=="TNEF" or w[0]=="TNEQ": self.parlinesTNEFEEQ.append(line) elif w[0]=="TNRedAmp" or w[0]=="TNRedGam" or w[0]=="TNDMAmp" or w[0]=="TNDMGam" : self.parlinesTNRNDM.append(line) else: self.parlines.append(line) if verbose!=0 : for i in xrange(len(self.syslist)): print "\t -",self.syslist[i],": EFAC =",self.EFAC[i]," EQUAD =",self.EQUAD[i] print "\t - Red noise : amplitude =",self.RNAmp," gamma =",self.RNGam print "\t - DM : amplitude =",self.DMAmp," gamma =",self.DMGam #### Extracting list of toas and timlines : # The data are store in timTOAs, each element containing : # toas in mpmath format, errs in mpmath format, sys, words of original line, observation frequency self.timHead = [] self.timTOAs = [] self.loadtim(timfile) #### Idealizing each backend for xSys in self.syslist : if verbose!=0 : print "Idealizing backend",xSys,"..." localverbose = 0 if verbose>1 : localverbose = 1 for ite in xrange(self.niter): ### Using libstempo.tempopulsar to get residuals self.savepar("TmpSys", verbose=localverbose) self.savetim("TmpSys", xSys, verbose=localverbose) psrS = libstempo.tempopulsar(parfile="TmpSys.par",timfile="TmpSys.tim",dofit=False) res = psrS.residuals() ### Substract residuals k=0 for itoa in xrange(len(self.timTOAs)) : if self.timTOAs[itoa][2]==xSys : self.timTOAs[itoa][0] -= mp.mpf(repr(res[k])) / mp.mpf('86400.') k += 1 ### Substract residuals to libstempo.tempopulsar just to compute RMS if verbose>1 : print "\t - iteration %d : before : rms = %e" % ( ite, psrS.rms()) psrS.stoas[:] -= res / 86400. if verbose>1 : print "\t - iteration %d : after : rms = %e , residuals mean (std) = %e (%e) s" % ( ite, psrS.rms(), np.mean(res), np.std(res) ) #### Keep ideal TOAs in memory to be the basis of self.timTOAsIdeal = copy.deepcopy(self.timTOAs)
pulsars.sort() print pulsars ################################################################################################################################ # PASSING THROUGH TEMPO2 VIA libstempo ################################################################################################################################ if args.mean_or_max == 'mean': par_ext = 'Mean' elif args.mean_or_max == 'max': par_ext = 'ML' t2psr=[] for ii in range(len(pulsars)): os.chdir(path+'/'+pulsars[ii]) if os.path.isfile('{0}_NoAFB.par'.format(pulsars[ii])): t2psr.append(T2.tempopulsar(parfile=path+'/'+pulsars[ii]+'/'+pulsars[ii]+'_TD.{0}.par'.format(par_ext),\ timfile=path+'/'+pulsars[ii]+'/'+pulsars[ii]+'_NoAFB.tim')) else: t2psr.append(T2.tempopulsar(parfile=path+'/'+pulsars[ii]+'/'+pulsars[ii]+'_TD.{0}.par'.format(par_ext),\ timfile=path+'/'+pulsars[ii]+'/'+pulsars[ii]+'_all.tim')) os.chdir(path) t2psr[ii].fit(iters=10) if np.any(np.isfinite(t2psr[ii].residuals())==False)==True: os.chdir(path+'/'+pulsars[ii]) if os.path.isfile('{0}_NoAFB.par'.format(pulsars[ii])): t2psr[ii] = T2.tempopulsar(parfile=path+'/'+pulsars[ii]+'/'+pulsars[ii]+'_TD.{0}.par'.format(par_ext),\ timfile=path+'/'+pulsars[ii]+'/'+pulsars[ii]+'_NoAFB.tim') else: t2psr[ii] = T2.tempopulsar(parfile=path+'/'+pulsars[ii]+'/'+pulsars[ii]+'_TD.{0}.par'.format(par_ext),\ timfile=path+'/'+pulsars[ii]+'/'+pulsars[ii]+'_all.tim') os.chdir(path)
def main(): save_path = sys.argv[2] try: completeName = os.path.join( save_path, sys.argv[3] ) except IndexError: completeName = os.path.join( save_path, "CorrelationDATA.txt" ) outFile = open( completeName, 'w' ) pList = [] FILES = os.listdir( sys.argv[1] ) FILESpar = [ x for x in FILES if x.endswith(".par") ] FILEStim = [ x for x in FILES if x.endswith(".tim") ] for par in FILESpar: for tim in FILEStim: if par.split('.')[0] == tim.split('.')[0]: pList.append( ( par, tim ) ) T.data = sys.argv[1] DATA = [] # DATA[i] contains two lists - first one has all TOAs, second one has all residuals COOR = [] # COOR[i] contains celestial coordinates (tuple) of pulsar i for i in range( len( pList ) ): PSR = T.tempopulsar( parfile = T.data+pList[i][0], timfile = T.data+pList[i][1], maxobs = 100000 ) try: # different data sets use different coordinate systems PSR['RAJ'].val COOR.append( (PSR['RAJ'].val, PSR['DECJ'].val) ) except KeyError: COOR.append( copy.copy( Ecl2Cel( PSR['ELONG'].val, PSR['ELAT'].val, PSR['POSEPOCH'].val ) ) ) ok = False FILES = os.listdir( save_path ) for X in FILES: if X[:len( X )-23] == PSR.name: currFile = open( os.path.join( save_path, X ), "r" ) ok = True if( not ok ): os.system( "python Average_Epochs.py "+T.data+pList[i][0]+" "+T.data+pList[i][1]+" "+save_path ) currFile = open( os.path.join( save_path, PSR.name+"Output_for_plotting.tim" ), "r" ) toas = [] resid = [] lines = currFile.readlines()[7:] for line in lines: toas.append( float( line.split('\t')[0] ) ) resid.append( float( line.split('\t')[1] ) ) currFile.close() DATA.append( [ copy.copy( toas ), copy.copy( resid ) ] ) # send a copy because DATA[i] points to objects del PSR gc.collect() # free up some memory DATA[i] = [ [ DATA[i][0][x], DATA[i][1][x] ] for x in range( len( DATA[i][0] ) ) ] DATA[i].sort( key = lambda row: row[0] ) # sort by TOAs nPSR = len( pList ) # number of all pulsars for i in range( nPSR-1 ): for j in range( i+1, nPSR ): C = find_C( DATA[i], DATA[j] ) # find correlation between pulsar i and pulsar j ANG_SEP = angsep( COOR[i], COOR[j] ) # find angular separation between pulsar i and pulsar j if C != -500: # C becomes -500 when there is not enough residuals to calculate the correlation outFile.write( str( ANG_SEP )+" "+str( C )+"\n" ) outFile.close() try: where = sys.argv[3] if where[-4] != '.': where += ".txt" os.system( "python HD_Plot.py "+sys.argv[1]+" "+sys.argv[2]+" "+where ) except IndexError: os.system( "python HD_Plot.py "+sys.argv[1]+" "+sys.argv[2]+" "+"CorrelationDATA.txt" )
else: fnoi.write(p+" EQUAD global "+str(EQg)+" -1\n") if not options.UseTNEFEQ : for x in EFEQs : fnoi.write(p+" EFAC "+x[0]+" "+str(x[1])+" -1\n") fnoi.write(p+" EQUAD "+x[0]+" "+str(x[2])+" -1\n") fnoi.close() ##### Checking plots if options.Plots : Npsrfits = 10 ### Loading the original pulsar psr_o = T.tempopulsar(parfile=DirInSub+"/"+parfile,timfile=DirInSub+"/"+timfile) for i in xrange(Npsrfits): psr_o.fit() toas_d_o = psr_o.toas() # days res_o = 1.0e6*psr_o.residuals() # microseconds errs_o = psr_o.toaerrs # microseconds toas_yr_o = 2014+(toas_d_o-RefMJD_d)/365.25 rms_o = psr_o.rms()*1e6 """ ### Loading the simulated pulsar psr_n = T.tempopulsar(parfile=DirSimu+"/"+p+".par",timfile=DirSimu+"/"+p+".tim",dofit=False) toas_d_n = psr_n.toas() # days res_n = 1.0e6*psr_n.residuals() # microseconds errs_n = psr_n.toaerrs # microseconds toas_yr_n = 2014+(toas_d_n-RefMJD_d)/365.25
def addDistance(self, parfile, timfile, distfile): """ Add puslar distance and uncertainty from file. """ # Check whether the two files exist if not os.path.isfile(parfile) or not os.path.isfile(timfile): raise IOError, "Cannot find parfile (%s) or timfile (%s)!" % (parfile, timfile) assert(self.filename != None), "ERROR: HDF5 file not set!" # 'a' means: read/write if exists, create otherwise self.h5file = h5.File(self.filename, 'a') # Create the data subgroup if it does not exist if "Data" in self.h5file: datagroup = self.h5file["Data"] else: raise IOError, "Cannot add noise parameters if Data group does not exist!" # Load pulsar data from the JPL Cython tempo2 library t2pulsar = t2.tempopulsar(parfile, timfile) # Create the pulsar subgroup if it does not exist if "Pulsars" in datagroup: pulsarsgroup = datagroup["Pulsars"] else: raise IOError, "Cannot add noise parameters if pulsar group does not exist!" # Look up the name of the pulsar, and see if it exist if t2pulsar.name in pulsarsgroup: pass else: raise IOError, "%s must already exists in %s to add noise parameters!"\ % (t2pulsar.name, self.filename) pulsarsgroup = pulsarsgroup[t2pulsar.name] # find distance and uncertainty from file dfile = open(distfile,'r') dist = None distErr = None for line in dfile.readlines(): if t2pulsar.name in line or 'J' + t2pulsar.name in line or 'B' + t2pulsar.name in line: dist = float(line.split()[1]) distErr = float(line.split()[2]) # add distance to file if found if dist is not None and distErr is not None: pulsarsgroup.create_dataset('dist', data=dist) pulsarsgroup.create_dataset('distErr', data=distErr) else: print "Cannot find PSR {0} in distance file {1}. Using dist = 1kpc with 10% uncertainty".format(t2pulsar.name, distfile) pulsarsgroup.create_dataset('dist', data=1.0) pulsarsgroup.create_dataset('distErr', data=0.1) self.h5file.close() dfile.close()
float( B ) return True except ValueError: return False def remove_empty( A ): ret = [] for i in range( len( A ) ): if A[i] != "": ret.append( A[i] ) return ret inFile = open( sys.argv[2], "r" ) # the .tim file All_Lines = inFile.readlines() psr = T.tempopulsar( parfile = sys.argv[1], timfile = sys.argv[2], maxobs = 100000 ) start = float( sys.argv[3] ) # start and end frequency end = float( sys.argv[4] ) save_path = sys.argv[5] if not save_path.endswith('.tim'): nameFile = os.path.join( save_path, "FreqRange_"+sys.argv[2].split("/")[-1] ) else: nameFile = save_path outFile = open( nameFile, "w" ) # outfile that will contain the filtered frequencies outFile.write('FORMAT 1\n') cnt = 0 for i in range( len( All_Lines ) ): X = All_Lines[i].split(' ')
import pint.toa as toa import libstempo as lt import matplotlib.pyplot as plt import tempo2_utils import astropy.units as u from pint.residuals import resids import numpy as np import os, unittest datapath = os.path.join(os.environ['PINT'],'tests','datafile') # Using Nanograv data B1855 parfile = os.path.join(datapath, 'B1855+09_NANOGrav_dfg+12_modified.par') timfile = os.path.join(datapath, 'B1855+09_NANOGrav_dfg+12.tim') # libstempo calculation print "libstempo calculation" psr = lt.tempopulsar(parfile, timfile) # Build PINT model print "PINT calculation" mdd = mb.get_model(parfile) # Get toas to pint toas = toa.get_TOAs(timfile, planets=True) tt = toas.table # Run tempo2 general2 pluging tempo2_vals = tempo2_utils.general2(parfile, timfile, ['tt2tb', 'roemer', 'post_phase', 'shapiro', 'shapiroJ','bat','clock0', 'clock1','clock2','clock3','clock4','sat', 'tropo']) # compute residules t2_resids = tempo2_vals['post_phase'] / float(mdd.F0.value) * 1e6 * u.us presids_us = resids(toas, mdd).time_resids.to(u.us)
parFile = [pulsargroup[key]['parFile'].value for key in pulsargroup] timFile = [pulsargroup[key]['timFile'].value for key in pulsargroup] # close hdf5 file pfile.close() # check to make sure same number of tim and par files if len(parFile) != len(timFile): raise IOError, "Need same number of par and tim files!" # check to make sure same number of tim/par files as was in hdf5 file if len(parFile) != npsr: raise IOError, "Different number of pulsars in par directory and hdf5 file!" # run tempo2 pp = [t2.tempopulsar(parFile[ii],timFile[ii]) for ii in range(npsr)] # finally check to make sure that they are the same pulsars for ct,p in enumerate(psr): if p.name not in [ps.name for ps in pp]: raise IOError, "PSR {0} not found in hd5f file!".format(p.name) # make sure pulsar names are in correct order # TODO: is this a very round about way to do this? index = [] for ct,p in enumerate(pp): if p.name == psr[ct].name: index.append(ct) else: for ii in range(npsr):
noisefiles = [ x for x in noisefiles if x.split('/')[-1].split('_')[0] in psrlist ] print(len(parfiles), len(timfiles), len(noisefiles)) ####################################### # PASSING THROUGH TEMPO2 VIA libstempo ####################################### t2psr = [] for ii in range(len(parfiles)): t2psr.append( T2.tempopulsar(parfile=parfiles[ii], timfile=timfiles[ii], maxobs=30000, ephem='DE436')) if np.any(np.isfinite(t2psr[ii].residuals()) == False) == True: t2psr[ii] = T2.tempopulsar(parfile=parfiles[ii], timfile=timfiles[ii]) print('\r{0} of {1}'.format(ii + 1, len(parfiles)), flush=True, end='') noise_params = {} for nf in noisefiles: noise_params.update(get_noise_from_pal2(nf)) #Now parse this large dictionary so that we can call noise parameters as noise_dict[pulsar name][noise type] #Returns either floats or 2 column arrays of flags and values. noise_dict = {}
from triplot import getsigmalevels, makesubplot2d from pylab import * import matplotlib.pyplot as plt import numpy as np import os, sys import libstempo #data = np.load('1950.before.npz') data = np.load('1950.after.npz') fitpars = list(data['fitpars']) res = data['res'] #psr = libstempo.tempopulsar(parfile='before_DDGR.par', timfile='J1950+2414_T2.tim') psr = libstempo.tempopulsar(parfile='after_DDGR.par', timfile='1950.all.tim') psr.fit() pars = psr.pars() vals = psr.vals() errs = psr.errs() fitidx = [i for i,p in enumerate(pars) if p in fitpars ] #print fitidx vals0 = vals[fitidx] errs0 = errs[fitidx] parsize = vals0.size #print parsize #print 'fit for: ', fitpars plist = fitpars MarkovChain = res[:,1:] MCMCSize = len(MarkovChain)
def addInverseCovFromNoiseFile(self, parfile, timfile, noisefile, DMOFF=None, DMXOFF=None, dailyAverage=False): """ Add noise covariance matrix after timing model subtraction. """ # Check whether the two files exist if not os.path.isfile(parfile) or not os.path.isfile(timfile): raise IOError, "Cannot find parfile (%s) or timfile (%s)!" % (parfile, timfile) assert(self.filename != None), "ERROR: HDF5 file not set!" # 'a' means: read/write if exists, create otherwise self.h5file = h5.File(self.filename, 'a') # Create the data subgroup if it does not exist if "Data" in self.h5file: datagroup = self.h5file["Data"] else: raise IOError, "Cannot add noise parameters if Data group does not exist!" # Load pulsar data from the JPL Cython tempo2 library t2pulsar = t2.tempopulsar(parfile, timfile) # turn off DMMODEL fitting if DMOFF is not None: t2pulsar['DMMODEL'].fit = False # turn off DMX fitting if DMXOFF is not None: DMXFlag = False print 'Turning off DMX fitting and turning DM fitting on' for par in t2pulsar.pars: if 'DMX' in par: t2pulsar[par].fit = False t2pulsar['DM'].fit = True DMXFlag = True if DMXFlag== False: print 'NO DMX for pulsar {0}'.format(t2pulsar.name) # refit 5 times to make sure we are converged t2pulsar.fit(iters=5) # Create the pulsar subgroup if it does not exist if "Pulsars" in datagroup: pulsarsgroup = datagroup["Pulsars"] else: raise IOError, "Cannot add noise parameters if pulsar group does not exist!" # Look up the name of the pulsar, and see if it exist if t2pulsar.name in pulsarsgroup: pass else: raise IOError, "%s must already exists in %s to add noise parameters!"\ % (t2pulsar.name, self.filename) pulsarsgroup = pulsarsgroup[t2pulsar.name] # first create G matrix from design matrix and toas designmatrix = np.double(t2pulsar.designmatrix()) toas = np.double(t2pulsar.toas()*86400) errs = np.double(t2pulsar.toaerrs*1e-6) # if doing daily averaging if dailyAverage: # get average quantities toas, qmatrix, errs, dmatrix, freqs, bands = PALutils.dailyAverage(t2pulsar) # construct new daily averaged residuals and designmatrix toas *= 86400 designmatrix = np.dot(qmatrix, dmatrix) G = PALutils.createGmatrix(designmatrix) # create matrix of time lags tm = PALutils.createTimeLags(toas, toas, round=True) # now read noise file to get model and parameters file = open(noisefile,'r') fH = None tau = None DMAmp = None DMgam = None for line in file.readlines(): # default parameters for different models other than pure PL key = line.split()[0] # get amplitude if "Amp" == key: Amp = float(line.split()[-1]) # get spectral index elif "gam" == key: gam = float(line.split()[-1]) # get efac elif "efac" == key: efac = float(line.split()[-1]) # get quad elif "equad" == key: equad = float(line.split()[-1]) # get high frequency cutoff if available elif "fH" == key: fH = float(line.split()[-1]) # get correlation time scale if available elif "tau" == key: tau = float(line.split()[-1]) # get DM Amplitude if available elif "DMAmp" == key: DMAmp = float(line.split()[-1]) # get DM Spectral Index if available elif "DMgam" == key: DMgam = float(line.split()[-1]) # cosstruct red and white noise covariance matrices red = PALutils.createRedNoiseCovarianceMatrix(tm, Amp, gam, fH=fH) white = PALutils.createWhiteNoiseCovarianceMatrix(errs, efac, equad, tau=tau) # construct post timing model marginalization covariance matrix cov = red + white pcov = np.dot(G.T, np.dot(cov, G)) # finally construct "inverse" invCov = np.dot(G, np.dot(np.linalg.inv(pcov), G.T)) # create dataset for inverse covariance matrix pulsarsgroup.create_dataset('invCov', data = invCov) # create dataset for G matrix pulsarsgroup.create_dataset('Gmatrix', data = G) # record noise parameter values pulsarsgroup.create_dataset('Amp', data = Amp) pulsarsgroup.create_dataset('gam', data = gam) pulsarsgroup.create_dataset('efac', data = efac) pulsarsgroup.create_dataset('equad', data = equad) if fH is not None: pulsarsgroup.create_dataset('fH', data = fH) if tau is not None: pulsarsgroup.create_dataset('tau', data = tau) if DMAmp is not None: pulsarsgroup.create_dataset('DMAmp', data = DMAmp) if DMgam is not None: pulsarsgroup.create_dataset('DMgam', data = DMgam) # Close the hdf5 file self.h5file.close()
parfiles = [] timfiles = [] for file in sorted(glob.glob(args.datapath+"/*.par")): parfiles.append(file) for file in sorted(glob.glob(args.datapath+"/*.tim")): timfiles.append(file) print parfiles, timfiles ################################################################################################################################ # PASSING THROUGH TEMPO2 VIA libstempo ################################################################################################################################ t2psr=[] for ii in range(len(parfiles)): t2psr.append(T2.tempopulsar(parfile=parfiles[ii], timfile=timfiles[ii])) #t2psr[ii].fit(iters=10) #if np.any(np.isfinite(t2psr[ii].residuals())==False)==True: # t2psr[ii] = T2.tempopulsar(parfile=parfiles[ii], timfile=timfiles[ii]) # storing red-noise amplitude (nano style), # gamma (nano style), white-noise level (microseconds) # [from Arzoumanian et al. (2015a)] active_psrs = OrderedDict.fromkeys([p.name for p in t2psr]) active_psrs['B1855+09'] = [0.017,-4.9,0.505] active_psrs['J0030+0451'] = [0.014,-4.8,0.212] active_psrs['J0613-0200'] = [0.093,-2.9,0.165] active_psrs['J1012+5307'] = [0.669,-1.0,0.355] active_psrs['J1024-0719'] = [0.0,0.0,0.280]
def addpulsar(self, parfile, timfile, DMOFF=None, DMXOFF=None, dailyAverage=False): """ Add another pulsar to the HDF5 file, given a tempo2 par and tim file. @param parfile: tempo2 par file @param timfile: tempo2 tim file @param DMOFF: Option to turn off DMMODEL fitting @param DMOFF: Option to turn off DMX fitting @param dailyAverage: Option to perform daily averaging to reduce the number of points by consructing daily averaged TOAs that have one residual per day per frequency band. (This has only been tested on NANOGrav data thus far.) """ # Check whether the two files exist if not os.path.isfile(parfile) or not os.path.isfile(timfile): raise IOError, "Cannot find parfile (%s) or timfile (%s)!" % (parfile, timfile) assert(self.filename != None), "ERROR: HDF5 file not set!" # 'a' means: read/write if exists, create otherwise self.h5file = h5.File(self.filename, 'a') if "Model" in self.h5file: self.h5file.close() self.h5file = None raise IOError, "model already available in '%s'. Refusing to add data" % (self.filename) # Create the data subgroup if it does not exist if "Data" in self.h5file: datagroup = self.h5file["Data"] else: datagroup = self.h5file.create_group("Data") # Load pulsar data from the JPL Cython tempo2 library t2pulsar = t2.tempopulsar(parfile, timfile) # do multiple fits #t2pulsar.fit(iters=10) # turn off DMMODEL fitting if DMOFF is not None: t2pulsar['DMMODEL'].fit = False # turn off DMX fitting if DMXOFF is not None: DMXFlag = False print 'Turning off DMX fitting and turning DM fitting on' for par in t2pulsar.pars: if 'DMX' in par: print par t2pulsar[par].fit = False t2pulsar['DM'].fit = True DMXFlag = True if DMXFlag== False: print 'NO DMX for pulsar {0}'.format(t2pulsar.name) # refit 5 times to make sure we are converged t2pulsar.fit(iters=5) # Create the pulsar subgroup if it does not exist if "Pulsars" in datagroup: pulsarsgroup = datagroup["Pulsars"] else: pulsarsgroup = datagroup.create_group("Pulsars") # Look up the name of the pulsar, and see if it exist if t2pulsar.name in pulsarsgroup: self.h5file.close() raise IOError, "%s already exists in %s!" % (t2pulsar.name, self.filename) pulsarsgroup = pulsarsgroup.create_group(t2pulsar.name) # Read the data from the tempo2 structure. designmatrix = np.double(t2pulsar.designmatrix()) residuals = np.double(t2pulsar.residuals()) toas = np.double(t2pulsar.toas()) errs = np.double(t2pulsar.toaerrs*1e-6) pname = t2pulsar.name try: # if tim file has frequencies freqs = np.double(t2pulsar.freqs) except AttributeError: freqs = 0 try: # if tim file has frequency band flags bands = t2pulsar.flags['B'] except KeyError: bands = 0 # if doing daily averaging if dailyAverage: # get average quantities toas, qmatrix, errs, dmatrix, freqs, bands = PALutils.dailyAverage(t2pulsar) # construct new daily averaged residuals and designmatrix residuals = np.dot(qmatrix, residuals) designmatrix = np.dot(qmatrix, dmatrix) # Write the TOAs, residuals, and uncertainties. spd = 24.0*3600 # seconds per day pulsarsgroup.create_dataset('TOAs', data = toas*spd) # days (MJD) * sec per day pulsarsgroup.create_dataset('residuals', data = residuals) # seconds pulsarsgroup.create_dataset('toaErr', data = errs) # seconds pulsarsgroup.create_dataset('freqs', data = freqs*1e6) # Hz pulsarsgroup.create_dataset('bands', data = bands) # Hz # add tim and par file paths pulsarsgroup.create_dataset('parFile', data = parfile) # string pulsarsgroup.create_dataset('timFile', data = timfile) # string # Write the full design matrix pulsarsgroup.create_dataset('designmatrix', data = designmatrix) # Obtain the timing model parameters tmpname = np.array(t2pulsar.pars) tmpvalpre = np.double([t2pulsar.prefit[parname].val for parname in t2pulsar.pars]) tmpvalpost = np.double([t2pulsar[parname].val for parname in t2pulsar.pars]) tmperrpre = np.double([t2pulsar.prefit[parname].err for parname in t2pulsar.pars]) tmperrpost = np.double([t2pulsar[parname].err for parname in t2pulsar.pars]) # Write the timing model parameter (TMP) descriptions pulsarsgroup.create_dataset('pname', data=pname) # pulsar name pulsarsgroup.create_dataset('tmp_name', data=tmpname) # TMP name pulsarsgroup.create_dataset('tmp_valpre', data=tmpvalpre) # TMP pre-fit value pulsarsgroup.create_dataset('tmp_valpost', data=tmpvalpost) # TMP post-fit value pulsarsgroup.create_dataset('tmp_errpre', data=tmperrpre) # TMP pre-fit error pulsarsgroup.create_dataset('tmp_errpost', data=tmperrpost) # TMP post-fit error # Close the hdf5 file self.h5file.close()
def readPrepRealisations(path): psrs = [] ntotobs, ntotpars = 0, 0 relparpath = '/par/' reltimpath = '/tim/' reldespath = '/design/' relrespath = '/res/' relcovpath = '/cov/' # Read in all the pulsars through libstempo for infile in glob.glob(os.path.join(path+relparpath, '*.par')): filename = os.path.splitext(infile) basename = os.path.basename(filename[0]) # Locate the par-file and the timfile parfile = path+relparpath+basename+'.par' timfile = path+reltimpath+basename+'.tim' desfile = path+reldespath+basename+'designMatrix.txt' # Make the libstempo object timfiletup = os.path.split(timfile) dirname = timfiletup[0] reltimfile = timfiletup[-1] relparfile = os.path.relpath(parfile, dirname) savedir = os.getcwd() os.chdir(dirname) psrs.append(T.tempopulsar(relparfile, reltimfile)) os.chdir(savedir) # Read the designmatrix from the file #desmat = psrs[-1].designmatrix().copy() desmat = np.loadtxt(desfile) # Register how many paramters and observations we have #ntotobs += psr.nobs #ntotpars += psr.ndim+1 ntotobs += desmat.shape[0] ntotpars += desmat.shape[1] if desmat.shape[0] != psrs[-1].nobs: print "For " + basename + " obs != obs ", desmat.shape[0], psrs[-1].nobs if desmat.shape[1] != psrs[-1].ndim+1: print "For " + basename + " pars != pars ", desmat.shape[1], psrs[-1].ndim+1 hdmat = hdcormat(psrs) # Allocate memory for the model description toas = np.zeros(ntotobs) residuals = np.zeros(ntotobs) toaerrs = np.zeros(ntotobs) designmatrix = np.zeros((ntotobs, ntotpars)) Gmatrix = np.zeros((ntotobs, ntotobs-ntotpars)) GNGinv = [] ptheta = [] pphi = [] psrobs = [] psrpars = [] psrg = [] infiles = glob.glob(os.path.join(path+relparpath, '*.par')) indo, indp, indg = 0, 0, 0 for i in range(len(infiles)): # This automatically also loops over the psrs of course filename = os.path.splitext(infiles[i]) basename = os.path.basename(filename[0]) # Locate the par-file and the timfile parfile = path+relparpath+basename+'.par' timfile = path+reltimpath+basename+'.tim' desfile = path+reldespath+basename+'designMatrix.txt' covfile = path+relcovpath+basename+'covMatrix.txt' resfile = path+relrespath+basename+'res.dat' # Read in the design matrix (again), covariance matrix, and the residuals desmat = np.loadtxt(desfile) covmat = np.loadtxt(covfile) resvec = np.loadtxt(resfile) # These comments are for when reading in from the psr object #desmat = psrs[i].designmatrix().copy() #covmat = np.diag((psrs[i].toaerrs*1e-6)**2) #resvec = np.array([psrs[i].toas(), psrs[i].residuals(), psrs[i].toaerrs*1e-6]).T # Determine the dimensions pobs = desmat.shape[0] ppars = desmat.shape[1] pgs = desmat.shape[0] - desmat.shape[1] psrobs.append(pobs) psrpars.append(ppars) psrg.append(pgs) # Load the basic quantities toas[indo:indo+pobs] = resvec[:,0] residuals[indo:indo+pobs] = resvec[:,1] toaerrs[indo:indo+pobs] = resvec[:,2] designmatrix[indo:indo+pobs, indp:indp+ppars] = desmat ptheta.append(0.5*np.pi - psrs[i]['DECJ'].val) pphi.append(psrs[i]['RAJ'].val) # Create the G-matrix U, s, Vh = sl.svd(desmat) Gmatrix[indo:indo+pobs, indg:indg+pgs] = U[:,ppars:].copy() # Create the noise matrix pNoise = covmat GNG = np.dot(U[:,ppars:].copy().T, np.dot(pNoise, U[:,ppars:].copy())) cf = sl.cho_factor(GNG) GNGinv.append(sl.cho_solve(cf, np.identity(GNG.shape[0]))) indo += pobs indp += ppars indg += pgs model = (toas, residuals, toaerrs, designmatrix, Gmatrix, hdmat, psrobs, psrpars, psrg, GNGinv, ptheta, pphi) return (psrs, model)
import numpy as N import matplotlib.pyplot as P import libstempo as T import os.path def freq_idx( F ): freq=[ [100, 360], [361, 600], [601, 999], [1000, 2100], [2101, 3000] ] for i in range( 5 ): if ( F >= freq[ i ][ 0 ] ) and ( F <= freq[ i ][ 1 ] ): return i return 0 F = [ 350, 450, 800, 1400, 2300 ] output_dir = str(sys.argv[ 3 ]) psr = T.tempopulsar( parfile = str( sys.argv[ 1 ] ), timfile = str( sys.argv[ 2 ] ) ) sort_cmp = N.argsort( psr.stoas ) bin = [] # format: residuals, error, TOA, frequency # sorting residuals, errors, frequencies, and TOAs by TOAs Residuals = psr.residuals()[ sort_cmp ] Errors = psr.toaerrs[ sort_cmp ] TOA = psr.stoas[ sort_cmp ] FREQ = psr.freqs[ sort_cmp ] curr = [ Residuals[ 0 ], Errors[ 0 ], TOA[ 0 ], FREQ[ 0 ] ] for i in range( 1, len( TOA ) ): if( TOA[ i ]-TOA[ i-1 ] > (3.0/144.0) ): bin.append( curr ) curr = [] curr.append( Residuals[ i ] )
parfiles = [] timfiles = [] for file in sorted(glob.glob(args.datapath+"/*.par")): parfiles.append(file) for file in sorted(glob.glob(args.datapath+"/*.tim")): timfiles.append(file) print parfiles, timfiles ################################################################################################################################ # PASSING THROUGH TEMPO2 VIA libstempo ################################################################################################################################ t2psr=[] for ii in range(len(parfiles)): t2psr.append(T2.tempopulsar(parfile=parfiles[ii], timfile=timfiles[ii])) t2psr[ii].fit(iters=10) #if np.any(np.isfinite(t2psr[ii].residuals())==False)==True: # t2psr[ii] = T2.tempopulsar(parfile=parfiles[ii], timfile=timfiles[ii]) # storing red-noise amplitude (nano style), # gamma (nano style), white-noise level (microseconds) # [from Arzoumanian et al. (2015a)] active_psrs = OrderedDict.fromkeys([p.name for p in t2psr]) active_psrs['B1855+09'] = [0.017,-4.9,0.505] active_psrs['J0030+0451'] = [0.014,-4.8,0.212] active_psrs['J0613-0200'] = [0.093,-2.9,0.165] active_psrs['J1012+5307'] = [0.669,-1.0,0.355] active_psrs['J1024-0719'] = [0.0,0.0,0.280]
parser.add_option('--timfile', dest='timfile', action='store', type=str, help='Full path to timfile') parser.add_option('--sample-or-maximize', dest='sample_or_maximize', action='store', type=str, default='maximize', help='Do you want sample from the posteror distribution or just find the maximum likelihood noise values? (default=\'maximize\')?') (args, x) = parser.parse_args() if args.nmodes: print "\n You've given me the number of frequencies to include in the low-rank time-frequency approximation, got it?\n" else: print "\n You've given me the sampling cadence for the observations, which determines the upper frequency limit and the number of modes, got it?\n" ################################################################################################################################ # PASSING THROUGH TEMPO2 VIA libstempo ################################################################################################################################ t2psr = T2.tempopulsar(parfile=args.parfile, timfile=args.timfile) t2psr.fit(iters=10) if np.any(np.isfinite(t2psr.residuals())==False)==True: t2psr = T2.tempopulsar(parfile=args.parfile,timfile=args.timfile) psr = NX01_psr.PsrObj(t2psr) psr.grab_all_vars() if args.sample_or_maximize == 'maximize': from pyswarm import pso else: if not os.path.exists('chains_singlePsr_{0}'.format(psr.name)): os.makedirs('chains_singlePsr_{0}'.format(psr.name)) ################################################################################################################################ # GETTING MAXIMUM TIME, COMPUTING FOURIER DESIGN MATRICES, AND GETTING MODES
parser.add_argument( dest='pulsar', help='pulsar name (no suffix)') cfg = parser.parse_args() # by default, we search over all parameters that are fit by tempo2 if not cfg.searchpars: cfg.searchpars = psr.fitpars else: cfg.searchpars = libstempo.like.expandranges(cfg.searchpars.split(',')) # the output files will be of the form {outputdir}/{pulsar}[-{suffix}]-... basename = '{0}/{1}{2}'.format(cfg.outputdir,cfg.pulsar,'-' + cfg.suffix if cfg.suffix else '') parfile, timfile = libstempo.findpartim(pulsar=cfg.pulsar,dirname=cfg.inputdir,partimfiles=cfg.files) pulsar = libstempo.tempopulsar(parfile=parfile,timfile=timfile) for par in cfg.searchpars: if par in pulsar.fitpars: pulsar[par].fit = False ll = libstempo.like.Loglike(pulsar,cfg.searchpars) p0 = libstempo.like.Prior(pulsar,cfg.searchpars) iamroot = MPI.COMM_WORLD.Get_rank() == 0 if cfg.config is None: cfg.config = cfg.pulsar + '.ini' if os.path.isfile(cfg.config): if iamroot: print "Loading configuration file", cfg.config execfile(cfg.config)
def Pulsar(*args, **kwargs): ephem = kwargs.get('ephem', None) planets = kwargs.get('planets', True) sort = kwargs.get('sort', True) drop_t2pulsar = kwargs.get('drop_t2pulsar', True) timing_package = kwargs.get('timing_package', 'tempo2') if pint: toas = list(filter(lambda x: isinstance(x, toa.TOAs), args)) model = list(filter(lambda x: isinstance(x, TimingModel), args)) t2pulsar = list(filter(lambda x: isinstance(x, t2.tempopulsar), args)) parfile = list(filter(lambda x: isinstance(x, str) and x.split('.')[-1] == 'par', args)) timfile = list(filter(lambda x: isinstance(x, str) and x.split('.')[-1] in ['tim', 'toa'], args)) if pint and toas and model: return PintPulsar(toas[0], model[0], sort=sort, planets=planets) elif t2pulsar: return Tempo2Pulsar(t2pulsar, sort=sort, drop_t2pulsar=drop_t2pulsar, planets=planets) elif parfile and timfile: # Check whether the two files exist if not os.path.isfile(parfile[0]) or not os.path.isfile(timfile[0]): msg = 'Cannot find parfile {0} or timfile {1}!'.format( parfile[0], timfile[0]) raise IOError(msg) # Obtain the directory name of the timfile, and change to it timfiletup = os.path.split(timfile[0]) dirname = timfiletup[0] or './' reltimfile = timfiletup[-1] relparfile = os.path.relpath(parfile[0], dirname) # get current directory cwd = os.getcwd() # Change directory to the base directory of the tim-file to deal with # INCLUDE statements in the tim-file os.chdir(dirname) if timing_package.lower() == 'pint': if ephem is None: ephem = 'DE421' toas = toa.get_TOAs(reltimfile, ephem=ephem, planets=planets) model = mb.get_model(relparfile) os.chdir(cwd) return PintPulsar(toas, model, sort=sort, planets=planets) elif timing_package.lower() == 'tempo2': # hack to set maxobs maxobs = get_maxobs(reltimfile) + 100 t2pulsar = t2.tempopulsar(relparfile, reltimfile, maxobs=maxobs, ephem=ephem) os.chdir(cwd) return Tempo2Pulsar(t2pulsar, sort=sort, drop_t2pulsar=drop_t2pulsar, planets=planets) else: print('Unknown arguments {}'.format(args))
def readPrepRealisations(path): psrs = [] ntotobs, ntotpars = 0, 0 relparpath = '/par/' reltimpath = '/tim/' reldespath = '/design/' relrespath = '/res/' relcovpath = '/cov/' # Read in all the pulsars through libstempo for infile in glob.glob(os.path.join(path + relparpath, '*.par')): filename = os.path.splitext(infile) basename = os.path.basename(filename[0]) # Locate the par-file and the timfile parfile = path + relparpath + basename + '.par' timfile = path + reltimpath + basename + '.tim' desfile = path + reldespath + basename + 'designMatrix.txt' # Make the libstempo object timfiletup = os.path.split(timfile) dirname = timfiletup[0] reltimfile = timfiletup[-1] relparfile = os.path.relpath(parfile, dirname) savedir = os.getcwd() os.chdir(dirname) psrs.append(T.tempopulsar(relparfile, reltimfile)) os.chdir(savedir) # Read the designmatrix from the file #desmat = psrs[-1].designmatrix().copy() desmat = np.loadtxt(desfile) # Register how many paramters and observations we have #ntotobs += psr.nobs #ntotpars += psr.ndim+1 ntotobs += desmat.shape[0] ntotpars += desmat.shape[1] if desmat.shape[0] != psrs[-1].nobs: print "For " + basename + " obs != obs ", desmat.shape[0], psrs[ -1].nobs if desmat.shape[1] != psrs[-1].ndim + 1: print "For " + basename + " pars != pars ", desmat.shape[ 1], psrs[-1].ndim + 1 hdmat = hdcormat(psrs) # Allocate memory for the model description toas = np.zeros(ntotobs) residuals = np.zeros(ntotobs) toaerrs = np.zeros(ntotobs) designmatrix = np.zeros((ntotobs, ntotpars)) Gmatrix = np.zeros((ntotobs, ntotobs - ntotpars)) GNGinv = [] ptheta = [] pphi = [] psrobs = [] psrpars = [] psrg = [] infiles = glob.glob(os.path.join(path + relparpath, '*.par')) indo, indp, indg = 0, 0, 0 for i in range(len(infiles)): # This automatically also loops over the psrs of course filename = os.path.splitext(infiles[i]) basename = os.path.basename(filename[0]) # Locate the par-file and the timfile parfile = path + relparpath + basename + '.par' timfile = path + reltimpath + basename + '.tim' desfile = path + reldespath + basename + 'designMatrix.txt' covfile = path + relcovpath + basename + 'covMatrix.txt' resfile = path + relrespath + basename + 'res.dat' # Read in the design matrix (again), covariance matrix, and the residuals desmat = np.loadtxt(desfile) covmat = np.loadtxt(covfile) resvec = np.loadtxt(resfile) # These comments are for when reading in from the psr object #desmat = psrs[i].designmatrix().copy() #covmat = np.diag((psrs[i].toaerrs*1e-6)**2) #resvec = np.array([psrs[i].toas(), psrs[i].residuals(), psrs[i].toaerrs*1e-6]).T # Determine the dimensions pobs = desmat.shape[0] ppars = desmat.shape[1] pgs = desmat.shape[0] - desmat.shape[1] psrobs.append(pobs) psrpars.append(ppars) psrg.append(pgs) # Load the basic quantities toas[indo:indo + pobs] = resvec[:, 0] residuals[indo:indo + pobs] = resvec[:, 1] toaerrs[indo:indo + pobs] = resvec[:, 2] designmatrix[indo:indo + pobs, indp:indp + ppars] = desmat ptheta.append(0.5 * np.pi - psrs[i]['DECJ'].val) pphi.append(psrs[i]['RAJ'].val) # Create the G-matrix U, s, Vh = sl.svd(desmat) Gmatrix[indo:indo + pobs, indg:indg + pgs] = U[:, ppars:].copy() # Create the noise matrix pNoise = covmat GNG = np.dot(U[:, ppars:].copy().T, np.dot(pNoise, U[:, ppars:].copy())) cf = sl.cho_factor(GNG) GNGinv.append(sl.cho_solve(cf, np.identity(GNG.shape[0]))) indo += pobs indp += ppars indg += pgs model = (toas, residuals, toaerrs, designmatrix, Gmatrix, hdmat, psrobs, psrpars, psrg, GNGinv, ptheta, pphi) return (psrs, model)
Nbins = len(profamps) Step=100 noiselist=[] for i in range(Nbins-Step): noise=np.std(profamps[i:i+Step]) noiselist.append(noise) noiselist=np.array(noiselist) minnoise=np.min(noiselist) threesiglist=noiselist[noiselist<3*minnoise] mediannoise=np.median(threesiglist) return mediannoise SECDAY = 24*60*60 #First load pulsar. We need the sats (separate day/second), and the file names of the archives (FNames) psr = T.tempopulsar(parfile="OneProf.par", timfile = "OneChan.tim") psr.fit() SatSecs = psr.satSec() SatDays = psr.satDay() FNames = psr.fnames() NToAs = psr.nobs #Check how many timing model parameters we are fitting for (in addition to phase) numTime=len(psr.pars()) redChisq = psr.chisq()/(psr.nobs-len(psr.pars())-1) TempoPriors=np.zeros([numTime,2]).astype(np.float128) for i in range(numTime): TempoPriors[i][0]=psr[psr.pars()[i]].val TempoPriors[i][1]=psr[psr.pars()[i]].err/np.sqrt(redChisq) print "fitting for: ", psr.pars()[i], TempoPriors[i][0], TempoPriors[i][1]
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 """ self._interface = "libstempo" 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) timfile.write(J1744_timfile) parfile.close() timfile.close() self._psr = lt.tempopulsar(parfilename, timfilename, dofit=False) os.remove(parfilename) os.remove(timfilename) elif parfile is not None and timfile is not None: self._psr = lt.tempopulsar(parfile, timfile, dofit=False) else: raise ValueError("No valid pulsar to load") # Some parameters we do not want to add a fitting checkbox for: self.nofitboxpars = ['START', 'FINISH', 'POSEPOCH', 'PEPOCH', 'DMEPOCH', \ 'EPHVER', 'TZRMJD', 'TZRFRQ', 'TRES'] # The possible binary pulsar parameters self.binarypars = [ 'T0', 'T0_1', 'PB', 'PBDOT', 'PB_1', 'ECC', 'ECC_1', 'OM', 'OM_1', 'A1', 'A1_1', 'OM', 'OM_1', 'E2DOT', 'EDOT', 'KOM', 'KIN', 'SHAPMAX', 'M2', 'MTOT', 'DR', 'DTH', 'A0', 'B0', 'BP', 'BPP', 'DTHETA', 'SINI', 'H3', 'STIG', 'H4', 'NHARM', 'GAMMA', 'PBDOT', 'XPBDOT', 'XDOT', 'X2DOT', 'XOMDOT', 'AFAC', 'OMDOT', 'OM2DOT', 'ORBPX', 'TASC', 'EPS1', 'EPS1DOT', 'EPS2', 'EPS2DOT', 'TZRMJD', 'TZRFRQ', 'TSPAN', 'BPJEP_0', 'BPJEP_1', 'BPJPH_0', 'BPJPH_1', 'BPJA1_0', 'BPJA1_1', 'BPJEC_0', 'BPJEC_1', 'BPJOM_0', 'BPJOM_1', 'BPJPB_0', 'BPJPB_1' ] self.binmodel_ids = [ 'BT', 'BTJ', 'BTX', 'ELL1', 'DD', 'DDK', 'DDS', 'MSS', 'DDGR', 'T2', 'T2-PTA', 'DDH', 'ELL1H' ] # BTmodel self.binmodel = OrderedDict() self.binmodel['BT'] = OrderedDict({ 'T0': [50000.0, 60000.0], 'PB': [0.01, 3000], 'ECC': [0.0, 1.0], 'PBDOT': [0.0, 1.0e-8], 'A1': [0.0, 1.0e3], 'XDOT': [-1.0e-12, 1.0e-12], 'OMDOT': [0.0, 5.0], 'OM': [0.0, 360.0], 'GAMMA': [0.0, 1.0] # What is the scale of this parameter?? }) self.binmodel['BTJ'] = OrderedDict({ 'T0': [50000.0, 60000.0], 'PB': [0.01, 3000], 'ECC': [0.0, 1.0], 'PBDOT': [0.0, 1.0e-8], 'XDOT': [-1.0e-12, 1.0e-12], 'A1': [0.0, 1.0e3], 'OMDOT': [0.0, 5.0], 'OM': [0.0, 360.0], 'GAMMA': [0.0, 1.0], # What is the scale of this parameter?? 'BPJEP_0': [0.0, 1.0], # ?? 'BPJEP_1': [0.0, 1.0], 'BPJPH_0': [0.0, 1.0], 'BPJPH_1': [0.0, 1.0], 'BPJA1_0': [0.0, 1.0], 'BPJA1_1': [0.0, 1.0], 'BPJEC_0': [0.0, 1.0], 'BPJEC_1': [0.0, 1.0], 'BPJOM_0': [0.0, 1.0], 'BPJOM_1': [0.0, 1.0], 'BPJPB_0': [0.0, 1.0], 'BPJPB_1': [0.0, 1.0] }) self.binmodel['BTX'] = OrderedDict({ 'T0': [50000.0, 60000.0], 'ECC': [0.0, 1.0], 'XDOT': [-1.0e-12, 1.0e-12], 'A1': [0.0, 1.0e3], 'OMDOT': [0.0, 5.0], 'OM': [0.0, 360.0], 'GAMMA': [0.0, 1.0], # What is the scale of this parameter?? 'FB0': [0.0, 1.0], # ?? 'FB1': [0.0, 1.0], # ?? 'FB2': [0.0, 1.0], # ?? 'FB3': [0.0, 1.0], # ?? 'FB4': [0.0, 1.0], # ?? 'FB5': [0.0, 1.0], # ?? 'FB6': [0.0, 1.0], # ?? 'FB7': [0.0, 1.0], # ?? 'FB8': [0.0, 1.0], # ?? 'FB9': [0.0, 1.0] # ?? }) self.binmodel['DD'] = OrderedDict({ 'SINI': [0.0, 1.0], 'M2': [0.0, 10.0], 'PB': [0.01, 3000], 'OMDOT': [0.0, 5.0], 'T0': [50000.0, 60000.0], 'GAMMA': [0.0, 1.0], # What is the scale of this parameter?? 'OM': [0.0, 360.0], 'A1': [0.0, 1.0e3], 'XDOT': [-1.0e-12, 1.0e-12], 'PBDOT': [0.0, 1.0e-8], 'ECC': [0.0, 1.0], 'XPBDOT': [0.0, 1.0], # Units??? Scale??? 'EDOT': [0.0, 1.0] # Units??? Scale??? }) self.binmodel['DDS'] = OrderedDict({ 'SHAPMAX': [0.0, 1.0], # Scale? 'SINI': [0.0, 1.0], 'M2': [0.0, 10.0], 'PB': [0.01, 3000], 'OMDOT': [0.0, 5.0], 'T0': [50000.0, 60000.0], 'GAMMA': [0.0, 1.0], # What is the scale of this parameter?? 'OM': [0.0, 360.0], 'A1': [0.0, 1.0e3], 'XDOT': [-1.0e-12, 1.0e-12], 'PBDOT': [0.0, 1.0e-8], 'ECC': [0.0, 1.0], 'XPBDOT': [0.0, 1.0], # Units??? Scale??? 'EDOT': [0.0, 1.0] # Units??? Scale??? }) self.binmodel['DDGR'] = OrderedDict({ 'T0': [50000.0, 60000.0], 'SINI': [0.0, 1.0], 'M2': [0.0, 10.0], 'PB': [0.01, 3000], 'MTOT': [0.0, 10.0], 'OM': [0.0, 360.0], 'XDOT': [-1.0e-12, 1.0e-12], 'PBDOT': [0.0, 1.0e-8], 'XPBDOT': [0.0, 1.0], # Units??? Scale??? 'A1': [0.0, 1.0e3], 'ECC': [0.0, 1.0], 'EDOT': [0.0, 1.0] # Units??? Scale??? })