%
%     This file is part of the Code_Saturne Preprocessor, element of the
%     Code_Saturne CFD tool.
%
%     Copyright (C) 1998-2007 EDF S.A., France
%
%     contact: saturne-support@edf.fr
%
%     The Code_Saturne Preprocessor is free software; you can redistribute it
%     and/or modify it under the terms of the GNU General Public License
%     as published by the Free Software Foundation; either version 2 of
%     the License, or (at your option) any later version.
%
%     The Code_Saturne Preprocessor is distributed in the hope that it will be
%     useful, but WITHOUT ANY WARRANTY; without even the implied warranty
%     of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
%     GNU General Public License for more details.
%
%     You should have received a copy of the GNU General Public License
%     along with the Code_Saturne Preprocessor; if not, write to the
%     Free Software Foundation, Inc.,
%     51 Franklin St, Fifth Floor,
%     Boston, MA  02110-1301  USA
%


\section{Classes\label{cha:classe}}

La construction d'un logiciel, dans une conception structurée,
consiste à identifier les fonctions que le programme doit réaliser,
et à partitionner, de façon récursive, ces fonctions en sous-fonctions.
L'architecture logicielle est alors le reflet de la hiérarchie des fonctions.

Les fonctions sont fortement liées puisqu'elles partagent des données
et aucune méthode ne permet d'associer des fonctions à des données.
Une modification des données peut impliquer des modifications structurelles
importantes dans tout le programme.

L'approche objet consiste à regrouper les fonctions suivant les
données qu'elles utilisent ou modifient.
L'unité d'agrégation permettant de combiner les fonctions et les données
est la \classe.

Le \pcs est essentiellement un code de structure de données, par conséquent
bien adapté à une modélisation objet.
Elle manipule les concepts définis dans le chapitre précédent,
comme les \maillages, \entites, \champs, etc.,
qui trouvent une modélisation évidente en termes de \classes.

Ce chapitre répertorie les \classes pertinentes pour
appréhender le système \pcs et décrit les relations entre \classes
sous forme de diagrammes de \classes.

Le langage \uml (Unified Modeling Language) est utilisé pour décrire
les \classes et leurs relations.
Il permet de donner un contenu sémantique précis
aux notations graphiques utilisées sur les schémas.
Il n'est cependant pas nécessaire de connaître ce langage de modélisation
pour lire ce chapitre~: on pourra se contenter du texte qui
accompagne les schémas.


\subsection{Maillage\label{sec:classe.maillage}}


La classe \Maillage est une \classe principale~:
elle est la \classe de plus haut niveau manipulée par le \pcs.

\subsubsection{Relations de la classe \Maillage\label{sec:classe.relation.maillage}}

Un \maillage comporte au plus 3 \entites~:
\begin{liste}
\item \entsom~;
\item \entfac~;
\item \entcel.
\end{liste}

Si le \maillage est surfacique en connectivité nodale,
le \maillage pourra n'être défini qu'avec les 2 \entites~:
l'\entsom et l'\entfac.

Chacune de ces 3 \entites est généralisée par une classe \Entite.
La classe \Maillage sera alors une \compo d'au moins 2 classes
\Entite et d'au plus 3 classes \Entite.

La définition des \props du \maillage
en termes de \familles est facultative et transitoire~: les \props
sont généralement définies avec les \champprops.
La classe \Maillage peut donc ne pas contenir de \classe \Famille.

\begin{figfloat}
\begin{center}
\includegraphics*[width=2.921in]
  {\repgraphics/uml_relation_maillage.\extgraphics}
\captionfloat{Relations de la classe
  \label{fig:classe.relation.maillage}}
\end{center}
\end{figfloat}


\subsubsection{Attributs et méthodes de la classe \Maillage
\label{sec:classe.attribut.maillage}}

Le \pcs ne manipule que les \maillages 3D. Les \maillages 2D
sont transformés en 3D dès leur lecture.

L'outil de post-traitement \ensight impose
de donner les \connects des \eles par \typgeo~:
la \methode \fcla{trieTypeGéométrique()} réalise cette tâche.

La plupart des opérations sur un \maillage sont effectuées
dans la représentation en \connectdes du \maillage.
La transformation d'un \maillage de la \connectnod à la \connectdes
est réalisée par la \methode \fcla{creeConnectivitéDescendante()}.

