calculate_static_friction

Instructions

Determines whether an object will slip under applied force.

Args:
    normal_force: Normal force in Newtons
    coefficient_static_friction: Coefficient of static friction μ_s
    applied_force: Applied horizontal force in Newtons (optional)

Returns:
    Dict containing:
        - max_static_friction: Maximum static friction in Newtons
        - will_slip: Whether object will slip (if applied_force provided)
        - friction_force: Actual friction force (if applied_force provided)

Example - Box on floor:
    result = await calculate_static_friction(
        normal_force=100,
        coefficient_static_friction=0.5,
        applied_force=40
    )
    # will_slip = False (40N < 50N max)

Implementation Reference

• src/chuk_mcp_physics/statics.py:293-316 (handler)

  Core handler: computes f_s,max = μ_s × N, determines if object slips, returns actual friction force

  def calculate_static_friction(request: StaticFrictionRequest) -> StaticFrictionResponse:
      """Calculate maximum static friction force: f_s,max = μ_s × N.
  
      Args:
          request: Static friction request
  
      Returns:
          Maximum static friction and slip prediction
      """
      max_static_friction = request.coefficient_static_friction * request.normal_force
  
      will_slip = None
      friction_force = None
  
      if request.applied_force is not None:
          will_slip = request.applied_force > max_static_friction
          # Actual friction force equals applied force up to the maximum
          friction_force = min(request.applied_force, max_static_friction)
  
      return StaticFrictionResponse(
          max_static_friction=max_static_friction,
          will_slip=will_slip,
          friction_force=friction_force,
      )

• src/chuk_mcp_physics/tools/statics.py:124-162 (handler)

  MCP tool endpoint: async @tool-decorated function that wraps the core statics handler and exposes it via MCP protocol

  @tool  # type: ignore[arg-type]
  async def calculate_static_friction(
      normal_force: float,
      coefficient_static_friction: float,
      applied_force: float | None = None,
  ) -> dict:
      """Calculate maximum static friction force: f_s,max = μ_s × N.
  
      Determines whether an object will slip under applied force.
  
      Args:
          normal_force: Normal force in Newtons
          coefficient_static_friction: Coefficient of static friction μ_s
          applied_force: Applied horizontal force in Newtons (optional)
  
      Returns:
          Dict containing:
              - max_static_friction: Maximum static friction in Newtons
              - will_slip: Whether object will slip (if applied_force provided)
              - friction_force: Actual friction force (if applied_force provided)
  
      Example - Box on floor:
          result = await calculate_static_friction(
              normal_force=100,
              coefficient_static_friction=0.5,
              applied_force=40
          )
          # will_slip = False (40N < 50N max)
      """
      from ..statics import StaticFrictionRequest
      from ..statics import calculate_static_friction as calc_friction
  
      request = StaticFrictionRequest(
          normal_force=normal_force,
          coefficient_static_friction=coefficient_static_friction,
          applied_force=applied_force,
      )
      response = calc_friction(request)
      return response.model_dump()

• src/chuk_mcp_physics/statics.py:73-82 (schema)

  Pydantic request model: normal_force (gt=0), coefficient_static_friction (ge=0), applied_force (optional)

  class StaticFrictionRequest(BaseModel):
      """Request for static friction calculation."""
  
      normal_force: float = Field(..., description="Normal force in Newtons", gt=0.0)
      coefficient_static_friction: float = Field(
          ..., description="Coefficient of static friction μ_s", ge=0.0
      )
      applied_force: Optional[float] = Field(
          None, description="Applied horizontal force in Newtons (optional)"
      )

• src/chuk_mcp_physics/statics.py:85-94 (schema)

  Pydantic response model: max_static_friction, will_slip (optional), friction_force (optional)

  class StaticFrictionResponse(BaseModel):
      """Response for static friction calculation."""
  
      max_static_friction: float = Field(..., description="Maximum static friction force in Newtons")
      will_slip: Optional[bool] = Field(
          None, description="Whether object will slip (if applied_force provided)"
      )
      friction_force: Optional[float] = Field(
          None, description="Actual friction force in Newtons (if applied_force provided)"
      )

• src/chuk_mcp_physics/server.py:38-64 (registration)

  Registration: importing statics module triggers @tool decorator registration of calculate_static_friction

  # Import all tools modules to register their @tool decorated functions
  from .tools import (
      basic,
      rotational,
      oscillations,
      circular_motion,
      collisions,
      conservation,
      fluid as fluid_tools,
      kinematics_tools,
      statics,
      convert_units as unit_conversion_tools,
  )
  
  # Silence unused import warnings - these imports register @tool decorated functions
  _ = (
      basic,
      unit_conversion_tools,
      rotational,
      oscillations,
      circular_motion,
      collisions,
      conservation,
      fluid_tools,
      kinematics_tools,
      statics,
  )