← К каталогу
Исходный код · ID 4844

Liquidity Sweep Map

indicator liquidity sweep map for tradingview.pine

Похожие материалы по тегам

#4 solid trend (white).mq5MQL5 / MetaTrader 5 · 1 общих теговindicator_rolling_candle_profile_with_buysell_signals_for_tradingview.pineTradingView · 1 общих теговrachmad imam tarecha.mq4MQL4 / MetaTrader 4 · 1 общих тегов2 to 1 strategy with signals.pineTradingView · 1 общих теговindicator_arrows.mq5MQL5 / MetaTrader 5 · 1 общих теговcci'hma minmax levels aa mtf sv+tt 1.mq5MQL5 / MetaTrader 5 · 1 общих тегов
Вы автор или правообладатель?

Сообщите нам, если считаете, что материал размещён без разрешения.

Краткий обзор

О программе

Индикатор «Liquidity Sweep Map» (LSM) — это инструмент Pine Script v6 для TradingView, который визуализирует пулы ликвидности на графике. Он отслеживает уровни, образованные свечными максимумами/минимумами, равными максимумами/минимумами, дневными и недельными экстремумами, сессионными максимумами/минимумами и диапазоном открытия.

Основная особенность — тепловая карта, показывающая относительную значимость каждой зоны ликвидности. Интенсивность тепла рассчитывается на основе типа пула, количества касаний и затухания во времени. Доступны несколько цветовых палитр и режимы масштабирования.

Индикатор отмечает события спрея (sweep), когда масть цены проходит через уровень, с возможностью подсветки последнего спрея, отображения призрачных линий взятых и пробитых уровней, а также лестницы глубины у правого края.

Встроена система цепочки подтверждения (спрей → обратный FVG → цель) и условные оповещения для reclaim-спрея, пробоя дневного/недельного уровня, подтверждения обратного FVG и достижения цели.

Настройки программы