Si plusieurs \maillages doivent être traités, ils doivent être concaténés
deux à deux (i.e. les entités du second sont ajoutées au premier,
ce qui implique un changement de numérotation, sans changer leurs
connectivités) et doivent pouvoir être ensuite recollés~:
les 2 \methodes respectives \fcla{concatène()} et 
\fcla{recolle()} implémentent ces opérations.

Plusieurs \methodes sont dédiées aux \familles~:
\begin{liste}
\item création des \familles à partir des \champatts~: \fcla{créeFamille()}~;
\item transformation des \familles en \champatts~: \fcla{créePropriétés()}
(et \fcla{détruitFamille()}).
\end{liste}

La dernière méthode (\fcla{extrait()}) concerne la visualisation
pour vérification de faces du maillage.

\begin{figfloat}
\begin{center}

\renewcommand{\arraystretch}{1.2}
\sffamily
\begin{tabular}{|l|}
\cline{1-1}
\multicolumn{1}{|c|}{{\large \Maillage}\rule[-3truemm]{0mm}{10truemm}}\\
\cline{1-1}
\small
$-$ \underline{dimension : Dimension}\rule[-4truemm]{0mm}{10truemm}\\
\cline{1-1}
\small
$+$ trieTypeGéométrique()\\
\small
$+$ creeConnectivitéDescendante()\\
\small
$+$ concatene(Maillage)\\
\small
$+$ recolle(TabEntier, TabReal)\\
\small
$+$ créeFamille()\\
\small
$+$ détruitFamille()\\
\small
$+$ créePropriétés()\\
\small
$+$ extrait(TabEntier, TabChaîne) : Maillage\rule[-4truemm]{0mm}{4truemm}\\
\cline{1-1}
\end{tabular}

\captionfloat{Description de la classe \Maillage
\label{fig:classe.attribut.maillage}}
\end{center}
\end{figfloat}


\subsection{EntitéMaillage\label{sec:classe.entite}}


\subsubsection{Généralisation des entités de maillage
\label{sec:classe.entite.generalisation}}

On généralise les 3 \entites par la \classe
\Entite.

\begin{figfloat}
\begin{center}
\includegraphics*[width=10cm]
  {\repgraphics/uml_classification_entite.\extgraphics}
\captionfloat{Généralisation des \entites
  \label{fig:classe.classification.entite}}
\end{center}
\end{figfloat}


\subsubsection{Relations de la classe \Entite\label{sec:classe.entite.relation}}


Les \entites sont liées entre elles par le type
de \connect qui sert à définir le \maillage~:
par exemple, en \connectnod, chaque \fac de l'\entfac est définie
par des \soms de l'\entsom. 

Une \entite regroupe en son sein un certain nombre de \champs~:
\begin{liste}
\item le \champpal~;
\item un nombre quelconque de \champauxs.
\end{liste}

\begin{figfloat}
\begin{center}
\includegraphics*[width=7cm]
  {\repgraphics/uml_relation_entite.\extgraphics}
\captionfloat{Relations de la classe \Entite
  \label{fig:classe.relation.entite}}
\end{center}
\end{figfloat}


\subsection{Famille\label{sec:classe.fam}}


Une \famille est une collection de \descrs, chacun d'entre eux
contenant une description de la \prop qui participe à la définition
de la \famille.

Un même \descr peut appartenir à plusieurs \familles~;
une \famille existe si elle a au moins un \descr.

Si les \familles existent, le \champfam contient pour chaque \elem
son numéro de \famille (il existe au plus un \champfam).\\
Les \familles sont donc ordonnées de façon à correspondre
aux numéros de \familles contenus dans le \champfam.

S'il existe une \famille, c'est qu'il existe au moins un \elem
qui porte le numéro de cette \famille.\\
Si le \champfam existe, c'est qu'il existe au moins une \famille.


\bigskip

\begin{figfloat}
\begin{center}
\includegraphics*[width=6cm]
  {\repgraphics/uml_relation_famille.\extgraphics}
\captionfloat{Relations de la classe \famille
  \label{fig:classe.relation.fam}}
\end{center}
\end{figfloat}


\subsection{Champ\label{sec:classe.champ}}


La \classe \Champ est une \classe centrale dans la modélisation du \pcs.
Elle regroupe les divers \champs participant à la définition du \maillage.

La figure~\ref{fig:classe.classification.champ} donne une classification
des \champs et mentionne les \attributs de la \classe \Champ.


\subsubsection{Classification des \champs\label{sec:classe.champ.classification}}

