Update modules/studentact/current_situation_analysis.py

modules/studentact/current_situation_analysis.py

@@ -444,14 +444,19 @@ def get_dependency_depths(token, depth=0, analyzed_tokens=None):
     
     return current_result
 
-def normalize_score(value, optimal_value=1.0, range_factor=2.0, optimal_length=None, 
+###########################################################33
+def normalize_score(value, metric_type, 
+                   min_threshold=0.0, target_threshold=1.0, 
+                   range_factor=2.0, optimal_length=None, 
                    optimal_connections=None, optimal_depth=None):
     """
-    Normaliza un valor a una escala de 0-1 con manejo de casos extremos.
+    Normaliza un valor considerando umbrales específicos por tipo de métrica.
     
     Args:
         value: Valor a normalizar
-        optimal_value: Valor óptimo de referencia
+        metric_type: Tipo de métrica ('vocabulary', 'structure', 'cohesion', 'clarity')
+        min_threshold: Valor mínimo aceptable
+        target_threshold: Valor objetivo
         range_factor: Factor para ajustar el rango
         optimal_length: Longitud óptima (opcional)
         optimal_connections: Número óptimo de conexiones (opcional)
@@ -461,6 +466,30 @@ def normalize_score(value, optimal_value=1.0, range_factor=2.0, optimal_length=N
         float: Valor normalizado entre 0 y 1
     """
     try:
+        # Definir umbrales por tipo de métrica
+        METRIC_THRESHOLDS = {
+            'vocabulary': {
+                'min': 0.60,
+                'target': 0.75,
+                'range_factor': 1.5
+            },
+            'structure': {
+                'min': 0.65,
+                'target': 0.80,
+                'range_factor': 1.8
+            },
+            'cohesion': {
+                'min': 0.55,
+                'target': 0.70,
+                'range_factor': 1.6
+            },
+            'clarity': {
+                'min': 0.60,
+                'target': 0.75,
+                'range_factor': 1.7
+            }
+        }
+
         # Validar valores negativos o cero
         if value < 0:
             logger.warning(f"Valor negativo recibido: {value}")
@@ -471,6 +500,13 @@ def normalize_score(value, optimal_value=1.0, range_factor=2.0, optimal_length=N
             logger.warning("Valor cero recibido")
             return 0.0
 
+        # Obtener umbrales específicos para el tipo de métrica
+        thresholds = METRIC_THRESHOLDS.get(metric_type, {
+            'min': min_threshold,
+            'target': target_threshold,
+            'range_factor': range_factor
+        })
+        
         # Identificar el valor de referencia a usar
         if optimal_depth is not None:
             reference = optimal_depth
@@ -479,25 +515,31 @@ def normalize_score(value, optimal_value=1.0, range_factor=2.0, optimal_length=N
         elif optimal_length is not None:
             reference = optimal_length
         else:
-            reference = optimal_value
+            reference = thresholds['target']
 
         # Validar valor de referencia
         if reference <= 0:
             logger.warning(f"Valor de referencia inválido: {reference}")
             return 0.0
 
-        # Calcular diferencia y máxima diferencia permitida
-        diff = abs(value - reference)
-        max_diff = reference * range_factor
-
-        # Validar max_diff
-        if max_diff <= 0:
-            logger.warning(f"Máxima diferencia inválida: {max_diff}")
-            return 0.0
+        # Calcular score basado en umbrales
+        if value < thresholds['min']:
+            # Valor por debajo del mínimo
+            score = (value / thresholds['min']) * 0.5  # Máximo 0.5 para valores bajo el mínimo
+        elif value < thresholds['target']:
+            # Valor entre mínimo y objetivo
+            range_size = thresholds['target'] - thresholds['min']
+            progress = (value - thresholds['min']) / range_size
+            score = 0.5 + (progress * 0.5)  # Escala entre 0.5 y 1.0
+        else:
+            # Valor alcanza o supera el objetivo
+            score = 1.0
+            
+            # Penalizar valores muy por encima del objetivo
+            if value > (thresholds['target'] * thresholds['range_factor']):
+                excess = (value - thresholds['target']) / (thresholds['target'] * thresholds['range_factor'])
+                score = max(0.7, 1.0 - excess)  # No bajar de 0.7 para valores altos
 
-        # Calcular score normalizado
-        score = 1.0 - min(diff / max_diff, 1.0)
-        
         # Asegurar que el resultado esté entre 0 y 1
         return max(0.0, min(1.0, score))
 
@@ -505,6 +547,11 @@ def normalize_score(value, optimal_value=1.0, range_factor=2.0, optimal_length=N
         logger.error(f"Error en normalize_score: {str(e)}")
         return 0.0
 
+
+
+
+##############################################################
+
 # Funciones de generación de gráficos
 def generate_sentence_graphs(doc):
     """Genera visualizaciones de estructura de oraciones"""