models/utils.py

"""
Model Utility Functions
"""

import torch
import torch.nn as nn


def interpolate_trajectory(t_eval, t_query, traj, dim_batch=1):
    """
    Interpolate trajectory (z or x) at t_query based on t_eval and traj.
    Args:
        t_eval: [T] time grid of ODE solution
        t_query: [B, L] query times for each batch
        traj: [T, B, D] trajectory (z or x)
        dim_batch: batch dimension (default 1)
    Returns:
        interp: [B, L, D]
    """
    B, L = t_query.shape
    T = t_eval.shape[0]
    indices_flat = torch.searchsorted(t_eval, t_query.flatten(), right=False)
    indices = torch.clamp(indices_flat, 0, T - 2).reshape(B, L)
    t_left = t_eval[indices]
    t_right = t_eval[indices + 1]
    batch_indices = torch.arange(B, device=t_eval.device).unsqueeze(1).expand(-1, L)
    traj_left = traj[indices, batch_indices, :]
    traj_right = traj[indices + 1, batch_indices, :]
    weight = ((t_query - t_left) / (t_right - t_left + 1e-8)).unsqueeze(-1)
    interp = traj_left + weight * (traj_right - traj_left)
    return interp


def interpolate_external_input(t_eval, t_batch, ut_batch, external_input_dim):
    """
    Interpolate external input at t_eval times using existing interpolate_trajectory function.
    
    Args:
        t_eval: [T] evaluation times
        t_batch: [B, L] relative time batches (not used, for API consistency)
        ut_batch: [B, L_u, U+1] external input batch with time as last dimension
        external_input_dim: dimension of external input
    
    Returns:
        u_interp: [T, B, U] interpolated external inputs
    """
    if ut_batch is None or external_input_dim == 0:
        return None
    
    u_batch = ut_batch[:, :, :external_input_dim]  # [B, L_u, U]
    t_u_batch = ut_batch[:, :, external_input_dim]  # [B, L_u]
    
    B, L_u, U = u_batch.shape
    T = len(t_eval)
    
    # 简单粗暴：用第一个batch的时间网格，假设所有batch时间一致
    t_u = t_u_batch[0, :] - t_batch[0]  # [L_u] 
    t_query = t_eval.unsqueeze(0).expand(B, -1)  # [B, T]
    traj = u_batch.permute(1, 0, 2)  # [L_u, B, U]
    
    # 直接调用 interpolate_trajectory
    result = interpolate_trajectory(t_u, t_query, traj)  # [B, T, U]
    
    # 转置成需要的格式 [T, B, U]
    return result.permute(1, 0, 2)


def create_vector_field_with_external_input(base_vector_field, u_interp, t_eval):
    """
    Universal wrapper to add external input to any vector field.
    
    Args:
        base_vector_field: Original vector field function
        u_interp: [T, B, U] interpolated external inputs (None if no external input)
        t_eval: [T] evaluation times
    
    Returns:
        Enhanced vector field function that includes external input
    """
    if u_interp is None:
        return base_vector_field
    
    def vector_field_with_input(t, state):
        t_idx = torch.searchsorted(t_eval, t, right=False)
        t_idx = torch.clamp(t_idx, 0, len(t_eval) - 1)
        u_t = u_interp[t_idx, :, :]  # [B, U]
        return base_vector_field(t, state, u_t)
    
    return vector_field_with_input

class VectorFieldWithInput(nn.Module):
    def __init__(self, base_vector_field: nn.Module, u_interp, t_eval):
        """
        base_vector_field: nn.Module, takes (t, state, u_t) and outputs dx/dt
        u_interp: [T, B, U] external inputs sampled on t_eval (None if no input)
        t_eval: [T] monotonically nondecreasing time grid corresponding to u_interp
        """
        super().__init__()
        self.base_vector_field = base_vector_field
        self.register_buffer("t_eval", t_eval)    # 注册成 buffer, 会跟随 device 移动
        if u_interp is not None:
            self.register_buffer("u_interp", u_interp)
        else:
            self.u_interp = None

    def forward(self, t, state):
        if self.u_interp is None:
            # 无外部输入，保持三输入形式
            return self.base_vector_field(t, state)

        T = self.t_eval.shape[0]
        t_scalar = torch.as_tensor(t, dtype=self.t_eval.dtype, device=self.t_eval.device)

        # Clamp to endpoints
        if t_scalar <= self.t_eval[0]:
            u_t = self.u_interp[0, :, :]  # [B, U]
        elif t_scalar >= self.t_eval[-1]:
            u_t = self.u_interp[-1, :, :]
        else:
            idx_right = torch.searchsorted(self.t_eval, t_scalar, right=False)
            idx_right = torch.clamp(idx_right, 1, T - 1)
            idx_left = idx_right - 1

            t_left = self.t_eval[idx_left]
            t_right = self.t_eval[idx_right]

            u_left = self.u_interp[idx_left, :, :]
            u_right = self.u_interp[idx_right, :, :]

            w = (t_scalar - t_left) / (t_right - t_left + 1e-8)
            u_t = u_left + w * (u_right - u_left)

        # 传给原始 vector field（恢复三参数形式，不再拼接）
        return self.base_vector_field(t, state, u_t)


def create_vector_field_with_external_input(base_vector_field, u_interp, t_eval):
    return VectorFieldWithInput(base_vector_field, u_interp, t_eval)

# def create_vector_field_with_external_input(base_vector_field, u_interp, t_eval):
#     """
#     Wrap a vector field to inject time-varying external input u(t) via linear interpolation.

#     Args:
#         base_vector_field: callable(t, state, u_t) -> dx/dt
#         u_interp: [T, B, U] external inputs sampled on t_eval (None if no input)
#         t_eval: [T] monotonically nondecreasing time grid corresponding to u_interp

#     Returns:
#         vector_field_with_input(t, state): calls base_vector_field with linearly
#         interpolated u(t) aligned to t_eval.
#     """
#     if u_interp is None:
#         return base_vector_field

#     T = t_eval.shape[0]

#     def vector_field_with_input(t, state):
#         # Ensure t is a tensor on the same device/dtype as t_eval
#         t_scalar = torch.as_tensor(t, dtype=t_eval.dtype, device=t_eval.device)

#         # Clamp to endpoints: constant extension outside [t_eval[0], t_eval[-1]]
#         if t_scalar <= t_eval[0]:
#             u_t = u_interp[0, :, :]  # [B, U]
#         elif t_scalar >= t_eval[-1]:
#             u_t = u_interp[-1, :, :]  # [B, U]
#         else:
#             # Find the right interval [t_left, t_right] with t_left <= t < t_right
#             idx_right = torch.searchsorted(t_eval, t_scalar, right=False)
#             # Guarantee we have both neighbors
#             idx_right = torch.clamp(idx_right, 1, T - 1)
#             idx_left = idx_right - 1

#             t_left = t_eval[idx_left]
#             t_right = t_eval[idx_right]

#             u_left = u_interp[idx_left, :, :]  # [B, U]
#             u_right = u_interp[idx_right, :, :]  # [B, U]

#             # Linear interpolation weight in [0,1]
#             w = (t_scalar - t_left) / (t_right - t_left + 1e-8)

#             # Linear interpolation of u(t)
#             u_t = u_left + w * (u_right - u_left)  # [B, U]

#         # Call the original vector field with interpolated control
#         return base_vector_field(t, state, u_t)

#     return vector_field_with_input