Ejemplo n.º 1
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
        '''
        self.RMs = {}
        self.dRMs = {}
        self.B_paras = {}
        self.TEC = {}
        self.dTEC = {}

        alt_src, az_src = self._hp_arr()
        zen_src , _ = hp.pix2ang(self.nside, np.arange(self.npix))
        az_src = np.degrees(az_src)
        zen_src = np.degrees(zen_src)

        for uday in self.day_groups:
            group = self.day_groups[uday]
            time_strs = [item.split(' ')[1] for item in group]
            UTs_dec = []
            for time_str in time_strs:
                Hr, Min, Sec = [float(x) for x in time_str.split(':')]
                dec_hour = Hr + Min / 60. + Sec / 3600.
                UTs_dec.append(dec_hour)
            year, month, day = [int(x) for x in uday.split('-')]

            tec_a, rms_a, ion_height, TEC = self.ionex_data(year, month, day)
            tec_hp = itp.ionex2healpix(tec_a, UTs_dec, TEC['lat'], TEC['lon'])
            rms_hp = itp.ionex2healpix(rms_a, UTs_dec, TEC['lat'], TEC['lon'])

            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(UTs_dec):
                TEC_path, RMS_TEC_path = itp.get_los_tec(tec_hp[ui], rms_hp[ui],
                                                          coord_lat, coord_lon,
                                                          zen_punct)
                RM_ut = phys.RotationMeasure(TEC_path, B_para)
                dRM_ut = phys.RotationMeasure(RMS_TEC_path, B_para)
                RMs.append(RM_ut)
                dRMs.append(dRM_ut)

            self.RMs.update({key:RMs[ti] for ti, key in enumerate(group)})
            self.dRMs.update({key:dRMs[ti] for ti, key in enumerate(group)})
            self.B_paras[uday] = B_para
            self.TEC.update({key:tec_hp[ti] for ti,key in enumerate(group)})
            self.dTEC.update({key:rms_hp[ti] for ti,key in enumerate(group)})
Ejemplo 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)
Ejemplo n.º 3
0
    def calc_ionRIME_rm(self, verbose=False):
        
        # angle logic
        hpxidx = np.arange(self.npix)
        theta, phi = hp.pix2ang(self.nside, hpxidx)
        R = hp.rotator.Rotator(rot=[0,-120.712])
        zen, az = R(theta, phi)
        az[az < 0] += 2. * np.pi # az = -az
        zen_src = np.degrees(zen)
        az_src = np.degrees(az)
       
        # setup storage
        self.RMs = {}
        self.dRMs = {}
        self.B_paras = {}
        self.TEC = {}
        self.dTEC = {}

        for uday in self.day_groups:
            # time logic
            group = self.day_groups[uday]
            time_strs = [item.split(' ')[1] for item in group]
            UTs_dec = []
            for time_str in time_strs:
                Hr, Min, Sec = [float(x) for x in time_str.split(':')]
                dec_hour = Hr + Min / 60. + Sec / 3600.
                UTs_dec.append(dec_hour)
            year, month, day = [int(x) for x in uday.split('-')]

            tec_a, rms_a, ion_height, TEC = self.ionex_data(year, month, day)
            tec_hp = itp.ionex2healpix(tec_a, UTs_dec, TEC['lat'], TEC['lon'])
            rms_hp = itp.ionex2healpix(rms_a, UTs_dec, TEC['lat'], TEC['lon'])
            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(UTs_dec):
                TEC_path, RMS_TEC_path = itp.get_los_tec(tec_hp[ui], rms_hp[ui],
                                                          coord_lat, coord_lon,
                                                          zen_punct)
                RM_ut = phys.RotationMeasure(TEC_path, B_para)
                dRM_ut = phys.RotationMeasure(RMS_TEC_path, B_para)
                RMs.append(RM_ut)
                dRMs.append(dRM_ut)

            self.RMs.update({key:RMs[ti] for ti, key in enumerate(group)})
            self.dRMs.update({key:dRMs[ti] for ti, key in enumerate(group)})
            self.B_paras[uday] = B_para
            self.TEC.update({key:tec_hp[ti] for ti,key in enumerate(group)})
            self.dTEC.update({key:rms_hp[ti] for ti,key in enumerate(group)})
Ejemplo 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)
Ejemplo n.º 5
0
def _test_ionosphere_map(date_str='2004-05-19T00:00:00'):
    # date_str = '2004-05-19T00:00:00'
    lat_str = '30d43m17.5ss'
    lon_str = '21d25m41.9se'



    year, month, day = date_str.split('T')[0].split('-')

    tec_hp, rms_hp, ion_height = inx.IONEX_data(year, month, day, verbose=False)

    nside_in = 2**4
    npix_in = hp.nside2npix(nside_in)
    hpxidx = np.arange(npix_in)
    za, az = hp.pix2ang(nside_in, hpxidx)

    lat, lon, az_p, za_p = phys.ipp(lat_str, lon_str,
                                np.degrees(az), np.degrees(za),
                                ion_height)

    B_para = phys.B_IGRF(year, month, day,
                    lat, lon,
                    ion_height,
                    az_p, za_p)

    TEC_path = np.zeros((24,npix))
    for t in range(0,24):
        hour = rad.std_hour(t, verbose=False)

        TEC_path[t], _ = itp.interp_space(tec_hp[t], rms_hp[t],
                                                 lat, lon,
                                                 za_p)

    RM_maps = ion_RM(B_para, TEC_path)

    for t in range(24):
        RM_maps[t] = rotate_healpix_map(RM_maps[t], R_z0.T)
Ejemplo n.º 6
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)
Ejemplo n.º 7
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)
Ejemplo n.º 8
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'
        # setup storage
        self.B_paras = {}
        self.RMs = {}
        self.dRMs = {}
        self.TEC = {}
        self.dTEC = {}
        self.lsts_s = {}
        alt_src_s = {}

        for uday in self.day_groups:
            # time logic
            group = self.day_groups[uday]
            time_strs = [item.split(' ')[1] for item in group]
            UTs_dec = []
            for time_str in time_strs:
                Hr, Min, Sec = [float(x) for x in time_str.split(':')]
                dec_hour = Hr + Min / 60. + Sec / 3600.
                UTs_dec.append(dec_hour)
            year, month, day = [int(x) for x in uday.split('-')]

            #data aquisition
            tec_a, rms_a, ion_height, TEC = self.ionex_data(year, month, day)
            tec_hp = itp.ionex2healpix(tec_a, UTs_dec, TEC['lat'], TEC['lon'])
            rms_hp = itp.ionex2healpix(rms_a, UTs_dec, TEC['lat'], TEC['lon'])
            lsts,RMs,dRMs = [],[],[]
            
            # predict the ionospheric RM for every hour within a day
            for ui,UT in enumerate(UTs_dec):
                time = Time(uday + ' ' +  time_strs[ui], format='iso', scale='utc') # XXX is this string reconstructed properly? not tested
                c_icrs = SkyCoord(ra=ras * u.radian, dec=decs * u.radian,
                                        location=self.location,
                                        obstime=time,
                                        frame='icrs')

                # Added to calculate LST for the given time
                c_local = AltAz(az=0.*u.deg, alt=90.*u.deg, obstime=time, 
                                location=self.location)
                c_local_Zeq = c_local.transform_to(ICRS)
                lsts.append(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)

                # 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)
                RMs_ut = phys.RotationMeasure(TEC_path, B_para)
                dRMs_ut = phys.RotationMeasure(RMS_TEC_path, B_para)

                #TODO: replace append commands with numpy array indicies
                RMs.append(RMs_ut)
                dRMs.append(dRMs_ut)
            
            self.RMs.update({key:RMs[ti] for ti, key in enumerate(group)})
            self.dRMs.update({key:dRMs[ti] for ti, key in enumerate(group)})
            self.B_paras[uday] = B_para
            self.TEC.update({key:tec_hp[ti] for ti,key in enumerate(group)})
            self.dTEC.update({key:rms_hp[ti] for ti,key in enumerate(group)})