Example #1
0
 def __init__(self, parfilenm):
     self.FILE = parfilenm
     pf = open(parfilenm)
     for line in pf.readlines():
         # Skip comments
         if line[0] == '#':
             continue
         # Convert any 'D-' or 'D+' to 'E-' or 'E+'
         line = line.replace("D-", "E-")
         line = line.replace("D+", "E+")
         splitline = line.split()
         # Skip blank lines
         if len(splitline) == 0:
             continue
         key = splitline[0]
         if key in str_keys:
             setattr(self, key, splitline[1])
         elif key in float_keys:
             try:
                 setattr(self, key, float(splitline[1]))
             except ValueError:
                 pass
         if len(
                 splitline
         ) == 3:  # Some parfiles don't have flags, but do have errors
             if splitline[2] not in ['0', '1']:
                 setattr(self, key + '_ERR', float(splitline[2]))
         if len(splitline) == 4:
             setattr(self, key + '_ERR', float(splitline[3]))
     # Deal with Ecliptic coords
     if (hasattr(self, 'BETA') and hasattr(self, 'LAMBDA')):
         setattr(self, 'ELAT', self.BETA)
         setattr(self, 'ELONG', self.LAMBDA)
     if (slalib and hasattr(self, 'ELAT') and hasattr(self, 'ELONG')):
         if hasattr(self, 'POSEPOCH'):
             epoch = self.POSEPOCH
         else:
             epoch = self.PEPOCH
         ra_rad, dec_rad = sla_ecleq(self.ELONG * pu.DEGTORAD,
                                     self.ELAT * pu.DEGTORAD, epoch)
         rstr = pu.coord_to_string(*pu.rad_to_hms(ra_rad))
         dstr = pu.coord_to_string(*pu.rad_to_dms(dec_rad))
         setattr(self, 'RAJ', rstr)
         setattr(self, 'DECJ', dstr)
     if hasattr(self, 'RAJ'):
         setattr(self, 'RA_RAD', pu.ra_to_rad(self.RAJ))
     if hasattr(self, 'DECJ'):
         setattr(self, 'DEC_RAD', pu.dec_to_rad(self.DECJ))
     # Compute the Galactic coords
     if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
         l, b = sla_eqgal(self.RA_RAD, self.DEC_RAD)
         setattr(self, 'GLONG', l * pu.RADTODEG)
         setattr(self, 'GLAT', b * pu.RADTODEG)
     # Compute the Ecliptic coords
     if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
         if hasattr(self, 'POSEPOCH'):
             epoch = self.POSEPOCH
         else:
             epoch = self.PEPOCH
         elon, elat = sla_eqecl(self.RA_RAD, self.DEC_RAD, epoch)
         setattr(self, 'ELONG', elon * pu.RADTODEG)
         setattr(self, 'ELAT', elat * pu.RADTODEG)
     if hasattr(self, 'P'):
         setattr(self, 'P0', self.P)
     if hasattr(self, 'P0'):
         setattr(self, 'F0', 1.0 / self.P0)
     if hasattr(self, 'F0'):
         setattr(self, 'P0', 1.0 / self.F0)
     if hasattr(self, 'FB0'):
         setattr(self, 'PB', (1.0 / self.FB0) / 86400.0)
     if hasattr(self, 'P0_ERR'):
         if hasattr(self, 'P1_ERR'):
             f, ferr, fd, fderr = pu.pferrs(self.P0, self.P0_ERR, self.P1,
                                            self.P1_ERR)
             setattr(self, 'F0_ERR', ferr)
             setattr(self, 'F1', fd)
             setattr(self, 'F1_ERR', fderr)
         else:
             f, fd, = pu.p_to_f(self.P0, self.P1)
             setattr(self, 'F0_ERR', self.P0_ERR / (self.P0 * self.P0))
             setattr(self, 'F1', fd)
     if (hasattr(self, 'F0_ERR') and hasattr(self, 'F1_ERR')):
         p, perr, pd, pderr = pu.pferrs(self.F0, self.F0_ERR, self.F1,
                                        self.F1_ERR)
         setattr(self, 'P0_ERR', perr)
         setattr(self, 'P1', pd)
         setattr(self, 'P1_ERR', pderr)
     elif (hasattr(self, 'F0') and hasattr(self, 'F0_ERR')):
         setattr(self, 'P0_ERR', self.F0_ERR / (self.F0 * self.F0))
     if hasattr(self, 'EPS1') and hasattr(self, 'EPS2'):
         ecc = math.sqrt(self.EPS1 * self.EPS1 + self.EPS2 * self.EPS2)
         omega = math.atan2(self.EPS1, self.EPS2)
         setattr(self, 'E', ecc)
         setattr(self, 'OM', omega * pu.RADTODEG)
         setattr(self, 'T0', self.TASC + self.PB * omega / pu.TWOPI)
     if hasattr(self, 'PB') and hasattr(self, 'A1') and not \
            (hasattr(self, 'E') or hasattr(self, 'ECC')):
         setattr(self, 'E', 0.0)
     if hasattr(self, 'T0') and not hasattr(self, 'TASC'):
         setattr(self, 'TASC', self.T0 - self.PB * self.OM / 360.0)
     pf.close()
