def threshold(
data, threshold=-7.6, cloud=-5, returnfield=False, binsize=0, inTime=True, continuous=False, vertbin=5, **kwargs
):
"""
for a formatted backsctter dataset, determine a timeseries of the lowest incidence
of the specified backscatter value, regardless of mathematical base.
Parameters
----------
threshold: float, optional
specify the cutoff value for the threshold to be determined from the bottom up
data: numpy 2-d array
the dataset from which the thresholds are determined
"""
if data == "about":
"Then something just wants an info string about the method, so spit it out"
return "010Threshold"
if binsize == 0:
"no binning or averaging or whatnot is to be done."
z = data["height"]
t = data["time"]
data = data["bs"]
else:
data, t, z = u._ComputeFieldMeans(data, binsize, inTime=inTime, continuous=continuous, vertbin=vertbin)
if returnfield:
return (data, t, z)
depth = u._ThresholdLT(data, z, threshold, limit=1200)
del data
return (depth, t)
def idealized_multiple(
data,
binsize=300,
returnfield=False,
inTime=True,
savebin=False,
continuous=False,
guessmean=False,
guessheight=False,
vertbin=5,
limit=1000,
background=-8.2,
threshold=-7.6,
**kwargs
):
"""
Use the idealized backscatter method to identify the top of the aerosol layer.
This routine will use the -7.6 threshold method as a first guess, and will
then minimize the defined function to determine the function coefficients
This is from the method proposed by Eresmaa et al 2012
Parameters
----------
data: list
The produced output from the slice for ceilometer data for the time
period analyzed
binsize: int, optional
the length in SECONDS for bins to be produced. Longer bins increase
the chance of success
returnfield: bool, optional
return only the field analyzed, not very useful for this operation.
inTime: bool, optional
specify if the provided time dimension is actually epoch time stamps,
or just bin numbers
savebin: str, optional
only save a demonstrative figure of a single bin. A possibly useful
demonstration operation.
background: float, optional
set the background (low value) approximation. The current value is -8.2,
which is sufficient for Vaisala CL31 ceilometer backscatter in (m*sr)^-1
units.
"""
l.warning("The mutli-layer idealized profile method has not been implemented")
exit()
if data == "about":
"Then something just wants an info string about the method, so spit it out"
return "100Idealized Profile"
from scipy import optimize, special
bs, times, z = u._ComputeFieldMeans(data, binsize, inTime=inTime, continuous=continuous, vertbin=vertbin)
bs, z = bs[:, : limit / 10], z[: limit / 10]
"no, this method will not use power"
if returnfield:
return (bs, times, z)
if guessmean and guessheight:
"A fixed guess mean has been assigned"
first_guesses = [guessheight for x in times]
first_guess_mean = [guessmean for x in times]
else:
print "Applying threshold theory"
first_guesses = u._ThresholdLT(bs, z, threshold)
"compute the low-level means from the 5th ob up to the guess height"
guess_mean_func = lambda x: np.mean(bs[x][z <= first_guesses[x]])
first_guess_mean = map(guess_mean_func, range(len(first_guesses)))
"now, for each time bin, we will run the optimization"
outH = np.zeros(len(times))
outdH = np.zeros(len(times))
for i in range(len(times)):
"""
make first guesses and fix the two variables
"""
b = bs[i] # the backscatter profile
h = first_guesses[i] # first guess height (a very good guess)]
dh = 100.0 # guess value of dh, based on observation
"for now we are always assuming a 100m transition layer until told otherwise"
p0 = [h, dh]
if h == 0:
continue
bm = first_guess_mean[i] # approximation for boundary layer intensity
bu = background # approximation for free atmosphere intensity
"There are two coefficients, A1 and A2, and one is fixed for the fitting"
a1 = (bm + bu) / 2.0
a2 = (bm - bu) / 2.0
fitfunc = lambda p, z: a1 - a2 * special.erf((z - p[0]) / p[1])
errfunc = lambda p, z, bs: np.sum((fitfunc(p, z) - bs) ** 2)
# print errfunc(p0,height,b)
p1 = optimize.fmin(errfunc, p0, args=(z, b))
print p1
outH[i] = p1[0]
outdH[i] = p1[1]
if savebin:
"this code can just save an example bin plot."
import matplotlib.pyplot as plt
plt.plot(fitfunc(p1, z), z)
plt.plot(b, z)
plt.xlabel("Bakscatter ($m^{-1}sr^{-1}$)")
plt.ylabel("Height AGL (m)")
plt.savefig(savebin)
"in this case, this is the only operation engaged by the code."
return True
"this can solve to some bizzaro solutions, so we need to filter realistic values"
outH[(outH > limit) | (outH < 0)] = 0
outdH[(outdH > limit) | (outdH < -limit)] = 0
return (outH, times, outdH, first_guess_mean)