def getSolarPosition(t, project_data):
# Get solar position from lat/lng, elevation and datetime
phi, theta_h, rasc, d, h = sunpos(t, project_data['latitude'], project_data['longitude'], project_data['elevation'])[:5]
# Convert azimuth (N) to azimuth (S)
phi_south = phi - 180.0;
# Calculate tilt angle from vertical
eta = project_data['tilt'];
# Calculate surface-solar azimuth angle
gamma = math.fabs((phi_south - project_data['azimuth']));
if project_data['zenith_filter'] and theta_h > project_data['zenith_limit']:
theta_h = project_data['zenith_limit']
# Calculate altitude angle
beta = 90.0 - theta_h;
# Calculate incident angle to surface
theta = rad2deg(math.acos((( math.cos(deg2rad(beta)) * math.cos(deg2rad(gamma)) * math.sin(deg2rad(eta)) ) + (math.sin(deg2rad(beta)) * math.cos(deg2rad(eta))))));
# Solar position datum
sp_datum = {
'Datetime_UTC': t,
'Azimuth': phi,
'Zenith': theta_h,
'RightAscension': rasc,
'Declination': d,
'HourAngle': h,
'IncidentAngle': theta
}
return sp_datum
def rad_clear_instant(self):
self.utc = self.lt - relativedelta(hours=self.ltz)
self.theta = sunpos(self.utc, self.lat, self.lon, self.z, radians=True)[1]
if self.theta>=np.pi/2.0:
rad_total, rad_beam, rad_diff, rad_norm = 0.0, 0.0, 0.0, 0.0
else:
self.jd = self.utc.timetuple().tm_yday
sun2earth = 1.0-0.01672*np.cos(0.9856*(self.jd-4.0)*np.pi/180.) # relative sun-earth distance [-]
s = hybrid.s0*sun2earth**2
I0 = s*np.cos(self.theta)
self._air_mass()
self._corrected_air_mass()
self._taug()
self._taur()
self._tauw()
self._tauo()
self._taua()
self._tau_clear_beam()
self._tau_clear_diff()
rad_beam = I0*self.tau_clear_beam
rad_diff = I0*self.tau_clear_diff
rad_norm = s *self.tau_clear_beam
rad_total = rad_beam + rad_diff
return rad_total, rad_beam, rad_diff, rad_norm
def coszen(self):
self.dt = self.datetime
az, zen, ra, dec, h = sunpos(self.datetime,
self.latitude,
self.longitudeE,
self.surface_elevation_km * 1000.0,
radians=True)
return s.cos(zen)
def main():
parser = argparse.ArgumentParser()
parser.description = "draw analemma, the Sun runs from red point to green point to blue point"
parser.add_argument("--camera_azimuth", default=-1000, help="azimuth", type=float)
parser.add_argument("--camera_pitch", default=-1000, help="pitch", type=float)
parser.add_argument("--camera_roll", default=-1000, help="roll", type=float)
parser.add_argument("--facing_back", default=True, help="camera facing back or not", type=lambda s: s == "True")
parser.add_argument("--focal_length", default=24, help="camera focal length in mm", type=float)
parser.add_argument("--sensor_width", default=36, help="camera sensor width in mm", type=float)
parser.add_argument("--sensor_height", default=24, help="camera sensor height in mm", type=float)
parser.add_argument("--pixel_width", default=5760, help="image width in pixel", type=int)
parser.add_argument("--pixel_height", default=3840, help="image height in pixel", type=int)
parser.add_argument("--datetime", default=datetime.utcnow(), help="UTC datetime in format %%Y-%%m-%%d H:M:S", type=lambda s: datetime.strptime(s, '%Y-%m-%d %H:%M:%S'))
parser.add_argument("--npoints_before", default=15, help="number of points before datetime", type=int)
parser.add_argument("--npoints_after", default=15, help="number of points after datetime", type=int)
parser.add_argument("--latitude", help="latitude", type=float)
parser.add_argument("--longitude", help="longitude", type=float)
parser.add_argument("--elevation", default=0, help="elevation", type=float)
parser.add_argument("--save", metavar="FILENAME", nargs="?", const="analemma.png", help="save image", type=str)
args = parser.parse_args()
if args.latitude == None or args.longitude == None:
args.latitude, args.longitude = getLatitudeLongitude()
if args.camera_azimuth == -1000 or args.camera_pitch == -1000 or args.camera_roll == -1000:
marchDateTime = args.datetime - timedelta(days = (args.datetime.month - 3)*30)
default_azimuth, default_zenith = sunpos(marchDateTime, latitude=args.latitude, longitude=args.longitude, elevation=args.elevation)[:2]
# if args.facing_back == True:
# args.camera_azimuth = default_azimuth
# args.camera_pitch = default_zenith - 180.0
# args.camera_roll = 0.0
# else:
# args.camera_azimuth = default_azimuth - 180.0
# if args.camera_azimuth < 0.0:
# args.camera_azimuth += 360.0
# args.camera_pitch = -default_zenith
# args.camera_roll = 0.0
if default_zenith <= 90.0:
args.camera_azimuth = default_azimuth - 180.0
if args.camera_azimuth < 0:
args.camera_azimuth += 360.0
args.camera_pitch = -default_zenith
args.camera_roll = 180.0
else:
args.camera_azimuth = default_azimuth
args.camera_pitch = default_zenith - 180.0
args.camera_roll = 0.0
if args.facing_back == False:
args.camera_roll += 180.0
if args.camera_roll > 180.0:
args.camera_roll -= 360.0
print "default camera_azimuth is %f" % args.camera_azimuth
print "default camera_pitch is %f" % args.camera_pitch
print "default camera_roll is %f" % args.camera_roll
xs, ys, colors = getPoints(args)
plot(args, xs, ys, colors)
def getSolarPositions(args):
dates = getDateTimes(args.datetime, args.npoints_before, args.npoints_after)
azimuth_list = []
zenith_list = []
for date in dates:
azimuth,zenith = sunpos(date, latitude=args.latitude, longitude=args.longitude, elevation=args.elevation)[:2]
azimuth_list.append(azimuth)
zenith_list.append(zenith)
return azimuth_list,zenith_list
def coszen(self):
""" Return the cosine of the solar zenith."""
self.dt = self.datetime
az, zen, ra, dec, h = sunpos(self.datetime,
self.latitude,
self.longitudeE,
self.surface_elevation_km * 1000.0,
radians=True)
return s.cos(zen)
def calculate_g(direction, tilt, latitude, longitude, time):
if time is None:
time = datetime.utcnow()
azimuth, zenith, _, _, _ = sunpos(time, [latitude], [longitude], 0)[0]
factor = cos((zenith - tilt) * 0.017453)
if factor < 0 or zenith > 90:
factor = 0
factor *= cos((azimuth - direction) * 0.017453)
if factor < 0:
factor = 0
return 1000 * factor
def init():
global loopRunning
loopRunning = True
while loopRunning:
time.sleep(5)
now = datetime.utcnow()
for thing in myThings():
lat = thing.paramValue(sunPositionThingLatitudeParamTypeId)
lon = thing.paramValue(sunPositionThingLongitudeParamTypeId)
az, zen = sunpos(now, lat, lon, 0)[:2]
angle = 90 - zen.item()
logger.log("Updating thing", thing.name, "Angle:", angle)
thing.setStateValue(sunPositionAngleStateTypeId, angle)
def get_time_and_sza(args, dataframe, longitude, latitude):
dtime_1970, tz = common.time_common(args.timezone)
num_rows = dataframe['year'].size
time, time_bounds, sza = ([0] * num_rows for _ in range(3))
for idx in range(num_rows):
keys = ('year', 'month', 'day', 'hour')
dtime = datetime(*[dataframe[k][idx] for k in keys])
dtime = tz.localize(dtime.replace(tzinfo=None))
time[idx] = (dtime - dtime_1970).total_seconds()
time_bounds[idx] = (time[idx], time[idx] + common.seconds_in_hour)
sza[idx] = sunpos(dtime, latitude, longitude, 0)[1]
return time, time_bounds, sza
def solve(args):
datalist = json.loads(args.data)
worldPoints = np.empty(shape=[3, 0])
viewPoints = np.empty(shape=[3, 0])
for i in range(len(datalist)):
data = datalist[i]
xInPixel = data[0]
yInPixel = data[1]
date = datetime.strptime(data[2], '%Y-%m-%d %H:%M:%S')
azimuth, zenith = sunpos(date, latitude=args.latitude, longitude=args.longitude, elevation=args.elevation)[:2]
worldPoint = worldAzimuthZenith2WorldPoint(azimuth, zenith)
xInMM, yInMM = pixel2MM(xInPixel, yInPixel, args.pixel_width, args.pixel_height, args.sensor_width, args.sensor_height)
viewPoint = projection2ViewPoint(xInMM, yInMM, args.focal_length, args.sensor_width, args.sensor_height, args.facing_back)
worldPoints = np.append(worldPoints, worldPoint, 1)
viewPoints = np.append(viewPoints, viewPoint, 1)
cameraAzimuth, cameraPitch, cameraRoll = getOrientation(worldPoints, viewPoints)
return cameraAzimuth,cameraPitch, cameraRoll
def get_time_and_sza(args, input_file, latitude, longitude):
dtime_1970, tz = common.time_common(args.timezone)
header_rows = 8
with open(input_file) as stream:
lines = stream.readlines()[header_rows:]
time, bounds, sza = [], [], []
for line in lines:
dtime = line.strip().split(",")[0]
dtime = datetime.strptime(dtime, '%Y-%m-%dT%H:%M:%SZ')
dtime = tz.localize(dtime.replace(tzinfo=None))
seconds = (dtime - dtime_1970).total_seconds()
time.append(seconds)
bounds.append((seconds - common.seconds_in_hour, seconds))
sza.append(sunpos(dtime, latitude, longitude, 0)[1])
return time, bounds, sza
def get_time_and_sza(args, dataframe, longitude, latitude):
# Divided by 4 because each hour value is a multiple of 4
# and then multiplied by 100 to convert decimal to integer
hour_conversion = 100 / 4
last_hour = 23
seconds_in_hour = common.seconds_in_hour
num_rows = dataframe['year'].size
month, day, time, time_bounds, sza = ([0] * num_rows for _ in range(5))
hour = dataframe['julian_decimal_time']
hour = [round(i - int(i), 3) * hour_conversion for i in hour]
hour = [int(h) if int(h) <= last_hour else 0 for h in hour]
dtime_1970, tz = common.time_common(args.timezone)
for idx in range(num_rows):
time_year = dataframe['year'][idx]
time_j = int(dataframe['julian_decimal_time'][idx])
time_hour = hour[idx]
temp_dtime = '{} {} {}'.format(time_year, time_j, time_hour)
temp_dtime = datetime.strptime(temp_dtime, "%Y %j %H")
temp_dtime = tz.localize(temp_dtime.replace(tzinfo=None))
if time_j <= 366:
time[idx] = (temp_dtime - dtime_1970).total_seconds()
else:
# Assign time of previous row, if julian_decimal_time > 366
time[idx] = time[idx - 1]
time_bounds[idx] = (time[idx] - seconds_in_hour, time[idx])
sza[idx] = sunpos(temp_dtime, latitude, longitude, 0)[1]
return hour, month, day, time, time_bounds, sza
def aaws2nc(args, op_file, station_dict, station_name, convert_temp, convert_press, seconds_in_hour, fillvalue_double):
header_rows = 8
column_names = ['timestamp', 'air_temp', 'vtempdiff', 'rh', 'pressure', 'wind_dir', 'wind_spd']
df = pd.read_csv(args.input_file or args.fl_in, skiprows = header_rows, skip_blank_lines=True, header=None, names = column_names)
df.index.name = 'time'
df.loc[:,'air_temp'] += convert_temp
df.loc[:,'pressure'] *= convert_press
df = df.where((pd.notnull(df)), fillvalue_double)
ds = xr.Dataset.from_dataframe(df)
ds = ds.drop('time')
# Intializing variables
num_rows = df['timestamp'].size
time, time_bounds, sza = ([0]*num_rows for x in range(3))
print('retrieving latitude and longitude...')
f = open(args.input_file or args.fl_in)
f.readline()
for line in f:
x = str(line[12:].strip('\n'))
break
f.close()
if x == 'AGO-4':
temp_stn = 'aaws_ago4'
elif x == 'Alexander Tall Tower!':
temp_stn = 'aaws_alexander'
elif x == 'Austin':
temp_stn = 'aaws_austin'
elif x == 'Baldrick':
temp_stn = 'aaws_baldrick'
elif x == 'Bear Peninsula':
temp_stn = 'aaws_bearpeninsula'
elif x == 'Bonaparte Point':
temp_stn = 'aaws_bonapartepoint'
elif x == 'Byrd':
temp_stn = 'aaws_byrd'
elif x == 'Cape Bird':
temp_stn = 'aaws_capebird'
elif x == 'Cape Denison':
temp_stn = 'aaws_capedenison'
elif x == 'Cape Hallett':
temp_stn = 'aaws_capehallett'
elif x == 'D-10':
temp_stn = 'aaws_d10'
elif x == 'D-47':
temp_stn = 'aaws_d47'
elif x == 'D-85':
temp_stn = 'aaws_d85'
elif x == 'Dismal Island':
temp_stn = 'aaws_dismalisland'
elif x == 'Dome C II':
temp_stn = 'aaws_domecII'
elif x == 'Dome Fuji':
temp_stn = 'aaws_domefuji'
elif x == 'Elaine':
temp_stn = 'aaws_elaine'
elif x == 'Elizabeth':
temp_stn = 'aaws_elizabeth'
elif x == 'Emilia':
temp_stn = 'aaws_emilia'
elif x == 'Emma':
temp_stn = 'aaws_emma'
elif x == 'Erin':
temp_stn = 'aaws_erin'
elif x == 'Evans Knoll':
temp_stn = 'aaws_evansknoll'
elif x == 'Ferrell':
temp_stn = 'aaws_ferrell'
elif x == 'Gill':
temp_stn = 'aaws_gill'
elif x == 'Harry':
temp_stn = 'aaws_harry'
elif x == 'Henry':
temp_stn = 'aaws_henry'
elif x == 'Janet':
temp_stn = 'aaws_janet'
elif x == 'JASE2007':
temp_stn = 'aaws_jase2007'
elif x == 'Kathie':
temp_stn = 'aaws_kathie'
elif x == 'Kominko-Slade':
temp_stn = 'aaws_kominkoslade'
elif x == 'Laurie II':
temp_stn = 'aaws_laurieII'
elif x == 'Lettau':
temp_stn = 'aaws_lettau'
elif x == 'Linda':
temp_stn = 'aaws_linda'
elif x == 'Lorne':
temp_stn = 'aaws_lorne'
elif x == 'Manuela':
temp_stn = 'aaws_manuela'
elif x == 'Marble Point':
temp_stn = 'aaws_marblepoint'
elif x == 'Marble Point II':
temp_stn = 'aaws_marblepointII'
elif x == 'Margaret':
temp_stn = 'aaws_margaret'
elif x == 'Marilyn':
temp_stn = 'aaws_marilyn'
elif x == 'Minna Bluff':
temp_stn = 'aaws_minnabluff'
elif x == 'Mizuho':
temp_stn = 'aaws_mizuho'
elif x == 'Mount Siple':
temp_stn = 'aaws_mountsiple'
elif x == 'Nico':
temp_stn = 'aaws_nico'
elif x == 'PANDA-South':
temp_stn = 'aaws_pandasouth'
elif x == 'Pegasus North':
temp_stn = 'aaws_pegasusnorth'
elif x == 'Phoenix':
temp_stn = 'aaws_phoenix'
elif x == 'Port Martin':
temp_stn = 'aaws_portmartin'
elif x == 'Possession Island':
temp_stn = 'aaws_possessionisland'
elif x == 'Relay Station':
temp_stn = 'aaws_relaystation'
elif x == 'Sabrina':
temp_stn = 'aaws_sabrina'
elif x == 'Schwerdtfeger':
temp_stn = 'aaws_schwerdtfeger'
elif x == 'Siple Dome':
temp_stn = 'aaws_sipledome'
elif x == 'Theresa':
temp_stn = 'aaws_theresa'
elif x == 'Thurston Island':
temp_stn = 'aaws_thurstonisland'
elif x == 'Vito':
temp_stn = 'aaws_vito'
elif x == 'White Island':
temp_stn = 'aaws_whiteisland'
elif x == 'Whitlock':
temp_stn = 'aaws_whitlock'
elif x == 'Willie Field':
temp_stn = 'aaws_williefield'
elif x == 'Windless Bight':
temp_stn = 'aaws_windlessbight'
latitude = (station_dict.get(temp_stn)[0])
longitude = (station_dict.get(temp_stn)[1])
print('retrieving station name...')
if args.station_name:
print('Default station name overrided by user provided station name')
else:
station_name = x
print('calculating time and sza...')
tz = pytz.timezone(args.timezone)
dtime_1970 = datetime(1970,1,1)
dtime_1970 = tz.localize(dtime_1970.replace(tzinfo=None))
i = 0
with open(args.input_file or args.fl_in, "r") as infile:
for line in infile.readlines()[header_rows:]:
temp_dtime = datetime.strptime(line.strip().split(",")[0], '%Y-%m-%dT%H:%M:%SZ')
temp_dtime = tz.localize(temp_dtime.replace(tzinfo=None))
time[i] = (temp_dtime-dtime_1970).total_seconds()
time_bounds[i] = (time[i]-seconds_in_hour, time[i])
sza[i] = sunpos(temp_dtime,latitude,longitude,0)[1]
i += 1
ds['time'] = (('time'),time)
ds['time_bounds'] = (('time', 'nbnd'),time_bounds)
ds['sza'] = (('time'),sza)
ds['station_name'] = ((),station_name)
ds['latitude'] = ((),latitude)
ds['longitude'] = ((),longitude)
ds.attrs = {'source':'surface observation', 'featureType':'timeSeries', 'institution':'UW SSEC', 'reference':'https://amrc.ssec.wisc.edu/', 'Conventions':'CF-1.7', 'data_type':'q1h', 'time_convention':"'time: point' variables match the time coordinate values exactly, whereas 'time: mean' variables are valid for the mean time within the time_bounds variable." + " e.g.: air_temp is continuously measured and then hourly-mean values are stored for each period contained in the time_bounds variable"}
ds['air_temp'].attrs= {'units':'kelvin', 'long_name':'air temperature', 'standard_name':'air_temperature', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['vtempdiff'].attrs= {'units':'1', 'long_name':'vertical temperature differential', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['rh'].attrs= {'units':'1', 'long_name':'relative humidity', 'standard_name':'relative_humidity', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['pressure'].attrs= {'units':'pascal', 'long_name':'air pressure', 'standard_name':'air_pressure', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['wind_dir'].attrs= {'units':'degree', 'long_name':'wind direction', 'standard_name':'wind_from_direction', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['wind_spd'].attrs= {'units':'meter second-1', 'long_name':'wind speed', 'standard_name':'wind_speed', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['time'].attrs= {'units':'seconds since 1970-01-01 00:00:00', 'long_name':'time of measurement', 'standard_name':'time', 'bounds':'time_bounds', 'calendar':'noleap'}
ds['sza'].attrs= {'units':'degree', 'long_name':'Solar Zenith Angle', 'standard_name':'solar_zenith_angle', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['station_name'].attrs= {'long_name':'Station Name', 'cf_role':'timeseries_id'}
ds['latitude'].attrs= {'units':'degrees_north', 'standard_name':'latitude'}
ds['longitude'].attrs= {'units':'degrees_east', 'standard_name':'longitude'}
encoding = {'air_temp': {'_FillValue': fillvalue_double},
'vtempdiff': {'_FillValue': fillvalue_double},
'rh': {'_FillValue': fillvalue_double},
'pressure': {'_FillValue': fillvalue_double},
'wind_dir': {'_FillValue': fillvalue_double},
'wind_spd': {'_FillValue': fillvalue_double},
'time': {'_FillValue': False},
'time_bounds': {'_FillValue': False},
'sza': {'_FillValue': False},
'latitude': {'_FillValue': False},
'longitude': {'_FillValue': False}
}
write_data(args, ds, op_file, encoding)
def promice2nc(args, op_file, station_dict, station_name, convert_temp,
convert_press, seconds_in_hour, fillvalue_double):
header_rows = 1
convert_current = 1000
check_na = -999
column_names = [
'year', 'month', 'day', 'hour', 'day_of_year', 'day_of_century',
'air_pressure', 'air_temperature', 'air_temperature_hygroclip',
'relative_humidity_wrtwater', 'relative_humidity', 'wind_speed',
'wind_direction', 'shortwave_radiation_down',
'shortwave_radiation_down_cor', 'shortwave_radiation_up',
'shortwave_radiation_up_cor', 'albedo_theta',
'longwave_radiation_down', 'longwave_radiation_up', 'cloudcover',
'surface_temp', 'height_sensor_boom', 'height_stakes',
'depth_pressure_transducer', 'depth_pressure_transducer_cor',
'ice_temp_01', 'ice_temp_02', 'ice_temp_03', 'ice_temp_04',
'ice_temp_05', 'ice_temp_06', 'ice_temp_07', 'ice_temp_08',
'tilt_east', 'tilt_north', 'time_GPS', 'latitude_GPS', 'longitude_GPS',
'elevation', 'hor_dil_prec', 'logger_temp', 'fan_current',
'battery_voltage'
]
df = pd.read_csv(args.input_file or args.fl_in,
delim_whitespace=True,
skiprows=header_rows,
skip_blank_lines=True,
header=None,
names=column_names)
df.index.name = 'time'
df.replace(check_na, np.nan, inplace=True)
df.loc[:, [
'air_temperature', 'air_temperature_hygroclip', 'surface_temp',
'ice_temp_01', 'ice_temp_02', 'ice_temp_03', 'ice_temp_04',
'ice_temp_05', 'ice_temp_06', 'ice_temp_07', 'ice_temp_08',
'logger_temp'
]] += convert_temp
df.loc[:, ['air_pressure']] *= convert_press
df.loc[:, ['fan_current']] /= convert_current
df = df.where((pd.notnull(df)), fillvalue_double)
ds = xr.Dataset.from_dataframe(df)
ds = ds.drop('time')
# Intializing variables
num_rows = df['year'].size
time, time_bounds, sza, velocity, ice_velocity_GPS_total, ice_velocity_GPS_x, ice_velocity_GPS_y = (
[0] * num_rows for x in range(7))
print('retrieving lat and lon...')
k = os.path.basename(args.input_file or args.fl_in)
if ('EGP') in k:
temp_stn = 'promice_egp'
elif ('KAN_B') or ('Kangerlussuaq-B') in k:
temp_stn = 'promice_kanb'
elif ('KAN_L') or ('Kangerlussuaq-L') in k:
temp_stn = 'promice_kanl'
elif ('KAN_M') or ('Kangerlussuaq-M') in k:
temp_stn = 'promice_kanm'
elif ('KAN_U') or ('Kangerlussuaq-U') in k:
temp_stn = 'promice_kanu'
elif ('KPC_L') or ('KronprinsChristianland-L') in k:
temp_stn = 'promice_kpcl'
elif ('KPC_U') or ('KronprinsChristianland-U') in k:
temp_stn = 'promice_kpcu'
elif ('MIT') in k:
temp_stn = 'promice_mit'
elif ('NUK_K') or ('Nuuk-K') in k:
temp_stn = 'promice_nukk'
elif ('NUK_L') or ('Nuuk-L') in k:
temp_stn = 'promice_nukl'
elif ('NUK_N') or ('Nuuk-N') in k:
temp_stn = 'promice_nukn'
elif ('NUK_U') or ('Nuuk-U') in k:
temp_stn = 'promice_nuku'
elif ('QAS_A') or ('Qassimiut-A') in k:
temp_stn = 'promice_qasa'
elif ('QAS_L') or ('Qassimiut-L') in k:
temp_stn = 'promice_qasl'
elif ('QAS_M') or ('Qassimiut-M') in k:
temp_stn = 'promice_qasm'
elif ('QAS_U') or ('Qassimiut-U') in k:
temp_stn = 'promice_qasu'
elif ('SCO_L') or ('Scoresbysund-L') in k:
temp_stn = 'promice_scol'
elif ('SCO_U') or ('Scoresbysund-U') in k:
temp_stn = 'promice_scou'
elif ('TAS_A') or ('Tasiilaq-A') in k:
temp_stn = 'promice_tasa'
elif ('TAS_L') or ('Tasiilaq-L') in k:
temp_stn = 'promice_tasl'
elif ('TAS_U') or ('Tasiilaq-U') in k:
temp_stn = 'promice_tasu'
elif ('THU_L') or ('ThuleAirbase-L') in k:
temp_stn = 'promice_thul'
elif ('THU_U') or ('ThuleAirbase-U') in k:
temp_stn = 'promice_thuu'
elif ('UPE_L') or ('Upernavik-L') in k:
temp_stn = 'promice_upel'
elif ('UPE_U') or ('Upernavik-U') in k:
temp_stn = 'promice_upeu'
elif ('CEN') in k:
temp_stn = 'promice_cen'
latitude = (station_dict.get(temp_stn)[0])
longitude = (station_dict.get(temp_stn)[1])
if args.station_name:
print('Default station name overrided by user provided station name')
else:
station_name = station_dict.get(temp_stn)[2]
print('converting lat_GPS and lon_GPS...')
def lat_lon_gps(coords):
deg = np.floor(coords / 100)
minutes = np.floor(((coords / 100) - deg) * 100)
seconds = (((coords / 100) - deg) * 100 - minutes) * 100
return deg + minutes / 60 + seconds / 3600
# Exclude NAs
logic1 = df.latitude_GPS != fillvalue_double
logic2 = df.longitude_GPS != fillvalue_double
df1 = df[logic1]
df2 = df[logic2]
df.latitude_GPS = lat_lon_gps(df1.latitude_GPS)
df.longitude_GPS = lat_lon_gps(df2.longitude_GPS)
print('calculating time and sza...')
tz = pytz.timezone(args.timezone)
dtime_1970 = datetime(1970, 1, 1)
dtime_1970 = tz.localize(dtime_1970.replace(tzinfo=None))
i = 0
while i < num_rows:
temp_dtime = datetime(df['year'][i], df['month'][i], df['day'][i],
df['hour'][i])
temp_dtime = tz.localize(temp_dtime.replace(tzinfo=None))
time[i] = (temp_dtime - dtime_1970).total_seconds()
time_bounds[i] = (time[i], time[i] + seconds_in_hour)
sza[i] = sunpos(temp_dtime, latitude, longitude, 0)[1]
i += 1
print('calculating ice velocity...')
def ice_velocity(n, o):
m, p = 0, 1
R = 6373.0 #Approx radius of earth
while p < num_rows:
if (df['latitude_GPS'][m] == fillvalue_double
or df['longitude_GPS'][m] == fillvalue_double
or df['latitude_GPS'][n] == fillvalue_double
or df['longitude_GPS'][o] == fillvalue_double):
velocity[m] = fillvalue_double
else:
lat1 = radians(df['latitude_GPS'][m])
lon1 = radians(df['longitude_GPS'][m])
lat2 = radians(df['latitude_GPS'][n])
lon2 = radians(df['longitude_GPS'][o])
dlat = lat2 - lat1
dlon = lon2 - lon1
a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
c = 2 * atan2(sqrt(a), sqrt(1 - a))
distance = (
R * c) * 1000 #Multiplied by 1000 to convert km to meters
velocity[m] = round(
distance / seconds_in_hour, 4
) #Divided by 3600 because time change between 2 records is one hour
m += 1
n += 1
o += 1
p += 1
return velocity[:]
ice_velocity_GPS_total[:] = ice_velocity(1, 1)
ice_velocity_GPS_x[:] = ice_velocity(0, 1)
ice_velocity_GPS_y[:] = ice_velocity(1, 0)
ds['ice_velocity_GPS_total'] = (('time'), ice_velocity_GPS_total)
ds['ice_velocity_GPS_x'] = (('time'), ice_velocity_GPS_x)
ds['ice_velocity_GPS_y'] = (('time'), ice_velocity_GPS_y)
ds['time'] = (('time'), time)
ds['time_bounds'] = (('time', 'nbnd'), time_bounds)
ds['sza'] = (('time'), sza)
ds['station_name'] = ((), station_name)
ds['latitude'] = ((), latitude)
ds['longitude'] = ((), longitude)
ds.attrs = {
'title':
'Weather Station Data',
'source':
'Surface Observations',
'featureType':
'timeSeries',
'institution':
'Programme for Monitoring of the Greenland Ice Sheet',
'reference':
'http://www.promice.dk/home.html',
'Conventions':
'CF-1.7',
'time_convention':
"'time: point' variables match the time coordinate values exactly, whereas 'time: mean' variables are valid for the mean time within the time_bounds variable."
+
" e.g.: elevation is measured once per hour at the time stored in the 'time' coordinate."
+
" On the other hand, air_temperature is continuously measured and then hourly-mean values are stored for each period contained in the time_bounds variable"
}
ds['year'].attrs = {'units': '1', 'long_name': 'Year'}
ds['month'].attrs = {'units': '1', 'long_name': 'Month of Year'}
ds['day'].attrs = {'units': '1', 'long_name': 'Day of Month'}
ds['hour'].attrs = {'units': '1', 'long_name': 'Hour of Day(UTC)'}
ds['day_of_year'].attrs = {'units': '1', 'long_name': 'Day of Year'}
ds['day_of_century'].attrs = {'units': '1', 'long_name': 'Day of Century'}
ds['air_pressure'].attrs = {
'units': 'pascal',
'long_name': 'Air Pressure',
'standard_name': 'air_pressure',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['air_temperature'].attrs = {
'units': 'kelvin',
'long_name': 'Air Temperature',
'standard_name': 'air_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['air_temperature_hygroclip'].attrs = {
'units': 'kelvin',
'long_name': 'Air Temperature HygroClip',
'standard_name': 'air_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['relative_humidity_wrtwater'].attrs = {
'units': '1',
'long_name': 'Relative Humidity wrt Water',
'standard_name': 'relative_humidity',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['relative_humidity'].attrs = {
'units': '1',
'long_name': 'Relative Humidity',
'standard_name': 'relative_humidity',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['wind_speed'].attrs = {
'units': 'meter second-1',
'long_name': 'Wind Speed',
'standard_name': 'wind_speed',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['wind_direction'].attrs = {
'units': 'degree',
'long_name': 'Wind Direction',
'standard_name': 'wind_from_direction',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['shortwave_radiation_down'].attrs = {
'units': 'watt meter-2',
'long_name': 'Shortwave Radiation Down',
'standard_name': 'downwelling_shortwave_flux_in_air',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['shortwave_radiation_down_cor'].attrs = {
'units': 'watt meter-2',
'long_name': 'Shortwave Radiation Down Cor',
'standard_name': 'downwelling_shortwave_flux_in_air',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['shortwave_radiation_up'].attrs = {
'units': 'watt meter-2',
'long_name': 'Shortwave Radiation Up',
'standard_name': 'upwelling_shortwave_flux_in_air',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['shortwave_radiation_up_cor'].attrs = {
'units': 'watt meter-2',
'long_name': 'Shortwave Radiation Up Cor',
'standard_name': 'upwelling_shortwave_flux_in_air',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['albedo_theta'].attrs = {
'units': '1',
'long_name': 'Albedo_theta<70d',
'standard_name': 'surface_albedo',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['longwave_radiation_down'].attrs = {
'units': 'watt meter-2',
'long_name': 'Longwave Radiation Down',
'standard_name': 'downwelling_longwave_flux_in_air',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['longwave_radiation_up'].attrs = {
'units': 'watt meter-2',
'long_name': 'Longwave Radiation Up',
'standard_name': 'upwelling_longwave_flux_in_air',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['cloudcover'].attrs = {
'units': '1',
'long_name': 'Cloud Cover',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['surface_temp'].attrs = {
'units': 'kelvin',
'long_name': 'Surface Temperature',
'standard_name': 'surface_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['height_sensor_boom'].attrs = {
'units': 'meter',
'long_name': 'Height Sensor Boom',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['height_stakes'].attrs = {
'units': 'meter',
'long_name': 'Height Stakes',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['depth_pressure_transducer'].attrs = {
'units': 'meter',
'long_name': 'Depth Pressure Transducer',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['depth_pressure_transducer_cor'].attrs = {
'units': 'meter',
'long_name': 'Depth Pressure Transducer Cor',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['ice_temp_01'].attrs = {
'units': 'kelvin',
'long_name': 'Ice Temperature 1',
'standard_name': 'land_ice_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['ice_temp_02'].attrs = {
'units': 'kelvin',
'long_name': 'Ice Temperature 2',
'standard_name': 'land_ice_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['ice_temp_03'].attrs = {
'units': 'kelvin',
'long_name': 'Ice Temperature 3',
'standard_name': 'land_ice_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['ice_temp_04'].attrs = {
'units': 'kelvin',
'long_name': 'Ice Temperature 4',
'standard_name': 'land_ice_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['ice_temp_05'].attrs = {
'units': 'kelvin',
'long_name': 'Ice Temperature 5',
'standard_name': 'land_ice_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['ice_temp_06'].attrs = {
'units': 'kelvin',
'long_name': 'Ice Temperature 6',
'standard_name': 'land_ice_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['ice_temp_07'].attrs = {
'units': 'kelvin',
'long_name': 'Ice Temperature 7',
'standard_name': 'land_ice_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['ice_temp_08'].attrs = {
'units': 'kelvin',
'long_name': 'Ice Temperature 8',
'standard_name': 'land_ice_temperature',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['tilt_east'].attrs = {
'units': 'degree',
'long_name': 'Tilt to East',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['tilt_north'].attrs = {
'units': 'degree',
'long_name': 'Tilt to North',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['time_GPS'].attrs = {
'units': 'UTC',
'long_name': 'Time GPS(hhmmssUTC)',
'standard_name': 'time'
}
ds['latitude_GPS'].attrs = {
'units': 'degrees_north',
'long_name': 'Latitude GPS',
'standard_name': 'latitude'
}
ds['longitude_GPS'].attrs = {
'units': 'degrees_east',
'long_name': 'Longitude GPS',
'standard_name': 'longitude'
}
ds['elevation'].attrs = {
'units': 'meter',
'long_name': 'Elevation GPS',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['hor_dil_prec'].attrs = {
'units': '1',
'long_name': 'Horizontal Dilution of Precision GPS',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['logger_temp'].attrs = {
'units': 'kelvin',
'long_name': 'Logger Temperature',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['fan_current'].attrs = {
'units': 'ampere',
'long_name': 'Fan Current',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['battery_voltage'].attrs = {
'units': 'volts',
'long_name': 'Battery Voltage',
'standard_name': 'battery_voltage',
'coordinates': 'longitude latitude',
'cell_methods': 'time: point'
}
ds['ice_velocity_GPS_total'].attrs = {
'units': 'meter second-1',
'long_name': 'Ice velocity derived from GPS Lat and Long',
'standard_name': '',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['ice_velocity_GPS_x'].attrs = {
'units': 'meter second-1',
'long_name':
'x-component of Ice velocity derived from GPS Lat and Long',
'standard_name': 'land_ice_surface_x_velocity',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['ice_velocity_GPS_y'].attrs = {
'units': 'meter second-1',
'long_name':
'y-component of Ice velocity derived from GPS Lat and Long',
'standard_name': 'land_ice_surface_y_velocity',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['time'].attrs = {
'units': 'seconds since 1970-01-01 00:00:00',
'long_name': 'time of measurement',
'standard_name': 'time',
'bounds': 'time_bounds',
'calendar': 'noleap'
}
ds['sza'].attrs = {
'units': 'degree',
'long_name': 'Solar Zenith Angle',
'standard_name': 'solar_zenith_angle',
'coordinates': 'longitude latitude',
'cell_methods': 'time: mean'
}
ds['station_name'].attrs = {
'long_name': 'Station Name',
'cf_role': 'timeseries_id'
}
ds['latitude'].attrs = {
'units': 'degrees_north',
'standard_name': 'latitude'
}
ds['longitude'].attrs = {
'units': 'degrees_east',
'standard_name': 'longitude'
}
encoding = {
'year': {
'_FillValue': False
},
'month': {
'_FillValue': False
},
'day': {
'_FillValue': False
},
'hour': {
'_FillValue': False
},
'day_of_year': {
'_FillValue': False
},
'day_of_century': {
'_FillValue': False
},
'air_pressure': {
'_FillValue': fillvalue_double
},
'air_temperature': {
'_FillValue': fillvalue_double
},
'air_temperature_hygroclip': {
'_FillValue': fillvalue_double
},
'relative_humidity_wrtwater': {
'_FillValue': fillvalue_double
},
'relative_humidity': {
'_FillValue': fillvalue_double
},
'wind_speed': {
'_FillValue': fillvalue_double
},
'wind_direction': {
'_FillValue': fillvalue_double
},
'shortwave_radiation_down': {
'_FillValue': fillvalue_double
},
'shortwave_radiation_down_cor': {
'_FillValue': fillvalue_double
},
'shortwave_radiation_up': {
'_FillValue': fillvalue_double
},
'shortwave_radiation_up_cor': {
'_FillValue': fillvalue_double
},
'albedo_theta': {
'_FillValue': fillvalue_double
},
'longwave_radiation_down': {
'_FillValue': fillvalue_double
},
'longwave_radiation_up': {
'_FillValue': fillvalue_double
},
'cloudcover': {
'_FillValue': fillvalue_double
},
'surface_temp': {
'_FillValue': fillvalue_double
},
'height_sensor_boom': {
'_FillValue': fillvalue_double
},
'height_stakes': {
'_FillValue': fillvalue_double
},
'depth_pressure_transducer': {
'_FillValue': fillvalue_double
},
'depth_pressure_transducer_cor': {
'_FillValue': fillvalue_double
},
'ice_temp_01': {
'_FillValue': fillvalue_double
},
'ice_temp_02': {
'_FillValue': fillvalue_double
},
'ice_temp_03': {
'_FillValue': fillvalue_double
},
'ice_temp_04': {
'_FillValue': fillvalue_double
},
'ice_temp_05': {
'_FillValue': fillvalue_double
},
'ice_temp_06': {
'_FillValue': fillvalue_double
},
'ice_temp_07': {
'_FillValue': fillvalue_double
},
'ice_temp_08': {
'_FillValue': fillvalue_double
},
'tilt_east': {
'_FillValue': fillvalue_double
},
'tilt_north': {
'_FillValue': fillvalue_double
},
'time_GPS': {
'_FillValue': fillvalue_double
},
'latitude_GPS': {
'_FillValue': fillvalue_double
},
'longitude_GPS': {
'_FillValue': fillvalue_double
},
'elevation': {
'_FillValue': fillvalue_double
},
'hor_dil_prec': {
'_FillValue': fillvalue_double
},
'logger_temp': {
'_FillValue': fillvalue_double
},
'fan_current': {
'_FillValue': fillvalue_double
},
'battery_voltage': {
'_FillValue': fillvalue_double
},
'ice_velocity_GPS_total': {
'_FillValue': fillvalue_double
},
'ice_velocity_GPS_x': {
'_FillValue': fillvalue_double
},
'ice_velocity_GPS_y': {
'_FillValue': fillvalue_double
},
'time': {
'_FillValue': False
},
'time_bounds': {
'_FillValue': False
},
'sza': {
'_FillValue': False
},
'latitude': {
'_FillValue': False
},
'longitude': {
'_FillValue': False
}
}
write_data(args, ds, op_file, encoding)
tf = TimezoneFinder()
#variable initization
address = '144 East Ave., Ithaca, NY 148530'
print(address)
#Gets latitude and longitude from enteted address
geocode_result = gmaps.geocode(address)
latitude = geocode_result[0]['geometry']['location']['lat']
longitude = geocode_result[0]['geometry']['location']['lng']
print('Latitude: ' + str(latitude))
print('Longitude: ' + str(longitude))
#Gets timezone of location
timezone_str = tf.certain_timezone_at(lng=longitude, lat=latitude)
print(timezone_str)
#Conerts timezone to utc
timezone = pytz.timezone(timezone_str)
utc = datetime.utcnow()
timezone = utc + timezone.utcoffset(utc)
print(timezone)
#uses sunposition's sunpos function to get angles
Azimuth = sunpos(utc, latitude, longitude, 0)[0]
Zenith = sunpos(utc, latitude, longitude, 0)[1]
Elevation = 90 - Zenith
print("Sun Azimuth angle (east to west): " + str(Azimuth) +
"\nSun Zenith angle: " + str(Zenith) +
"\nSun Elevation angle from horizon: " + str(Elevation))
def getSolarPosition(date):
azimuth, zenith = sunpos(date,
latitude=latitude,
longitude=longitude,
elevation=elevation)[:2]
return azimuth, zenith
def gcnet2nc(args, op_file, station_dict, station_name, convert_temp, convert_press, seconds_in_hour, fillvalue_double):
header_rows = 54
check_na = 999.0
hour_conversion = (100/4) #Divided by 4 because each hour value is a multiple of 4 and then multiplied by 100 to convert decimal to integer
last_hour = 23
column_names = ['station_number', 'year', 'julian_decimal_time', 'sw_down', 'sw_up', 'net_radiation', 'temperature_tc_1', 'temperature_tc_2', 'temperature_cs500_1', 'temperature_cs500_2', 'relative_humidity_1', 'relative_humidity_2',
'u1_wind_speed', 'u2_wind_speed', 'u_direction_1', 'u_direction_2', 'atmos_pressure', 'snow_height_1', 'snow_height_2', 't_snow_01', 't_snow_02', 't_snow_03', 't_snow_04', 't_snow_05', 't_snow_06', 't_snow_07', 't_snow_08', 't_snow_09', 't_snow_10',
'battery_voltage', 'sw_down_max', 'sw_up_max', 'net_radiation_max', 'max_air_temperature_1', 'max_air_temperature_2', 'min_air_temperature_1', 'min_air_temperature_2', 'max_windspeed_u1', 'max_windspeed_u2', 'stdev_windspeed_u1', 'stdev_windspeed_u2',
'ref_temperature', 'windspeed_2m', 'windspeed_10m', 'wind_sensor_height_1', 'wind_sensor_height_2', 'albedo', 'zenith_angle', 'qc1', 'qc9', 'qc17', 'qc25']
df = pd.read_csv(args.input_file or args.fl_in, delim_whitespace=True, skiprows=header_rows, skip_blank_lines=True, header=None, names = column_names)
df.index.name = 'time'
df['qc25'] = df['qc25'].astype(str) # To avoid 999 values marked as N/A
df.replace(check_na, np.nan, inplace=True)
df.loc[:,['temperature_tc_1', 'temperature_tc_2', 'temperature_cs500_1', 'temperature_cs500_2', 't_snow_01', 't_snow_02', 't_snow_03', 't_snow_04', 't_snow_05', 't_snow_06', 't_snow_07', 't_snow_08', 't_snow_09', 't_snow_10', 'max_air_temperature_1', 'max_air_temperature_2', 'min_air_temperature_1', 'min_air_temperature_2', 'ref_temperature']] += convert_temp
df.loc[:,'atmos_pressure'] *= convert_press
df = df.where((pd.notnull(df)), fillvalue_double)
df['qc25'] = df['qc25'].astype(int) #Convert it back to int
station_number = df['station_number'][0]
df.drop('station_number', axis=1, inplace=True)
ds = xr.Dataset.from_dataframe(df)
ds = ds.drop('time')
# Intializing variables
num_rows = df['year'].size
qc_swdn, qc_swup, qc_netradiation, qc_ttc1, qc_ttc2, qc_tcs1, qc_tcs2, qc_rh1, qc_rh2, qc_u1, qc_u2, qc_ud1, qc_ud2, qc_pressure, qc_snowheight1, qc_snowheight2, qc_tsnow1, qc_tsnow2, qc_tsnow3, qc_tsnow4, qc_tsnow5, qc_tsnow6, qc_tsnow7, qc_tsnow8, qc_tsnow9, qc_tsnow10, qc_battery = ([0]*num_rows for x in range(27))
hour, month, day, time, time_bounds, sza = ([0]*num_rows for x in range(6))
print('calculating quality control variables...')
temp1 = [list(map(int, i)) for i in zip(*map(str, df['qc1']))]
temp9 = [list(map(int, i)) for i in zip(*map(str, df['qc9']))]
temp17 = [list(map(int, i)) for i in zip(*map(str, df['qc17']))]
temp25 = [list(map(int, i)) for i in zip(*map(str, df['qc25']))]
qc_swdn[:] = temp1[0]
qc_swup[:] = temp1[1]
qc_netradiation[:] = temp1[2]
qc_ttc1[:] = temp1[3]
qc_ttc2[:] = temp1[4]
qc_tcs1[:] = temp1[5]
qc_tcs2[:] = temp1[6]
qc_rh1[:] = temp1[7]
qc_rh2[:] = temp9[0]
qc_u1[:] = temp9[1]
qc_u2[:] = temp9[2]
qc_ud1[:] = temp9[3]
qc_ud2[:] = temp9[4]
qc_pressure[:] = temp9[5]
qc_snowheight1[:] = temp9[6]
qc_snowheight2[:] = temp9[7]
qc_tsnow1[:] = temp17[0]
qc_tsnow2[:] = temp17[1]
qc_tsnow3[:] = temp17[2]
qc_tsnow4[:] = temp17[3]
qc_tsnow5[:] = temp17[4]
qc_tsnow6[:] = temp17[5]
qc_tsnow7[:] = temp17[6]
qc_tsnow8[:] = temp17[7]
qc_tsnow9[:] = temp25[0]
qc_tsnow10[:] = temp25[1]
qc_battery[:] = temp25[2]
ds['qc_swdn'] = (('time',qc_swdn))
ds['qc_swup'] = (('time',qc_swup))
ds['qc_netradiation'] = (('time',qc_netradiation))
ds['qc_ttc1'] = (('time',qc_ttc1))
ds['qc_ttc2'] = (('time',qc_ttc2))
ds['qc_tcs1'] = (('time',qc_tcs1))
ds['qc_tcs2'] = (('time',qc_tcs2))
ds['qc_rh1'] = (('time',qc_rh1))
ds['qc_rh2'] = (('time',qc_rh2))
ds['qc_u1'] = (('time',qc_u1))
ds['qc_u2'] = (('time',qc_u2))
ds['qc_ud1'] = (('time',qc_ud1))
ds['qc_ud2'] = (('time',qc_ud2))
ds['qc_pressure'] = (('time',qc_pressure))
ds['qc_snowheight1'] = (('time',qc_snowheight1))
ds['qc_snowheight2'] = (('time',qc_snowheight2))
ds['qc_tsnow1'] = (('time',qc_tsnow1))
ds['qc_tsnow2'] = (('time',qc_tsnow2))
ds['qc_tsnow3'] = (('time',qc_tsnow3))
ds['qc_tsnow4'] = (('time',qc_tsnow4))
ds['qc_tsnow5'] = (('time',qc_tsnow5))
ds['qc_tsnow6'] = (('time',qc_tsnow6))
ds['qc_tsnow7'] = (('time',qc_tsnow7))
ds['qc_tsnow8'] = (('time',qc_tsnow8))
ds['qc_tsnow9'] = (('time',qc_tsnow9))
ds['qc_tsnow10'] = (('time',qc_tsnow10))
ds['qc_battery'] = (('time',qc_battery))
print('retrieving lat and lon...')
if station_number == 1:
temp_stn = 'gcnet_swiss'
elif station_number == 2:
temp_stn = 'gcnet_crawford'
elif station_number == 3:
temp_stn = 'gcnet_nasa-u'
elif station_number == 4:
temp_stn = 'gcnet_gits'
elif station_number == 5:
temp_stn = 'gcnet_humboldt'
elif station_number == 6:
temp_stn = 'gcnet_summit'
elif station_number == 7:
temp_stn = 'gcnet_tunu-n'
elif station_number == 8:
temp_stn = 'gcnet_dye2'
elif station_number == 9:
temp_stn = 'gcnet_jar'
elif station_number == 10:
temp_stn = 'gcnet_saddle'
elif station_number == 11:
temp_stn = 'gcnet_dome'
elif station_number == 12:
temp_stn = 'gcnet_nasa-e'
elif station_number == 13:
temp_stn = 'gcnet_cp2'
elif station_number == 14:
temp_stn = 'gcnet_ngrip'
elif station_number == 15:
temp_stn = 'gcnet_nasa-se'
elif station_number == 16:
temp_stn = 'gcnet_kar'
elif station_number == 17:
temp_stn = 'gcnet_jar2'
elif station_number == 18:
temp_stn = 'gcnet_kulu'
elif station_number == 19:
temp_stn = 'gcnet_jar3'
elif station_number == 20:
temp_stn = 'gcnet_aurora'
elif station_number == 21 or 26:
temp_stn = 'gcnet_petermann-gl'
elif station_number == 22:
temp_stn = 'gcnet_peterman-ela'
elif station_number == 23:
temp_stn = 'gcnet_neem'
elif station_number == 30:
temp_stn = 'gcnet_lar1'
elif station_number == 31:
temp_stn = 'gcnet_lar2'
elif station_number == 32:
temp_stn = 'gcnet_lar3'
latitude = station_dict.get(temp_stn)[0]
longitude = station_dict.get(temp_stn)[1]
if args.station_name:
print('Default station name overrided by user provided station name')
else:
station_name = station_dict.get(temp_stn)[2]
print('calculating hour...')
hour[:] = [int(x) for x in [round((y-int(y)),3)*hour_conversion for y in df['julian_decimal_time']]]
z = 0
while z < num_rows:
if hour[z] > last_hour:
hour[z] = 0
z += 1
print("calculating time and sza...")
tz = pytz.timezone(args.timezone)
dtime_1970 = datetime(1970,1,1)
dtime_1970 = tz.localize(dtime_1970.replace(tzinfo=None))
i = 0
while i < num_rows:
temp_dtime = datetime.strptime("%s %s %s" % (df['year'][i], int(df['julian_decimal_time'][i]), hour[i]), "%Y %j %H")
temp_dtime = tz.localize(temp_dtime.replace(tzinfo=None))
time[i] = (temp_dtime-dtime_1970).total_seconds()
time_bounds[i] = (time[i]-seconds_in_hour, time[i])
sza[i] = sunpos(temp_dtime,latitude,longitude,0)[1]
i += 1
if args.analysis:
print('calculating month and day...')
def get_month_day(year, day, one_based=False):
if one_based: # if Jan 1st is 1 instead of 0
day -= 1
dt = datetime(year, 1, 1) + timedelta(days=day)
return dt.month, dt.day
j = 0
while j < num_rows:
month[j] = get_month_day(int(df['year'][j]), int(df['julian_decimal_time'][j]), True)[0]
day[j] = get_month_day(int(df['year'][j]), int(df['julian_decimal_time'][j]), True)[1]
j += 1
ds['hour'] = (('time'),hour)
ds['month'] = (('time'),month)
ds['day'] = (('time'),day)
ds['time'] = (('time'),time)
ds['time_bounds'] = (('time', 'nbnd'),time_bounds)
ds['sza'] = (('time'),sza)
ds['station_number'] = ((),station_number)
ds['station_name'] = ((),station_name)
ds['latitude'] = ((),latitude)
ds['longitude'] = ((),longitude)
ds.attrs = {'title':'Surface Radiation Data from Greenland Climate Network', 'source':'Surface Observations', 'featureType':'timeSeries', 'institution':'Cooperative Institute for Research in Enviornmental Sciences',
'reference':'http://cires.colorado.edu/science/groups/steffen/gcnet/', 'Conventions':'CF-1.7', 'time_convention':"'time: point' variables match the time coordinate values exactly, whereas 'time: mean' variables are valid for the mean time within the time_bounds variable." + " e.g.: battery_voltage is measured once per hour at the time stored in the 'time' coordinate." + " On the other hand, temperature_tc_1 is continuously measured and then hourly-mean values are stored for each period contained in the time_bounds variable"}
ds['station_number'].attrs= {'units':'1', 'long_name':'Station Number'}
ds['year'].attrs= {'units':'1', 'long_name':'Year'}
ds['julian_decimal_time'].attrs= {'units':'decimal time', 'long_name':'Julian Decimal Time', 'note':'For each year, time starts at 1.0000 and ends at 365.9999.'}
ds['sw_down'].attrs= {'units':'watt meter-2', 'long_name':'Shortwave Flux Down', 'standard_name':'downwelling_shortwave_flux_in_air', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['sw_up'].attrs= {'units':'watt meter-2', 'long_name':'Shortwave Flux Up', 'standard_name':'upwelling_shortwave_flux_in_air', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['net_radiation'].attrs= {'units':'watt meter-2', 'long_name':'Net Radiation', 'standard_name':'surface_net_downward_radiative_flux', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['temperature_tc_1'].attrs= {'units':'kelvin', 'long_name':'TC-1 Air Temperature', 'standard_name':'air_temperature', 'note':'air temperature from TC sensor', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['temperature_tc_2'].attrs= {'units':'kelvin', 'long_name':'TC-2 Air Temperature', 'standard_name':'air_temperature', 'note':'air temperature from TC sensor', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['temperature_cs500_1'].attrs= {'units':'kelvin', 'long_name':'CS500-1 Air Temperature', 'standard_name':'air_temperature', 'note':'air temperature from CS500 sensor', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['temperature_cs500_2'].attrs= {'units':'kelvin', 'long_name':'CS500-2 Air Temperature', 'standard_name':'air_temperature', 'note':'air temperature from CS500 sensor', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['relative_humidity_1'].attrs= {'units':'1', 'long_name':'Relative Humidity 1', 'standard_name':'realtive_humidity', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['relative_humidity_2'].attrs= {'units':'1', 'long_name':'Relative Humidity 2', 'standard_name':'realtive_humidity', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['u1_wind_speed'].attrs= {'units':'meter second-1', 'long_name':'U1 Wind Speed', 'standard_name':'wind_speed', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['u2_wind_speed'].attrs= {'units':'meter second-1', 'long_name':'U2 Wind Speed', 'standard_name':'wind_speed', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['u_direction_1'].attrs= {'units':'degree', 'long_name':'U Direction 1', 'standard_name':'wind_from_direction', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['u_direction_2'].attrs= {'units':'degree', 'long_name':'U Direction 2', 'standard_name':'wind_from_direction', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['atmos_pressure'].attrs= {'units':'pascal', 'long_name':'Atmospheric Pressure', 'standard_name':'surface_air_pressure', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['snow_height_1'].attrs= {'units':'meter', 'long_name':'Snow Height 1', 'standard_name':'snow_height', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['snow_height_2'].attrs= {'units':'meter', 'long_name':'Snow Height 2', 'standard_name':'snow_height', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['t_snow_01'].attrs= {'units':'kelvin', 'long_name':'T Snow 1', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['t_snow_02'].attrs= {'units':'kelvin', 'long_name':'T Snow 2', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['t_snow_03'].attrs= {'units':'kelvin', 'long_name':'T Snow 3', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['t_snow_04'].attrs= {'units':'kelvin', 'long_name':'T Snow 4', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['t_snow_05'].attrs= {'units':'kelvin', 'long_name':'T Snow 5', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['t_snow_06'].attrs= {'units':'kelvin', 'long_name':'T Snow 6', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['t_snow_07'].attrs= {'units':'kelvin', 'long_name':'T Snow 7', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['t_snow_08'].attrs= {'units':'kelvin', 'long_name':'T Snow 8', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['t_snow_09'].attrs= {'units':'kelvin', 'long_name':'T Snow 9', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['t_snow_10'].attrs= {'units':'kelvin', 'long_name':'T Snow 10', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['battery_voltage'].attrs= {'units':'volts', 'long_name':'Battery Voltage', 'standard_name':'battery_voltage', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['sw_down_max'].attrs= {'units':'watt meter-2', 'long_name':'Shortwave Flux Down Max', 'standard_name':'maximum_downwelling_shortwave_flux_in_air', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['sw_up_max'].attrs= {'units':'watt meter-2', 'long_name':'Shortwave Flux Up Max', 'standard_name':'maximum_upwelling_shortwave_flux_in_air', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['net_radiation_max'].attrs= {'units':'watt meter-2', 'long_name':'Net Radiation Max', 'standard_name':'maximum_net_radiation', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['max_air_temperature_1'].attrs= {'units':'kelvin', 'long_name':'Max Air Temperature 1', 'standard_name':'air_temperature', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['max_air_temperature_2'].attrs= {'units':'kelvin', 'long_name':'Max Air Temperature 2', 'standard_name':'air_temperature', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['min_air_temperature_1'].attrs= {'units':'kelvin', 'long_name':'Min Air Temperature 1', 'standard_name':'air_temperature', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['min_air_temperature_2'].attrs= {'units':'kelvin', 'long_name':'Min Air Temperature 2', 'standard_name':'air_temperature', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['max_windspeed_u1'].attrs= {'units':'meter second-1', 'long_name':'Max Windspeed-U1', 'standard_name':'wind_speed', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['max_windspeed_u2'].attrs= {'units':'meter second-1', 'long_name':'Max Windspeed-U2', 'standard_name':'wind_speed', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['stdev_windspeed_u1'].attrs= {'units':'meter second-1', 'long_name':'StdDev Windspeed-U1', 'standard_name':'wind_speed', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['stdev_windspeed_u2'].attrs= {'units':'meter second-1', 'long_name':'StdDev Windspeed-U2', 'standard_name':'wind_speed', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['ref_temperature'].attrs= {'units':'kelvin', 'long_name':'Reference Temperature', 'standard_name':'Need to ask network manager about long name', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['windspeed_2m'].attrs= {'units':'meter second-1', 'long_name':'Windspeed@2m', 'standard_name':'wind_speed', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['windspeed_10m'].attrs= {'units':'meter second-1', 'long_name':'Windspeed@10m', 'standard_name':'wind_speed', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['wind_sensor_height_1'].attrs= {'units':'meter', 'long_name':'Wind Sensor Height 1', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['wind_sensor_height_2'].attrs= {'units':'meter', 'long_name':'Wind Sensor Height 2', 'standard_name':'', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['albedo'].attrs= {'units':'1', 'long_name':'Albedo', 'standard_name':'surface_albedo', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['zenith_angle'].attrs= {'units':'degree', 'long_name':'Zenith Angle', 'standard_name':'solar_zenith_angle', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['qc1'].attrs= {'units':'1', 'long_name':'Quality Control variables 01-08', 'coordinates':'longitude latitude'}
ds['qc9'].attrs= {'units':'1', 'long_name':'Quality Control variables 09-16', 'coordinates':'longitude latitude'}
ds['qc17'].attrs= {'units':'1', 'long_name':'Quality Control variables 17-24', 'coordinates':'longitude latitude'}
ds['qc25'].attrs= {'units':'1', 'long_name':'Quality Control variables 25-27', 'coordinates':'longitude latitude'}
ds['qc_swdn'].attrs= {'units':'1', 'long_name':'Quality Control flag for Shortwave Flux Down'}
ds['qc_swup'].attrs= {'units':'1', 'long_name':'Quality Control flag for Shortwave Flux Up'}
ds['qc_netradiation'].attrs= {'units':'1', 'long_name':'Quality Control flag for Net Radiation'}
ds['qc_ttc1'].attrs= {'units':'1', 'long_name':'Quality Control flag for TC-1 Air Temperature'}
ds['qc_ttc2'].attrs= {'units':'1', 'long_name':'Quality Control flag for TC-2 Air Temperature'}
ds['qc_tcs1'].attrs= {'units':'1', 'long_name':'Quality Control flag for CS500-1 Air Temperature'}
ds['qc_tcs2'].attrs= {'units':'1', 'long_name':'Quality Control flag for CS500-2 Air Temperature'}
ds['qc_rh1'].attrs= {'units':'1', 'long_name':'Quality Control flag for Relative Humidity 1'}
ds['qc_rh2'].attrs= {'units':'1', 'long_name':'Quality Control flag for Relative Humidity 2'}
ds['qc_u1'].attrs= {'units':'1', 'long_name':'Quality Control flag for U1 Wind Speed'}
ds['qc_u2'].attrs= {'units':'1', 'long_name':'Quality Control flag for U2 Wind Speed'}
ds['qc_ud1'].attrs= {'units':'1', 'long_name':'Quality Control flag for U Direction 1'}
ds['qc_ud2'].attrs= {'units':'1', 'long_name':'Quality Control flag for U Direction 2'}
ds['qc_pressure'].attrs= {'units':'1', 'long_name':'Quality Control flag for Atmospheric Pressure'}
ds['qc_snowheight1'].attrs= {'units':'1', 'long_name':'Quality Control flag for Snow Height 1'}
ds['qc_snowheight2'].attrs= {'units':'1', 'long_name':'Quality Control flag for Snow Height 2'}
ds['qc_tsnow1'].attrs= {'units':'1', 'long_name':'Quality Control flag for T Snow 1'}
ds['qc_tsnow2'].attrs= {'units':'1', 'long_name':'Quality Control flag for T Snow 2'}
ds['qc_tsnow3'].attrs= {'units':'1', 'long_name':'Quality Control flag for T Snow 3'}
ds['qc_tsnow4'].attrs= {'units':'1', 'long_name':'Quality Control flag for T Snow 4'}
ds['qc_tsnow5'].attrs= {'units':'1', 'long_name':'Quality Control flag for T Snow 5'}
ds['qc_tsnow6'].attrs= {'units':'1', 'long_name':'Quality Control flag for T Snow 6'}
ds['qc_tsnow7'].attrs= {'units':'1', 'long_name':'Quality Control flag for T Snow 7'}
ds['qc_tsnow8'].attrs= {'units':'1', 'long_name':'Quality Control flag for T Snow 8'}
ds['qc_tsnow9'].attrs= {'units':'1', 'long_name':'Quality Control flag for T Snow 9'}
ds['qc_tsnow10'].attrs= {'units':'1', 'long_name':'Quality Control flag for T Snow 10'}
ds['qc_battery'].attrs= {'units':'1', 'long_name':'Quality Control flag for Battery Voltage'}
ds['time'].attrs= {'units':'seconds since 1970-01-01 00:00:00', 'long_name':'time of measurement', 'standard_name':'time', 'bounds':'time_bounds', 'calendar':'noleap'}
ds['sza'].attrs= {'units':'degree', 'long_name':'Solar Zenith Angle', 'standard_name':'solar_zenith_angle', 'coordinates':'longitude latitude', 'cell_methods':'time: mean'}
ds['station_name'].attrs= {'long_name':'Station Name', 'cf_role':'timeseries_id'}
ds['latitude'].attrs= {'units':'degrees_north', 'standard_name':'latitude'}
ds['longitude'].attrs= {'units':'degrees_east', 'standard_name':'longitude'}
encoding = {'julian_decimal_time': {'_FillValue': False},
'sw_down': {'_FillValue': fillvalue_double},
'sw_up': {'_FillValue': fillvalue_double},
'net_radiation': {'_FillValue': fillvalue_double},
'temperature_tc_1': {'_FillValue': fillvalue_double},
'temperature_tc_2': {'_FillValue': fillvalue_double},
'temperature_cs500_1': {'_FillValue': fillvalue_double},
'temperature_cs500_2': {'_FillValue': fillvalue_double},
'relative_humidity_1': {'_FillValue': fillvalue_double},
'relative_humidity_2': {'_FillValue': fillvalue_double},
'u1_wind_speed': {'_FillValue': fillvalue_double},
'u2_wind_speed': {'_FillValue': fillvalue_double},
'u_direction_1': {'_FillValue': fillvalue_double},
'u_direction_2': {'_FillValue': fillvalue_double},
'atmos_pressure': {'_FillValue': fillvalue_double},
'snow_height_1': {'_FillValue': fillvalue_double},
'snow_height_2': {'_FillValue': fillvalue_double},
't_snow_01': {'_FillValue': fillvalue_double},
't_snow_02': {'_FillValue': fillvalue_double},
't_snow_03': {'_FillValue': fillvalue_double},
't_snow_04': {'_FillValue': fillvalue_double},
't_snow_05': {'_FillValue': fillvalue_double},
't_snow_06': {'_FillValue': fillvalue_double},
't_snow_07': {'_FillValue': fillvalue_double},
't_snow_08': {'_FillValue': fillvalue_double},
't_snow_09': {'_FillValue': fillvalue_double},
't_snow_10': {'_FillValue': fillvalue_double},
'battery_voltage': {'_FillValue': fillvalue_double},
'sw_down_max': {'_FillValue': fillvalue_double},
'sw_up_max': {'_FillValue': fillvalue_double},
'net_radiation_max': {'_FillValue': fillvalue_double},
'max_air_temperature_1': {'_FillValue': fillvalue_double},
'max_air_temperature_2': {'_FillValue': fillvalue_double},
'min_air_temperature_1': {'_FillValue': fillvalue_double},
'min_air_temperature_2': {'_FillValue': fillvalue_double},
'max_windspeed_u1': {'_FillValue': fillvalue_double},
'max_windspeed_u2': {'_FillValue': fillvalue_double},
'stdev_windspeed_u1': {'_FillValue': fillvalue_double},
'stdev_windspeed_u2': {'_FillValue': fillvalue_double},
'ref_temperature': {'_FillValue': fillvalue_double},
'windspeed_2m': {'_FillValue': fillvalue_double},
'windspeed_10m': {'_FillValue': fillvalue_double},
'wind_sensor_height_1': {'_FillValue': fillvalue_double},
'wind_sensor_height_2': {'_FillValue': fillvalue_double},
'albedo': {'_FillValue': fillvalue_double},
'zenith_angle': {'_FillValue': fillvalue_double},
'time': {'_FillValue': False},
'time_bounds': {'_FillValue': False},
'sza': {'_FillValue': False},
'latitude': {'_FillValue': False},
'longitude': {'_FillValue': False}
}
write_data(args, ds, op_file, encoding)
def main():
indir = "nomiss-merra/"
outdir = "rrtm-merra/"
if not os.path.exists(outdir):
os.makedirs(outdir)
# constants
fillvalue_float = 9.96921e+36
alb = 0.75
emis = 0.985
solar_constant = 1367.0
absorber_vmr = dict()
absorber_vmr['CO2'] = 355. / 1E6
absorber_vmr['CH4'] = 1714. / 1E9
absorber_vmr['N2O'] = 311. / 1E9
absorber_vmr['O2'] = 0.21
absorber_vmr['CFC11'] = 0.280 / 1E9
absorber_vmr['CFC12'] = 0.503 / 1E9
absorber_vmr['CFC22'] = 0.
absorber_vmr['CCL4'] = 0.
# stn names and lat/lon
lst_stn = pd.read_csv('../resources/stations_radiation.txt')
stn_names = lst_stn['network_name'].tolist()
latstn = lst_stn['lat'].tolist()
lonstn = lst_stn['lon'].tolist()
nstn = len(stn_names)
'''stn_names = 'gcnet_summit'
latstn = 72.57972
lonstn = -38.50454
nstn = 1'''
hours_merra = [1, 4, 7, 10, 13, 16, 19, 22]
hours_24 = list(range(24))
cleardays = pd.read_csv('cleardays.csv')
# main function
for i in range(nstn):
stn = stn_names[i]
lat_deg = latstn[i]
lon_deg = lonstn[i]
'''stn = stn_names
lat_deg = latstn
lon_deg = lonstn'''
fout = outdir + stn + '.rrtm.nc'
sw_dn_complete = []
sw_up_complete = []
lw_dn_complete = []
lw_up_complete = []
time_op = []
flname = indir + stn + '.' + 'merra2.inst3.asm.1991-2018' + '.nc'
clr_dates = cleardays.loc[cleardays['network_name'] == stn, 'date']
for date in clr_dates:
sw_dn = []
sw_up = []
lw_dn = []
lw_up = []
'''flname = indir + stn + '.' + str(date) + '.nc'
if not os.path.isfile(flname):
continue'''
fin = xr.open_dataset(flname)
fin = fin.sel(time=str(date))
tmp = fin['t'].values
ts = fin['ts'].values
plev = fin['plev'].values
ps = fin['ps'].values
h2o_q = fin['q'].values
o3_mmr = fin['o3'].values
o3_vmr = climlab.utils.thermo.mmr_to_vmr(o3_mmr, gas='O3')
aod_count = int(fin['aod_count'].values[0])
# knob
aod = np.zeros((6, 1, 42))
aod[1, 0, -aod_count:] = 0.12 / aod_count
aod[5, 0, :20] = 0.0077 / 20
idx = 0
for hr in hours_merra:
dtime = datetime.strptime(str(date), "%Y%m%d") + timedelta(
hours=hr, minutes=30)
sza = sunposition.sunpos(dtime, lat_deg, lon_deg, 0)[1]
cossza = np.cos(np.radians(sza))
state = make_column(lev=plev[idx],
ps=ps[idx],
tmp=tmp[idx],
ts=ts[idx])
absorber_vmr['O3'] = o3_vmr[idx]
rad = climlab.radiation.RRTMG(name='Radiation',
state=state,
specific_humidity=h2o_q[idx],
albedo=alb,
coszen=cossza,
absorber_vmr=absorber_vmr,
emissivity=emis,
S0=solar_constant,
icld=0,
iaer=6,
ecaer_sw=aod)
rad.compute_diagnostics()
dout = rad.to_xarray(diagnostics=True)
sw_dn.append(dout['SW_flux_down_clr'].values[-1])
sw_up.append(dout['SW_flux_up_clr'].values[-1])
lw_dn.append(dout['LW_flux_down_clr'].values[-1])
lw_up.append(dout['LW_flux_up_clr'].values[-1])
idx += 1
sw_dn_24 = CubicSpline(hours_merra, sw_dn,
extrapolate=True)(hours_24)
sw_up_24 = CubicSpline(hours_merra, sw_up,
extrapolate=True)(hours_24)
lw_dn_24 = CubicSpline(hours_merra, lw_dn,
extrapolate=True)(hours_24)
lw_up_24 = CubicSpline(hours_merra, lw_up,
extrapolate=True)(hours_24)
sw_dn_complete.append(sw_dn_24)
sw_up_complete.append(sw_up_24)
lw_dn_complete.append(lw_dn_24)
lw_up_complete.append(lw_up_24)
for hr in range(24):
time_op.append(
datetime.strptime(str(date), "%Y%m%d") +
timedelta(hours=hr, minutes=30))
# Combine fsds for multiple days into single list
sw_dn_complete = [
item for sublist in sw_dn_complete for item in sublist
]
sw_up_complete = [
item for sublist in sw_up_complete for item in sublist
]
lw_dn_complete = [
item for sublist in lw_dn_complete for item in sublist
]
lw_up_complete = [
item for sublist in lw_up_complete for item in sublist
]
# Get seconds since 1970
time_op = [(i - datetime(1970, 1, 1)).total_seconds() for i in time_op]
if sw_dn_complete: # Write data
ds = xr.Dataset()
ds['fsds'] = 'time', sw_dn_complete
ds['fsus'] = 'time', sw_up_complete
ds['flds'] = 'time', lw_dn_complete
ds['flus'] = 'time', lw_up_complete
ds['time'] = 'time', time_op
ds['fsds'].attrs = {
"_FillValue":
fillvalue_float,
"units":
'watt meter-2',
"long_name":
'RRTM simulated shortwave downwelling radiation at surface'
}
ds['fsus'].attrs = {
"_FillValue":
fillvalue_float,
"units":
'watt meter-2',
"long_name":
'RRTM simulated shortwave upwelling radiation at surface'
}
ds['flds'].attrs = {
"_FillValue":
fillvalue_float,
"units":
'watt meter-2',
"long_name":
'RRTM simulated longwave downwelling radiation at surface'
}
ds['flus'].attrs = {
"_FillValue":
fillvalue_float,
"units":
'watt meter-2',
"long_name":
'RRTM simulated longwave upwelling radiation at surface'
}
ds['time'].attrs = {
"_FillValue": fillvalue_float,
"units": 'seconds since 1970-01-01 00:00:00',
"calendar": 'standard'
}
ds.to_netcdf(fout)
print(fout)
def load_picky_solar(mat, t1, t2, configfile):
from sunposition import sunpos
jdate = mat["jdate"].squeeze()
lon = mat["wrflon"]
lat = mat["wrflat"]
hgt = mat['hgt']
swdown = mat['data']
lon = np.mean(lon)
lat = np.mean(lat)
hgt = np.mean(hgt)
# Only use the data from t1 to t2
tstart = matplotlib.dates.date2num(t1) + 366
tend = matplotlib.dates.date2num(t2) + 366
ind = (jdate >= tstart) * (jdate <= tend)
jdate = jdate[ind]
swdown = swdown[ind]
swdown = np.mean(swdown, axis=1) #
datevec = matplotlib.dates.num2date(jdate - 366)
day_of_year = np.zeros([len(jdate)])
for i in range(len(jdate)):
day_of_year[i] = datevec[i].timetuple().tm_yday
# Find azimuth, zenith, declination, angle
logger.info(
'Compute the coordinates of the sun as viewed at the given time and location. This may take some time...'
)
coords = np.zeros((len(jdate), 5))
coords = sunpos(datevec, lat, lon, hgt)
az = coords[:,
0] #coords[...,0] = observed azimuth angle, measured eastward from north
zen = coords[:,
1] #coords[...,1] = observed zenith angle, measured down from vertical matlab.zen
delta = coords[:,
3] #coords[...,3] = topocentric declination (delta?) Same as matlab.delta
omega = coords[:,
4] + 360 #coords[...,4] = topocentric hour angle (omega?) Same as matlab.omega -360
logger.debug('Computiation of coordinates of the sun is finished.')
def cost(angle):
return np.cos(np.radians(angle))
def sint(angle):
return np.sin(np.radians(angle))
def tant(angle):
return np.tan(np.radians(angle))
#bbeam
b00 = 1367
grad = swdown
eps0 = 1 + 0.033 * cost((360 * day_of_year) / 365)
# Extraterrestial radiation
b = b00 * eps0 * cost(zen)
sun_alt = 90 - zen
b[sun_alt <= 0] = 0
# Clearness index
kt = np.zeros(b.shape)
kt[b > 0] = grad[b > 0] / b[b > 0]
kt[kt > 1] = 0
# Diffuse indices
fd = 0.868 + 1.335 * (kt) - 5.782 * (kt**2) + 3.721 * (kt**3)
fd[kt <= 0.13] = 0.952
fd[kt > 0.8] = 0.141
drad = grad * fd
# Beam radiation (Global radiation - diffuse radiation)
brad = grad - drad # beam radiation
bbeam = brad / cost(zen)
bbeam[bbeam < 0] = 0
bbeam[bbeam > 2000] = 0
efficiency = 0.1
p_inst = 1
area = p_inst * 0.00875
derate = 0.77
#set panel orientation
panel_matrix_az, panel_matrix_tlt, panel_matrix_weight, azimuth_median, tilt_median = read_solar_panel(
configfile)
if not azimuth_median:
azimuth_median = 0
if not tilt_median:
tilt_median = lat
logger.info(
'Panel is directed with azimuth at median %d and tilt at median %d' %
(azimuth_median, tilt_median))
panel_matrix_az = azimuth_median + panel_matrix_az
panel_matrix_tlt = tilt_median + panel_matrix_tlt
prod = np.zeros(len(bbeam))
# solar tracker is considered
# TIPS: https://www.e-education.psu.edu/eme810/node/576
# https://www.e-education.psu.edu/eme810/node/485
if solar_tracker == False: # use the standard model if False
for i in range(3):
for j in range(3):
panel_az = panel_matrix_az[i, j]
panel_slp = panel_matrix_tlt[i, j]
weight = panel_matrix_weight[i, j]
#angel between beam and panel
costh_s = sint(delta) * sint(lat) * cost(panel_slp) - np.sign(
lat) * sint(delta) * cost(lat) * sint(panel_slp) * cost(
panel_az) + cost(delta) * cost(omega) * cost(
lat) * cost(panel_slp) + np.sign(lat) * cost(
delta) * cost(omega) * sint(lat) * sint(
panel_slp) * cost(panel_az) + cost(
delta) * sint(omega) * sint(
panel_az) * sint(panel_slp)
bbeam_panel = bbeam * np.maximum(0, costh_s)
drad_panel = drad * (1 + cost(panel_slp)) / 2
rad_panel = bbeam_panel + drad_panel
prod = prod + weight * rad_panel * efficiency * area * derate
elif solar_tracker == True:
costh_s_tracker = 1 # strålen treffer 90 grader på panelet hele tiden, ergo er cos av denne vinkelen lik 1
bbeam_panel = bbeam * costh_s_tracker # bbeam sørger for at dette blir null når solen er nede
drad_panel = drad * (1 + cost(zen)) / 2 # setter zentih angle som tilt
rad_panel = bbeam_panel + drad_panel
prod = rad_panel * efficiency * area * derate
return jdate, swdown, prod, lat, lon
for row in reader:
date_time = row[0].split(' UTC')[0]
date = date_time.split(' ')[0]
time = date_time.split(' ')[1]
year = int(date.split('-')[0])
month = int(date.split('-')[1])
day = int(date.split('-')[2])
hour = int(time.split(':')[0])
minute = int(time.split(':')[1])
second = int(time.split(':')[2])
dt = datetime(year, month, day, hour, minute, second, 0)
azimuth, zenith = sunpos(dt,lat,lon,ele)[:2]
elevation = 90 - zenith
azimuth = round(azimuth, 3)
elevation = round(elevation, 3)
temperature = float(row[2])
humidity = float(row[3])
vPanel = float(row[4])
vPyra = float(row[5])
date = date.replace('-','')
if date not in data.keys():
data[date] = ()
if 7 < hour < 15:
def ReadDecomp(F1, F2, F3, F4, SAT_ID, SEN_ID):
if (SAT_ID == "C03" and SEN_ID == "MX"):
t = "2019-11-06 10:22:56"
lat = 21.45
lon = 78.12
cloud = 0
total = 0
##################################### Deep Learning Code #########################################
model = Sequential()
model.add(Dense(16, activation='relu', input_shape=(4, )))
model.add(BatchNormalization())
model.add(Dense(32, activation='relu'))
model.add(BatchNormalization())
model.add(Dense(64, activation='relu'))
model.add(BatchNormalization())
model.add(Dense(32, activation='relu'))
model.add(BatchNormalization())
model.add(Dense(16, activation='relu'))
model.add(BatchNormalization())
model.add(Dense(2, activation='softmax'))
model.load_weights(
"/maintenance/rkrg_dnd/DLProjects/RealTimeCloudC3/Model_Final.h5")
##################################################################################################
files = [F1, F2, F3, F4]
AUX_LEN = 200
CCD_COUNT = 16080
NUMBER_OF_BITS = 11
BYTE_COUNT = 2
LINE_BYTES = CCD_COUNT * BYTE_COUNT
while not (os.path.exists(F1) and os.path.exists(F2)
and os.path.exists(F3) and os.path.exists(F4)):
time.sleep(1)
print('waiting for the pass')
start_point = 0
file1_size = 0
while True:
f_sizes = []
for i in range(1, 5):
f2 = os.stat(files[i - 1])
file2_size = f2.st_size
comp = file2_size - file1_size
f_sizes.append(comp)
f_sizes = np.array(f_sizes)
min_lines = np.min((f_sizes // (LINE_BYTES + AUX_LEN)))
#print(file1_size, file2_size, comp
if min_lines > 0:
status = 0
print('Reading newly received data')
# FILE_SIZE= os.path.getsize(FILE_NAME)
# print(FILE_SIZE)
# if(not NUM_LINES.is_integer()):
# print(' THE DATA MIGHT BE CORRUPTED OR IS INCOMPLETE, IGNORING THE INCOMPLETE LINE AND READING COMPLETE LINES')
#- READING BINARY ---
# 0 (or os.SEEK_SET): means your reference point is the beginning of the file
# 1 (or os.SEEK_CUR): means your reference point is the current file position
# 2 (or os.SEEK_END): means your reference point is the end of the file
bands = []
for i in range(1, 5):
file = open(files[i - 1], "rb")
data = []
file.seek(start_point)
end_point = start_point + min_lines * (LINE_BYTES +
AUX_LEN)
for line in range(min_lines):
# - EACH LINE CONSISTS OF BYTE_COUNT*CCD_COUNT BYTES
# - DETERMINE THE NUMBER OF LINES = FILE_SIZE(bytes)/12000
# - IF NOT EXACTLY DIVISIBLE TAKE FLOOR. ( RETURN A WARNING IF POSSIBLE )
file.seek(AUX_LEN, 1)
x = np.fromfile(file, np.uint16, CCD_COUNT)
#print(x)
data.append(x)
# break
#print(np.shape(np.array(data)), min_line
bands.append(np.array(data))
#print(line)
start_point = end_point
file1_size = file1_size + min_lines * (LINE_BYTES + AUX_LEN)
print(np.shape(np.array(bands)), min_lines)
az, zen = sunpos(t, lat, lon, 0)[:2]
print('Generating TOA Images')
bands = GenerateTOAImages(np.array(bands), 4, 1, t, 90 - zen,
C3_ExoAtmospheric_Irradiance)
print(np.shape(bands))
print(
'TOA Images are generated and are being classified to check for cloud pixels'
)
bands = np.array(bands)
X_test = np.reshape(bands, (4, -1))
X_test = np.swapaxes(X_test, 0, 1)
print(np.shape(X_test))
labels_test = model.predict_classes(X_test,
batch_size=10000000,
verbose=1)
total = total + len(labels_test)
labels_test = labels_test.reshape(
np.shape(bands)[1],
np.shape(bands)[2])
print('Classification Done using Deep Neural Network')
cloud = cloud + np.count_nonzero(labels_test == 0)
#return(labels_test, min_lines)
else:
if status == 0:
t1 = datetime.datetime.now()
status = 1
else:
diff = datetime.datetime.now() - t1
if diff.seconds > 15:
print('Cloud Percentage: ' +
str((cloud / total) * 100))
return 0
pass
else:
return None
def main():
indir = "nomiss-airx3std/"
outdir = "rrtm-airx3std/"
if not os.path.exists(outdir):
os.makedirs(outdir)
# constants
fillvalue_float = 9.96921e+36
alb = 0.75
emis = 0.985
solar_constant = 1367.0
absorber_vmr = dict()
absorber_vmr['CO2'] = 355. / 1E6
absorber_vmr['CH4'] = 1714. / 1E9
absorber_vmr['N2O'] = 311. / 1E9
absorber_vmr['O2'] = 0.21
absorber_vmr['CFC11'] = 0.280 / 1E9
absorber_vmr['CFC12'] = 0.503 / 1E9
absorber_vmr['CFC22'] = 0.
absorber_vmr['CCL4'] = 0.
# stn names and lat/lon
lst_stn = pd.read_csv('../resources/stations_radiation.txt')
stn_names = lst_stn['network_name'].tolist()
latstn = lst_stn['lat'].tolist()
lonstn = lst_stn['lon'].tolist()
nstn = len(stn_names)
'''stn_names = 'imau09'
latstn = -75.0
lonstn = 0.0
nstn = 1'''
cleardays = pd.read_csv('cleardays.csv')
# main function
for i in range(nstn):
stn = stn_names[i]
lat_deg = latstn[i]
lon_deg = lonstn[i]
'''stn = stn_names
lat_deg = latstn
lon_deg = lonstn'''
fout = outdir + stn + '.rrtm.nc'
sw_dn_complete = []
sw_up_complete = []
lw_dn_complete = []
lw_up_complete = []
time_op = []
clr_dates = cleardays.loc[cleardays['network_name'] == stn, 'date']
for date in clr_dates:
sw_dn = []
sw_up = []
lw_dn = []
lw_up = []
sw_dn_final = [None] * 24
sw_up_final = [None] * 24
lw_dn_final = [None] * 24
lw_up_final = [None] * 24
for sfx in ['A', 'D']:
flname = indir + stn + '/' + stn + '.' + str(
date) + '.' + sfx + '.nc'
if not os.path.isfile(flname): # Check if nomiss file exists
continue
fin = xr.open_dataset(flname)
# Get values from nomiss netCDF file
tmp = fin['t'].values
ts = fin['ts'].values
plev = fin['plev'].values
ps = fin['ps'].values
state = make_column(lev=plev, ps=ps, tmp=tmp, ts=ts)
o3 = fin['o3'].values
absorber_vmr['O3'] = o3
h2o_q = fin['q'].values
aod_count = fin['aod_count'].values
# knob
aod = np.zeros((6, 1, 24))
aod[1, 0, -aod_count:] = 0.12 / aod_count
aod[5, 0, :15] = 0.0077 / 15
# Calculate shortwave radiation down for each hour
for hr in range(24):
dtime = datetime.strptime(flname.split('.')[1],
"%Y%m%d") + timedelta(hours=hr,
minutes=30)
sza = sunposition.sunpos(dtime, lat_deg, lon_deg, 0)[1]
cossza = np.cos(np.radians(sza))
rad = climlab.radiation.RRTMG(name='Radiation',
state=state,
specific_humidity=h2o_q,
albedo=alb,
coszen=cossza,
absorber_vmr=absorber_vmr,
emissivity=emis,
S0=solar_constant,
icld=0,
iaer=6,
ecaer_sw=aod)
rad.compute_diagnostics()
dout = rad.to_xarray(diagnostics=True)
sw_dn.append(dout['SW_flux_down_clr'].values[-1])
sw_up.append(dout['SW_flux_up_clr'].values[-1])
lw_dn.append(dout['LW_flux_down_clr'].values[-1])
lw_up.append(dout['LW_flux_up_clr'].values[-1])
if sw_dn:
if len(sw_dn) == 24:
sw_dn_final = sw_dn # If only either 'A' or 'D' file present
sw_up_final = sw_up # If only either 'A' or 'D' file present
lw_dn_final = lw_dn # If only either 'A' or 'D' file present
lw_up_final = lw_up # If only either 'A' or 'D' file present
else:
count = 0
while count < 24:
sw_dn_final[count] = (sw_dn[count] + sw_dn[
count + 24]) / 2.0 # Average of both 'A' and 'D'
sw_up_final[count] = (sw_up[count] + sw_up[
count + 24]) / 2.0 # Average of both 'A' and 'D'
lw_dn_final[count] = (lw_dn[count] + lw_dn[
count + 24]) / 2.0 # Average of both 'A' and 'D'
lw_up_final[count] = (lw_up[count] + lw_up[
count + 24]) / 2.0 # Average of both 'A' and 'D'
count += 1
sw_dn_complete.append(
sw_dn_final
) # Combine sw_dn_final for multiple days in a single variable
sw_up_complete.append(
sw_up_final
) # Combine sw_up_final for multiple days in a single variable
lw_dn_complete.append(
lw_dn_final
) # Combine lw_dn_final for multiple days in a single variable
lw_up_complete.append(
lw_up_final
) # Combine lw_up_final for multiple days in a single variable
for hr in range(
24): # Time variable to be written in netCDF file
time_op.append(
datetime.strptime(str(date), "%Y%m%d") +
timedelta(hours=hr, minutes=30))
if sw_dn_complete: # Write data
# Make single list from list of lists
sw_dn_complete = [
item for sublist in sw_dn_complete for item in sublist
]
sw_up_complete = [
item for sublist in sw_up_complete for item in sublist
]
lw_dn_complete = [
item for sublist in lw_dn_complete for item in sublist
]
lw_up_complete = [
item for sublist in lw_up_complete for item in sublist
]
# Get seconds since 1970
time_op = [(i - datetime(1970, 1, 1)).total_seconds()
for i in time_op]
ds = xr.Dataset()
ds['fsds'] = 'time', sw_dn_complete
ds['fsus'] = 'time', sw_up_complete
ds['flds'] = 'time', lw_dn_complete
ds['flus'] = 'time', lw_up_complete
ds['time'] = 'time', time_op
ds['fsds'].attrs = {
"_FillValue":
fillvalue_float,
"units":
'watt meter-2',
"long_name":
'RRTM simulated shortwave downwelling radiation at surface'
}
ds['fsus'].attrs = {
"_FillValue":
fillvalue_float,
"units":
'watt meter-2',
"long_name":
'RRTM simulated shortwave upwelling radiation at surface'
}
ds['flds'].attrs = {
"_FillValue":
fillvalue_float,
"units":
'watt meter-2',
"long_name":
'RRTM simulated longwave downwelling radiation at surface'
}
ds['flus'].attrs = {
"_FillValue":
fillvalue_float,
"units":
'watt meter-2',
"long_name":
'RRTM simulated longwave upwelling radiation at surface'
}
ds['time'].attrs = {
"_FillValue": fillvalue_float,
"units": 'seconds since 1970-01-01 00:00:00',
"calendar": 'standard'
}
ds.to_netcdf(fout)
print(fout)
