Exemplo n.º 1
0
    def map_to_npz(self, time_str, loc_str='PAPER', verbose=False):
        '''
        writes map of particular time to npz file

        Parameters
        ----------
        time_str | str: time and date of map
        loc_str | str: name of obs location to incorporate into filename output
        verbose | Optional[bool]: whether to print values or not
        '''
        #I could fish around in the file read to get npix and then re-loop, but why not just be lazy sometimes
        rng = np.arange(24)
        final_TEC, final_rm, final_drm, ra, dec = np.zeros((rng.shape[0], self.npix)),\
                                                  np.zeros((rng.shape[0], self.npix)),\
                                                  np.zeros((rng.shape[0], self.npix)),\
                                                  np.zeros((rng.shape[0], self.npix)),\
                                                  np.zeros((rng.shape[0], self.npix))
        RM_dir = os.path.join(self.rm_dir, '{date}'.format(date=time_str))
        for UT in rng:
            rm_file = os.path.join(
                RM_dir, 'IonRM{num}.txt'.format(
                    num=utils.std_hour(UT, verbose=verbose)))
            radec_file = os.path.join(
                RM_dir, 'radec{num}.txt'.format(
                    num=utils.std_hour(UT, verbose=verbose)))

            _, TEC, B, RM, dRM = np.loadtxt(rm_file, unpack=True)
            RA, DEC = np.loadtxt(radec_file, unpack=True)

            final_TEC[UT, :] = TEC
            final_rm[UT, :] = RM
            final_drm[UT, :] = dRM
            ra[UT, :] = RA
            dec[UT, :] = DEC

        f_name = ''.join((time_str, '_', loc_str, '.npz'))
        npz_dir = os.path.join(rad.root_dir, 'npz')
        if not os.path.exists(npz_dir):
            os.mkdir(npz_dir)
        npz_file = os.path.join(npz_dir, f_name)
        if verbose:
            print(
                'Saving TEC, RM +/- dRM data and RA/Dec mapping to {filename}'.
                format(filename=npz_file))

        np.savez(npz_file,
                 TEC=final_TEC,
                 RM=final_rm,
                 dRM=final_drm,
                 RA=ra,
                 DEC=dec)
Exemplo n.º 2
0
    def altaz(self):
        '''
        outputs RM data from altaz calculation

        Returns
        -------
        tuple:
            array[float]: parallel B field array
            array[float]: RM data
            array[float]: RM error data
        '''
        rm_s = []
        drm_s = []
        b_para_s = []

        alt_src, az_src = self._hp_arr()
        zen_src = 90. - alt_src

        for date in self.times:
            date_str, _, _ = str(date).partition('T')
            RM_dir = self.make_rm_dir(date_str)
            year, month, day = map(int, date_str.split('-'))
            tec_hp, rms_hp, ion_height = self.ionex_data(year, month, day)

            coord_lat, coord_lon, az_punct, zen_punct = phys.ipp(
                self.lat_str, self.lon_str, az_src, zen_src, ion_height)
            #XXX B_para calculated per DAY
            B_para = phys.B_IGRF(year, month, day, coord_lat, coord_lon,
                                 ion_height, az_punct, zen_punct)

            RMs = []
            dRMs = []
            for ui, UT in enumerate(self.UTs):
                hour = utils.std_hour(UT)
                radec_file = os.path.join(RM_dir,
                                          'radec{hour}.txt'.format(hour=hour))
                utils.write_radec(UT, radec_file, alt_src, az_src, date_str,
                                  self.location)
                #UTs are integer distances apart. Would an enumeration be better?
                TEC_path, RMS_TEC_path = itp.get_los_tec(
                    tec_hp[ui], rms_hp[ui], coord_lat, coord_lon, zen_punct)

                new_file = os.path.join(RM_dir,
                                        'IonRM{hour}.txt'.format(hour=hour))
                utils.write_RM(hour, new_file, B_para, TEC_path, RMS_TEC_path)

                _, _, _, RM_ut, dRM_ut = np.loadtxt(new_file, unpack=True)
                RMs.append(RM_ut)
                dRMs.append(dRM_ut)

            rm_s.append(RMs)
            drm_s.append(dRMs)
            b_para_s.append(B_para)

        self.RMs = np.array(rm_s)
        self.dRMs = np.array(drm_s)
        self.B_paras = np.array(b_para_s)