Example #2
0
 def __init__(self, parfilenm):
     self.FILE = parfilenm
     pf = open(parfilenm)
     for line in pf.readlines():
         # Skip comments
         if line[0] == "#":
             continue
         # Convert any 'D-' or 'D+' to 'E-' or 'E+'
         line = line.replace("D-", "E-")
         line = line.replace("D+", "E+")
         splitline = line.split()
         # Skip blank lines
         if len(splitline) == 0:
             continue
         key = splitline[0]
         if key in str_keys:
             setattr(self, key, splitline[1])
         elif key in float_keys:
             try:
                 setattr(self, key, float(splitline[1]))
             except ValueError:
                 pass
         if len(splitline) == 3:  # Some parfiles don't have flags, but do have errors
             if splitline[2] not in ["0", "1"]:
                 setattr(self, key + "_ERR", float(splitline[2]))
         if len(splitline) == 4:
             setattr(self, key + "_ERR", float(splitline[3]))
     # Deal with Ecliptic coords
     if hasattr(self, "BETA") and hasattr(self, "LAMBDA"):
         setattr(self, "ELAT", self.BETA)
         setattr(self, "ELONG", self.LAMBDA)
     if slalib and hasattr(self, "ELAT") and hasattr(self, "ELONG"):
         if hasattr(self, "POSEPOCH"):
             epoch = self.POSEPOCH
         else:
             epoch = self.PEPOCH
         ra_rad, dec_rad = sla_ecleq(self.ELONG * pu.DEGTORAD, self.ELAT * pu.DEGTORAD, epoch)
         rstr = pu.coord_to_string(*pu.rad_to_hms(ra_rad))
         dstr = pu.coord_to_string(*pu.rad_to_dms(dec_rad))
         setattr(self, "RAJ", rstr)
         setattr(self, "DECJ", dstr)
     if hasattr(self, "RAJ"):
         setattr(self, "RA_RAD", pu.ra_to_rad(self.RAJ))
     if hasattr(self, "DECJ"):
         setattr(self, "DEC_RAD", pu.dec_to_rad(self.DECJ))
     # Compute the Galactic coords
     if slalib and hasattr(self, "RA_RAD") and hasattr(self, "DEC_RAD"):
         l, b = sla_eqgal(self.RA_RAD, self.DEC_RAD)
         setattr(self, "GLONG", l * pu.RADTODEG)
         setattr(self, "GLAT", b * pu.RADTODEG)
     # Compute the Ecliptic coords
     if slalib and hasattr(self, "RA_RAD") and hasattr(self, "DEC_RAD"):
         if hasattr(self, "POSEPOCH"):
             epoch = self.POSEPOCH
         else:
             epoch = self.PEPOCH
         elon, elat = sla_eqecl(self.RA_RAD, self.DEC_RAD, epoch)
         setattr(self, "ELONG", elon * pu.RADTODEG)
         setattr(self, "ELAT", elat * pu.RADTODEG)
     if hasattr(self, "P"):
         setattr(self, "P0", self.P)
     if hasattr(self, "P0"):
         setattr(self, "F0", 1.0 / self.P0)
     if hasattr(self, "F0"):
         setattr(self, "P0", 1.0 / self.F0)
     if hasattr(self, "FB0"):
         setattr(self, "PB", (1.0 / self.FB0) / 86400.0)
     if hasattr(self, "P0_ERR"):
         if hasattr(self, "P1_ERR"):
             f, ferr, fd, fderr = pu.pferrs(self.P0, self.P0_ERR, self.P1, self.P1_ERR)
             setattr(self, "F0_ERR", ferr)
             setattr(self, "F1", fd)
             setattr(self, "F1_ERR", fderr)
         else:
             f, fd, = pu.p_to_f(self.P0, self.P1)
             setattr(self, "F0_ERR", self.P0_ERR / (self.P0 * self.P0))
             setattr(self, "F1", fd)
     if hasattr(self, "F0_ERR"):
         if hasattr(self, "F1_ERR"):
             p, perr, pd, pderr = pu.pferrs(self.F0, self.F0_ERR, self.F1, self.F1_ERR)
             setattr(self, "P0_ERR", perr)
             setattr(self, "P1", pd)
             setattr(self, "P1_ERR", pderr)
         else:
             p, pd, = pu.p_to_f(self.F0, self.F1)
             setattr(self, "P0_ERR", self.F0_ERR / (self.F0 * self.F0))
             setattr(self, "P1", pd)
     if hasattr(self, "EPS1") and hasattr(self, "EPS2"):
         ecc = math.sqrt(self.EPS1 * self.EPS1 + self.EPS2 * self.EPS2)
         omega = math.atan2(self.EPS1, self.EPS2)
         setattr(self, "E", ecc)
         setattr(self, "OM", omega * pu.RADTODEG)
         setattr(self, "T0", self.TASC + self.PB * omega / pu.TWOPI)
     if hasattr(self, "PB") and hasattr(self, "A1") and not (hasattr(self, "E") or hasattr(self, "ECC")):
         setattr(self, "E", 0.0)
     if hasattr(self, "T0") and not hasattr(self, "TASC"):
         setattr(self, "TASC", self.T0 - self.PB * self.OM / 360.0)
     pf.close()