Un \champ peut être un \champpal ou un \champaux.

Le seul \champpal est le \champdef, qui contient la définition des
\elems en fonction d'\elems d'ordre inférieur~; il est aussi utilisé
pour donner le nombre d'\eles liés à une \entite~;

Un \champaux est toujours un \champatt.

Parmi les \champatts, on distingue~:
\begin{liste}
\item le \champfam, qui contient les numéros de \famille des \eles~;
\item les \champprops;
\item le \champfil, qui contient pour chaque \ele, la référence à un
      \ele père dans une transformation.
\end{liste}

Les \champprops sont au nombre de 2~: le \champcou et le \champgrp,
contenant pour chaque \ele, respectivement,
le numéro du \descr de la \couleur
et le numéro du \descr du \groupe.


\subsubsection{Attributs de la classe Champ\label{sec:classe.champ.attrib}}


Un \champ est identifié par un \fcla{nom}.
On lui attribue un \fcla{nombre d'éléments} et un \fcla{type}.

Les \champs se comportent différemment en cas de modification du \maillage.
Une modification du \maillage transforme un \elem \og père \fg avant modification
en un ou plusieurs \eles \og fils \fg.\\
L'\attribut \fcla{statut} contient le type de comportement~:
\begin{liste}
\item \fcla{statutIndéfini}~;
\item \fcla{statutReferenceÉlément}~: les valeurs du champ correspondent à
  des numéros d\eles (par exemple pour la description de la périodicité).
\item \fcla{statutHéritable}~: un \ele \og fils \fg aura la valeur du champ
  de l'\ele \og père \fg~;
\end{liste}


\subsubsection{Relations de la classe \Champ\label{sec:classe.champ.relation}}

Un \champ est composé de 2 tables, la \tablpos et la \tablval,
qui servent à stocker les valeurs du champ. A des fins d'économie
de mémoire, la \tablpos peut être définie par une \regl dans le cas d'un
\champ entier.

Pour faciliter l'utilisation des valeurs d'un \champ dans les algorithmes.
un \vect est une structure réimplémentant les \tablposval.
Un \vect est donc bien associé à un \champ, mais a une existence propre
(sa \classe n'est pas une composante de la \classe \Champ).

Les \champprops contiennent les numéros des \descrs,
chaque \descr contenant la description de la \prop (\couleur ou \groupe).
Un même \descr ne peut appartenir qu'à un \champprop (on ne mélange pas les
\couleurs et les \groupes dans un même champ)~;
un \champprop existe s'il a au moins un \descr.

De même, le \champfam contient les numéros des \familles,
chaque \famille étant une collection de \descrs.
Le \champfam existe s'il existe au moins une \famille~;
inversement, s'il existe au moins une \famille, le \champfam existe.

\newpage

\begin{figfloat}
\begin{center}
\includegraphics*[width=0.8\textwidth]
  {\repgraphics/uml_classification_champ.\extgraphics}
\captionfloat{Classification des \champs
  \label{fig:classe.classification.champ}}
\end{center}
\end{figfloat}

\newpage

\begin{figfloat}
\begin{center}
\includegraphics*[width=0.7\textwidth]
  {\repgraphics/uml_relation_champ.\extgraphics}
\captionfloat{Relations de la classe \Champ
  \label{fig:classe.relation.champ}}
\end{center}
\end{figfloat}


\subsection{Descripteur\label{sec:classe.descripteur}}


Un \descr décrit~:
\begin{liste}
\item soit une \prop \couleur, représentée par un \fcla{numéro}~;
\item soit une \prop \groupe, représentée par un \fcla{nom} de \groupe
et éventuellement un \fcla{numéro}.
\end{liste}


\begin{figfloat}
\begin{center}
\includegraphics*[width=0.55\textwidth]
  {\repgraphics/uml_classification_descripteur.\extgraphics}
\captionfloat{Classification des \descrs
  \label{fig:classe.classification.descripteur}}
\end{center}
\end{figfloat}


La \classe \Descripteur intervient pour décrire les \familles
et pour décrire les \champprops, comme on l'a vu précédemment.


\begin{figfloat}
\begin{center}
\includegraphics*[width=4.796in]
  {\repgraphics/uml_relation_descripteur.\extgraphics}
\captionfloat{Relations de la classe \Descripteur
  \label{fig:classe.relation.descripteur}}
\end{center}
\end{figfloat}


{\newpage}
%\passepage

