# Path: pyDFTutils/math/peakdetect.py
# def peakdetect(y_axis, x_axis = None, lookahead = 300, delta=0):
#     """
#     Converted from/based on a MATLAB script at:
#     http://billauer.co.il/peakdet.html
# 
#     function for detecting local maximas and minmias in a signal.
#     Discovers peaks by searching for values which are surrounded by lower
#     or larger values for maximas and minimas respectively
# 
#     keyword arguments:
#     y_axis -- A list containg the signal over which to find peaks
#     x_axis -- (optional) A x-axis whose values correspond to the y_axis list
#         and is used in the return to specify the postion of the peaks. If
#         omitted an index of the y_axis is used. (default: None)
#     lookahead -- (optional) distance to look ahead from a peak candidate to
#         determine if it is the actual peak (default: 200)
#         '(sample / period) / f' where '4 >= f >= 1.25' might be a good value
#     delta -- (optional) this specifies a minimum difference between a peak and
#         the following points, before a peak may be considered a peak. Useful
#         to hinder the function from picking up false peaks towards to end of
#         the signal. To work well delta should be set to delta >= RMSnoise * 5.
#         (default: 0)
#             delta function causes a 20% decrease in speed, when omitted
#             Correctly used it can double the speed of the function
# 
#     return -- two lists [max_peaks, min_peaks] containing the positive and
#         negative peaks respectively. Each cell of the lists contains a tupple
#         of: (position, peak_value)
#         to get the average peak value do: np.mean(max_peaks, 0)[1] on the
#         results to unpack one of the lists into x, y coordinates do:
#         x, y = zip(*tab)
#     """
#     max_peaks = []
#     min_peaks = []
#     dump = []   #Used to pop the first hit which almost always is false
# 
#     # check input data
#     x_axis, y_axis = _datacheck_peakdetect(x_axis, y_axis)
#     # store data length for later use
#     length = len(y_axis)
# 
# 
#     #perform some checks
#     if lookahead < 1:
#         raise ValueError("Lookahead must be '1' or above in value")
#     if not (np.isscalar(delta) and delta >= 0):
#         raise ValueError("delta must be a positive number")
# 
#     #maxima and minima candidates are temporarily stored in
#     #mx and mn respectively
#     mn, mx = np.Inf, -np.Inf
# 
#     #Only detect peak if there is 'lookahead' amount of points after it
#     for index, (x, y) in enumerate(zip(x_axis[:-lookahead],
#                                         y_axis[:-lookahead])):
#         if y > mx:
#             mx = y
#             mxpos = x
#         if y < mn:
#             mn = y
#             mnpos = x
# 
#         ####look for max####
#         if y < mx-delta and mx != np.Inf:
#             #Maxima peak candidate found
#             #look ahead in signal to ensure that this is a peak and not jitter
#             if y_axis[index:index+lookahead].max() < mx:
#                 max_peaks.append([mxpos, mx])
#                 dump.append(True)
#                 #set algorithm to only find minima now
#                 mx = np.Inf
#                 mn = np.Inf
#                 if index+lookahead >= length:
#                     #end is within lookahead no more peaks can be found
#                     break
#                 continue
#             #else:  #slows shit down this does
#             #    mx = ahead
#             #    mxpos = x_axis[np.where(y_axis[index:index+lookahead]==mx)]
# 
#         ####look for min####
#         if y > mn+delta and mn != -np.Inf:
#             #Minima peak candidate found
#             #look ahead in signal to ensure that this is a peak and not jitter
#             if y_axis[index:index+lookahead].min() > mn:
#                 min_peaks.append([mnpos, mn])
#                 dump.append(False)
#                 #set algorithm to only find maxima now
#                 mn = -np.Inf
#                 mx = -np.Inf
#                 if index+lookahead >= length:
#                     #end is within lookahead no more peaks can be found
#                     break
#             #else:  #slows shit down this does
#             #    mn = ahead
#             #    mnpos = x_axis[np.where(y_axis[index:index+lookahead]==mn)]
# 
# 
#     #Remove the false hit on the first value of the y_axis
#     try:
#         if dump[0]:
#             max_peaks.pop(0)
#         else:
#             min_peaks.pop(0)
#         del dump
#     except IndexError:
#         #no peaks were found, should the function return empty lists?
#         pass
# 
#     return array([array(max_peaks),array( min_peaks)])


import os
import numpy as np
import sys
    import matplotlib.pyplot as plt
from numpy import maximum,minimum,NaN,Inf,arange,isscalar,array
from pyDFTutils.math.peakdetect import peakdetect
from numpy import *
from functools import reduce
    if delta <= 0:
        sys.exit('Input argument delta must be positive')
    mn, mx = Inf, -Inf
    mnpos, mxpos = NaN, NaN
    lookformax = True
    for i in arange(len(v)):
        this = v[i]
        if this > mx:
            mx = this
            mxpos = x[i]
        if this < mn:
            mn = this
            mnpos = x[i]
        if lookformax:
            if this < mxpos-delta:
                maxtab.append((mxpos, mx))
                mn = this
                mnpos = x[i]
                lookformax = False
        else:
            if this > mn+delta:
                mintab.append((mnpos, mn))
                mx = this
                mxpos = x[i]
                lookformax = True

    return array(maxtab), array(mintab)

def test(step=None, ):
    pos,pot=get_potential()