Example #3
0
    def read(self, parfilenm):
        self.FILE = parfilenm
        #print parfilenm
        pf = open(parfilenm)
        for line in pf.readlines():
            # Convert any 'D-' or 'D+' to 'E-' or 'E+'
            line = line.replace("D-", "E-")
            line = line.replace("D+", "E+")
            try:
                splitline = line.split()
                key = splitline[0]
                if key in str_keys:
                    setattr(self, key, splitline[1])
                elif key in float_keys:
                    try:
                        setattr(self, key, float(splitline[1]))
                    except ValueError:
                        pass
                if len(
                        splitline
                ) == 3:  # Some parfiles don't have flags, but do have errors
                    if splitline[2] not in ['0', '1']:
                        setattr(self, key + '_ERR', float(splitline[2]))
                if len(splitline) == 4:
                    setattr(self, key + '_ERR', float(splitline[3]))
            except:
                if line.strip():
                    print ' ', line
# Read PSR name
        if hasattr(self, 'PSR'):
            setattr(self, 'PSR', self.PSR)
        if hasattr(self, 'PSRJ'):
            setattr(self, 'PSRJ', self.PSRJ)
        # Deal with Ecliptic coords
        if (hasattr(self, 'BETA') and hasattr(self, 'LAMBDA')):
            self.use_eclip = True
            setattr(self, 'ELAT', self.BETA)
            setattr(self, 'ELONG', self.LAMBDA)
        if (slalib and hasattr(self, 'ELAT') and hasattr(self, 'ELONG')):
            self.use_eclip = True
            if hasattr(self, 'POSEPOCH'):
                epoch = self.POSEPOCH
            else:
                epoch = self.PEPOCH
            ra_rad, dec_rad = sla_ecleq(self.ELONG * pu.DEGTORAD,
                                        self.ELAT * pu.DEGTORAD, epoch)
            rstr = pu.coord_to_string(*pu.rad_to_hms(ra_rad))
            dstr = pu.coord_to_string(*pu.rad_to_dms(dec_rad))
            setattr(self, 'RAJ', rstr)
            setattr(self, 'DECJ', dstr)
        if (slalib and hasattr(self, 'ELAT') and hasattr(self, 'ELONG')):
            setattr(self, 'PMELONG', self.PMELONG)
            setattr(self, 'PMELAT', self.PMELAT)
        if hasattr(self, 'RAJ'):
            setattr(self, 'RA_RAD', pu.ra_to_rad(self.RAJ))
        if hasattr(self, 'DECJ'):
            setattr(self, 'DEC_RAD', pu.dec_to_rad(self.DECJ))
        # Compute the Galactic coords
        if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
            l, b = sla_eqgal(self.RA_RAD, self.DEC_RAD)
            setattr(self, 'GLONG', l * pu.RADTODEG)
            setattr(self, 'GLAT', b * pu.RADTODEG)
        # Compute the Ecliptic coords
        if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
            if hasattr(self, 'POSEPOCH'):
                epoch = self.POSEPOCH
            else:
                epoch = self.PEPOCH
            elon, elat = sla_eqecl(self.RA_RAD, self.DEC_RAD, epoch)
            setattr(self, 'ELONG', elon * pu.RADTODEG)
            setattr(self, 'ELAT', elat * pu.RADTODEG)
        if hasattr(self, 'P'):
            setattr(self, 'P0', self.P)
        if hasattr(self, 'P0'):
            setattr(self, 'F0', 1.0 / self.P0)
        if hasattr(self, 'F0'):
            setattr(self, 'P0', 1.0 / self.F0)
        if hasattr(self, 'F1'):
            setattr(self, 'P1', -self.F1 / (self.F0 * self.F0))
        if hasattr(self, 'FB0'):
            setattr(self, 'PB', (1.0 / self.FB0) / 86400.0)
        if hasattr(self, 'P0_ERR'):
            if hasattr(self, 'P1_ERR'):
                f, ferr, fd, fderr = pu.pferrs(self.P0, self.P0_ERR, self.P1,
                                               self.P1_ERR)
                setattr(self, 'F0_ERR', ferr)
                setattr(self, 'F1', fd)
                setattr(self, 'F1_ERR', fderr)
            else:
                f, fd, = pu.p_to_f(self.P0, self.P1)
                setattr(self, 'F0_ERR', self.P0_ERR / (self.P0 * self.P0))
                setattr(self, 'F1', fd)
        if hasattr(self, 'F0_ERR'):
            if hasattr(self, 'F1_ERR'):
                p, perr, pd, pderr = pu.pferrs(self.F0, self.F0_ERR, self.F1,
                                               self.F1_ERR)
                setattr(self, 'P0_ERR', perr)
                setattr(self, 'P1', pd)
                setattr(self, 'P1_ERR', pderr)
            else:
                p, pd, = pu.p_to_f(self.F0, self.F1)
                setattr(self, 'P0_ERR', self.F0_ERR / (self.F0 * self.F0))
                setattr(self, 'P1', pd)
        if hasattr(self, 'DM'):
            setattr(self, 'DM', self.DM)
        if hasattr(self, 'DM1'):
            setattr(self, 'DM1', self.DM1)
        if hasattr(self, 'DM2'):
            setattr(self, 'DM2', self.DM2)
        if hasattr(self, 'EPS1') and hasattr(self, 'EPS2'):
            self.use_ell = True
            ecc = math.sqrt(self.EPS1 * self.EPS1 + self.EPS2 * self.EPS2)
            omega = math.atan2(self.EPS1, self.EPS2)
            if self.EPS1 == 0.0 and self.EPS2 == 0.0:
                ecc_err = pow(
                    pow(self.EPS1_ERR, 2) + pow(self.EPS2_ERR, 2), .5)
            else:
                ecc_err = pow(
                    pow(self.EPS1 * self.EPS1_ERR, 2) +
                    pow(self.EPS2 * self.EPS2_ERR, 2), 0.5) / ecc
            setattr(self, 'ECC', ecc)
            setattr(self, 'ECC_ERR', ecc_err)
            setattr(self, 'OM', omega)
        if hasattr(self, 'PB') and hasattr(self,
                                           'A1') and not hasattr(self, 'ECC'):
            setattr(self, 'ECC', 0.0)
        if hasattr(self, 'BINARY'):
            setattr(self, 'BINARY', self.BINARY)
        if hasattr(self, 'KIN'):
            setattr(self, 'SINI', math.sin(self.KIN * np.pi / 180.))
            setattr(
                self, 'SINI_ERR',
                math.sin(self.KIN * np.pi / 180.) -
                math.sin(self.KIN * np.pi / 180. -
                         self.KIN_ERR * np.pi / 180.))
        pf.close()
