Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
ext
insitu
trios
Commits
fa46ae1f
Commit
fa46ae1f
authored
Mar 12, 2019
by
Harmel Tristan
Browse files
clean up package
parent
c9a02a96
Changes
15
Hide whitespace changes
Inline
Side-by-side
build/__init__.py
deleted
100644 → 0
View file @
c9a02a96
build/lib/__init__.py
deleted
100644 → 0
View file @
c9a02a96
build/lib/process/__init__.py
deleted
100644 → 0
View file @
c9a02a96
build/lib/process/process.py
deleted
100644 → 0
View file @
c9a02a96
import
numpy
as
np
import
pandas
as
pd
from
scipy
import
interpolate
,
integrate
from
scipy.optimize
import
curve_fit
import
plotly.plotly
as
py
# import plotly.graph_objs as go
from
plotly.graph_objs
import
*
from
utils.utils
import
reshape
as
r
import
utils.auxdata
as
ua
from
..config
import
*
class
awr_process
:
def
__init__
(
self
,
df
=
None
,
wl
=
None
):
self
.
df
=
df
self
.
aot
=
0.1
self
.
ws
=
2
self
.
wl
=
wl
self
.
rhosoaa_fine_file
=
rhosoaa_fine_file
self
.
rhosoaa_coarse_file
=
rhosoaa_coarse_file
self
.
M1999_file
=
M1999_file
self
.
M2015_file
=
M2015_file
self
.
load_rho_lut
()
self
.
rho
=
self
.
rhosoaa_fine
def
load_rho_lut
(
self
):
self
.
rhosoaa_fine
=
pd
.
read_csv
(
self
.
rhosoaa_fine_file
,
index_col
=
[
0
,
1
,
2
,
3
,
4
,
5
])
self
.
rhosoaa_coarse
=
pd
.
read_csv
(
self
.
rhosoaa_coarse_file
,
index_col
=
[
0
,
1
,
2
,
3
,
4
,
5
])
self
.
rhoM1999
=
pd
.
read_csv
(
self
.
M1999_file
,
skiprows
=
7
,
index_col
=
[
0
,
1
,
2
,
3
])
self
.
rhoM2015
=
pd
.
read_csv
(
self
.
M2015_file
,
skiprows
=
8
,
index_col
=
[
0
,
1
,
2
,
3
])
self
.
rhoM1999
.
dropna
(
inplace
=
True
)
self
.
rhoM2015
.
dropna
(
inplace
=
True
)
def
get_rho_values
(
self
,
sza
,
vza
,
azi
,
ws
=
[
2
],
aot
=
[
0.1
],
wl
=
[
550
],
sunglint
=
False
):
'''
Interpolate the rho factor values from tabulated data
:param sza: solar zenith angle in deg, array-like
:param vza: view zenith angle in deg, array-like
:param azi: relative azimuth in deg (=0 when looking at Sun), array-like
:param ws: wind speed, m/s,(based on Cox-Munk parametrization of surface roughness) array-like
:param aot: aerosol optical thickness at 550 nm, array-like
:param wl: wavelength in nm, array-like
:param sunglint: add sunglint component in rho calculation if True
:return:
'''
grid
=
self
.
rho
.
rho
.
index
.
levels
# convert pandas dataframe into 6D array of the tabulated rho values for interpolation
rhoname
=
'rho'
if
sunglint
:
rhoname
=
'rho_g'
rho_6d
=
r
().
df2ndarray
(
self
.
rho
,
rhoname
)
rho_
=
calc
().
spline_2d
(
grid
[
-
2
:],
rho_6d
,
(
azi
,
vza
))
rho_wl
=
calc
().
spline_4d
(
grid
[:
-
2
],
rho_
,
(
ws
,
aot
,
wl
,
sza
))
return
rho_wl
.
squeeze
()
def
get_rho_mobley
(
self
,
rhodf
,
sza
,
vza
,
azi
,
ws
):
'''
Get the Mobley rho factor from cubic interpolation in the tabulated values
:param rhodf:
:param sza:
:param vza:
:param azi:
:param ws:
:return:
'''
rhodf
=
rhodf
.
query
(
'sza<75 & vza >0'
)
rhodf
.
index
=
rhodf
.
index
.
remove_unused_levels
()
# grid {wind, sza, vza, azi}
grid
=
rhodf
.
index
.
levels
rho_
=
r
().
df2ndarray
(
rhodf
,
'rho'
)
rho_mobley
=
calc
().
spline_4d
(
grid
,
rho_
,
(
ws
,
sza
,
vza
,
azi
))
return
rho_mobley
def
call_process
(
self
,
vza
=
[
40
],
azi
=
[
135
],
ws
=
2
,
aot
=
0.1
):
wl
=
self
.
wl
Lt
=
self
.
df
.
loc
[:,
(
"Lt"
)]
Lsky
=
self
.
df
.
loc
[:,
(
"Lsky"
)]
Ed
=
self
.
df
.
loc
[:,
(
"Ed"
)]
sza
=
self
.
df
.
loc
[:,
(
"sza"
)].
values
.
mean
()
Rrs
=
self
.
process
(
wl
,
Lt
,
Lsky
,
Ed
,
sza
,
vza
,
azi
,
ws
,
aot
)
Rrs
.
columns
=
pd
.
MultiIndex
.
from_product
([[
'Rrs(awr)'
],
self
.
Rrs
.
columns
],
names
=
[
'param'
,
'wl'
])
self
.
Rrs
=
Rrs
return
self
.
Rrs
def
process
(
self
,
wl
,
Lt
,
Lsky
,
Ed
,
sza
,
vza
=
[
40
],
azi
=
[
135
],
ws
=
[
2
],
aot
=
[
0.1
]):
'''
:param wl:
:param Lt:
:param Lsky:
:param Ed:
:param sza:
:param vza:
:param azi:
:param ws:
:param aot:
:return:
'''
rho
=
self
.
get_rho_values
([
sza
],
vza
,
azi
,
wl
=
wl
,
ws
=
ws
,
aot
=
aot
)
self
.
Rrs
=
(
Lt
-
rho
*
Lsky
)
/
Ed
return
self
.
Rrs
,
rho
class
swr_process
:
def
__init__
(
self
,
df
=
None
,
wl
=
None
,
):
self
.
df
=
df
self
.
wl
=
wl
def
call_process
(
self
,
shade_corr
=
False
):
wl
=
self
.
wl
Lu
=
self
.
df
.
loc
[:,
(
"Lu0+"
)]
Ed
=
self
.
df
.
loc
[:,
(
"Ed"
)]
sza
=
self
.
df
.
loc
[:,
(
"sza"
)].
values
.
mean
()
Rrs
=
self
.
process
(
Lu
,
Ed
,
sza
,
wl
,
shade_corr
=
shade_corr
)
Rrs
.
columns
=
pd
.
MultiIndex
.
from_product
([[
'Rrs(swr)'
],
Rrs
.
columns
],
names
=
[
'param'
,
'wl'
])
self
.
Rrs
=
Rrs
return
Rrs
def
process
(
self
,
Lu
,
Ed
,
sza
,
wl
,
R
=
0.05
,
shade_corr
=
False
):
Rrs
=
Lu
/
Ed
ang_w
=
calc
().
angle_w
(
sza
)
iopw
=
ua
.
iopw
()
iopw
.
load_iopw
()
iopw
.
get_iopw
(
wl
)
a
,
bb
=
iopw
.
aw
,
iopw
.
bbw
# TODO add particulate and dissolved component to a and bb values
# a,bb = aux.get_iop(..., withwater=True)
acdom
=
ua
.
cdom
(
0.5
,
wl
).
get_acdom
()
a
=
a
+
acdom
+
0.4
bb
=
bb
+
0.05
if
shade_corr
:
Rrs
=
self
.
shade_corr
(
Rrs
,
R
,
ang_w
,
a
,
bb
,
wl
)
# Rrs.columns = pd.MultiIndex.from_product([['Rrs(swr)'], Rrs.columns], names=['param', 'wl'])
self
.
Rrs
=
Rrs
self
.
a
=
a
self
.
bb
=
bb
self
.
acdom
=
acdom
return
self
.
Rrs
def
epsilon
(
self
,
K
,
R
,
ang_w
):
'''
epsilon from Shang et al, 2017, Applied Optics
:param K:
:param R:
:param ang_w: Sun zenith angle below surface (in deg)
:return:
'''
self
.
eps
=
np
.
array
(
1
-
np
.
exp
(
-
K
*
R
/
np
.
tan
(
np
.
radians
(
ang_w
))))
return
self
.
eps
def
K
(
self
,
a
,
bb
,
ang_w
):
'''
K (sum attenuation coef. of Lu in and outside the shade) from Shang et al, 2017, Applied Optics
:param a: total absorption coefficient (m-1)
:param bb: total backscattering coefficient (m-1)
:param ang_w: Sun zenith angle below surface (in deg)
:return:
'''
sin_ang_w
=
np
.
sin
(
np
.
radians
(
ang_w
))
self
.
K_
=
(
3.15
*
sin_ang_w
+
1.15
)
*
a
*
np
.
exp
(
-
1.57
*
bb
)
\
+
(
5.62
*
sin_ang_w
-
0.23
)
*
bb
*
np
.
exp
(
-
0.5
*
a
)
return
self
.
K_
def
shade_corr
(
self
,
Rrs
,
R
,
ang_w
,
a
,
bb
,
wl
,
wl_cutoff
=
900
):
'''
Correction of shading error from Shang et al, 2017, Applied Optics
:param Rrs:
:param R:
:param ang_w:
:param a:
:param bb:
:return:
'''
K
=
self
.
K
(
a
,
bb
,
ang_w
)
eps
=
self
.
epsilon
(
K
,
R
,
ang_w
)
eps
[
wl
>
wl_cutoff
]
=
0
self
.
Rrs
=
Rrs
/
(
1
-
eps
)
return
self
.
Rrs
class
iwr_process
:
def
__init__
(
self
,
df
=
None
,
wl
=
None
,
):
self
.
df
=
df
self
.
wl
=
wl
def
process
(
self
):
wl
=
self
.
wl
df
=
self
.
df
reflectance
=
df
.
loc
[:,
(
"Luz"
)]
/
df
.
loc
[:,
(
"Edz"
)]
reflectance
.
columns
=
pd
.
MultiIndex
.
from_product
([[
'reflectance'
],
reflectance
.
columns
],
names
=
[
'param'
,
'wl'
])
self
.
reflectance
=
reflectance
df
[
'rounded_depth'
,
''
]
=
df
.
prof_Edz
.
round
(
1
)
df
.
groupby
(
'rounded_depth'
).
mean
()
return
self
.
reflectance
@
staticmethod
def
f_Edz
(
depth
,
Kd
,
Ed0
):
'''simple Edz model for homogeneous water column'''
return
Ed0
*
np
.
exp
(
-
Kd
*
depth
)
@
staticmethod
def
f_logEdz
(
depth
,
Kd
,
Ed0
):
'''simple Edz model for homogeneous water column'''
return
np
.
log
(
1
+
iwr_process
.
f_Edz
(
depth
,
Kd
,
Ed0
))
#Ed0) -Kd*depth
def
Kd
(
self
,
depth
,
Edz
):
Kd
=
np
.
diff
(
Edz
)
/
np
.
diff
(
depth
)
def
plot_raw
(
self
,
x
=
'Luz'
,
y
=
'prof_Luz'
):
trace
=
Scattergl
(
x
=
self
.
df
[
x
].
values
,
y
=
self
.
df
[
y
].
values
,
text
=
self
.
df
.
index
.
get_level_values
(
0
),
hoverinfo
=
"text"
,
marker
=
{
'size'
:
7
,
'opacity'
:
0.5
,
# 'color': 'rgba({}, {}, {}, {})'.format(*s_m.to_rgba(parameters[i]).flatten()),
# x.unique(),#color': df.index.get_level_values(0),
'line'
:
{
'width'
:
0.5
,
'color'
:
'white'
},
},
# error_y=ErrorY(
# type='data',
# array=df['Error'],
# thickness=1.5,
# width=2,
# color='#B4E8FC'
# ),
)
layout
=
Layout
(
height
=
450
,
xaxis
=
dict
(
range
=
[
0
,
200
],
showgrid
=
False
,
showline
=
False
,
zeroline
=
False
,
fixedrange
=
True
,
tickvals
=
[
0
,
50
,
100
,
150
,
200
],
ticktext
=
[
'200'
,
'150'
,
'100'
,
'50'
,
'0'
],
title
=
''
),
yaxis
=
dict
(
range
=
[
min
(
-
5
,
min
(
self
.
df
[
y
])),
max
(
0
,
max
(
self
.
df
[
y
]))],
showline
=
False
,
fixedrange
=
True
,
zeroline
=
False
,
# nticks=max(6, round(df['Speed'].iloc[-1]/10))
),
margin
=
Margin
(
t
=
45
,
l
=
50
,
r
=
50
)
)
return
Figure
(
data
=
[
trace
],
layout
=
layout
)
class
self_shading
:
def
__init__
(
self
):
'''GordonDing 1992 values for epsilon'''
self
.
ang
=
np
.
linspace
(
0
,
90
,
10
)
self
.
eps_dir_LuZ
=
[
2.17
,
2.17
,
2.23
,
2.23
,
2.29
,
2.37
,
2.41
,
2.45
,
2.45
,
2.45
]
self
.
eps_dir_EuZ
=
[
3.14
,
3.14
,
3.05
,
2.94
,
2.80
,
2.64
,
2.47
,
2.33
,
2.33
,
2.33
]
self
.
eps_dif_LuZ
=
4.61
,
self
.
eps_dif_EuZ
=
2.70
def
epsilon
(
self
,
sza
):
eps
=
interpolate
.
interp1d
(
self
.
ang
,
self
.
eps_dif_EuZ
)(
sza
)
return
eps
class
calc
:
def
__init__
(
self
):
pass
def
PAR
(
self
,
wl
,
Ed
):
'''
Compute instantaneous PAR from Ed spectrum.
PAR in mW m-2
PAR_quanta in µmol photon m-2 s-1
:param wl:
:param Ed:
:return:
'''
# ---------------------------------------------
# PARAMETERS
# Planck constant in J s or W s2
h
=
6.6260695729e-3
# d-34
# light speed in m s-1
c
=
2.99792458e0
# d8
# Avogadro Number in mol-1
Avogadro
=
6.0221412927e0
# d23
hc
=
Avogadro
*
h
*
c
# ---------------------------------------------
idx_par
=
(
wl
>=
400
)
&
(
wl
<=
700
)
wl
=
wl
[
idx_par
]
Ed
=
Ed
[
idx_par
]
par
=
integrate
.
trapz
(
Ed
,
wl
)
par_quanta
=
integrate
.
trapz
(
np
.
multiply
(
wl
,
Ed
),
wl
)
/
hc
return
par
,
par_quanta
def
earth_sun_correction
(
self
,
dayofyear
):
'''
Earth-Sun distance correction factor for adjustment of mean solar irradiance
:param dayofyear:
:return: correction factor
'''
theta
=
2.
*
np
.
pi
*
dayofyear
/
365
d2
=
1.00011
+
0.034221
*
np
.
cos
(
theta
)
+
0.00128
*
np
.
sin
(
theta
)
+
\
0.000719
*
np
.
cos
(
2
*
theta
)
+
0.000077
*
np
.
sin
(
2
*
theta
)
return
d2
def
bidir
(
self
,
sza
,
vza
,
azi
):
bidir
=
1
return
bidir
def
angle_w
(
self
,
angle_air
,
n
=
1.334
):
'''
convert above surface angle (angle_air) into sub-surface angle
:param angle_air in deg
:param n: refractive index of water
:return: sub-surface angle in deg
'''
return
np
.
degrees
(
np
.
arcsin
(
np
.
sin
(
np
.
radians
(
angle_air
))
/
n
))
def
spline_2d
(
self
,
gin
,
arr
,
gout
):
'''
Interpolation of a 6D array (arr) with bicubic splines on a 2D grid
corresponding to the 5th and 6th dimensions of arr.
Return 4D array interpolated on gout.
:param gin: regular 2D grid of the tabulated data (tuple/array/list of arrays)
:param arr: tabulated data (N dimensions, interpolation on N-1 and N)
:param gout: new 2D grid on which data are interpolated (with dims 2 and 3 of the same length);
(tuple/array/list of arrays)
:return: Interpolated data (1D or 3D array depending on the dimension shapes of gout
'''
N
=
arr
.
shape
interp
=
np
.
zeros
(
N
[:
-
2
])
for
i
in
range
(
N
[
0
]):
for
j
in
range
(
N
[
1
]):
for
k
in
range
(
N
[
2
]):
for
l
in
range
(
N
[
3
]):
interp
[
i
,
j
,
k
,
l
]
=
interpolate
.
RectBivariateSpline
(
gin
[
0
],
gin
[
1
],
arr
[
i
,
j
,
k
,
l
,
...])(
gout
[
0
],
gout
[
1
],
grid
=
False
)
return
interp
def
spline_4d
(
self
,
gin
,
lut
,
gout
):
'''
Interpolation with two successive bicubic splines on a regular 4D grid.
Designed for interpolation in radiative transfer look-up tables with the two last dimensions
(i.e., wavelength and solar zenith angle) of the same length.
Those dimensions are then reduced/merged to a single one to get interpolated data on a 3D grid.
:param gin: regular 4D grid of the tabulated data (tuple/array/list of arrays)
:param lut: tabulated data
:param gout: new 4D grid on which data are interpolated (with dims 2 and 3 of the same length);
(tuple/array/list of arrays)
:return: Interpolated data (1D or 3D array depending on the dimension shapes of gout
'''
N
=
gin
[
0
].
__len__
(),
gin
[
1
].
__len__
(),
gin
[
2
].
__len__
(),
gin
[
3
].
__len__
()
Nout
=
gout
[
0
].
__len__
(),
gout
[
1
].
__len__
(),
gout
[
2
].
__len__
()
tmp
=
np
.
zeros
([
N
[
0
],
N
[
1
],
Nout
[
2
]])
for
i
in
range
(
N
[
0
]):
for
j
in
range
(
N
[
1
]):
tmp
[
i
,
j
,
:]
=
interpolate
.
RectBivariateSpline
(
gin
[
2
],
gin
[
3
],
lut
[
i
,
j
,
:,
:])(
gout
[
2
],
gout
[
3
],
grid
=
False
)
if
Nout
[
0
]
==
Nout
[
1
]
==
1
:
interp
=
np
.
ndarray
(
Nout
[
2
])
for
iband
in
range
(
Nout
[
2
]):
interp
[
iband
]
=
interpolate
.
RectBivariateSpline
(
gin
[
0
],
gin
[
1
],
tmp
[:,
:,
iband
])(
gout
[
0
],
gout
[
1
],
grid
=
False
)
else
:
interp
=
np
.
ndarray
([
Nout
[
0
],
Nout
[
1
],
Nout
[
2
]])
for
iband
in
range
(
Nout
[
2
]):
interp
[:,
:,
iband
]
=
interpolate
.
RectBivariateSpline
(
gin
[
0
],
gin
[
1
],
tmp
[:,
:,
iband
])(
gout
[
0
],
gout
[
1
],
grid
=
True
)
return
interp
build/lib/process/process_compar_awr.py
deleted
100644 → 0
View file @
c9a02a96
import
base64
import
pandas
as
pd
import
numpy
as
np
import
glob
import
io
import
os
from
textwrap
import
dedent
as
d
import
re
import
matplotlib.pyplot
as
plt
import
plotly
import
plotly.graph_objs
as
go
from
scipy.interpolate
import
interp1d
from
utils.sunposition
import
sunpos
import
utils.utils
as
u
import
utils.auxdata
as
ua
from
trios.process
import
*
coordf
=
glob
.
glob
(
"/DATA/OBS2CO/data/info/mesures_in_situ.csv"
)[
0
]
coords
=
pd
.
read_csv
(
coordf
,
sep
=
';'
)
dirfig
=
os
.
path
.
abspath
(
'/DATA/OBS2CO/data/trios/fig'
)
awrfiles
=
glob
.
glob
(
"/DATA/OBS2CO/data/trios/raw/aw*idpr*.csv"
)
# awrfiles = glob.glob("/DATA/OBS2CO/data/trios/test_setup/raw/aw*idpr*.csv")
swrfiles
=
glob
.
glob
(
"/DATA/OBS2CO/data/trios/raw/Lu0*idpr*.csv"
)
iopw
=
ua
.
iopw
()
iopw
.
load_iopw
()
def
add_curve
(
ax
,
x
,
mean
,
std
,
c
=
'red'
,
label
=
''
):
ax
.
plot
(
x
,
mean
,
linestyle
=
'solid'
,
c
=
c
,
lw
=
2.5
,
alpha
=
0.8
,
label
=
label
)
ax
.
fill_between
(
x
,
mean
-
std
,
mean
+
std
,
alpha
=
0.35
,
color
=
c
)
idpr
=
'167'
# get idpr numbers
idprs
=
np
.
unique
([
re
.
findall
(
r
'idpr(\d+)'
,
x
)[
0
]
for
x
in
swrfiles
])
#idprs = np.array(['170'])
# loop over idpr
for
idpr
in
idprs
:
c
=
coords
[
coords
.
ID_prel
==
int
(
idpr
)]
# .values[0]
lat
=
c
[
'Lat'
].
values
[
0
]
lon
=
c
[
'Lon'
].
values
[
0
]
alt
=
0
# c['Altitude']
name
=
c
[
'ID_lac'
].
values
[
0
]
fig
,
ax
=
plt
.
subplots
(
nrows
=
1
,
ncols
=
1
,
figsize
=
(
10
,
8
))
fig
.
subplots_adjust
(
left
=
0.1
,
right
=
0.9
,
hspace
=
.
5
,
wspace
=
0.65
)
# -----------------------------------------------
# SWR processing
# -----------------------------------------------
uswr
=
u
.
swr_data
(
idpr
,
swrfiles
)
if
uswr
.
file
:
df
,
wl_swr
=
uswr
.
reader
(
lat
,
lon
,
alt
)
df
[
'sza'
,
''
]
=
np
.
nan
for
index
,
row
in
df
.
iterrows
():
# print index
sza
=
sunpos
(
index
,
lat
,
lon
,
alt
)[
1
]
df
.
at
[
index
,
'sza'
]
=
sza
swr
=
swr_process
(
df
,
wl_swr
)
Rrs_swr
=
swr
.
call_process
()
add_curve
(
ax
,
wl_swr
,
Rrs_swr
.
transpose
().
mean
(
axis
=
1
),
Rrs_swr
.
transpose
().
std
(
axis
=
1
),
label
=
'swr'
,
c
=
'black'
)
Rrs_swr
=
swr
.
call_process
(
shade_corr
=
True
)
add_curve
(
ax
,
wl_swr
,
Rrs_swr
.
transpose
().
mean
(
axis
=
1
),
Rrs_swr
.
transpose
().
std
(
axis
=
1
),
label
=
'swr'
,
c
=
'red'
)
# -----------------------------------------------
# AWR processing
# -----------------------------------------------
azi
=
135
vza
=
40
awr
=
u
.
awr_data
(
idpr
,
awrfiles
)
if
awr
.
Edf
:
index_idx
=
[
0
]
d
=
u
.
data
(
index_idx
)
Ed
,
wl_Ed
=
d
.
load_csv
(
awr
.
Edf
)
Lsky
,
wl_Lsky
=
d
.
load_csv
(
awr
.
Lskyf
)
Lt
,
wl_Lt
=
d
.
load_csv
(
awr
.
Ltf
)
# ''' interpolate Ed and Lsky data upon Lt wavelength'''
wl
=
wl_Lt
Lt
.
columns
=
pd
.
MultiIndex
.
from_tuples
(
zip
([
'Lt'
]
*
len
(
wl
),
wl
),
names
=
[
'param'
,
'wl'
])
intEd
=
interp1d
(
wl_Ed
,
Ed
.
values
,
fill_value
=
'extrapolate'
)(
wl
)
newEd
=
pd
.
DataFrame
(
index
=
Ed
.
index
,
columns
=
pd
.
MultiIndex
.
from_tuples
(
zip
([
'Ed'
]
*
len
(
wl
),
wl
),
names
=
[
'param'
,
'wl'
]),
data
=
intEd
)
intLsky
=
interp1d
(
wl_Lsky
,
Lsky
.
values
,
fill_value
=
'extrapolate'
)(
wl
)
newLsky
=
pd
.
DataFrame
(
index
=
Lsky
.
index
,
columns
=
pd
.
MultiIndex
.
from_tuples
(
zip
([
'Lsky'
]
*
len
(
wl
),
wl
),
names
=
[
'param'
,
'wl'
]),
data
=
intLsky
)
awr
=
awr_process
()
ws
=
[
2
]
print
(
azi
,
vza
)
Lsky
=
newLsky
# .loc[(newLsky.index.get_level_values(1) == vza) & (newLsky.index.get_level_values(2) == azi)]
Ed
=
newEd
# .loc[(newEd.index.get_level_values(1) == vza) & (newEd.index.get_level_values(2) == azi)]
# Lsky_idx = Lsky.index
# Ed_idx= Ed.index
# Lt_idx = Lt.index
# Lsky.reset_index(level=[1,2],inplace=True)
# Ed.reset_index(level=[1,2],inplace=True)
# Lt.reset_index(level=[1,2],inplace=True)
# merge sensor data on time
df
=
pd
.
merge_asof
(
Lt
,
Ed
,
left_index
=
True
,
right_index
=
True
,
tolerance
=
pd
.
Timedelta
(
"2 seconds"
),
direction
=
"nearest"
)
df
=
pd
.
merge_asof
(
df
,
Lsky
,
left_index
=
True
,
right_index
=
True
,
tolerance
=
pd
.
Timedelta
(
"2 seconds"
),
direction
=
"nearest"
)
# add solar angle data and idpr
# compute solar angle (mean between fisrt and last aqcuisition time
df
[
'sza'
,
''
]
=
np
.
nan
for
index
,
row
in
df
.
iterrows
():
# print index
sza
=
sunpos
(
index
,
lat
,
lon
,
alt
)[
1
]
df
.
at
[
index
,
'sza'
]
=
sza
rho_h
=
awr
.
get_rho_values
([
df
.
sza
.
mean
()],
[
vza
],
[
azi
],
wl
=
wl
)
rho15
=
awr
.
get_rho_mobley
(
awr
.
rhoM2015
,
[
df
.
sza
.
mean
()],
[
vza
],
[
azi
],
[
ws
])
rho99
=
awr
.
get_rho_mobley
(
awr
.
rhoM1999
,
[
df
.
sza
.
mean
()],
[
vza
],
[
azi
],
[
ws
])
Rrs_h
=
(
df
.
loc
[:,
'Lt'
]
-
rho_h
*
df
.
loc
[:,
'Lsky'
])
/
df
.
loc
[:,
'Ed'
]
Rrs15
=
(
df
.
loc
[:,
'Lt'
]
-
rho15
*
df
.
loc
[:,
'Lsky'
])
/
df
.
loc
[:,
'Ed'
]
Rrs99
=
(
df
.
loc
[:,
'Lt'
]
-
rho99
*
df
.
loc
[:,
'Lsky'
])
/
df
.
loc
[:,
'Ed'
]
# plt.figure()
add_curve
(
ax
,
wl
,
Rrs15
.
transpose
().
mean
(
axis
=
1
),
Rrs15
.
transpose
().
std
(
axis
=
1
),
label
=
'M2015 ('
+
str
(
rho15
)
+
')'
)
add_curve
(
ax
,
wl
,
Rrs99
.
transpose
().
mean
(
axis
=
1
),
Rrs99
.
transpose
().
std
(
axis
=
1
),
c
=
'orange'
,
label
=
'M1999('
+
str
(
rho99
)
+
')'
)
add_curve
(
ax
,
wl
,
Rrs_h
.
transpose
().
mean
(
axis
=
1
),
Rrs_h
.
transpose
().
std
(
axis
=
1
),
c
=
'grey'
,
label
=
'h('
+
str
(
rho_h
.
mean
())
+
')'
)
ax
.
set_title
(
'azi='
+
str
(
azi
)
+
', vza='
+
str
(
vza
)
+
', sza='
+
str
(
sza
))
ax
.
legend
(
loc
=
'best'
,
frameon
=
False
)
ax
.
set_ylabel
(
r
'$R_{rs}\ (sr^{-1})$'
)
ax
.
set_xlabel
(
r
'Wavelength (nm)'
)
fig
.
savefig
(
os
.
path
.
join
(
dirfig
,
'trios_awr_'
+
name
+
'_idpr'
+
idpr
+
'.png'
))
plt
.
close
()
build/lib/process/process_test_setup.py
deleted
100644 → 0
View file @
c9a02a96
import
base64
import
pandas
as
pd
import
numpy
as
np
import
glob
import
io
import
os
from
textwrap
import
dedent
as
d
import
re
import
matplotlib.pyplot
as
plt
import
plotly
import
plotly.graph_objs
as
go
from
scipy.interpolate
import
interp1d
from
utils.sunposition
import
sunpos
import
utils.utils
as
u
from
trios.process
import
*