НастройкаОписание
palette Цветовая палитра тепловой карты: Ember, Liquidation, Fire, Ice, Mono или Classic.
colHi Цвет для уровней максимумов в классической палитре.
colLo Цвет для уровней минимумов в классической палитре.
glowOn Включает или отключает свечение полос тепловой карты.
glowK Размер свечения вокруг полосы тепловой карты в долях ATR.
heatMode Режим масштабирования тепла: «Relative» — самая сильная видимая полоса всегда самая горячая; «Fixed» — цвет соответствует одному и тому же весу на всех графиках.
weightScale Значение веса, при котором полоса достигает полной интенсивности тепла в фиксированном режиме.
ladderOn Включает отображение лестницы глубины у правого края графика.
ladderLen Длина лестницы глубины в барах у правого края графика.
rightPad Зазор после последней свечи для отображения лестницы глубины.
labelsOn Включает или отключает отображение меток уровней.
priceOn Отображает цену уровня рядом с меткой.
labelPill Отображает метки уровней на цветных капсулах вместо цветного текста.
labelSizeIn Размер меток уровней на графике.
legendOn Включает отображение легенды тепловой карты.
legendPos Позиция легенды тепловой карты на графике.
bandsPerSide Максимальное количество отображаемых полос выше и ниже цены на графике.
renderRange Диапазон отображения полос тепловой карты от цены в долях ATR.
mergeTolK Допуск объединения близких уровней в долях ATR.
bandPadK Толщина полосы тепловой карты в долях ATR.
maxLookback Максимальное количество баров назад, от которых начинаются полосы тепловой карты.
showSweeps Отображает отметки спреев на графике.
showGhosts Отображает призрачные линии для взятых уровней ликвидности.
showBreaks Отображает призрачные линии для пробитых уровней ликвидности.
heroOn Подсвечивает последний спрей с помощью рамки на масти и именованного вызова.
sweepNames Отображает имя уровня на старых отметках спреев. Если отключено, имя всегда доступно во всплывающей подсказке.
keepSweeps Максимальное количество сохраняемых отметок спреев на графике.
useSW Включает отслеживание свечных максимумов/минимумов (необходимо для расчёта равных экстремумов).
useEQ Включает отслеживание равных максимумов/минимумов.
usePD Включает отслеживание дневных максимумов/минимумов.
usePW Включает отслеживание недельных максимумов/минимумов.
useAsia Включает отслеживание азиатских максимумов/минимумов.
useLondon Включает отслеживание лондонских максимумов/минимумов.
useNYs Включает отслеживание нью-йоркских максимумов/минимумов.
useOR Включает отслеживание максимумов/минимумов диапазона открытия.
pivL Количество баров слева для определения свечного максимума/минимума.
pivR Количество баров справа для определения свечного максимума/минимума.
kEq Допуск равенства экстремумов в долях ATR.
maxEqSpan Максимальный временной промежуток (в барах) для объединения равных экстремумов.
halfLife Период полураспада тепла (в барах) для свечных и равных экстремумов. Дневные, недельные и сессионные уровни сохраняют полное тепло до следующего периода.
minWeight Пороговое значение веса: пулы с весом ниже этого значения удаляются.
maxActive Максимальное количество отслеживаемых активных пулов ликвидности.
tzIn Часовой пояс для расчёта торговых дней, недель и сессий. Для криптовалют рекомендуется UTC.
rollH Час начала торгового дня для расчёта дневных уровней (CME фьючерсы — 18, FX — 17, крипто — 0).
sessAsia Временной диапазон азиатской торговой сессии.
sessLondon Временной диапазон лондонской торговой сессии.
sessNY Временной диапазон нью-йоркской торговой сессии.
orStartIn Время начала диапазона открытия в формате ЧЧММ.
orMinutes Длительность диапазона открытия в минутах.
bSW Весовой коэффициент для пула свечных максимумов/минимумов.
bEQ Весовой коэффициент для пула равных максимумов/минимумов.
bSS Весовой коэффициент для пула сессионных максимумов/минимумов.
bPD Весовой коэффициент для пула дневных максимумов/минимумов.
bPW Весовой коэффициент для пула недельных максимумов/минимумов.
bOR Весовой коэффициент для пула диапазона открытия.
touchStep Прирост множителя веса за каждое дополнительное касание уровня.
touchCap Максимальный множитель веса за дополнительные касания уровня.
atrLen Период расчёта ATR (средний истинный диапазон), используемый для масштабирования параметров.
minTicks Минимальное количество тиков проникновения для распознавания спрея.
kPen Минимальное проникновение для распознавания спрея в долях ATR.
useMaxPen Включает использование порога глубины проникновения для определения пробоя.
kMaxPen Порог глубины проникновения в ATR, при котором уровень считается пробитым.
delayedOn Разрешает отложенный реклайм в заданном количестве баров после спрея.
kReclaim Количество баров для разрешённого отложенного реклайма.
chainOn Включает отслеживание цепочки подтверждения (спрей → инвертированный FVG → цель) для оповещений.
chainDraw Включает отрисовку цепочки подтверждения на графике.
kLeg Количество баров до спрея, в течение которых должен образоваться FVG для подтверждения.
kIfvg Максимальное количество баров для инвертирования FVG после спрея.
kTarget Таймаут в барах для достижения целевого уровня в цепочке.
fvgMin Минимальный размер инвертированного FVG в долях ATR для подтверждения.
invBuf Буфер инвалидации в долях ATR для цепочки подтверждения.
alReclaim Включает оповещение при спрее и реклайме уровня ликвидности.
alBreakHT Включает оповещение при пробое дневного или недельного уровня ликвидности.
alIfvg Включает оповещение при подтверждении инвертированного FVG после спрея.
alTarget Включает оповещение при достижении целевого уровня в цепочке подтверждения.

Поиск по коду файла

indicator("Liquidity Sweep Map", shorttitle = "LSM", overlay = true, max_boxes_count = 500, max_lines_count = 500, max_labels_count = 500, max_bars_back = 5000)

SRC_SW = 1
SRC_EQ = 2
SRC_PD = 3
SRC_PW = 4
SRC_SS = 5
SRC_OR = 6
CLS_RECLAIM = 1
CLS_DELAYED = 2
CLS_BREAK = 3
ST_ACTIVE = 0
ST_SWEPT = 1
ST_BROKEN = 2
ST_EXPIRED = 3
ST_PENDING = 4
ST_ROLLED = 5
ST_DROPPED = 6
CH_SWEPT = 1
CH_TARGET = 2
CH_HIT = 10
CH_INVALID = 11
CH_TIMEOUT = 12
CH_NOFVG = 13
CH_NOCONF = 14

