Xây Dựng Máy Tính ETG Thực Tế: Từ BAC đến Cửa Sổ Phát Hiện ETG

type Sex = "male" | "female";

interface Drink {
  /** Khối lượng tính bằng milliliters */
  ml: number;
  /** ABV dưới dạng phần trăm (ví dụ: 5 cho 5%) */
  abvPct: number;
}

interface EtgInput {
  weightKg: number;
  sex: Sex;
  /** Thời gian uống lần đầu tiên tính bằng ms kể từ epoch. Tùy chọn, dùng để đánh dấu thời gian */
  startedAtMs?: number;
  /** Thời gian uống tính bằng phút */
  durationMin: number;
  drinks: Drink[];
  /** Tỷ lệ loại bỏ tính bằng g/dL/giờ; mặc định là 0.015 */
  beta?: number;
}

interface EtgResult {
  totalGrams: number;
  standardDrinks: number;
  peakBac_gPerDl: number;
  timeToZeroHours: number;
  etgTailHours: number;
  /** Tổng số giờ từ ngụm cuối cùng cho đến khi ETG dự kiến không phát hiện được */
  expectedUndetectableHours: number;
  /** Từ khóa tuyệt đối nếu startedAtMs được cung cấp */
  expectedUndetectableAtMs?: number;
}

/** Chuyển đổi danh sách đồ uống sang grams ethanol nguyên chất */
export function gramsOfAlcohol(drinks: Drink[]): number {
  const ethanolDensity = 0.789; // g/mL
  return drinks.reduce((sum, d) => {
    const pureMl = d.ml * (d.abvPct / 100);
    return sum + pureMl * ethanolDensity;
  }, 0);
}

/** Tính ly rượu chuẩn (Mỹ) */
export function toStandardDrinks(grams: number): number {
  return grams / 14;
}

/** Widmark r theo giới tính (có thể ghi đè nếu cần) */
export function widmarkR(sex: Sex): number {
  return sex === "male" ? 0.68 : 0.55;
}

/**
 * Ước lượng BAC đỉnh điểm (g/dL) vào cuối khoảng thời gian uống.
 * Đơn giản hóa: tất cả lượng tiêu thụ được phân bổ đều trong khoảng thời gian, không có độ trễ hấp thụ.
 */
export function peakBac({
  totalGrams,
  weightKg,
  sex,
  durationMin,
  beta = 0.015,
}: {
  totalGrams: number;
  weightKg: number;
  sex: Sex;
  durationMin: number;
  beta?: number;
}): number {
  const r = widmarkR(sex);
  const K = 1.2; // tỷ lệ để ước lượng g/dL từ đầu vào theo hệ mét
  const tHours = Math.max(0, durationMin / 60);
  // BAC vào cuối khoảng thời gian uống
  const bac = Math.max(0, (totalGrams / (r * weightKg)) * K - beta * tHours);
  return bac;
}

/** Giờ để chuyển hóa xuống ~0 g/dL từ một BAC nhất định sử dụng loại bỏ beta */
export function hoursToZero(bac_gPerDl: number, beta = 0.015): number {
  return bac_gPerDl <= 0 ? 0 : bac_gPerDl / beta;
}

/**
 * Độ trễ ETG sau khi BAC ≈ 0.
 * Giới hạn giữa 24h và 80h, được điều chỉnh bởi tổng ly rượu chuẩn.
 */
export function etgTailHours(stdDrinks: number): number {
  const tail = 24 + 6 * stdDrinks;
  return Math.max(24, Math.min(80, tail));
}

/**
 * Ước lượng ETG: từ NGỤM CUỐI cùng đến thời gian dự kiến không phát hiện được.
 * Giả sử ngụm cuối cùng vào (startedAt + duration).
 */
export function estimateEtgWindow(input: EtgInput): EtgResult {
  const totalGrams = gramsOfAlcohol(input.drinks);
  const standardDrinks = toStandardDrinks(totalGrams);
  const peak = peakBac({
    totalGrams,
    weightKg: input.weightKg,
    sex: input.sex,
    durationMin: input.durationMin,
    beta: input.beta,
  });
  const timeZero = hoursToZero(peak, input.beta ?? 0.015);
  const tail = etgTailHours(standardDrinks);
  const expectedUndetectableHours = tail; // từ ngụm cuối cùng

  const res: EtgResult = {
    totalGrams,
    standardDrinks,
    peakBac_gPerDl: peak,
    timeToZeroHours: timeZero,
    etgTailHours: tail,
    expectedUndetectableHours,
  };

  if (input.startedAtMs !== undefined) {
    const lastSipMs = input.startedAtMs + input.durationMin * 60_000;
    res.expectedUndetectableAtMs = lastSipMs + expectedUndetectableHours * 3_600_000;
  }

  return res;
}