Exemplo n.º 3
0
    def map_to_npz(self, time_str, loc_str="PAPER", verbose=False):
        """
        writes map of particular time to npz file

        Parameters
        ----------
        time_str | str: time and date of map
        loc_str | str: name of obs location to incorporate into filename output
        verbose | Optional[bool]: whether to print values or not
        """
        # I could fish around in the file read to get npix and then re-loop, but why not just be lazy sometimes
        rng = np.arange(24)
        final_TEC, final_rm, final_drm, ra, dec = (
            np.zeros((rng.shape[0], self.npix)),
            np.zeros((rng.shape[0], self.npix)),
            np.zeros((rng.shape[0], self.npix)),
            np.zeros((rng.shape[0], self.npix)),
            np.zeros((rng.shape[0], self.npix)),
        )
        RM_dir = os.path.join(self.rm_dir, "{date}".format(date=time_str))
        for UT in rng:
            rm_file = os.path.join(RM_dir, "IonRM{num}.txt".format(num=utils.std_hour(UT, verbose=verbose)))
            radec_file = os.path.join(RM_dir, "radec{num}.txt".format(num=utils.std_hour(UT, verbose=verbose)))

            _, TEC, B, RM, dRM = np.loadtxt(rm_file, unpack=True)
            RA, DEC = np.loadtxt(radec_file, unpack=True)

            final_TEC[UT, :] = TEC
            final_rm[UT, :] = RM
            final_drm[UT, :] = dRM
            ra[UT, :] = RA
            dec[UT, :] = DEC

        f_name = "".join((time_str, "_", loc_str, ".npz"))
        npz_dir = os.path.join(rad.root_dir, "npz")
        if not os.path.exists(npz_dir):
            os.mkdir(npz_dir)
        npz_file = os.path.join(npz_dir, f_name)
        if verbose:
            print("Saving TEC, RM +/- dRM data and RA/Dec mapping to {filename}".format(filename=npz_file))

        np.savez(npz_file, TEC=final_TEC, RM=final_rm, dRM=final_drm, RA=ra, DEC=dec)
Exemplo n.º 4
0
    def altaz(self):
        """
        outputs RM data from altaz calculation

        Returns
        -------
        tuple:
            array[float]: parallel B field array
            array[float]: RM data
            array[float]: RM error data
        """
        rm_s = []
        drm_s = []
        b_para_s = []

        alt_src, az_src = self._hp_arr()
        zen_src = 90.0 - alt_src

        for date in self.times:
            date_str, _, _ = str(date).partition("T")
            RM_dir = self.make_rm_dir(date_str)
            year, month, day = map(int, date_str.split("-"))
            tec_hp, rms_hp, ion_height = self.ionex_data(year, month, day)

            coord_lat, coord_lon, az_punct, zen_punct = phys.ipp(
                self.lat_str, self.lon_str, az_src, zen_src, ion_height
            )
            # XXX B_para calculated per DAY
            B_para = phys.B_IGRF(year, month, day, coord_lat, coord_lon, ion_height, az_punct, zen_punct)

            RMs = []
            dRMs = []
            for UT in self.UTs:
                hour = utils.std_hour(UT)
                radec_file = os.path.join(RM_dir, "radec{hour}.txt".format(hour=hour))
                utils.write_radec(UT, radec_file, alt_src, az_src, date_str, self.location)

                TEC_path, RMS_TEC_path = itp.get_los_tec(tec_hp[UT], rms_hp[UT], coord_lat, coord_lon, zen_punct)

                new_file = os.path.join(RM_dir, "IonRM{hour}.txt".format(hour=hour))
                utils.write_RM(hour, new_file, B_para, TEC_path, RMS_TEC_path)

                _, _, _, RM_ut, dRM_ut = np.loadtxt(new_file, unpack=True)
                RMs.append(RM_ut)
                dRMs.append(dRM_ut)

            rm_s.append(RMs)
            drm_s.append(dRMs)
            b_para_s.append(B_para)

        self.RMs = np.array(rm_s)
        self.dRMs = np.array(drm_s)
        self.B_paras = np.array(b_para_s)