G_L = "Look"
palette     = input.string("Ember", "Heat palette", options = ["Ember", "Liquidation", "Fire", "Ice", "Mono", "Classic"], group = G_L, tooltip = "Ember: indigo → magenta → amber → white-hot (deepens to burnt orange on light charts). Liquidation: purple → teal → yellow. Fire: navy → orange → white. Ice: deep blue → cyan → white. Mono: follows your chart text colour. Classic: red above, teal below.")
colHi       = input.color(#F23645, "Classic: highs", inline = "cl", group = G_L)
colLo       = input.color(#089981, "lows", inline = "cl", group = G_L)
glowOn      = input.bool(true, "Glow", inline = "gl", group = G_L)
glowK       = input.float(0.5, "size (× ATR)", minval = 0.0, step = 0.05, inline = "gl", group = G_L)
heatMode    = input.string("Relative", "Heat scale", options = ["Relative", "Fixed"], group = G_L, tooltip = "Relative: the strongest visible band is always the hottest (like a liquidation heatmap). Fixed: a colour means the same weight on every chart.")
weightScale = input.float(4.0, "Fixed: full heat at weight", minval = 0.5, step = 0.5, group = G_L)
ladderOn    = input.bool(true, "Depth ladder at the right edge", group = G_L)
ladderLen   = input.int(20, "Ladder length (bars)", minval = 3, maxval = 100, group = G_L)
rightPad    = input.int(6, "Gap after last bar", minval = 1, maxval = 100, group = G_L)
labelsOn    = input.bool(true, "Level labels", inline = "lb", group = G_L)
priceOn     = input.bool(true, "with price", inline = "lb", group = G_L)
labelPill   = input.bool(true, "Filled pill labels", group = G_L, tooltip = "Labels sit on a pill in the band's heat colour. Off: coloured text only.")
labelSizeIn = input.string("Small", "Label size", options = ["Tiny", "Small", "Normal"], group = G_L)
legendOn    = input.bool(true, "Heat legend", inline = "lg", group = G_L)
legendPos   = input.string("Top right", "", options = ["Top right", "Bottom right", "Bottom left", "Top left"], inline = "lg", group = G_L)

G_D = "Declutter"
bandsPerSide = input.int(6, "Bands above and below price", minval = 1, maxval = 30, group = G_D)
renderRange  = input.float(6.0, "Only within (× ATR of price)", minval = 0.5, step = 0.5, group = G_D)
mergeTolK    = input.float(0.15, "Merge levels closer than (× ATR)", minval = 0.0, step = 0.01, group = G_D)
bandPadK     = input.float(0.08, "Band thickness (× ATR)", minval = 0.0, step = 0.01, group = G_D)
maxLookback  = input.int(300, "Start bands at most N bars back", minval = 10, maxval = 4999, group = G_D)

G_SW = "Sweeps"
showSweeps  = input.bool(true, "Mark sweeps", group = G_SW)
showGhosts  = input.bool(true, "Ghost lines for taken levels", group = G_SW)
showBreaks  = input.bool(false, "Ghost lines for broken levels", group = G_SW)
heroOn      = input.bool(true, "Spotlight the latest sweep", group = G_SW, tooltip = "The most recent sweep gets a box on the wick and a named callout. Older sweeps fade to a small ✕.")
sweepNames  = input.bool(false, "Name the level on older sweep marks", group = G_SW, tooltip = "Off keeps the chart clean; the name is always in the hover tooltip.")
keepSweeps  = input.int(12, "Keep last N sweeps", minval = 1, maxval = 150, group = G_SW)

G_P = "Pools"
useSW      = input.bool(true, "Swing highs/lows", group = G_P, tooltip = "Equal highs/lows are built from swings, so they need this on.")
useEQ      = input.bool(true, "Equal highs/lows", group = G_P)
usePD      = input.bool(true, "Previous day high/low", group = G_P)
usePW      = input.bool(true, "Previous week high/low", group = G_P)
useAsia    = input.bool(true, "Asia high/low", inline = "ss", group = G_P)
useLondon  = input.bool(true, "London", inline = "ss", group = G_P)
useNYs     = input.bool(false, "NY", inline = "ss", group = G_P)
useOR      = input.bool(false, "Opening range high/low", group = G_P)
pivL       = input.int(5, "Pivot left", minval = 1, inline = "piv", group = G_P)
pivR       = input.int(3, "right", minval = 1, inline = "piv", group = G_P)
kEq        = input.float(0.10, "Equal tolerance (× ATR)", minval = 0.0, step = 0.01, group = G_P)
maxEqSpan  = input.int(100, "Max equal-high span (bars)", minval = 1, group = G_P)
halfLife   = input.float(200.0, "Heat half-life (bars)", minval = 1.0, group = G_P, tooltip = "Applies to swing and equal highs/lows. Previous day/week and session levels keep full heat until the next period replaces them.")
minWeight  = input.float(0.15, "Remove below weight", minval = 0.0, step = 0.01, group = G_P)
maxActive  = input.int(150, "Max tracked pools", minval = 10, maxval = 400, group = G_P)

G_C = "Calendar"
tzIn       = input.string("America/New_York", "Timezone", group = G_C, tooltip = "Used for trading days, weeks and sessions. Crypto: UTC.")
rollH      = input.int(18, "Trading day starts at (hour)", minval = 0, maxval = 23, group = G_C, tooltip = "CME futures 18, FX 17, crypto 0.")
sessAsia   = input.session("2000-0000", "Asia", group = G_C)
sessLondon = input.session("0200-0500", "London", group = G_C)
sessNY     = input.session("0930-1600", "New York", group = G_C)
orStartIn  = input.string("0930", "Opening range start (HHMM)", inline = "or", group = G_C)
orMinutes  = input.int(30, "minutes", minval = 1, inline = "or", group = G_C)

G_W = "Heat weights"
bSW = input.float(1.0, "Swing", inline = "w1", group = G_W)
bEQ = input.float(1.6, "Equal", inline = "w1", group = G_W)
bSS = input.float(1.4, "Session", inline = "w1", group = G_W)
bPD = input.float(1.8, "Day", inline = "w2", group = G_W)
bPW = input.float(2.0, "Week", inline = "w2", group = G_W)
bOR = input.float(1.2, "OR", inline = "w2", group = G_W)
touchStep = input.float(0.25, "Per extra touch", inline = "w3", group = G_W)
touchCap  = input.float(2.0, "cap", inline = "w3", group = G_W)

G_S = "Sweep rules"
atrLen    = input.int(14, "ATR length", minval = 1, group = G_S)
minTicks  = input.int(2, "Min penetration (ticks)", minval = 0, group = G_S)
kPen      = input.float(0.02, "Min penetration (× ATR)", minval = 0.0, step = 0.01, group = G_S)
useMaxPen = input.bool(true, "Deeper than", inline = "mp", group = G_S)
kMaxPen   = input.float(1.5, "× ATR is a break", minval = 0.0, step = 0.1, inline = "mp", group = G_S)
delayedOn = input.bool(false, "Allow delayed reclaim within", inline = "dr", group = G_S)
kReclaim  = input.int(3, "bars", minval = 1, inline = "dr", group = G_S)

G_CH = "Confirmation chain (sweep → inverse FVG → target)"
chainOn   = input.bool(true, "Track (for alerts)", inline = "cd", group = G_CH)
chainDraw = input.bool(false, "draw on chart", inline = "cd", group = G_CH)
kLeg      = input.int(5, "FVG must form within (bars before sweep)", minval = 0, group = G_CH)
kIfvg     = input.int(10, "Inversion within (bars)", minval = 0, group = G_CH)
kTarget   = input.int(100, "Target timeout (bars)", minval = 1, group = G_CH)
fvgMin    = input.float(0.0, "FVG min size (× ATR)", minval = 0.0, step = 0.05, group = G_CH)
invBuf    = input.float(0.1, "Invalidation buffer (× ATR)", minval = 0.0, step = 0.05, group = G_CH)

G_A = "Alerts (bar close only)"
alReclaim = input.bool(true, "Sweep & reclaim", group = G_A)
alBreakHT = input.bool(true, "Break of previous day/week level", group = G_A)
alIfvg    = input.bool(true, "Inverse FVG confirmed", group = G_A)
alTarget  = input.bool(true, "Target reached", group = G_A)

type Pool
    int id
    float level
    int side
    int src
    int created
    int pivotBar
    int touches = 1
    int members = 1
    int state = 0
    int endBar = -1
    float expiryAge = 0.0
    int sess = -1

type Pending
    Pool pool
    int bar
    float maxpen
    float ext
    float penAtr

type Cand
    Pool pool
    int cls
    float penAtr
    float ext
    int orig

type Chain
    int eventId
    int side
    int sweepBar
    float extreme
    float buffer
    float invLevel
    int state = 1
    int confBar = -1
    float confClose = na
    float confAtr = na
    float target = na
    int endBar = -1
    line tline = na

type Tracker
    float hi = na
    float lo = na
    bool valid = false

type Ctr
    int pid = 0
    int eid = 0

type Band
    int side
    float top
    float bot
    float w
    int left
    float core
    float coreW
    string name
    string tip
    int n

bool isLight = color.r(chart.bg_color) + color.g(chart.bg_color) + color.b(chart.bg_color) > 382

f_g4(float x, color c0, color c1, color c2, color c3) =>
    x < 1.0 / 3 ? color.from_gradient(x, 0.0, 1.0 / 3, c0, c1) : x < 2.0 / 3 ? color.from_gradient(x, 1.0 / 3, 2.0 / 3, c1, c2) : color.from_gradient(x, 2.0 / 3, 1.0, c2, c3)
f_g5(float x, color c0, color c1, color c2, color c3, color c4) =>
    x < 0.25 ? color.from_gradient(x, 0.0, 0.25, c0, c1) : x < 0.5 ? color.from_gradient(x, 0.25, 0.5, c1, c2) : x < 0.75 ? color.from_gradient(x, 0.5, 0.75, c2, c3) : color.from_gradient(x, 0.75, 1.0, c3, c4)

f_heat(float xIn, int side) =>
    float x = math.max(0.0, math.min(1.0, xIn))
    switch palette
        "Ember"       => isLight ? f_g5(x, #9A8FE0, #A64CC4, #D63A66, #E2671B, #9A3A08) : f_g5(x, #3A2C8C, #8E3BC4, #E8457A, #FF8A3D, #FFE9B8)
        "Liquidation" => f_g5(x, #7A4FD0, #4A7FD8, #22B5A8, #74DC6A, #FDE725)
        "Fire"        => f_g4(x, #5B6FC8, #D04C82, #F5952F, #FFF1CC)
        "Ice"         => f_g4(x, #4069C0, #2BA2D6, #55DCE4, #E6FBFF)
        "Mono"        => color.from_gradient(x, 0.0, 1.0, color.new(chart.fg_color, 75), chart.fg_color)
        => color.from_gradient(x, 0.0, 1.0, color.new(side == 1 ? colHi : colLo, 60), side == 1 ? colHi : colLo)

f_text(float x, int side) => isLight or palette == "Mono" ? color.new(chart.fg_color, 5) : f_heat(math.max(x, 0.75), side)

f_ink(color c) => 0.299 * color.r(c) + 0.587 * color.g(c) + 0.114 * color.b(c) > 140 ? #17121F : #FFFFFF
f_accent(int side) => palette == "Ember" ? f_heat(1.0, side) : isLight ? (palette == "Classic" ? (side == 1 ? colHi : colLo) : f_heat(0.55, side)) : f_heat(1.0, side)
labelSize = labelSizeIn == "Tiny" ? size.tiny : labelSizeIn == "Normal" ? size.normal : size.small

f_hm(string s, int at) => int(str.tonumber(str.substring(s, at, at + 2))) * 60 + int(str.tonumber(str.substring(s, at + 2, at + 4)))
f_in(int m, int st, int en) => st < en ? (m >= st and m < en) : (m >= st or m < en)
f_base(int src) => src == SRC_SW ? bSW : src == SRC_EQ ? bEQ : src == SRC_PD ? bPD : src == SRC_PW ? bPW : src == SRC_SS ? bSS : bOR
f_name(int src, int side, int sess, int members) =>
    string hl = side == 1 ? "H" : "L"
    switch src
        SRC_PD => "PD" + hl
        SRC_PW => "PW" + hl
        SRC_EQ => "EQ" + hl + (members > 2 ? " ×" + str.tostring(members) : "")
        SRC_SS => (sess == 0 ? "Asia " : sess == 1 ? "London " : "NY ") + hl
        SRC_OR => "OR" + hl
        => "Swing " + hl

method tmult(Pool p) => math.min(1.0 + touchStep * (p.touches - 1), touchCap)

f_decays(int src) => src == SRC_SW or src == SRC_EQ
method weight(Pool p, int t) => f_base(p.src) * p.tmult() * (f_decays(p.src) ? math.pow(0.5, (t - p.created) / halfLife) : 1.0)
method refreshExpiry(Pool p) =>
    float b = f_base(p.src) * p.tmult()
    p.expiryAge := b <= minWeight ? 0.0 : not f_decays(p.src) ? 1e12 : halfLife * math.log(b / minWeight) / math.log(2.0)
    p

float atr = ta.atr(atrLen)

int shiftMs = rollH * 3600000 - (rollH >= 12 ? 86400000 : 0)
int tsh = time - shiftMs
int tday = math.floor(timestamp("UTC", year(tsh, tzIn), month(tsh, tzIn), dayofmonth(tsh, tzIn), 0, 0) / 86400000.0)
int week = math.floor((tday + 3) / 7.0)
int mins = hour(time, tzIn) * 60 + minute(time, tzIn)
int orSt = f_hm(orStartIn, 0)
bool inA = f_in(mins, f_hm(sessAsia, 0), f_hm(sessAsia, 5))
bool inL = f_in(mins, f_hm(sessLondon, 0), f_hm(sessLondon, 5))
bool inN = f_in(mins, f_hm(sessNY, 0), f_hm(sessNY, 5))
bool inO = mins >= orSt and mins < orSt + orMinutes

f_pivHi(int L, int R) =>
    bool ok = bar_index >= L + R
    if ok
        float hc = high[R]
        for j = 1 to L
            if not (hc > high[R + j])
                ok := false
                break
        if ok
            for j = 0 to R - 1
                if not (hc >= high[j])
                    ok := false
                    break
    ok
f_pivLo(int L, int R) =>
    bool ok = bar_index >= L + R
    if ok
        float lc = low[R]
        for j = 1 to L
            if not (lc < low[R + j])
                ok := false
                break
        if ok
            for j = 0 to R - 1
                if not (lc <= low[j])
                    ok := false
                    break
    ok
bool pivHi = f_pivHi(pivL, pivR)
bool pivLo = f_pivLo(pivL, pivR)

var array<Pool> pools = array.new<Pool>()
var array<Pending> pendings = array.new<Pending>()
var array<Chain> chains = array.new<Chain>()
var Ctr ctr = Ctr.new()
var Tracker trD = Tracker.new()
var Tracker trW = Tracker.new()
var Tracker trA = Tracker.new()
var Tracker trL = Tracker.new()
var Tracker trN = Tracker.new()
var Tracker trO = Tracker.new()

var array<line> ghostLines = array.new<line>()
var array<box> sweepBoxes = array.new<box>()
var array<label> sweepTags = array.new<label>()
var array<label> chainTags = array.new<label>()

var box heroBox = na
var label heroTag = na
var line heroGhost = na
var string heroName = ""

f_newPool(float lvl, int side, int src, int t, int pb, int sess) =>
    Pool p = Pool.new(ctr.pid, lvl, side, src, t, pb, 1, 1, ST_ACTIVE, -1, 0.0, sess)
    p.refreshExpiry()
    ctr.pid += 1
    pools.push(p)
    p

f_commit(Tracker tr, int src, int sess, int t) =>
    if tr.valid
        for p in pools
            if p.state == ST_ACTIVE and p.src == src and p.sess == sess
                p.state := ST_ROLLED
                p.endBar := t
        f_newPool(tr.hi, 1, src, t, t, sess)
        f_newPool(tr.lo, -1, src, t, t, sess)
    true

method trackSess(Tracker tr, bool f, bool fPrev, bool isFirst) =>
    if f
        if isFirst or not fPrev
            tr.hi := high
            tr.lo := low
            tr.valid := not isFirst
        else
            tr.hi := math.max(tr.hi, high)
            tr.lo := math.min(tr.lo, low)
    else
        tr.valid := false
    tr

method trackPeriod(Tracker tr, bool isNew, bool isFirst) =>
    if isFirst or isNew
        tr.hi := high
        tr.lo := low
        tr.valid := not isFirst
    else
        tr.hi := math.max(tr.hi, high)
        tr.lo := math.min(tr.lo, low)
    tr

f_target(int side, float c) =>
    float best = na
    for p in pools
        if p.state == ST_ACTIVE and p.side == -side
            if side == 1 and p.level < c and (na(best) or p.level > best)
                best := p.level
            else if side == -1 and p.level > c and (na(best) or p.level < best)
                best := p.level
    best

method step(Chain ch, int t, float a) =>
    bool confirmed = false
    if ch.state < 10
        bool beyond = ch.side == 1 ? high >= ch.extreme + ch.buffer : low <= ch.extreme - ch.buffer
        if ch.state == CH_SWEPT
            if na(ch.invLevel)
                ch.state := CH_NOFVG
                ch.endBar := t
            else if t > ch.sweepBar and beyond
                ch.state := CH_INVALID
                ch.endBar := t
            else if (ch.side == 1 ? close < ch.invLevel : close > ch.invLevel)
                ch.state := CH_TARGET
                ch.confBar := t
                ch.confClose := close
                ch.confAtr := a
                ch.target := f_target(ch.side, close)
                confirmed := true
            else if t - ch.sweepBar >= kIfvg
                ch.state := CH_NOCONF
                ch.endBar := t
        else if t > ch.confBar
            if beyond
                ch.state := CH_INVALID
                ch.endBar := t
            else if not na(ch.target) and (ch.side == 1 ? low <= ch.target : high >= ch.target)
                ch.state := CH_HIT
                ch.endBar := t
            else if t - ch.confBar >= kTarget
                ch.state := CH_TIMEOUT
                ch.endBar := t
    confirmed

f_legFvg(int side, float a) =>
    float lvl = na
    float minSize = fvgMin * a
    for j = 0 to kLeg
        if bar_index - j < 2
            break
        float gap = side == 1 ? low[j] - high[j + 2] : low[j + 2] - high[j]
        if gap > 0 and gap >= minSize
            lvl := side == 1 ? high[j + 2] : low[j + 2]
            break
    lvl

f_trimL(array<line> a, int n) =>
    while a.size() > n
        a.shift().delete()
    true
f_trimB(array<box> a, int n) =>
    while a.size() > n
        a.shift().delete()
    true
f_trimT(array<label> a, int n) =>
    while a.size() > n
        a.shift().delete()
    true

int evHiCls = 0
int evHiSrc = 0
float evHiLvl = na
int evLoCls = 0
int evLoSrc = 0
float evLoLvl = na
int chConfHi = 0
int chConfLo = 0
int nActive = na
bool aReclaim = false
bool aBreakHT = false
bool aIfvg = false
bool aTarget = false

if barstate.isconfirmed and not na(atr)
    int t = bar_index
    bool isFirst = na(atr[1])
    float a = atr
    float thr = math.max(minTicks * syminfo.mintick, kPen * a)
    float maxpen = kMaxPen * a
    float tol = kEq * a

    bool newDay = not isFirst and tday != tday[1]
    bool newWeek = not isFirst and week != week[1]
    if newDay and usePD
        f_commit(trD, SRC_PD, -1, t)
    if newWeek and usePW
        f_commit(trW, SRC_PW, -1, t)
    if not isFirst and inA[1] and not inA and useAsia
        f_commit(trA, SRC_SS, 0, t)
    if not isFirst and inL[1] and not inL and useLondon
        f_commit(trL, SRC_SS, 1, t)
    if not isFirst and inN[1] and no

Показано первые 50% кода (символов: 24963)