// ------------------- Ví dụ -------------------

if (typeof require !== "undefined" && require.main === module) {
  // Ví dụ: 3 chai bia 330 mL @ 5% trong 2 giờ, 75 kg nam
  const result = estimateEtgWindow({
    weightKg: 75,
    sex: "male",
    durationMin: 120,
    drinks: [
      { ml: 330, abvPct: 5 },
      { ml: 330, abvPct: 5 },
      { ml: 330, abvPct: 5 },
    ],
    startedAtMs: Date.now(),
  });

  console.log(result);
}

from dataclasses import dataclass
from typing import List, Optional

ETHANOL_DENSITY_G_PER_ML = 0.789  # g/mL

@dataclass
class Drink:
    ml: float       # khối lượng tính bằng mL
    abv_pct: float  # ABV tính bằng %

@dataclass
class EtgInput:
    weight_kg: float
    sex: str  # "male" hoặc "female"
    duration_min: float
    drinks: List[Drink]
    beta: float = 0.015  # g/dL mỗi giờ
    started_at_ms: Optional[int] = None

@dataclass
class EtgResult:
    total_grams: float
    standard_drinks: float
    peak_bac_g_per_dl: float
    time_to_zero_hours: float
    etg_tail_hours: float
    expected_undetectable_hours: float
    expected_undetectable_at_ms: Optional[int]

def widmark_r(sex: str) -> float:
    return 0.68 if sex.lower() == "male" else 0.55

def grams_of_alcohol(drinks: List[Drink]) -> float:
    grams = 0.0
    for d in drinks:
        grams += d.ml * (d.abv_pct / 100.0) * ETHANOL_DENSITY_G_PER_ML
    return grams

def to_standard_drinks(grams: float) -> float:
    return grams / 14.0

def etg_tail_hours(std_drinks: float) -> float:
    tail = 24 + 6 * std_drinks
    return max(24.0, min(80.0, tail))

def simulate_bac_peak(total_grams: float, weight_kg: float, sex: str, duration_min: float, beta: float = 0.015) -> float:
    """
    Mô phỏng thô: phân phối đều lượng tiêu thụ trong khoảng thời gian và áp dụng loại bỏ.
    Trả về ước lượng BAC đỉnh (g/dL).
    """
    r = widmark_r(sex)
    K = 1.2  # tỷ lệ để ước lượng từ hệ mét sang g/dL
    steps = max(1, int(duration_min))
    grams_per_min = total_grams / steps

    bac = 0.0
    peak = 0.0
    for minute in range(steps):
        bac += (grams_per_min / (r * weight_kg)) * K
        bac = max(0.0, bac - (beta / 60.0))
        peak = max(peak, bac)
    return peak

def estimate_etg_window(inp: EtgInput) -> EtgResult:
    total_grams = grams_of_alcohol(inp.drinks)
    std_drinks = to_standard_drinks(total_grams)
    peak = simulate_bac_peak(total_grams, inp.weight_kg, inp.sex, inp.duration_min, inp.beta)
    time_zero = peak / inp.beta if inp.beta > 0 else float('inf')
    tail = etg_tail_hours(std_drinks)
    expected_undetectable_hours = tail

    expected_at = None
    if inp.started_at_ms is not None:
        last_sip_ms = inp.started_at_ms + int(inp.duration_min * 60_000)
        expected_at = last_sip_ms + int(expected_undetectable_hours * 3_600_000)

    return EtgResult(
        total_grams=total_grams,
        standard_drinks=std_drinks,
        peak_bac_g_per_dl=peak,
        time_to_zero_hours=time_zero,
        etg_tail_hours=tail,
        expected_undetectable_hours=expected_undetectable_hours,
        expected_undetectable_at_ms=expected_at,
    )

if __name__ == "__main__":
    ex = EtgInput(
        weight_kg=75.0,
        sex="male",
        duration_min=120,
        drinks=[Drink(ml=330, abv_pct=5.0) for _ in range(3)]
    )
    print(estimate_etg_window(ex))

{
  "expectedUndetectableHours": { "low": 36, "high": 72 },
  "explanations": [
    "Thay đổi tỷ lệ loại bỏ β",
    "Làm tròn đến 6 giờ gần nhất để rõ ràng"
  ]
}