# Path: pyDFTutils/math/peakdetect.py
# def peakdetect(y_axis, x_axis = None, lookahead = 300, delta=0):
#     """
#     Converted from/based on a MATLAB script at:
#     http://billauer.co.il/peakdet.html
# 
#     function for detecting local maximas and minmias in a signal.
#     Discovers peaks by searching for values which are surrounded by lower
#     or larger values for maximas and minimas respectively
# 
#     keyword arguments:
#     y_axis -- A list containg the signal over which to find peaks
#     x_axis -- (optional) A x-axis whose values correspond to the y_axis list
#         and is used in the return to specify the postion of the peaks. If
#         omitted an index of the y_axis is used. (default: None)
#     lookahead -- (optional) distance to look ahead from a peak candidate to
#         determine if it is the actual peak (default: 200)
#         '(sample / period) / f' where '4 >= f >= 1.25' might be a good value
#     delta -- (optional) this specifies a minimum difference between a peak and
#         the following points, before a peak may be considered a peak. Useful
#         to hinder the function from picking up false peaks towards to end of
#         the signal. To work well delta should be set to delta >= RMSnoise * 5.
#         (default: 0)
#             delta function causes a 20% decrease in speed, when omitted
#             Correctly used it can double the speed of the function
# 
#     return -- two lists [max_peaks, min_peaks] containing the positive and
#         negative peaks respectively. Each cell of the lists contains a tupple
#         of: (position, peak_value)
#         to get the average peak value do: np.mean(max_peaks, 0)[1] on the
#         results to unpack one of the lists into x, y coordinates do:
#         x, y = zip(*tab)
#     """
#     max_peaks = []
#     min_peaks = []
#     dump = []   #Used to pop the first hit which almost always is false
# 
#     # check input data
#     x_axis, y_axis = _datacheck_peakdetect(x_axis, y_axis)
#     # store data length for later use
#     length = len(y_axis)
# 
# 
#     #perform some checks
#     if lookahead < 1:
#         raise ValueError("Lookahead must be '1' or above in value")
#     if not (np.isscalar(delta) and delta >= 0):
#         raise ValueError("delta must be a positive number")
# 
#     #maxima and minima candidates are temporarily stored in
#     #mx and mn respectively
#     mn, mx = np.Inf, -np.Inf
# 
#     #Only detect peak if there is 'lookahead' amount of points after it
#     for index, (x, y) in enumerate(zip(x_axis[:-lookahead],
#                                         y_axis[:-lookahead])):
#         if y > mx:
#             mx = y
#             mxpos = x
#         if y < mn:
#             mn = y
#             mnpos = x
# 
#         ####look for max####
#         if y < mx-delta and mx != np.Inf:
#             #Maxima peak candidate found
#             #look ahead in signal to ensure that this is a peak and not jitter
#             if y_axis[index:index+lookahead].max() < mx:
#                 max_peaks.append([mxpos, mx])
#                 dump.append(True)
#                 #set algorithm to only find minima now
#                 mx = np.Inf
#                 mn = np.Inf
#                 if index+lookahead >= length:
#                     #end is within lookahead no more peaks can be found
#                     break
#                 continue
#             #else:  #slows shit down this does
#             #    mx = ahead
#             #    mxpos = x_axis[np.where(y_axis[index:index+lookahead]==mx)]
# 
#         ####look for min####
#         if y > mn+delta and mn != -np.Inf:
#             #Minima peak candidate found
#             #look ahead in signal to ensure that this is a peak and not jitter
#             if y_axis[index:index+lookahead].min() > mn:
#                 min_peaks.append([mnpos, mn])
#                 dump.append(False)
#                 #set algorithm to only find maxima now
#                 mn = -np.Inf
#                 mx = -np.Inf
#                 if index+lookahead >= length:
#                     #end is within lookahead no more peaks can be found
#                     break
#             #else:  #slows shit down this does
#             #    mn = ahead
#             #    mnpos = x_axis[np.where(y_axis[index:index+lookahead]==mn)]
# 
# 
#     #Remove the false hit on the first value of the y_axis
#     try:
#         if dump[0]:
#             max_peaks.pop(0)
#         else:
#             min_peaks.pop(0)
#         del dump
#     except IndexError:
#         #no peaks were found, should the function return empty lists?
#         pass
# 
#     return array([array(max_peaks),array( min_peaks)])


# Path: pyDFTutils/vasp/plot_potential.py
import os
import numpy as np
import sys
    import matplotlib.pyplot as plt
from numpy import maximum,minimum,NaN,Inf,arange,isscalar,array
from pyDFTutils.math.peakdetect import peakdetect
from numpy import *
from functools import reduce

    if delta <= 0:
        sys.exit('Input argument delta must be positive')
    mn, mx = Inf, -Inf
    mnpos, mxpos = NaN, NaN
    lookformax = True
    for i in arange(len(v)):
        this = v[i]
        if this > mx:
            mx = this
            mxpos = x[i]
        if this < mn:
            mn = this
            mnpos = x[i]
        if lookformax:
            if this < mxpos-delta:
                maxtab.append((mxpos, mx))
                mn = this
                mnpos = x[i]
                lookformax = False
        else:
            if this > mn+delta:
                mintab.append((mnpos, mn))
                mx = this
                mxpos = x[i]
                lookformax = True

    return array(maxtab), array(mintab)

def test(step=None, ):
    pos,pot=get_potential()

    p=array(peakdetect(pot,lookahead=5,delta=0.01))