Support Board

  // Safety: clear the most recent bars of all subgraphs to prevent stale data.
  // Throttled to ~100ms and only runs on the last bar. Bars-to-clear is configurable.
static int LTF_DataConsistency(SCStudyInterfaceRef sc, const bool logging_enabled)
{
  // Only run data consistency checks on the most recent bar (last index)
  // This prevents unnecessary processing on historical bars during recalculation
  if (sc.Index != sc.ArraySize - 1)
    return -1;

  // Throttle execution to approximately 100ms intervals to prevent excessive clearing
  // Convert 100ms to days for SierraChart's date/time format (86400 seconds per day)
  const double now = sc.CurrentSystemDateTime.GetAsDouble();
  double& last_run_time = sc.GetPersistentDouble(1000);
  const double one_hundred_ms = 0.1 / 86400.0; // 100 ms in days

  if (last_run_time != 0.0 && (now - last_run_time) < one_hundred_ms)
    return -1;

  last_run_time = now;

  // Safety check: ensure we have valid array data
  if (sc.ArraySize == 0)
    return -1;

  // Get configurable number of recent bars to clear (prevents stale cross-chart data)
  const int bars_to_clear_setting = sc.Input[1].GetInt();
  const int bars_to_clear = (bars_to_clear_setting > 0) ? bars_to_clear_setting : 1;

  // Calculate the starting index for clearing (most recent N bars)
  const int current_index = sc.ArraySize - 1;
  const int target_start = current_index - (bars_to_clear - 1);
  int clear_start = (target_start >= 0) ? target_start : 0;
  if (clear_start < sc.DataStartIndex)
    clear_start = sc.DataStartIndex;
  if (clear_start >= sc.ArraySize)
    return -1;

  // Clear all 60 subgraphs from clear_start to end of array
  // This forces fresh recalculation of recent bars to ensure cross-chart data freshness
  const int total_subgraphs = 60;
  for (int sg = 0; sg < total_subgraphs; ++sg)
  {
    SCSubgraphRef subgraph = sc.Subgraph[sg];
    for (int idx = clear_start; idx < sc.ArraySize; ++idx)
    {
      subgraph[idx] = 0.0f;
    }
  }

  // Force SierraChart to recalculate from clear_start index onward
  // This ensures the cleared bars get recalculated with fresh data
  if (sc.EarliestUpdateSubgraphDataArrayIndex == -1 || clear_start < sc.EarliestUpdateSubgraphDataArrayIndex)
  {
    sc.EarliestUpdateSubgraphDataArrayIndex = clear_start;
  }

  // Optional debug logging when enabled
  if (logging_enabled)
  {
    SCString message;
    message.Format("LTF_DataConsistency fired: cleared bars %d-%d (ArraySize=%d).",
      clear_start, sc.ArraySize - 1, sc.ArraySize);
    sc.AddMessageToLog(message, 0);
  }

  return clear_start;
}

inline int ForceRecentBarsRecalculation(SCStudyInterfaceRef sc, int bars_to_recalc)
{
  if (sc.ArraySize == 0 || bars_to_recalc <= 0)
    return sc.DataStartIndex;

  int start = sc.ArraySize - bars_to_recalc;
  if (start < 0)
    start = 0;
  if (start < sc.DataStartIndex)
    start = sc.DataStartIndex;

  if (sc.EarliestUpdateSubgraphDataArrayIndex == -1
    || start < sc.EarliestUpdateSubgraphDataArrayIndex)
  {
    sc.EarliestUpdateSubgraphDataArrayIndex = start;
  }

  return start;
}