Début de la mise en place des RCUEs

app/pe/moys/pe_rcstag.py

@@ -144,14 +144,16 @@ class RCSemXTag(pe_tabletags.TableTag):
                 notes_cube,
                 coeffs_df,
                 coeffs_cube,
-            ) = self.compute_cubes(tag)
+                coeffs_rcues_df,
+                coeffs_rcues_cube,
+            ) = self.assemble_cubes(tag)
 
             # Calcule les moyennes, et synthétise les coeffs
             (
                 moys_competences,
                 matrice_coeffs_moy_gen,
             ) = self.compute_notes_et_coeffs_competences(
-                notes_cube, coeffs_cube, inscr_cube
+                notes_cube, coeffs_cube, coeffs_rcues_cube, inscr_cube
             )
 
             # Affichage des coeffs
@@ -182,13 +184,14 @@ class RCSemXTag(pe_tabletags.TableTag):
         else:
             return f"{self.__class__.__name__} {self.rcs_id}"
 
-    def compute_cubes(self, tag):
+    def assemble_cubes(self, tag):
-        """Pour un tag donné, construit les cubes de :
+        """Pour un tag donné, construit les cubes :
         * d'inscriptions aux compétences (etudid x competences x SxTag)
         * de notes (etudid x competences x SxTag)
-        * de coeffs (etudid x competences x SxTag)
+        * des coeffs pour le calcul des moyennes générales par UE (etudid x competences x SxTag)
+        * des coeffs pour le calcul des regroupements cohérents d'UE/compétences
 
-        nécessaire au calcul des moyennes, en :
+        nécessaires au calcul des moyennes, en :
 
         * transformant les données des UEs en données de compétences (changement de noms)
         * fusionnant les données d'un même semestre, lorsque plusieurs UEs traitent d'une même compétence (cas des RCSx = Sx)
@@ -203,7 +206,8 @@ class RCSemXTag(pe_tabletags.TableTag):
 
         inscriptions_dfs = {}
         notes_dfs = {}
-        coeffs_dfs = {}
+        coeffs_moy_gen_dfs = {}
+        coeffs_rcue_dfs = {}
 
         for sxtag_id, sxtag in self.sxstags_aggreges.items():
             # Partant de dataframes vierges
@@ -213,7 +217,10 @@ class RCSemXTag(pe_tabletags.TableTag):
             notes_df = pd.DataFrame(
                 np.nan, index=self.etudids_sorted, columns=self.competences_sorted
             )
-            coeffs_df = pd.DataFrame(
+            coeffs_moy_gen_df = pd.DataFrame(
+                np.nan, index=self.etudids_sorted, columns=self.competences_sorted
+            )
+            coeffs_rcue_df = pd.DataFrame(
                 np.nan, index=self.etudids_sorted, columns=self.competences_sorted
             )
 
@@ -224,7 +231,8 @@ class RCSemXTag(pe_tabletags.TableTag):
                 # Les inscr, les notes, les coeffs
                 acro_ues_inscr_parcours = sxtag.acro_ues_inscr_parcours
                 notes = moys_tag.matrice_notes_gen
-                coeffs = moys_tag.matrice_coeffs_moy_gen  # les coeffs
+                coeffs_moy_gen = moys_tag.matrice_coeffs_moy_gen  # les coeffs
+                coeffs_rcues = sxtag.coefs_rcue  # dictionnaire UE -> coeff
 
                 # Traduction des acronymes d'UE en compétences
                 # comp_to_ues = pe_comp.asso_comp_to_accronymes(self.acronymes_ues_to_competences)
@@ -253,14 +261,26 @@ class RCSemXTag(pe_tabletags.TableTag):
                         etudids_communs, acronyme
                     ]
 
-                    # Les coeffs
+                    # Les coeffs pour la moyenne générale
-                    etuds_avec_coeffs = coeffs[coeffs[acronyme].notnull()].index
+                    etuds_avec_coeffs = coeffs_moy_gen[
+                        coeffs_moy_gen[acronyme].notnull()
+                    ].index
                     etudids_communs = list(
-                        coeffs_df.index.intersection(etuds_avec_coeffs)
+                        coeffs_moy_gen_df.index.intersection(etuds_avec_coeffs)
                     )
