Discussion :

[Emeric974]

Bonjour,
Je travaille sur une modélisation d’un transfert de thermique (rayonnement, conduction, convection,…) entre trois éléments principaux qui subdivisé en un nombre fini d’élément. Pour chaque sous-élément (non-déformable) je peux faire un bilan et mettre en équation les conditions au limites.

J’aimerais traiter ce problème en réalisant un programme orienté objet (Langage DELPHI). L’idée est d’une classe pour chaque élément principal. Ensuite souhaite faire hériter ces classes en sous-classe. Ces sous-classes correspondront à la description d’un sous-élément (subdivision d’un élément principale).
L’idée ensuite est de géréner une array d’instance de sous-classe (des objets pour chaque sous-élément). Ainsi l’array crée sera la présentation de la subdivision d’un élément principal. Quand je possèderais les trois array de sous-objet correspondant à mes trois éléments principaux, j’aurai les caractéristiques physiques de chacun des sous-éléments.
D’un autre côte, j’ai un système d’équation modélisant les transferts thermiques entre tous les sous-éléments. Ce système se met sous la forme d’un système linéaire matriciel. Chacun des coefficients de ce système fait intervenir les caractéristique physiques des chaque sous-élément (sous-objet). Je souhaite :
• remplir mon système à l’aide des caractéristiques physique définit dans mes sous-objets,
• résoudre le système par des méthodes classique (ici factorisation LU).
• A partir de solution de cette résolution, mettre à jour les caractéristiques des éléments, typiquement les températures de cœur et de surface, les flux surfacique, ect.
• Pour finir remonter aux éléments principaux en calculant ces mêmes grandeurs à partir des valeurs des sous-éléments. Par exemple le flux radiatif que la surface de mon élément principal sera la somme des flux quittant les surfaces de sous-élément correspondant.

Est-ce cela vous parez réaliste ? Est-ce que vous connaissez des études similaires dont je puisse m’inspirer ? Avez-vous des conseils ? *

Merci par avance.

[ShaiLeTroll]

Est-ce cela vous paraît réaliste ?

Oui, tout dépend de ta motivation et du temps que tu vas y consacrer

Est-ce que vous connaissez des études similaires dont je puisse m’inspirer ?

Non, c'est plus un problème métier et de modélisation dans un premier temps qu'une problématique DELPHI

Ne fait pas trop de classe, le but de la OO est de trouver les éléments similaires pour avoir un code réutilisable par plusieurs classes !
Pense que tu peux instancier plusieurs fois la même classe avec des valeurs différentes dans les attributs (property)

Commence avec un papier et un stylo pour te lancer dans de joli gribouilli, la notation MERISE ou UML est standardisé, tu peux t'en inspirer, tu as des outils gratuit pour faire cela en version informatisé (une fois la grouille terminée)

[Pascal Jankowski]

Ton applicatif doit avoir trois grands axes.

1) Une unité accueillant le modèle objet pour modéliser l’environnement « physique ».

2) Une unité spécifique pour gérer la représentation matricielle ainsi que les opérations élémentaires sur les matrices.

Il faut te poser la question de la dimension de l’espace vectoriel dans lequel tu travailles car il sera plus simple de fixer la dimension pour éviter de développer une unité pour gérer les matrices de dimension n.p (avec n et p quelconque).

Si tu es en dimension maximum 4, tu peux utiliser OpenGL (gérant le graphisme de ton pc) qui intègre déjà de nombreuses opérations sur les matrices et qui de plus délègue les opérations au GPU, sinon tu devras soit rechercher sur le net une unité toute faite pour gérer le calcul matriciel, soit la développer toi-même (à mon avis solution la plus intéressante).

3) Une unité spécifique qui utilise les deux unités précédentes et qui est chargée de tous les calculs spécifiques relatifs au transfert thermique.

Puis tu construis une unité « la façade », c’est-à-dire l’IHM de ton applicatif.

