Buen día. Un gusto saludarte. He preparado para ti un caso integrado de “Dosificación de Mezclas de Ingeniería” que articula directamente el quehacer de la Ingeniería Civil (concreto) y la Ingeniería Agroindustrial (formulación de productos), pues ambas disciplinas resuelven el mismo problema matemático: combinar materiales en proporciones estrictas para alcanzar una propiedad objetivo, minimizando costos y validando restricciones. Es ideal para consolidar el concepto de función, paso de parámetros, retorno de múltiples valores y documentación (docstrings).

1. Planteamiento de la Situación y Marco Teórico

1.1 Contexto Ingeniería Civil

En el diseño de mezclas de concreto hidráulico, el ingeniero civil debe garantizar que un volumen específico de concreto cumpla con una resistencia a la compresión característica (\(f'c\)), un asentamiento (workability) y una relación agua/cemento (a/c) máxima por durabilidad. El método del volumen absoluto exige que la suma de los volúmenes individuales de los materiales (cemento, agua, agregados, aire) sea igual al volumen total de la mezcla.

1.2 Contexto Ingeniería Agroindustrial

En la formulación de alimentos balanceados o pre-mezclas de fertilizantes NPK, el ingeniero agroindustrial debe combinar materias primas (maíz, soya, salvado; o fuentes de N, P, K) para alcanzar un contenido objetivo de nutriente (por ejemplo, 18 % de Proteína Bruta — PB), respetando restricciones de inclusión máxima (por ejemplo, soya ≤ 30 % por factores antinutricionales) y minimizando el costo de la fórmula.

1.3 Ecuaciones Fundamentales

Concepto Ecuación Variables
Volumen absoluto (Civil) \(V_i = \dfrac{m_i}{SG_i \cdot \rho_w}\) \(m_i\): masa (kg), \(SG_i\): gravedad específica, \(\rho_w = 1000 \text{ kg/m}^3\)
Balance de volumen (Civil) \(\sum V_i + V_{aire} = V_{total}\) \(V_{aire}\): volumen de aire incluido (m³)
Relación a/c \(\dfrac{a}{c} = \dfrac{m_{agua}}{m_{cemento}}\) Debe ser ≤ 0.65 para ambientes moderados
Balance de nutriente (Agroindustrial) \(\sum (m_i \cdot N_i) = M_{total} \cdot N_{obj}\) \(N_i\): nutriente en ingrediente \(i\) (%), \(N_{obj}\): nutriente objetivo (%)
Costo total \(C_T = \sum (m_i \cdot c_i)\) \(c_i\): costo unitario ($/kg)
Costo unitario \(C_U = \dfrac{C_T}{M_{total}}\) Por kg de mezcla

2. Modelo de Solución: Arquitectura de Funciones

Se propone un sistema modular donde cada función tiene una responsabilidad única. Los estudiantes deben construirlas incrementalmente y luego integrarlas.

Función 1: volumen_absoluto(masas, gravedades_especificas, densidad_agua=1000)

  • Entrada: Lista de masas [kg], lista de SG [adimensional], densidad del agua.
  • Proceso: Aplica \(V_i = m_i / (SG_i \cdot \rho_w)\).
  • Salida: Lista de volúmenes [m³] y volumen total.

Función 2: dosificar_concreto(resistencia_fc, volumen_total, relacion_ac, materiales)

  • Entrada: \(f'c\) (MPa), \(V_{total}\) (m³), relación a/c, diccionario con masas de referencia de cemento, agua, arena, grava, % de aire.
  • Proceso: Escala proporcionalmente para el volumen solicitado y valida que \(\sum V_i + V_{aire} \approx V_{total}\).
  • Salida: Diccionario {"cemento_kg": x, "agua_kg": y, ...}.

Función 3: formular_por_nutriente(nutriente_objetivo, ingredientes, nutrientes_por_ingrediente, restricciones_max)

  • Entrada: Nutriente objetivo (%), lista de ingredientes, lista de nutrientes por ingrediente (%), lista de límites máximos de inclusión (%).
  • Proceso: Resuelve el sistema lineal por sustitución (método algebraico de mezclas) respetando restricciones.
  • Salida: Diccionario {"ingrediente": porcentaje, ...} y verificación del nutriente resultante.

Función 4: calcular_costo(cantidades, costos_unitarios)

  • Entrada: Diccionario de cantidades, diccionario de costos unitarios.
  • Salida: Tupla (costo_total, costo_por_kg).

Función 5: validar_y_reportar(dosificacion, criterios)

  • Entrada: Diccionario de resultados, diccionario de criterios (ej. {"relacion_ac_max": 0.65}).
  • Proceso: Compara resultados contra límites.
  • Salida: Tupla (es_valido: bool, mensajes: list).

3. Guía de Interacción con Kimi para Construir el Código

Instrucciones para tus estudiantes: “No copien código completo de internet. Usen a Kimi como tutor socrático. Copien y peguen estos prompts en una nueva conversación con Kimi y construyan su respuesta paso a paso.”

Paso Prompt sugerido para el estudiante Lo que debe lograr
A “En Python, escribe una función llamada volumen_absoluto que reciba una lista de masas en kg y una lista de gravedades específicas, y devuelva una lista de volúmenes en m³ usando la fórmula \(V = m / (SG \cdot 1000)\). Incluye un docstring y maneja el error si las listas tienen distinto tamaño.” Función base con validación de entrada.
B “Ahora necesito una función dosificar_concreto que reciba \(f'c\) en MPa, volumen total en m³, relación a/c, y un diccionario con las masas unitarias de cemento, agua, arena y grava para 1 m³. Debe escalar proporcionalmente al volumen pedido y retornar un diccionario con las masas finales. ¿Cómo hago para que la función llame a volumen_absoluto internamente?” Función intermedia que invoca a otra función.
C “Kimi, ayúdame a validar dentro de dosificar_concreto que la relación a/c calculada no supere 0.65. Si la supera, la función debe retornar un mensaje de advertencia junto con los resultados. ¿Debería usar una tupla como retorno (resultados, advertencia)?” Manejo de múltiples valores de retorno.
D “Necesito la función formular_por_nutriente para una mezcla de 3 ingredientes. El objetivo es 18 % de proteína. Los ingredientes son: Maíz 9 %, Soya 44 %, Salvado 12 %. La soya no puede pasar del 30 %. Explícame la lógica paso a paso y luego escribe la función que retorne los porcentajes de cada ingrediente.” Aplicación agroindustrial con restricciones.
E “Escribe una función calcular_costo que reciba dos diccionarios: cantidades y precios unitarios. Debe retornar el costo total y el costo por kilogramo. Luego, escribe una función generar_reporte que reciba todos los resultados anteriores e imprima un resumen formateado con f-strings.” Funciones de salida y presentación de resultados.
F “Tengo un error: cuando paso un diccionario a mi función, los valores llegan como strings en lugar de números. ¿Cómo hago para validar los tipos de datos al inicio de cada función y convertirlos si es necesario?” Depuración y robustez del código.

4. Valores de Entrada y Resultados Esperados (Validación)

Caso de Validación A: Ingeniería Civil (Concreto)

Datos de entrada: - \(f'c = 21 \text{ MPa}\) - \(V_{total} = 2.5 \text{ m}^3\) - Relación a/c = \(0.55\) - Materiales de referencia para 1 m³: Cemento = 350 kg, Agua = 192.5 kg, Arena = 700 kg, Grava = 1050 kg - Gravedades específicas: Cemento = 3.15, Agua = 1.0, Arena = 2.65, Grava = 2.70 - Aire incluido = 2 % del volumen total (\(0.02 \text{ m}^3\) por cada m³ de concreto)

Resultados que debe devolver el código: | Material | Masa para 2.5 m³ (kg) | Volumen absoluto (m³) | |———-|———————-|———————–| | Cemento | 875.0 | 0.2778 | | Agua | 481.25 | 0.4813 | | Arena | 1750.0 | 0.6604 | | Grava | 2625.0 | 0.9722 | | Aire | — | 0.0500 | | TOTAL | 5731.25 | ≈ 2.4417 (ajuste por aire: ≈ 2.50) |

  • Relación a/c verificada: \(481.25 / 875.0 = 0.55\) ✓
  • Costo unitario (ejemplo): si cemento = $800/kg, agua = $50/kg, arena = $120/kg, grava = $150/kg → Costo total = $1,375,312.5; Costo por m³ = $550,125

Caso de Validación B: Ingeniería Agroindustrial (Concentrado Animal)

Datos de entrada: - Nutriente objetivo (PB) = 18 % - Ingredientes y PB: Maíz = 9 %, Soya = 44 %, Salvado = 12 % - Restricción: Soya ≤ 30 %

Resultados que debe devolver el código: | Ingrediente | Porcentaje en fórmula (%) | PB aportada (%) | |————-|—————————|—————–| | Maíz | 64.8 | \(64.8 \times 0.09 = 5.83\) | | Soya | 30.0 | \(30.0 \times 0.44 = 13.20\) | | Salvado | 5.2 | \(5.2 \times 0.12 = 0.62\) | | TOTAL | 100.0 | ≈ 18.0 ✓ |

  • Costo unitario (ejemplo): Maíz = $2.0/kg, Soya = $4.5/kg, Salvado = $1.2/kg → Costo por kg de concentrado = $2.63

Nota para el estudiante: Si su código no devuelve exactamente estos valores numéricos (dentro de una tolerancia de ±0.1 %), debe revisar la aritmética de sus funciones.

5. Guía para el Desarrollo en Google Colab Notebook

Copia la siguiente estructura de celdas en un Nuevo Notebook de Google Colab (colab.research.google.com). El notebook debe ser entregado con el enlace de compartir en modo “Comentar” o “Leer”.

Celda 1: Portada (Markdown)

# 📐 Programación de Computadores con Python
## Módulo: Funciones y Modularidad
### Caso Integrado: Dosificación de Mezclas de Ingeniería
**Programas:** Ingeniería Civil & Agroindustrial  
**Docente:** [Tu nombre]  
**Estudiante:** [Nombre del estudiante]  
**Fecha:** [Fecha]

---
### Objetivo de aprendizaje
Construir un sistema de funciones en Python que resuelva problemas reales de dosificación en Ingeniería Civil (concreto) y Agroindustrial (formulación), aplicando conceptos de paso de parámetros, retorno de múltiples valores, validación de entrada y documentación de código.

Celda 2: Importaciones

# Solo librerías estándar. No instalar nada externo.
import math
from typing import Dict, List, Tuple, Union

Celda 3: Función Base — Volumen Absoluto

def volumen_absoluto(masas: List[float], 
                     gravedades_especificas: List[float], 
                     densidad_agua: float = 1000.0) -> Tuple[List[float], float]:
    """
    Calcula el volumen absoluto de cada material en una mezcla.
    
    Parámetros:
    -----------
    masas : list
        Lista de masas en kilogramos [kg].
    gravedades_especificas : list
        Lista de gravedades específicas [adimensional].
    densidad_agua : float, opcional
        Densidad del agua en kg/m³. Por defecto 1000.0.
    
    Retorna:
    --------
    tuple
        (lista_de_volumenes, volumen_total)
    """
    # TU CÓDIGO AQUÍ
    pass

Celda 4: Prueba Función 1

# Datos de validación Civil
masas_test = [350, 192.5, 700, 1050]  # cemento, agua, arena, grava
sg_test = [3.15, 1.0, 2.65, 2.70]

vols, total = volumen_absoluto(masas_test, sg_test)
print("Volúmenes individuales:", vols)
print("Volumen total:", total)
# Resultado esperado aproximado: [0.1111, 0.1925, 0.2642, 0.3889], total ≈ 0.9567 m³ para 1 m³ de material seco

Celda 5: Función — Dosificación de Concreto

def dosificar_concreto(resistencia_fc: float,
                       volumen_total: float,
                       relacion_ac: float,
                       materiales_referencia: Dict[str, float],
                       sg_materiales: Dict[str, float],
                       porcentaje_aire: float = 0.02) -> Tuple[Dict[str, float], str]:
    """
    Escala una dosificación de concreto a un volumen dado y valida restricciones.
    """
    # TU CÓDIGO AQUÍ
    pass

Celda 6: Prueba Función 2 (Caso Civil Completo)

# Usar los datos del Caso de Validación A (sección 4 de este documento)
# Imprimir el diccionario resultante y verificar que la relación a/c es 0.55

Celda 7: Función — Formulación Agroindustrial

def formular_por_nutriente(nutriente_objetivo: float,
                           ingredientes: List[str],
                           nutrientes_por_ingrediente: List[float],
                           restricciones_max: List[float]) -> Tuple[Dict[str, float], float]:
    """
    Calcula porcentajes de ingredientes para alcanzar un nutriente objetivo.
    """
    # TU CÓDIGO AQUÍ
    pass

Celda 8: Prueba Función 3 (Caso Agroindustrial Completo)

# Usar los datos del Caso de Validación B (sección 4 de este documento)
# Verificar que la proteína resultante sea ≈ 18 % y la soya ≤ 30 %

Celda 9: Función — Costos y Reporte

def calcular_costo(cantidades: Dict[str, float], 
                   costos_unitarios: Dict[str, float]) -> Tuple[float, float]:
    """Retorna (costo_total, costo_por_kg)."""
    pass

def generar_reporte(dosificacion: Dict, costos: Tuple[float, float], 
                    validacion: Tuple[bool, List[str]]) -> None:
    """Imprime un informe técnico formateado."""
    pass

Celda 10: Integración Final

# Ejecutar el caso Civil completo: calcular dosificación, costo y reporte
# Ejecutar el caso Agroindustrial completo: calcular formulación, costo y reporte

Celda 11: Reflexión Metacognitiva (Markdown obligatoria)

## 🧠 Reflexión final (responder en esta celda de texto)

1. ¿Qué ventaja tiene descomponer el problema en funciones individuales versus resolver todo en un solo bloque de código?
2. ¿Por qué es útil que una función retorne una tupla `(resultado, advertencia)` en lugar de solo el resultado?
3. Si el cliente (ingeniero civil) pide cambiar la relación a/c máxima de 0.65 a 0.60, ¿en qué parte del código haces el cambio y por qué no necesitas modificar todo el script?
4. ¿Qué dificultad tuviste al interactuar con Kimi y cómo la resolviste?

Recomendaciones de evaluación para el docente

  • Funcionalidad (40 %): Las funciones pasan los casos de validación A y B con tolerancia ±0.1 %.
  • Modularidad (20 %): Cada función tiene una única responsabilidad y usa docstrings.
  • Robustez (20 %): Validación de tipos de datos, manejo de divisiones por cero, verificación de que las listas/diccionarios tengan consistencia.
  • Interacción con Kimi (10 %): El estudiante adjunta capturas o transcripción de al menos 3 prompts usados y la respuesta de Kimi que aplicó.
  • Reflexión (10 %): Respuestas coherentes en la Celda 11.

Si deseas, puedo generar ahora el código de solución completo (para tu llave de respuestas) o una plantilla de Notebook .ipynb lista para subir a Colab. Solo indícame y lo preparo.