-                    coeffs_df.loc[etudids_communs, competence] = coeffs.loc[
+                    coeffs_moy_gen_df.loc[
-                        etudids_communs, acronyme
+                        etudids_communs, competence
+                    ] = coeffs_moy_gen.loc[etudids_communs, acronyme]
+
+                    # Les coeffs des RCUE reportés là où les étudiants ont des notes
+                    etuds_avec_notes = notes[notes[acronyme].notnull()].index
+                    etudids_communs = list(
+                        notes_df.index.intersection(etuds_avec_notes)
+                    )
+                    coeffs_rcue_df.loc[etudids_communs, competence] = coeffs_rcues[
+                        acronyme
                     ]
+
             # Supprime tout ce qui n'est pas numérique
             # for col in notes_df.columns:
             #    notes_df[col] = pd.to_numeric(notes_df[col], errors="coerce")
@@ -268,9 +288,10 @@ class RCSemXTag(pe_tabletags.TableTag):
             # Stocke les dfs
             inscriptions_dfs[sxtag_id] = inscription_df
             notes_dfs[sxtag_id] = notes_df
-            coeffs_dfs[sxtag_id] = coeffs_df
+            coeffs_moy_gen_dfs[sxtag_id] = coeffs_moy_gen_df
+            coeffs_rcue_dfs[sxtag_id] = coeffs_rcue_df
 
-        """Réunit les inscriptions sous forme d'un cube etudids x competences x semestres"""
+        # Réunit les inscriptions sous forme d'un cube etudids x competences x semestres
         sxtag_x_etudids_x_comps = [
             inscriptions_dfs[sxtag_id] for sxtag_id in self.sxstags_aggreges
         ]
@@ -278,25 +299,37 @@ class RCSemXTag(pe_tabletags.TableTag):
             sxtag_x_etudids_x_comps, axis=-1
         )
 
-        """Réunit les notes sous forme d'un cube etudids x competences x semestres"""
+        # Réunit les notes sous forme d'un cube etudids x competences x semestres
         sxtag_x_etudids_x_comps = [
             notes_dfs[sxtag_id] for sxtag_id in self.sxstags_aggreges
         ]
         notes_etudids_x_comps_x_sxtag = np.stack(sxtag_x_etudids_x_comps, axis=-1)
 
-        """Réunit les coeffs sous forme d'un cube etudids x competences x semestres"""
+        # Réunit les coeffs sous forme d'un cube etudids x competences x semestres
         sxtag_x_etudids_x_comps = [
-            coeffs_dfs[sxtag_id] for sxtag_id in self.sxstags_aggreges
+            coeffs_moy_gen_dfs[sxtag_id] for sxtag_id in self.sxstags_aggreges
         ]
         coeffs_etudids_x_comps_x_sxtag = np.stack(sxtag_x_etudids_x_comps, axis=-1)
 
+        # Normalise les coeffs de rcue par année (pour que le poids des années soit le
+        # même)
+        # Réunit les coeffs sous forme d'un cube etudids x competences x semestres
+        sxtag_x_etudids_x_comps = [
+            coeffs_rcue_dfs[sxtag_id] for sxtag_id in self.sxstags_aggreges
+        ]
+        coeffs_rcues_etudids_x_comps_x_sxtag = np.stack(
+            sxtag_x_etudids_x_comps, axis=-1
+        )
+
         return (
             inscriptions_dfs,
             inscriptions_etudids_x_comps_x_sxtag,
             notes_dfs,
             notes_etudids_x_comps_x_sxtag,
-            coeffs_dfs,
+            coeffs_moy_gen_dfs,
             coeffs_etudids_x_comps_x_sxtag,
+            coeffs_rcue_dfs,
+            coeffs_rcues_etudids_x_comps_x_sxtag,
         )
 
     def _do_taglist(self) -> list[str]:
@@ -324,7 +357,11 @@ class RCSemXTag(pe_tabletags.TableTag):
         return dict_competences
 
     def compute_notes_et_coeffs_competences(
-        self, notes_cube: np.array, coeffs_cube: np.array, inscr_mask: np.array
+        self,
+        notes_cube: np.array,
+        coeffs_cube: np.array,
+        coeffs_rcue: np.array,
+        inscr_mask: np.array,
     ):
         """Calcule la moyenne par compétences (à un tag donné) sur plusieurs semestres (partant du set_cube).
 
@@ -337,8 +374,10 @@ class RCSemXTag(pe_tabletags.TableTag):
             notes_cube: notes moyennes aux compétences ndarray
                      (etuds x UEs|compétences x sxtags), des floats avec des NaN
             coeffs_cube: coeffs appliqués aux compétences
-            (etuds x UEs|compétences x sxtags), des floats avec des NaN
+            (etuds x UEs|compétences x sxtags) dans le calcul des moyennes générales,
-            inscr_mask: inscrptions aux compétences ndarray
+            des floats avec des NaN
+            coeffs_rcue_cube: coeffs des RCUE appliqués dans les moyennes de RCS
+            inscr_mask: inscriptions aux compétences ndarray
                      (etuds x UEs|compétences x sxtags), des 0 et des 1
         Returns:
             Un DataFrame avec pour columns les moyennes par tags,

app/pe/moys/pe_ressemtag.py

@@ -72,6 +72,12 @@ class ResSemBUTTag(ResultatsSemestreBUT, pe_tabletags.TableTag):
         # Le nom du res_semestre taggué
         self.nom = self.get_repr(verbose=True)
 
+        # Le rang du ResultatsSemestreBUT
+        self.semestre_id = self.formsemestre.semestre_id
+        """Rang du ResultatsSemestreBUT"""
+        self.annee_id = (self.semestre_id - 1) // 2 + 1
+        """Année du ResultatsSemestreBUT"""
+
         # Les étudiants (etuds, états civils & etudis) ajouté
         self.add_etuds(self.etuds)
         self.etudids_sorted = sorted(self.etudids)
@@ -87,7 +93,7 @@ class ResSemBUTTag(ResultatsSemestreBUT, pe_tabletags.TableTag):
         ]
         """Liste des UEs standards du ResultatsSemestreBUT"""
 
-        # Les parcours des étudiants à ce semestre
+        # Les parcours des étudiants à ce semestre (None si pas de parcours)
         self.parcours = []
         """Parcours auxquels sont inscrits les étudiants"""
         for etudid in self.etudids_sorted:
@@ -104,11 +110,11 @@ class ResSemBUTTag(ResultatsSemestreBUT, pe_tabletags.TableTag):
         # Les acronymes des UEs
         self.ues_to_acronymes = {ue.id: ue.acronyme for ue in self.ues_standards}
         self.acronymes_sorted = sorted(self.ues_to_acronymes.values())
-        """Les acronymes de UE triés par ordre alphabétique"""
+        """Liste des acronymes des UE triés par ordre alphabétique"""
 
         # Les compétences associées aux UEs (définies par les acronymes)
         self.acronymes_ues_to_competences = {}
-        """Association acronyme d'UEs -> compétence"""
+        """Association {acronyme d'UEs -> compétence}"""
         for ue in self.ues_standards:
             assert ue.niveau_competence, ScoValueError(
                 "Des UEs ne sont pas rattachées à des compétences"
@@ -118,7 +124,7 @@ class ResSemBUTTag(ResultatsSemestreBUT, pe_tabletags.TableTag):
         self.competences_sorted = sorted(
             list(set(self.acronymes_ues_to_competences.values()))
         )
-        """Compétences triées par nom"""
+        """Liste de compétences triées par nom"""
         aff = pe_affichage.repr_asso_ue_comp(self.acronymes_ues_to_competences)
         pe_affichage.pe_print(f"--> UEs/Compétences : {aff}")
 
@@ -156,6 +162,12 @@ class ResSemBUTTag(ResultatsSemestreBUT, pe_tabletags.TableTag):
         self.capitalisations = self._get_capitalisations(self.ues_standards)
         """DataFrame indiquant les UEs capitalisables d'un étudiant (etudids x )"""
 
+        # Les coeffs des RCUE
+        self.coefs_rcue = {}
+        """Coefs de RCUE par acronyme d'UEs"""
+        for ue in self.ues_standards:
+            self.coefs_rcue[ue.acronyme] = ue.coef_rcue
+
         # Calcul des moyennes & les classements de chaque étudiant à chaque tag
         self.moyennes_tags = {}
         """Moyennes  par tags (personnalisés ou 'but')"""

app/pe/moys/pe_sxtag.py

@@ -109,6 +109,10 @@ class SxTag(pe_tabletags.TableTag):
         self.fid_final = sxtag_id[1]
         self.ressembuttag_final = ressembuttags[self.fid_final]
         """Le ResSemBUTTag final"""
+        self.semestre_id = self.ressembuttag_final.semestre_id
+        """Rang du SxTag"""
+        self.annee_id = self.ressembuttag_final.annee_id
+        """Année du SxTag"""
 
         # Ajoute les etudids et les états civils
         self.etuds = self.ressembuttag_final.etuds
@@ -137,11 +141,14 @@ class SxTag(pe_tabletags.TableTag):
         """L'association acronyme d'UEs -> compétence"""
         self.competences_sorted = sorted(self.acronymes_ues_to_competences.values())
         """Les compétences triées par nom"""
-
         aff = pe_affichage.repr_asso_ue_comp(self.acronymes_ues_to_competences)
         pe_affichage.pe_print(f"--> UEs/Compétences : {aff}")
 
-        # Les inscriptions des étudiants aux UEs (donnée par leur acronyme)
+        # Les coefs de RCUE issus du dernier semestre
+        self.coefs_rcue = self.ressembuttag_final.coefs_rcue
+        """Coefs de RCUE par acronyme d'UEs"""
+
+        # Les inscriptions des étudiants aux UEs (données par leur acronyme)
         # par report de celle du ressemfinal
         self.acro_ues_inscr_parcours = self.ressembuttag_final.acro_ues_inscr_parcours