def time_win_basic(start,end,Tlisin,Datalisin,outposix=True,invert=False,
out_array=False , out_boolis = False , only_boolis = False):
"""
In Intern, we works in POSIX
only_boolis : To gain speed, no operation on Tlis & Datalisin is be done
None is outputed for Tlisout , Datalisout
Outputs :
If out_boolis == True:
Tlisout , Datalisout , boolis
If out_boolis == False:
Tlisout , Datalisout
"""
if isinstance(Tlisin[0],dt.datetime):
Tlis = conv.dt2posix(Tlisin)
else:
Tlis = Tlisin
if isinstance(start,dt.datetime):
start = conv.dt2posix(start)
if isinstance(end,dt.datetime):
end = conv.dt2posix(end)
if not isinstance(Tlis,np.ndarray) or not isinstance(Datalisin,np.ndarray):
Tlis = np.array(Tlis)
Datalis = np.array(Datalisin)
else:
Tlis = Tlis
Datalis = Datalisin
boolis = (start <= Tlis) * (Tlis <= end)
if invert:
boolis = np.logical_not(boolis)
if only_boolis:
Datalisout = None
Tlisout = None
else:
Datalisout = Datalis[boolis]
Tlisout = Tlis[boolis]
if not outposix:
Tlisout = conv.posix2dt(Tlisout)
if out_array:
Tlisout , Datalisout = np.array(Tlisout) , np.array(Datalisout)
if out_boolis:
out_tuple = (Tlisout , Datalisout , boolis)
else:
out_tuple = (Tlisout , Datalisout)
return out_tuple
def find_point(self,tin,tol=0.001,stop_when_found=True):
find = False
if type(tin) is dt.datetime:
tin = conv.dt2posix(tin)
tmin = self.pts[0].T
tmax = self.pts[-1].T
if not ( tmin <= tin <= tmax ):
print("WARN : find_point : t !€ [tmin , tmax]")
if stop_when_found:
for i,p in enumerate(self.pts):
if np.abs(p.T - tin) < tol:
find = True
break
if find:
return p,i
else:
return Point(),np.nan
else:
pts_stk = []
i_stk = []
for i,p in enumerate(self.pts):
if np.abs(p.T - tin) < tol:
pts_stk.append(p)
i_stk.append(i)
return pts_stk , i_stk
def from_uniq_point(self, Point, startdate, enddate, pas=1):
self.del_data()
if type(startdate) == dt.datetime:
startdate = conv.dt2posix(startdate)
if type(enddate) == dt.datetime:
enddate = conv.dt2posix(enddate)
N = int(np.round(enddate - startdate / pas))
#datelist = np.arange(startdate,enddate,pas)
Point.Tset(startdate)
for i in range(N):
Point.Tset(Point.T + pas)
self.add_point(copy.copy(Point))
self.i_nomi = pas
def Tset(self, T=0):
if T == 0:
T = dt.datetime.now()
if type(T) == dt.datetime:
self.Tdt = T
self.T = conv.dt2posix(T)
else:
self.T = float(T)
self.Tdt = conv.posix2dt(float(T))
def find_point(self, tin, tol=0.001, stop_when_found=True):
"""
Method to find a specific point according to its timestamp
Parameters
----------
tin : float or datetime
timestamp of the researched point.
tol : float, optional
tolerence of the research. The default is 0.001.
stop_when_found : bool, optional
Stop the research when a point is found. The default is True.
Returns
-------
Point Object
Point Found.
int or list of int
index of the point.
"""
find = False
if type(tin) is dt.datetime:
tin = conv.dt2posix(tin)
tmin = self.pts[0].T
tmax = self.pts[-1].T
if not (tmin <= tin <= tmax):
print("WARN : find_point : t !€ [tmin , tmax]")
if stop_when_found:
for i, p in enumerate(self.pts):
if np.abs(p.T - tin) < tol:
find = True
break
if find:
return p, i
else:
return Point(), np.nan
else:
pts_stk = []
i_stk = []
for i, p in enumerate(self.pts):
if np.abs(p.T - tin) < tol:
pts_stk.append(p)
i_stk.append(i)
return pts_stk, i_stk
def lagrange_interpolate(Tdata,Ydata,Titrp,n=10):
"""
Perform a temporal lagrangian interpolation
the X-component is a time
Parameters
----------
Tdata : iterable of datetime
X/T component of the known points.
Ydata : iterable of floats
Y component of the known points..
Titrp : iterable of datetime
Epochs of the wished points.
n : int, optional
degree of the polynom. Better if even. The default is 10.
Returns
-------
Yintrp : float array
output interpolated data.
Tips
----
Use conv.dt_range to generate the wished epochs range
"""
Tdata = np.array(Tdata)
Ydata = np.array(Ydata)
Titrp = np.array(Titrp)
nn = int(n/2)
Tdata_px = conv.dt2posix(np.array(Tdata))
Titrp_px = conv.dt2posix(np.array(Titrp))
tref = Tdata_px[0]
### we substract a ref time to avoid numerical instability
Tdata_px = Tdata_px - tref
Titrp_px = Titrp_px - tref
sur_val = (np.nan,np.nan)
sur_idx = (np.nan,np.nan)
### some checks
if np.any(np.diff(Tdata_px) == 0):
print("WARN: lagrange_interpolate: some Tdata are equals")
if np.any(np.diff(Ydata) == 0):
print("WARN: lagrange_interpolate: some Ydata are equals")
if np.any(Titrp_px < 0):
print("WARN: lagrange_interpolate: some wanted values are outside the data interval!!!!")
Yintrp = []
for tintrp in Titrp_px:
if ( sur_val[0] <= tintrp ) & ( tintrp <= sur_val[1] ):
### the Polynom is alread determined
pass
else:
sur_val , sur_idx = utils.find_surrounding(Tdata_px, tintrp)
if (sur_idx[0] - nn < 0): # manage side effect for first points
imin = 0
imax = n+1
elif (sur_idx[1] + nn > len(Ydata)): # manage side effect for last points
imin = len(Ydata) - n-1
imax = len(Ydata)
else: # regular case
### if (sur_idx[0] - nn >= 0) and (sur_idx[1] + nn >= len(Ydata)):
imin = sur_idx[0] - nn
imax = sur_idx[1] + nn
Tuse = Tdata_px[imin:imax]
Yuse = Ydata[imin:imax]
Poly = lagrange1(list(zip(Tuse,Yuse)))
#Poly = lagrange2(Tuse,Yuse)
yintrp = Poly(tintrp)
Yintrp.append(yintrp)
return np.array(Yintrp)