Exemplo n.º 5
0
    def get_radec_RM(self, ras, decs, verbose=False):
        # TODO: allow ra,dec to be floats, rather than arrays of floats
        # (to maintain single-pointing functionality)

        if not all((i <= 2.0 * np.pi and i >= 0.0) for i in ras):
            raise ValueError("All RAs must be between 0 and 2*pi radians")
        if not all((i <= np.pi / 2.0 and i >= -np.pi / 2.0) for i in decs):
            raise ValueError("All Decs must be between -pi/2 and pi/2 radians")

        self.coordinates_flag = "J2000_RaDec"

        for time in self.times:
            time_str, _, _ = str(time).partition("T")
            RM_dir = self.make_rm_dir(time_str)
            year, month, day = map(int, time_str.split("-"))
            if verbose:
                print(year, month, day)
            tec_hp, rms_hp, ion_height = self.ionex_data(year, month, day)

            # predict the ionospheric RM for every hour within a day
            for UT in self.UTs:
                hour = utils.std_hour(UT)
                c_icrs = SkyCoord(
                    ra=ras * u.radian,
                    dec=decs * u.radian,
                    location=self.location,
                    obstime=time + UT * u.hr,
                    frame="icrs",
                )
                c_altaz = c_icrs.transform_to("altaz")
                alt_src = np.array(c_altaz.alt.degree)
                az_src = np.array(c_altaz.az.degree)
                zen_src = np.array(Angle(c_altaz.zen).degree)  # AltAz.zen doesn't have method to return angle data

                coord_lat, coord_lon, az_punct, zen_punct = phys.ipp(
                    self.lat_str, self.lon_str, az_src, zen_src, ion_height
                )
                # XXX B_para calculated per UT
                B_para = phys.B_IGRF(year, month, day, coord_lat, coord_lon, ion_height, az_punct, zen_punct)

                TEC_path, RMS_TEC_path = itp.get_los_tec(tec_hp[UT], rms_hp[UT], coord_lat, coord_lon, zen_punct)

                new_file = os.path.join(RM_dir, "IonRM{hour}.txt".format(hour=hour))
                utils.write_RM(hour, new_file, B_para, TEC_path, RMS_TEC_path, write_to_file=True)

        b_para_s = []
        rm_s = []
        drm_s = []
        for time in self.times:
            time_str, _, _ = str(time).partition("T")
            RM_add = []
            dRM_add = []
            RM_dir = os.path.join(self.rm_dir, "{date}".format(date=time_str))

            for UT in self.UTs:
                data_file = os.path.join(RM_dir, "IonRM{hour}.txt".format(hour=utils.std_hour(UT)))
                _, _, B_para, RM_ut, dRM_ut = np.loadtxt(data_file, unpack=True)
                b_para_s.append(B_para)
                RM_add.append(RM_ut)
                dRM_add.append(dRM_ut)
            rm_s.append(RM_add)
            drm_s.append(dRM_add)

        self.B_para = np.array(b_para_s)
        self.RMs = np.array(rm_s)
        self.dRMs = np.array(drm_s)
Exemplo n.º 6
0
    def calc_radec_rm(self, ras, decs, verbose=False):
        #TODO: allow ra,dec to be floats, rather than arrays of floats
        # (to maintain single-pointing functionality)

        if not all((i <= 2. * np.pi and i >= 0.) for i in ras):
            raise ValueError('All RAs must be between 0 and 2*pi radians')
        if not all((i <= np.pi / 2. and i >= -np.pi / 2.) for i in decs):
            raise ValueError('All Decs must be between -pi/2 and pi/2 radians')

        self.coordinates_flag = 'J2000_RaDec'

        #final storage arrays
        b_para_s = []
        rm_s = []
        drm_s = []
        lsts_s = []
        alt_src_s = []

        for time in self.times:  #for every day
            #parsing, creating directory structure
            time_str, _, _ = str(time).partition('T')
            RM_dir = self.make_rm_dir(time_str)
            year, month, day = map(int, time_str.split('-'))
            if verbose: print(year, month, day)

            #data aquisition
            tec_hp, rms_hp, ion_height = self.ionex_data(year, month, day)

            #temp storage arrays
            alt_src_all = np.zeros([24, 3072])
            lsts = np.zeros(24)
            RM_add = []
            dRM_add = []
            # predict the ionospheric RM for every hour within a day
            for ui, UT in enumerate(self.UTs):
                hour = utils.std_hour(UT)
                c_icrs = SkyCoord(ra=ras * u.radian,
                                  dec=decs * u.radian,
                                  location=self.location,
                                  obstime=time + UT * u.hr,
                                  frame='icrs')

                # Added to calculate LST for the given time
                c_local = AltAz(az=0. * u.deg,
                                alt=90. * u.deg,
                                obstime=time + UT * u.hr,
                                location=self.location)
                c_local_Zeq = c_local.transform_to(ICRS)
                lsts[ui] = c_local_Zeq.ra.degree

                # Transform given RA/Dec into alt/az
                c_altaz = c_icrs.transform_to('altaz')
                alt_src = np.array(c_altaz.alt.degree)
                az_src = np.array(c_altaz.az.degree)
                alt_src_all[ui, :] = alt_src

                # AltAz.zen doesn't have method to return angle data
                zen_src = np.array(Angle(c_altaz.zen).degree)

                # Calculating the ion piercing point (IPP) depends on alt/az coords
                coord_lat, coord_lon, az_punct, zen_punct = phys.ipp(
                    self.lat_str, self.lon_str, az_src, zen_src, ion_height)

                #XXX B_para calculated per UT
                #these are the data we care about
                B_para = phys.B_IGRF(year, month, day, coord_lat, coord_lon,
                                     ion_height, az_punct, zen_punct)
                TEC_path, RMS_TEC_path = itp.get_los_tec(
                    tec_hp[ui], rms_hp[ui], coord_lat, coord_lon, zen_punct)
                IRM = 2.6e-17 * B_para * TEC_path
                rms_IRM = 2.6e-17 * B_para * RMS_TEC_path

                #TODO: replace append commands with numpy array indicies
                b_para_s.append(B_para)
                RM_add.append(IRM)
                dRM_add.append(rms_IRM)

            alt_src_s.append(alt_src_all)
            lsts_s.append(lsts)
            rm_s.append(RM_add)
            drm_s.append(dRM_add)

        self.B_para = np.array(b_para_s)
        self.RMs = np.array(rm_s)
        self.dRMs = np.array(drm_s)
        self.alt_src = np.array(alt_src_s)
        self.lst = np.array(lsts_s)