En ce qui concerne le point (1), tu définis une première classe C1 après « factorisation » des éléments en communs entre un élément principal et un sous-élément.

Tu crées ensuite une classe CE héritant de C1 qui représentera un sous-élément.
Quant à la classe CP (élément principal), elle doit dériver la classe TList (ou TStringList si tu désires nommer chaque sous-élément). CP doit disposer d’une propriété de type C1. Chaque item de la liste est en fait un « Sous-élément » (ie : Objects).

L’avantage de ce modèle est que tu gères une liste de « sous-éléments » ce qui est bien plus pratique qu’un tableau d’objets.

La réalisation d’un « itérateur » te permettra de ne développer que les méthodes ou traitements de chaque « sous-élément » ce qui simplifiera énormément ton travail (ie : tu feras l’économie de nombreuses boucles « For…do » …)

[Emeric974]

Merci pour ces réponses.

ShaiLeTroll : Mon but est de créer une classe enfant qui utilise les attributs de la classe parent et qui les divises par N (définit comme attribut de la classe enfant). Ensuite une liste d’objets issus de la classe enfants. Les attributs de ces objets qui auront les mêmes valeurs au départ, verront leur valeur modifié à la suite du calcul matriciel.
Pascal Jankowski : Est-ce que tu connais des tutos qui présentent la méthode que tu as exposé ?

[Pascal Jankowski]

Je ne connais pas de tuto sur ce sujet.

Rapidement développé un exemple de structure objet (très perfectible) qui permettrait de gérer ton modèle.

TKindSubElement : type qui pourra te permettre degérer qu’un seul type ou plusieurs types de sous-éléments dans la liste lors d’un traitement. En revanche Il faut que tu inventories tous ces types en amont.

Pour « l’itérateur » : la méthode Traitement1 est une des techniques qui peut être utilisée. De mon côté je préfère utiliser les Interfaces objet car on fait l’économie du test d’existence de l’instance Sender.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Var
  InterfaceValue: TypeInterface
……………..
 if Supports(Sender,TypeInterface,InterfaceValue) then begin
  InterfaceValue.{Métode ou propriété} := …..
end;

Etudie ce modèle, je pense qu’il devrait t’inspirer.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
interface
uses
  Classes, RTLConsts;
 