Example #4
0
 def __init__(self, parfilenm):
     self.FILE = parfilenm
     pf = open(parfilenm)
     for line in pf.readlines():
         # Convert any 'D-' or 'D+' to 'E-' or 'E+'
         line = line.replace("D-", "E-")
         line = line.replace("D+", "E+")
         splitline = line.split()
         key = splitline[0]
         if key in str_keys:
             setattr(self, key, splitline[1])
         elif key in float_keys:
             try:
                 setattr(self, key, float(splitline[1]))
             except ValueError:
                 pass
         if len(splitline)==3:  # Some parfiles don't have flags, but do have errors
             if splitline[2] not in ['0', '1']:
                 setattr(self, key+'_ERR', float(splitline[2]))
         if len(splitline)==4:
             setattr(self, key+'_ERR', float(splitline[3]))
     # Deal with Ecliptic coords
     if (hasattr(self, 'BETA') and hasattr(self, 'LAMBDA')):
         setattr(self, 'ELAT', self.BETA)
         setattr(self, 'ELONG', self.LAMBDA)
     if (slalib and hasattr(self, 'ELAT') and hasattr(self, 'ELONG')):
         if hasattr(self, 'POSEPOCH'):
             epoch = self.POSEPOCH
         else:
             epoch = self.PEPOCH
         ra_rad, dec_rad = sla_ecleq(self.ELONG*pu.DEGTORAD,
                                     self.ELAT*pu.DEGTORAD, epoch)
         rstr = pu.coord_to_string(*pu.rad_to_hms(ra_rad))
         dstr = pu.coord_to_string(*pu.rad_to_dms(dec_rad))
         setattr(self, 'RAJ', rstr)
         setattr(self, 'DECJ', dstr)
     if hasattr(self, 'RAJ'):
         setattr(self, 'RA_RAD', pu.ra_to_rad(self.RAJ))
     if hasattr(self, 'DECJ'):
         setattr(self, 'DEC_RAD', pu.dec_to_rad(self.DECJ))
     # Compute the Galactic coords
     if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
         l, b = sla_eqgal(self.RA_RAD, self.DEC_RAD)
         setattr(self, 'GLONG', l*pu.RADTODEG)
         setattr(self, 'GLAT', b*pu.RADTODEG)
     # Compute the Ecliptic coords
     if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
         if hasattr(self, 'POSEPOCH'):
             epoch = self.POSEPOCH
         else:
             epoch = self.PEPOCH
         elon, elat = sla_eqecl(self.RA_RAD, self.DEC_RAD, epoch)
         setattr(self, 'ELONG', elon*pu.RADTODEG)
         setattr(self, 'ELAT', elat*pu.RADTODEG)
     if hasattr(self, 'P'):
         setattr(self, 'P0', self.P)
     if hasattr(self, 'P0'):
         setattr(self, 'F0', 1.0/self.P0)
     if hasattr(self, 'F0'):
         setattr(self, 'P0', 1.0/self.F0)
     if hasattr(self, 'FB0'):
         setattr(self, 'PB', (1.0/self.FB0)/86400.0)
     if hasattr(self, 'P0_ERR'):
         if hasattr(self, 'P1_ERR'):
             f, ferr, fd, fderr = pu.pferrs(self.P0, self.P0_ERR,
                                            self.P1, self.P1_ERR)
             setattr(self, 'F0_ERR', ferr) 
             setattr(self, 'F1', fd) 
             setattr(self, 'F1_ERR', fderr) 
         else:
             f, fd, = pu.p_to_f(self.P0, self.P1)
             setattr(self, 'F0_ERR', self.P0_ERR/(self.P0*self.P0))
             setattr(self, 'F1', fd) 
     if hasattr(self, 'F0_ERR'):
         if hasattr(self, 'F1_ERR'):
             p, perr, pd, pderr = pu.pferrs(self.F0, self.F0_ERR,
                                            self.F1, self.F1_ERR)
             setattr(self, 'P0_ERR', perr) 
             setattr(self, 'P1', pd) 
             setattr(self, 'P1_ERR', pderr) 
         else:
             p, pd, = pu.p_to_f(self.F0, self.F1)
             setattr(self, 'P0_ERR', self.F0_ERR/(self.F0*self.F0))
             setattr(self, 'P1', pd) 
     if hasattr(self, 'EPS1') and hasattr(self, 'EPS2'):
         ecc = math.sqrt(self.EPS1 * self.EPS1 + self.EPS2 * self.EPS2)
         omega = math.atan2(self.EPS1, self.EPS2)
         setattr(self, 'E', ecc)
         setattr(self, 'OM', omega * pu.RADTODEG)
         setattr(self, 'T0', self.TASC + self.PB * omega/pu.TWOPI)
     if hasattr(self, 'PB') and hasattr(self, 'A1') and not \
            (hasattr(self, 'E') or hasattr(self, 'ECC')):
         setattr(self, 'E', 0.0)
     if hasattr(self, 'T0') and hasattr(self, 'PB') and hasattr(self, 'OM')  and not hasattr(self, 'TASC'):
         setattr(self, 'TASC', self.T0 - self.PB * self.OM/360.0)
     pf.close()
