def run_IRI16_func(dataframe, no_rows, no_columns): print('models started...') for i in range(no_rows): # print("run line ", i, " of lines ", no_rows) pt = pyglow.Point(dataframe[i].datetime, float(dataframe[i].g_lat), float(dataframe[i].g_long), float(dataframe[i].alt)) # run iri2016... pt.run_iri() if (dataframe[i].alt <= max_IRI16_alt) & (dataframe[i].alt >= min_IRI16_alt): variable_classes.Outputs["ne_iri16"].append(pt.ne) # iri2016_output[0]=Ne variable_classes.Outputs["Te_iri16"].append(pt.Te) # iri2016_output[1]=Te variable_classes.Outputs["Ti_iri16"].append(pt.Ti) # iri2016_output[2]=Ti # .nn list contains 'NO+', 'H+', 'O2+', 'HE+', 'O+' from iri model variable_classes.Outputs["Oplus_iri16"].append(pt.ni['O+']) # iri2016_output[3]=Oplus else: variable_classes.Outputs["ne_iri16"].append(None) # iri2016_output[0]=Ne variable_classes.Outputs["Te_iri16"].append(None) # iri2016_output[1]=Te variable_classes.Outputs["Ti_iri16"].append(None) # iri2016_output[2]=Ti # .nn list contains 'NO+', 'H+', 'O2+', 'HE+', 'O+' from iri model variable_classes.Outputs["Oplus_iri16"].append(None) # iri2016_output[3]=Oplus if (dataframe[i].alt <= min_IRI116_NOplus_O2plus) & (dataframe[i].alt >= min_IRI16_alt): variable_classes.Outputs["O2plus_iri16"].append(pt.ni['O2+']) # iri2016_output[4]=O2_plus variable_classes.Outputs["NOplus_iri16"].append(pt.ni['NO+']) # iri2016_output[5]=NO_plus else: variable_classes.Outputs["O2plus_iri16"].append(None) # iri2016_output[4]=O2_plus variable_classes.Outputs["NOplus_iri16"].append(None) # iri2016_output[5]=NO_plus print('IRI16 finished') return
def setUp(self): dn = datetime(2017, 3, 23, 12) lat = 40 lon = -88 alt = 250 self.pt = pyglow.Point(dn, lat, lon, alt)
def run_HWM14_func(dataframe, no_rows, no_columns): print('models started...') for i in range(no_rows): #print("run line ", i, " of lines ", no_rows) pt = pyglow.Point(dataframe[i].datetime, float(dataframe[i].g_lat), float(dataframe[i].g_long), float(dataframe[i].alt)) pt.run_hwm() if (dataframe[i].alt <= max_HWM14_alt) & (dataframe[i].alt >= min_HWM14_alt): variable_classes.Outputs["v_hwm14"].append( pt.v) # meridional wind (northward) to output table variable_classes.Outputs["u_hwm14"].append( pt.u) # zonal wind (eastward) to output table else: variable_classes.Outputs["v_hwm14"].append(None) variable_classes.Outputs["u_hwm14"].append(None) print('HWM14 finished') return
def run_MSISE00_func(dataframe, no_rows, no_columns): print('models started...') for i in range(no_rows): #print("run line ", i, " of lines ", no_rows) pt = pyglow.Point(dataframe[i].datetime, float(dataframe[i].g_lat), float(dataframe[i].g_long), float(dataframe[i].alt)) # run iri2016... pt.run_msis() if (dataframe[i].alt <= max_MSISE00_alt) & (dataframe[i].alt >= min_MSISE00_alt): variable_classes.Outputs["Tn_msise00"].append( pt.Tn_msis) # msise00_output[0]=Tn variable_classes.Outputs["O_msise00"].append( pt.nn['O']) # msise00_output[1]=O variable_classes.Outputs["O2_msise00"].append( pt.nn['O2']) # msise00_output[2]=O2 variable_classes.Outputs["N2_msise00"].append( pt.nn['N2']) # msise00_output[3]=O2 variable_classes.Outputs["rho_msise00"].append( pt.rho ) # msise00_output[4]=Dn (Density) total mass density rho [grams/cm^3] else: variable_classes.Outputs["Tn_msise00"].append( None) # msise00_output[0]=Tn variable_classes.Outputs["O_msise00"].append( None) # msise00_output[1]=O variable_classes.Outputs["O2_msise00"].append( None) # msise00_output[2]=O2 variable_classes.Outputs["N2_msise00"].append( None) # msise00_output[3]=O2 variable_classes.Outputs["rho_msise00"].append( None ) # msise00_output[4]=Dn (Density) total mass density rho [grams/cm^3] print('MSISE finished') return
from datetime import datetime import pyglow terminate = 0 while not terminate: year = input() month = input() day = input() hour = input() minute = input() latitude = input() longitude = input() altitude = input() terminate = int(input()) time = datetime(int(year), int(month), int(day), int(hour), int(minute)) pt = pyglow.Point(time, float(latitude), float(longitude), float(altitude)) pt.run_iri() print(pt.ne, flush=True) if terminate: break
matplotlib.rcParams.update({'font.size': 16}) # Setting lat, lon, and a range of altitudes lat = 18.37 # Arecibo lon = -66.62 alts = np.linspace(85, 1000, 500) # Set time (i.e., dn) dn_lt = datetime(2012, 3, 22, 0, 0) tz = np.ceil(lon / 15.) dn_ut = dn_lt - timedelta(hours=tz) # Airglow calculation using pyglow: ag, ne = [], [] for alt in alts: pt = pyglow.Point(dn_ut, lat, lon, alt) pt.run_iri() pt.run_msis() pt.run_airglow() ag.append(pt.ag6300) ne.append(pt.ne) # Plot data: plt.figure(1, figsize=(7, 8)) plt.clf() plt.semilogy(ag, alts, '-k', lw=4, label='$V_{630.0}$') plt.grid() plt.ylim([alts[0], alts[-1]]) the_yticks = np.arange(100, 1001, 100)
def add_hwm_winds_and_ecef_vectors(inst, glat_label='glat', glong_label='glong', alt_label='alt'): """ Uses HWM (Horizontal Wind Model) model to obtain neutral wind details. Uses pyglow module to run HWM. Configured to use actual solar parameters to run model. Example ------- # function added velow modifies the inst object upon every inst.load call inst.custom.add(add_hwm_winds_and_ecef_vectors, 'modify', glat_label='custom_label') Parameters ---------- inst : pysat.Instrument Designed with pysat_sgp4 in mind glat_label : string label used in inst to identify WGS84 geodetic latitude (degrees) glong_label : string label used in inst to identify WGS84 geodetic longitude (degrees) alt_label : string label used in inst to identify WGS84 geodetic altitude (km, height above surface) Returns ------- inst Input pysat.Instrument object modified to include HWM winds. 'zonal_wind' for the east/west winds (u in model) in m/s 'meiridional_wind' for the north/south winds (v in model) in m/s 'unit_zonal_wind_ecef_*' (*=x,y,z) is the zonal vector expressed in the ECEF basis 'unit_mer_wind_ecef_*' (*=x,y,z) is the meridional vector expressed in the ECEF basis 'sim_inst_wind_*' (*=x,y,z) is the projection of the total wind vector onto s/c basis """ import pyglow import pysatMagVect hwm_params = [] for time, lat, lon, alt in zip(inst.data.index, inst[glat_label], inst[glong_label], inst[alt_label]): # Point class is instantiated. # Its parameters are a function of time and spatial location pt = pyglow.Point(time, lat, lon, alt) pt.run_hwm() hwm = {} hwm['zonal_wind'] = pt.u hwm['meridional_wind'] = pt.v hwm_params.append(hwm) # print 'Complete.' hwm = pds.DataFrame(hwm_params) hwm.index = inst.data.index inst[['zonal_wind', 'meridional_wind']] = hwm[['zonal_wind', 'meridional_wind']] # calculate zonal unit vector in ECEF # zonal wind: east - west; positive east # EW direction is tangent to XY location of S/C in ECEF coordinates mag = np.sqrt(inst['position_ecef_x']**2 + inst['position_ecef_y']**2) inst['unit_zonal_wind_ecef_x'] = -inst['position_ecef_y'] / mag inst['unit_zonal_wind_ecef_y'] = inst['position_ecef_x'] / mag inst['unit_zonal_wind_ecef_z'] = 0 * inst['position_ecef_x'] # calculate meridional unit vector in ECEF # meridional wind: north - south; positive north # mer direction completes RHS of position and zonal vector unit_pos_x, unit_pos_y, unit_pos_z = \ pysatMagVect.normalize_vector(-inst['position_ecef_x'], -inst['position_ecef_y'], -inst['position_ecef_z']) # mer = r x zonal inst['unit_mer_wind_ecef_x'], inst['unit_mer_wind_ecef_y'], inst['unit_mer_wind_ecef_z'] = \ pysatMagVect.cross_product(unit_pos_x, unit_pos_y, unit_pos_z, inst['unit_zonal_wind_ecef_x'], inst['unit_zonal_wind_ecef_y'], inst['unit_zonal_wind_ecef_z']) # Adding metadata information inst.meta['zonal_wind'] = { 'units': 'm/s', 'long_name': 'Zonal Wind', 'desc': 'HWM model zonal wind' } inst.meta['meridional_wind'] = { 'units': 'm/s', 'long_name': 'Meridional Wind', 'desc': 'HWM model meridional wind' } inst.meta['unit_zonal_wind_ecef_x'] = { 'units': '', 'long_name': 'Zonal Wind Unit ECEF x-vector', 'desc': 'x-value of zonal wind unit vector in ECEF co ordinates' } inst.meta['unit_zonal_wind_ecef_y'] = { 'units': '', 'long_name': 'Zonal Wind Unit ECEF y-vector', 'desc': 'y-value of zonal wind unit vector in ECEF co ordinates' } inst.meta['unit_zonal_wind_ecef_z'] = { 'units': '', 'long_name': 'Zonal Wind Unit ECEF z-vector', 'desc': 'z-value of zonal wind unit vector in ECEF co ordinates' } inst.meta['unit_mer_wind_ecef_x'] = { 'units': '', 'long_name': 'Meridional Wind Unit ECEF x-vector', 'desc': 'x-value of meridional wind unit vector in ECEF co ordinates' } inst.meta['unit_mer_wind_ecef_y'] = { 'units': '', 'long_name': 'Meridional Wind Unit ECEF y-vector', 'desc': 'y-value of meridional wind unit vector in ECEF co ordinates' } inst.meta['unit_mer_wind_ecef_z'] = { 'units': '', 'long_name': 'Meridional Wind Unit ECEF z-vector', 'desc': 'z-value of meridional wind unit vector in ECEF co ordinates' } return
def PROC_StatsCalculator(ProcessNum, CDF_filename, TypeOfCalculation): # partialResultFilename IS OBSOLETE, TMP_FOLDER is used to save all values #partialResultFilename = Data.ResultFilename+".part"+str(ProcessNum) #if os.path.exists(partialResultFilename): # print( "Process",ProcessNum, ":", partialResultFilename, "exists. I am not needed." ) # return # <<<< # check if the data of this process have already been calculated procfolder = TMP_FOLDER + "proc" + f"{ProcessNum:03}" + "/" if os.path.isdir(procfolder): print("Data for file", ProcessNum, "already calculated.", "Process", ProcessNum, "finished.") return # <<<< else: if os.path.isdir(TMP_FOLDER) == False: os.mkdir(TMP_FOLDER) os.mkdir(procfolder) # open netCDF file ######## while( os.path.exists("ReadingFile.flag") ): # wait until no other process is reading from disk/NFS ######## time.sleep(random.randint(8,20)) print("Process", ProcessNum, "reading ", CDF_filename[CDF_filename.rfind('/') + 1:], datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%S")) #Path("ReadingFile.flag").touch() # raise a flag that this process is now reading a file, so that other processes wait try: CDFroot = Dataset(CDF_filename, 'r') except: print(" !!!!!!!! WRONG FORMAT:", CDF_filename) #os.remove("ReadingFile.flag") # lower the reading-file flag return # read the data from the netCDF file #TIMEs = CDFroot.variables['time'][:] if "JH" in TypeOfCalculation: Ohmics = CDFroot.variables['Ohmic'][:, :, :, :] # m/s if "PedCond" in TypeOfCalculation: PEDs = CDFroot.variables['SIGMA_PED'][:, :, :, :] if "HallCond" in TypeOfCalculation: HALs = CDFroot.variables['SIGMA_HAL'][:, :, :, :] if "EEX_si" in TypeOfCalculation: EEXs = CDFroot.variables['EEX_si'][:, :, :, :] if "EEY_si" in TypeOfCalculation: EEYs = CDFroot.variables['EEY_si'][:, :, :, :] if "ConvHeat" in TypeOfCalculation: ConvH = CDFroot.variables['Convection_heating'][:, :, :, :] if "WindHeat" in TypeOfCalculation: WindH = CDFroot.variables['Wind_heating'][:, :, :, :] if "JHminusWindHeat" in TypeOfCalculation: WindH = CDFroot.variables['Wind_heating'][:, :, :, :] if "JHnoWindsEISCAT" in TypeOfCalculation: UI = CDFroot.variables['UI_ExB'][:, :, :, :] VI = CDFroot.variables['VI_ExB'][:, :, :, :] WI = CDFroot.variables['WI_ExB'][:, :, :, :] TIMEs = CDFroot.variables['time'][:] PEDs = CDFroot.variables['SIGMA_PED'][:, :, :, :] LONs = CDFroot.variables['lon'][:] ZGs = CDFroot.variables[ 'ZG'][:, :, :, :] / 100000 # Geometric height stored in cm, converted to km # if "EISCAT" in TypeOfCalculation: LATs = CDFroot.variables['lat'][:] MLATs = CDFroot.variables['mlat_qdf'][:, :, :, :] MLTs = CDFroot.variables['mlt_qdf'][:, :, :, :] ALTs = CDFroot.variables[ 'ZGMID'][:, :, :, :] / 100000 # Geometric height stored in cm, converted to km KPs = CDFroot.variables['Kp'][:] #try: # os.remove("ReadingFile.flag") # lower the reading-file flag #except: # pass ResultBuckets = Data.init_ResultDataStructure().copy() num_of_unbinned_items = 0 step = 1 for idx_time in range(0, len(ALTs), step): if idx_time % 20 == 0: print( idx_time, "of", len(ALTs), CDF_filename[CDF_filename.rfind("sech_") + 4:CDF_filename.rfind("_JH") + 1] + "...nc", datetime.datetime.now().strftime("%H:%M:%S")) for idx_lev in range(0, len(ALTs[0]), step): for idx_lat in range(0, len(ALTs[0, 0]), step): for idx_lon in range(0, len(ALTs[0, 0, 0]), step): curr_alt_km = ALTs[idx_time, idx_lev, idx_lat, idx_lon] # ignore values for out-of-range positions if curr_alt_km < Data.ALT_min or curr_alt_km > Data.ALT_max: continue if "EISCAT" in TypeOfCalculation: if LATs[idx_lat] < 71 or LATs[ idx_lat] > 78.5: #if LATs[idx_lat] < 60: continue curr_kp = KPs[idx_time] curr_mlt = MLTs[idx_time, idx_lev, idx_lat, idx_lon] curr_maglat = MLATs[idx_time, idx_lev, idx_lat, idx_lon] kp_to_fall, alt_to_fall, maglat_to_fall, mlt_to_fall = Data.LocatePositionInBuckets( curr_kp, curr_alt_km, curr_maglat, curr_mlt) if kp_to_fall is None or alt_to_fall is None or maglat_to_fall is None or mlt_to_fall is None: num_of_unbinned_items += 1 #if num_of_unbinned_items < 4: # print( "WARNING: [", curr_kp, curr_alt_km, curr_maglat, curr_mlt, "] -> [", kp_to_fall, alt_to_fall, maglat_to_fall, mlt_to_fall, "] not binned" ) break else: if TypeOfCalculation == "JHminusWindHeat" or TypeOfCalculation == "JHminusWindHeatEISCAT": aValue = Ohmics[idx_time, idx_lev, idx_lat, idx_lon] - WindH[idx_time, idx_lev, idx_lat, idx_lon] if aValue > 100: continue # ignore faulty large values elif TypeOfCalculation == "JHEISCAT" or TypeOfCalculation == "JH": aValue = Ohmics[idx_time, idx_lev, idx_lat, idx_lon] if aValue > 100: continue # ignore faulty large values elif "PedCond" in TypeOfCalculation: aValue = PEDs[idx_time, idx_lev, idx_lat, idx_lon] elif "HallCond" in TypeOfCalculation: aValue = HALs[idx_time, idx_lev, idx_lat, idx_lon] elif "EEX_si" in TypeOfCalculation: aValue = EEXs[idx_time, idx_lev, idx_lat, idx_lon] elif "EEY_si" in TypeOfCalculation: aValue = EEYs[idx_time, idx_lev, idx_lat, idx_lon] elif "ConvHeat" in TypeOfCalculation: aValue = ConvH[idx_time, idx_lev, idx_lat, idx_lon] if aValue > 100: continue # ignore faulty large values elif "WindHeat" in TypeOfCalculation: aValue = WindH[idx_time, idx_lev, idx_lat, idx_lon] elif TypeOfCalculation == "JHnoWindsEISCAT": I = list() B = list() time_p = datetime.datetime( 2015, 3, 15, 0, 0, 0) + datetime.timedelta( minutes=TIMEs[idx_time]) lat_p = LATs[idx_lat] lon_p = LONs[idx_lon] alt_p = ZGs[idx_time, idx_lev, idx_lat, idx_lon] pt = pyglow.Point(time_p, lat_p, lon_p, alt_p) # pyglow igrf pt.run_igrf() B.append(pt.Bx) # Be, Tesla (si) B.append(pt.By) # Bn, Tesla (si) B.append(pt.Bz) # Bu, Tesla (si) I.append(UI[idx_time, idx_lev, idx_lat, idx_lon]) I.append(VI[idx_time, idx_lev, idx_lat, idx_lon]) I.append(WI[idx_time, idx_lev, idx_lat, idx_lon]) E = -1 * np.cross(I, B) aValue = PEDs[idx_time, idx_lev, idx_lat, idx_lon] * np.dot(E, E) else: print("ERROR: UNRECOGNISED TypeOfCalculation '" + TypeOfCalculation + "'") CDFroot.close() return ResultBuckets[kp_to_fall, alt_to_fall, maglat_to_fall, mlt_to_fall, "Vals"].append(aValue) # close cdf print("Process", ProcessNum, "num_of_unbinned_items =", num_of_unbinned_items) CDFroot.close() # save results #XML.WriteResultsToXML( ResultBuckets, "Ohmic", ResultFilename + ".part" + str(ProcessNum), CDF_filename ) #Data.WriteResultsToCDF(ResultBuckets, partialResultFilename, "Joule Heating", "W/m3") # ---- save values of each bin in a txt file print("A", datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%S")) for aKP in Data.KPsequence: for anALT in Data.ALTsequence: for aMagLat in Data.MLATsequence: for aMLT in Data.MLTsequence: if len(ResultBuckets[aKP, anALT, aMagLat, aMLT, "Vals"]) > 0: fname = str(aKP) + "_" + str(anALT) + "_" + str( aMagLat) + "_" + str(aMLT) + ".txt" # FOR WRITING VALUES AS TEXT: # f = open( procfolder + fname, "w" ) # f.write( ' '.join([str(i) for i in ResultBuckets[aKP, anALT, aMagLat, aMLT, "Vals"]]) ) f = open(procfolder + fname, "wb") float_array = array( 'd', ResultBuckets[aKP, anALT, aMagLat, aMLT, "Vals"]) float_array.tofile(f) f.close() # ---- print("Process", ProcessNum, "concluded.")
limb=limb, Spherical=Spherical, reg_method=reg_method, regu_order=regu_order, contribution=contribution, dn=dn, f107=my_f107, f107a=my_f107a, f107p=my_f107p, apmsis=my_apmsis) ne_true = np.zeros_like(Ne) for m in range(len(ne_true)): pt = pyglow.Point(dn, satlatlonalt[0], satlatlonalt[1], h_centered[m], user_ind=True) # pt = pyglow.Point(dn, tanlats[m], tanlons[m], h_centered[m], user_ind=True) pt.f107 = my_f107 pt.f107a = my_f107a pt.f107p = my_f107p pt.apmsis = my_apmsis pt.run_iri() ne_true[m] = pt.ne hm, Nm, sig_hm, sig_Nm = find_hm_Nm_F2(Ne, h_centered, Sig_NE=Sig_Ne) hm_w, Nm_w, sig_hm_w, sig_Nm_w = find_hm_Nm_F2(Ne_w, h_centered, Sig_NE=Sig_Ne_w)
eph = load('de421.bsp') min_to_do = 60 # propagate every minute for n in range(0, min_to_do, 1): nm = timedelta(minutes=n) cdate = st_date + nm t = ts.utc(cdate.year, cdate.month, cdate.day, cdate.hour, cdate.minute, 0) # get the satellite pos geocentric = sat.at(t) sunlit = sat.at(t).is_sunlit(eph) subpoint = wgs84.subpoint(geocentric) # get ne and te data pt = pyglow.Point(cdate, subpoint.latitude.degrees, subpoint.longitude.degrees, alt) pt.run_iri() # save data ne.append(pt.ne * 100**3) # convert to m^-3 te.append(pt.Te) daynight.append(sunlit) lats.append(subpoint.latitude.degrees) lons.append(subpoint.longitude.degrees) if n % (min_to_do / 10) == 0: print('minutes is', n, 'of ', min_to_do) print('done propagating') # break into night and day
ze = ze[alt_arr > 150] lat_arr = lat_arr[alt_arr > 150] lon_arr = lon_arr[alt_arr > 150] alt_arr = alt_arr[alt_arr > 150] O_p_arr = np.zeros_like(alt_arr) O_arr = np.zeros_like(alt_arr) Ne_arr = np.zeros_like(alt_arr) RR1_arr = np.zeros_like(alt_arr) RR2_arr = np.zeros_like(alt_arr) D = create_cells_Matrix_spherical_symmetry(ze[::-1], satalt) for i, alt in enumerate(alt_arr): my_f107, my_f107a, my_f107p, my_apmsis = get_msisGPI( dn, year_day, f107, f107a, ap, ap3) pt = pyglow.Point(dn, lat_arr[i], lon_arr[i], alt, user_ind=True) # pt = pyglow.Point(dn, satlat, satlon, alt, user_ind=True) pt.f107 = my_f107 pt.f107a = my_f107a pt.f107p = my_f107p pt.apmsis = my_apmsis pt.run_iri() pt.run_msis() # Pull necessary constitutents O_p_arr[i] = pt.ni['O+'] # O+ density (1/cm^3) O_arr[i] = pt.nn['O'] # O density (1/cm^3) Ne_arr[i] = pt.ne # electron density (1/cm^3) # Calcualte radiative recombination (equation 17) and mutual neutralization (equation 18) a1356 = 7.3e-13 # radiative recombination rate (cm^3/s)
# CALL MSIS #============================================================================== lat = 0. lon = 0. dn = datetime(1992, 3, 20, 0, 2)#year,month,day,hour,minute MSIS_data = np.zeros((72,144)) marklon = 0 gridspace = 2.5 # 2.5 degree grid spacing #Loop through lat and lon. select what MSIS values are desired for Lon in range(-72,72,1) : marklat = 0 for Lat in range(-36,36,1): pt = pyglow.Point(dn, Lat*2.5, Lon*2.5, 400) #2.5 degree grid size result = pt.run_msis() MSIS_data[marklat,marklon] = result.nn['HE'] # helium number density marklat = marklat+1 marklon = marklon+1 F107 = pt.f107 Ap = pt.ap # LOAD MAGNETIC EQUATOR PTS #============================================================================== mag_equator = np.loadtxt("Magnetic_equator_lat_lon.txt", delimiter=',') magnetic_x = np.linspace(0, 143 / 6, 360) # Create grid