Exemplo n.º 7
0
from radiono import rm
from radiono import utils as ut
import healpy as hp, numpy as np, os
from matplotlib import pyplot as plt
from astropy.time import Time
# Moore et al.: 7 Dec 2011 to 27 Feb 2012
#dates = (('2011-12', range(6, 32)),('2012-01', range(1, 32)),('2012-02', range(1, 29)))

dates = []
for d in range(6, 32):
    dates.append('-'.join(['2011-12', ut.std_hour(d)]))
for d in range(1, 32):
    dates.append('-'.join(['2012-01', ut.std_hour(d)]))
for d in range(1, 29):
    dates.append('-'.join(['2012-02', ut.std_hour(d)]))

# PAPER INFO
lat_str = '30d43m17.5ss'
lon_str = '21d25m41.9se'

IM = rm.IonoMap(lat_str, lon_str, dates)
ras = [
    np.radians(15. * 2.),
    np.radians(15. * 4.),
    np.radians(15. * 6.),
    np.radians(15. * 8.)
]  #2,4,6,8 hrs
dec = np.radians(-30. - (43. / 60.) - (17.5 / 3600.))
#decs = [dec,dec,dec] #zenith
decs = [dec, dec, dec, dec]
Exemplo n.º 8
0
from radiono import rm
from radiono import utils as ut
import healpy as hp, numpy as np, os
from matplotlib import pyplot as plt
from astropy.time import Time
# Moore et al.: 7 Dec 2011 to 27 Feb 2012
#dates = (('2011-12', range(6, 32)),('2012-01', range(1, 32)),('2012-02', range(1, 29)))

dates = []
for d in range(6,32): dates.append('-'.join(['2011-12',ut.std_hour(d)]))
for d in range(1,32): dates.append('-'.join(['2012-01',ut.std_hour(d)]))
for d in range(1,29): dates.append('-'.join(['2012-02',ut.std_hour(d)]))

# PAPER INFO
lat_str = '30d43m17.5ss'
lon_str = '21d25m41.9se'

IM = rm.IonoMap(lat_str,lon_str,dates)
ras = [np.radians(15.*2.),np.radians(15.*4.),np.radians(15.*6.),np.radians(15.*8.)] #2,4,6,8 hrs
dec = np.radians(-30.-(43./60.)-(17.5/3600.))
#decs = [dec,dec,dec] #zenith
decs = [dec,dec,dec,dec]

#if not os.path.exists('./1h4h8h.npz'):
if not os.path.exists('./2h4h6h8h.npz'):
    print 'getting RMs'
    IM.get_radec_RM(ras,decs,verbose=True)
    np.savez('./2h4h6h8h.npz',RM=IM.RMs,dRM=IM.dRMs,dates=dates)
else:
    d = np.load('./2h4h6h8h.npz')
    dvec = np.zeros( (len(d['dates']),4,2) )
Exemplo n.º 9
0
 def test_stdHour(self):
     hr1 = ut.std_hour(1)
     self.assertEqual(hr1, '01')  #should be "01"
     hr10 = ut.std_hour(10, verbose=True)