Example #5
0
 def __init__(self, parfilenm):
     self.FILE = parfilenm
     pf = open(parfilenm)
     for line in pf.readlines():
         # Skip comments
         if line[0]=='#':
             continue
         # Convert any 'D-' or 'D+' to 'E-' or 'E+'
         line = line.replace("D-", "E-")
         line = line.replace("D+", "E+")
         splitline = line.split()
         # Skip blank lines
         if len(splitline)==0:
             continue
         key = splitline[0]
         # Regex checks for non-digit chars, followed by digit chars
         m1 = re.search(r'(\D+)(\d+)$', key)
         # This one looks for the DMX[RF][12]_* params
         m2 = re.search(r'(\D+\d+_)(\d+)$', key)
         if key == "JUMP":
             if splitline[3] not in ['0', '1']:
                 setattr(self, key+'_%s'%splitline[2], float(splitline[3]))
             if len(splitline)==5:
                 if splitline[4] not in ['0', '1']:
                     setattr(self, key+'_%s'%splitline[2]+'_ERR',
                             float(splitline[4]))
             elif len(splitline)==6:
                 setattr(self, key+'_%s'%splitline[2]+'_ERR',
                         float(splitline[5]))
         if key in str_keys:
             setattr(self, key, splitline[1])
         elif key in float_keys:
             try:
                 setattr(self, key, float(splitline[1]))
             except ValueError:
                 pass
         elif m1 is not None:
             m = m1
             if m2 is not None:
                 m = m2
             if m.group(1) in floatn_keys:
                 try:
                     setattr(self, key, float(splitline[1]))
                 except ValueError:
                     pass
         if len(splitline)==3:  # Some parfiles don't have flags, but do have errors
             if splitline[2] not in ['0', '1']:
                 setattr(self, key+'_ERR', float(splitline[2]))
         if len(splitline)==4:
             setattr(self, key+'_ERR', float(splitline[3]))
     # Deal with Ecliptic coords
     if (hasattr(self, 'BETA') and hasattr(self, 'LAMBDA')):
         setattr(self, 'ELAT', self.BETA)
         setattr(self, 'ELONG', self.LAMBDA)
     if (slalib and hasattr(self, 'ELAT') and hasattr(self, 'ELONG')):
         if hasattr(self, 'POSEPOCH'):
             epoch = self.POSEPOCH
         else:
             epoch = self.PEPOCH
         ra_rad, dec_rad = sla_ecleq(self.ELONG*pu.DEGTORAD,
                                     self.ELAT*pu.DEGTORAD, epoch)
         rstr = pu.coord_to_string(*pu.rad_to_hms(ra_rad))
         dstr = pu.coord_to_string(*pu.rad_to_dms(dec_rad))
         setattr(self, 'RAJ', rstr)
         setattr(self, 'DECJ', dstr)
     if hasattr(self, 'RAJ'):
         setattr(self, 'RA_RAD', pu.ra_to_rad(self.RAJ))
     if hasattr(self, 'DECJ'):
         setattr(self, 'DEC_RAD', pu.dec_to_rad(self.DECJ))
     # Compute the Galactic coords
     if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
         l, b = sla_eqgal(self.RA_RAD, self.DEC_RAD)
         setattr(self, 'GLONG', l*pu.RADTODEG)
         setattr(self, 'GLAT', b*pu.RADTODEG)
     # Compute the Ecliptic coords
     if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
         if hasattr(self, 'POSEPOCH'):
             epoch = self.POSEPOCH
         else:
             epoch = self.PEPOCH
         elon, elat = sla_eqecl(self.RA_RAD, self.DEC_RAD, epoch)
         setattr(self, 'ELONG', elon*pu.RADTODEG)
         setattr(self, 'ELAT', elat*pu.RADTODEG)
     if hasattr(self, 'P'):
         setattr(self, 'P0', self.P)
     if hasattr(self, 'P0'):
         setattr(self, 'F0', 1.0/self.P0)
     if hasattr(self, 'F0'):
         setattr(self, 'P0', 1.0/self.F0)
     if hasattr(self, 'FB0'):
         setattr(self, 'PB', (1.0/self.FB0)/86400.0)
     if hasattr(self, 'P0_ERR'):
         if hasattr(self, 'P1_ERR'):
             f, ferr, fd, fderr = pu.pferrs(self.P0, self.P0_ERR,
                                            self.P1, self.P1_ERR)
             setattr(self, 'F0_ERR', ferr) 
             setattr(self, 'F1', fd) 
             setattr(self, 'F1_ERR', fderr) 
         else:
             f, fd, = pu.p_to_f(self.P0, self.P1)
             setattr(self, 'F0_ERR', self.P0_ERR/(self.P0*self.P0))
             setattr(self, 'F1', fd)
     else:
         if hasattr(self, 'P1'):
             f, fd, = pu.p_to_f(self.P0, self.P1)
             setattr(self, 'F1', fd)
         elif hasattr(self, 'F1'):
             p, pd, = pu.p_to_f(self.F0, self.F1)
             setattr(self, 'P1', pd)
     if (hasattr(self, 'F0_ERR') and hasattr(self, 'F1_ERR')):
         p, perr, pd, pderr = pu.pferrs(self.F0, self.F0_ERR, 
                                        self.F1, self.F1_ERR)
         setattr(self, 'P0_ERR', perr) 
         setattr(self, 'P1', pd) 
         setattr(self, 'P1_ERR', pderr) 
     elif (hasattr(self, 'F0') and hasattr(self, 'F0_ERR')):
         setattr(self, 'P0_ERR', self.F0_ERR/(self.F0*self.F0))
     if hasattr(self, 'EPS1') and hasattr(self, 'EPS2'):
         ecc = math.sqrt(self.EPS1 * self.EPS1 + self.EPS2 * self.EPS2)
         omega = math.atan2(self.EPS1, self.EPS2)
         setattr(self, 'E', ecc)
         setattr(self, 'OM', omega * pu.RADTODEG)
         setattr(self, 'T0', self.TASC + self.PB * omega/pu.TWOPI)
     if hasattr(self, 'PB') and hasattr(self, 'A1') and not \
            (hasattr(self, 'E') or hasattr(self, 'ECC')):
         setattr(self, 'E', 0.0)
     if hasattr(self, 'T0') and not hasattr(self, 'TASC'):
         setattr(self, 'TASC', self.T0 - self.PB * self.OM/360.0)
     pf.close()