type
  TSubElement = class;
  TMainElement = class;
  TItemsEnumerator = class;
 
  TKindSubElement = (se_Piece1, se_Piece2,.......); {Ajouter tous les sorte d sous éléments}
 
  TComonParams = class(TObject)
  private
    FCoef: Double;
    function GetCoef: double;
    procedure SetCoef(const Value: double);
  public
    property Coef: double read GetCoef write SetCoef;
    {Definir toutes les propriétés communes à elt Principal et sous-élément}
  end;
 
  TSubElement = class(TObject)
  private
    FComonParams: TComonParams;
    FKind: TKindSubElement;
    function GetComonParams: TComonParams;
    procedure SetComonParams(const Value: TComonParams);
  public
    constructor Create;
    destructor Destroy; override;
    property ComonParams: TComonParams read GetComonParams write SetComonParams;
    property Kind: TKindSubElement read FKind write FKind;
    {Ajouter les propriétés spécifiques à un subElement...}
  end;
  {Se poser la question : Savoir si les "subElements"  }
  {Pour gérer la liste des subElements càd MainElemnt (élément principal)}
 
  TMainElement = class(TStringList)
  private
    FComonParams: TComonParams;
    function GetComonParams: TComonParams;
    procedure SetComonParams(const Value: TComonParams);
    function GetSubElement(Index: Integer): TSubElement;
  protected
  public
    destructor Destroy; override;
    property ComonParams: TComonParams read GetComonParams write SetComonParams;
    constructor Create;
    {Ajouter les propriétés spécifiques à un MainElement}
    procedure Clear; override;
    procedure Delete(Index: Integer); override;
    function Add(const ListLabel: string; const AObject: TObject):Integer; overload;
    {Pour l'itérateur}
    function GetItemsEnumerator: TItemsEnumerator;
    procedure ForEachSubElement(Method: TNotifyEvent);
    procedure Execute(Method: TNotifyEvent);
 
    {Décrire les méthodes qui seront utilisées par l'itérateur}
    procedure Traitement1(Sender: TObject);
 
    {Décrire les méthodes ...}
 
    {Une propriété tableau pour accéder à un subElement sans avoir besoin de le caster}
    property SubElement[Index: Integer]: TSubElement read GetSubElement;
  end;
 
  {Pour l'itérateur}
  TItemsEnumerator = class
  private
    FIndex: Integer;
    FStrings: TStrings;
  public
    constructor Create(AStrings: TStrings);
    function GetCurrent: TObject;
    function MoveNext: Boolean;
    property Current: TObject read GetCurrent;
  end;
 
implementation
 
{ TComonParams }
function TComonParams.GetCoef: double;
begin
  Result := FCoef;
end;
 
procedure TComonParams.SetCoef(const Value: double);
begin
  FCoef := Value;
end;
 
{ TSubElement }
function TSubElement.GetComonParams: TComonParams;
begin
  Result := FComonParams;
end;
 
procedure TSubElement.SetComonParams(const Value: TComonParams);
begin
  FComonParams := Value;
end;
 
constructor TSubElement.Create;
begin
  Inherited Create;
  FComonParams := TComonParams.Create;
end;
 
destructor TSubElement.Destroy;
begin
  FComonParams.Free;
  inherited;
end;
 
{ TMainElement }
function TMainElement.GetComonParams: TComonParams;
begin
  Result := FComonParams;
end;
 
procedure TMainElement.SetComonParams(const Value: TComonParams);
begin
  FComonParams := Value;
end;
 
constructor TMainElement.Create;
begin
  Inherited Create;
  FComonParams := TComonParams.Create;
end;
 
destructor TMainElement.Destroy;
begin
  Clear;
  inherited;
end;
 
procedure TMainElement.Delete(Index: Integer);
begin
  if (Index < 0) or (Index >= Count) then Error(@SListIndexError, Index);
  if Assigned(Objects[Index]) then Objects[Index].Free;
  inherited Delete(Index);
end;
 
procedure TMainElement.Clear;
var
  I: Integer;
begin
  for I := Pred(Count) downto 0 do
    Delete(I);
end;
 
function TMainElement.Add(const ListLabel: string; const AObject: TObject): Integer;
begin
  Result := AddObject(ListLabel,AObject);
end;
 
function TMainElement.GetSubElement(Index: Integer): TSubElement;
begin
  if (Index < 0) or (Index >= Count) then Error(@SListIndexError, Index);
  Result := TSubElement(Objects[Index]);
end;
 
function TMainElement.GetItemsEnumerator: TItemsEnumerator;
begin
  Result := TItemsEnumerator.Create(Self);
end;
 
procedure TMainElement.ForEachSubElement(Method: TNotifyEvent);
begin
  with GetItemsEnumerator do
    while MoveNext do Method(Current);
end;
 
procedure TMainElement.Traitement1(Sender: TObject);
begin
  if Assigned(Sender) and
     Sender.ClassType.InheritsFrom(TSubElement) then
    with TSubElement(Sender) do begin
      {décrire ici le traitement sur le sous-element}
    end;
end;
 
procedure TMainElement.Execute(Method: TNotifyEvent);
begin
  ForEachSubElement(Method);
end;
 
{ TItemsEnumerator }
constructor TItemsEnumerator.Create(AStrings: TStrings);
begin
  inherited Create;
  FIndex := -1;
  FStrings := AStrings;
end;
 
function TItemsEnumerator.MoveNext: Boolean;
begin
  Result := FIndex < FStrings.Count - 1;
  if Result then
    Inc(FIndex);
end;
 
function TItemsEnumerator.GetCurrent: TObject;
begin
  Result := FStrings.Objects[FIndex];
end;