Example #6
0
 def __init__(self, parfilenm):
     self.FILE = parfilenm
     pf = open(parfilenm)
     for line in pf.readlines():
         # Skip comments
         if line[0] == '#':
             continue
         # Convert any 'D-' or 'D+' to 'E-' or 'E+'
         line = line.replace("D-", "E-")
         line = line.replace("D+", "E+")
         splitline = line.split()
         # Skip blank lines
         if len(splitline) == 0:
             continue
         key = splitline[0]
         # Regex checks for non-digit chars, followed by digit chars
         m1 = re.search(r'(\D+)(\d+)$', key)
         # This one looks for the DMX[RF][12]_* params
         m2 = re.search(r'(\D+\d+_)(\d+)$', key)
         if key == "JUMP":
             if splitline[3] not in ['0', '1']:
                 setattr(self, key + '_%s' % splitline[2],
                         float(splitline[3]))
             if len(splitline) == 5:
                 if splitline[4] not in ['0', '1']:
                     setattr(self, key + '_%s' % splitline[2] + '_ERR',
                             float(splitline[4]))
             elif len(splitline) == 6:
                 setattr(self, key + '_%s' % splitline[2] + '_ERR',
                         float(splitline[5]))
         if key in str_keys:
             setattr(self, key, splitline[1])
         elif key in float_keys:
             try:
                 setattr(self, key, float(splitline[1]))
             except ValueError:
                 pass
         elif m1 is not None:
             m = m1
             if m2 is not None:
                 m = m2
             if m.group(1) in floatn_keys:
                 try:
                     setattr(self, key, float(splitline[1]))
                 except ValueError:
                     pass
         if len(
                 splitline
         ) == 3:  # Some parfiles don't have flags, but do have errors
             if splitline[2] not in ['0', '1']:
                 setattr(self, key + '_ERR', float(splitline[2]))
         if len(splitline) == 4:
             setattr(self, key + '_ERR', float(splitline[3]))
     # Deal with Ecliptic coords
     if (hasattr(self, 'BETA') and hasattr(self, 'LAMBDA')):
         setattr(self, 'ELAT', self.BETA)
         setattr(self, 'ELONG', self.LAMBDA)
     if (slalib and hasattr(self, 'ELAT') and hasattr(self, 'ELONG')):
         # TEMPO's ecliptic coords are always based on J2000 epoch
         ra_rad, dec_rad = sla_ecleq(self.ELONG * pc.DEGTORAD,
                                     self.ELAT * pc.DEGTORAD, J2000)
         rstr = pu.coord_to_string(*pu.rad_to_hms(ra_rad))
         dstr = pu.coord_to_string(*pu.rad_to_dms(dec_rad))
         setattr(self, 'RAJ', rstr)
         setattr(self, 'DECJ', dstr)
     if hasattr(self, 'RAJ'):
         setattr(self, 'RA_RAD', pu.ra_to_rad(self.RAJ))
     if hasattr(self, 'DECJ'):
         setattr(self, 'DEC_RAD', pu.dec_to_rad(self.DECJ))
     # Compute the Galactic coords
     if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
         l, b = sla_eqgal(self.RA_RAD, self.DEC_RAD)
         setattr(self, 'GLONG', l * pc.RADTODEG)
         setattr(self, 'GLAT', b * pc.RADTODEG)
     # Compute the Ecliptic coords
     if (slalib and hasattr(self, 'RA_RAD') and hasattr(self, 'DEC_RAD')):
         # TEMPO's ecliptic coords are always based on J2000 epoch
         elon, elat = sla_eqecl(self.RA_RAD, self.DEC_RAD, J2000)
         setattr(self, 'ELONG', elon * pc.RADTODEG)
         setattr(self, 'ELAT', elat * pc.RADTODEG)
     if hasattr(self, 'P'):
         setattr(self, 'P0', self.P)
     if hasattr(self, 'P0'):
         setattr(self, 'F0', 1.0 / self.P0)
     if hasattr(self, 'F0'):
         setattr(self, 'P0', 1.0 / self.F0)
     if hasattr(self, 'FB0'):
         setattr(self, 'PB', (1.0 / self.FB0) / pc.SECPERDAY)
     if hasattr(self, 'P0_ERR'):
         if hasattr(self, 'P1_ERR'):
             f, ferr, fd, fderr = pu.pferrs(self.P0, self.P0_ERR, self.P1,
                                            self.P1_ERR)
             setattr(self, 'F0_ERR', ferr)
             setattr(self, 'F1', fd)
             setattr(self, 'F1_ERR', fderr)
         else:
             f, fd, = pu.p_to_f(self.P0, self.P1)
             setattr(self, 'F0_ERR', self.P0_ERR / (self.P0 * self.P0))
             setattr(self, 'F1', fd)
     else:
         if hasattr(self, 'P1'):
             f, fd, = pu.p_to_f(self.P0, self.P1)
             setattr(self, 'F1', fd)
         elif hasattr(self, 'F1'):
             p, pd, = pu.p_to_f(self.F0, self.F1)
             setattr(self, 'P1', pd)
     if (hasattr(self, 'F0_ERR') and hasattr(self, 'F1_ERR')):
         p, perr, pd, pderr = pu.pferrs(self.F0, self.F0_ERR, self.F1,
                                        self.F1_ERR)
         setattr(self, 'P0_ERR', perr)
         setattr(self, 'P1', pd)
         setattr(self, 'P1_ERR', pderr)
     elif (hasattr(self, 'F0') and hasattr(self, 'F0_ERR')):
         setattr(self, 'P0_ERR', self.F0_ERR / (self.F0 * self.F0))
     if hasattr(self, 'EPS1') and hasattr(self, 'EPS2'):
         ecc = math.sqrt(self.EPS1 * self.EPS1 + self.EPS2 * self.EPS2)
         omega = math.atan2(self.EPS1, self.EPS2)
         setattr(self, 'E', ecc)
         setattr(self, 'OM', omega * pc.RADTODEG)
         setattr(self, 'T0', self.TASC + self.PB * omega / pc.TWOPI)
     if hasattr(self, 'PB') and hasattr(self, 'A1') and not \
            (hasattr(self, 'E') or hasattr(self, 'ECC')):
         setattr(self, 'E', 0.0)
     if hasattr(self, 'T0') and not hasattr(self, 'TASC'):
         setattr(self, 'TASC', self.T0 - self.PB * self.OM / 360.0)
     if hasattr(self, 'E') and not hasattr(self, 'ECC'):
         setattr(self, 'ECC', self.E)
         if not hasattr(self, 'EPS1'):
             if hasattr(self, 'E_ERR'):
                 setattr(self, 'ECC_ERR', self.E_ERR)
     if hasattr(self, 'ECC') and not hasattr(self, 'E'):
         setattr(self, 'E', self.ECC)
         setattr(self, 'E_ERR', self.ECC_ERR)
     pf.close()