ifort: utilisation de structures pour les indices de tableaux

Version imprimable

12/01/2018, 10h17
hilid

1 pièce(s) jointe(s)

ifort: utilisation de structures pour les indices de tableaux
Bonjour,

Je rencontre des difficultés pour écrire un code 3D de différences finies. Pour cela, j'utilise des structures qui représente des morceaux de mon domaine de calcul, celles-ci contiennent des entiers (type Dom):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 type :: Dom integer :: Xor, Yor, Zor, Xfin, Yfin, Zfin end type Dom type(dom) :: D D%Xor = 1 D%Xfin = Nbx D%Yor = 1 D%Yfin = Nby D%Zor = 1 D%Zfin = Nbz
Or quand je veux appeler ma subroutine de différence finies sur le domaine ciblé via:
Code:

1 2 3 4 CALL dfonc3dxd(rhoE_inter(D%Xor:D%Xfin,D%Yor:D%Yfin,D%Zor:D%Zfin),& rhoE(D%Xor:D%Xfin,D%Yor:D%Yfin,D%Zor:D%Zfin),& Nbx, Nby, Nbz, dx)
Ifort stop sans afficher de message d'erreur. Valgrind renseigne un segfault sur la ligne d'appelle de la subroutine. Avec Gfortran, il semble ne pas y avoir de soucis.

Ai-je mal compris le fonctionnement des structures?
Je joins un exemple de code complet et le Makefile associé.

Merci pour l'aide vous pourrez m'apporter

Version Ifort: ifort (IFORT) 15.0.1 20141023
version gfortran: ifort (IFORT) 15.0.1 20141023
Le tout sur une distribution linux CentOS à jour

PS: étant nouveau dans le domaine et n'aillant jamais suivis de cours de fortran, n'hésitez pas à signaler toute mauvaise pratique de programmation qui vous sauterais au yeux

Je ne crois pas que le problème vienne des types structures. J'ai plutôt l'impression qu'il y a ambiguïté entre ton appel à dfonc3dxd et sa définition.

À l'appel, tu passes des sections de tableau puisque tu indiques la plage d'indice à passer pour chaque dimension. Les sections correspondent au tableaux entiers, mais tu utilisent tout de même une syntaxe de section.

Dans la sub, tu utilises cependant une déclaration comme quoi tu t'attends à recevoir des tableaux entiers aux dimensions indiquées.

Je comprends que c'est de fait équivalent, mais peut-être que certains compilateurs ne sont pas d'accord !

Je modifierais donc comme suit :

Code:

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
 
! Possibilité #1
CALL dfonc3dxd(rhoE_inter(XXor:XXfin,YYor:YYfin,ZZor:ZZfin),&
           rhoE(XXor:XXfin,YYor:YYfin,ZZor:ZZfin),&
           Nbx, Nby, Nbz, dx) 
...
subroutine dfonc3dxd(fd,foncad,DimX, DimY,DimZ,da)
        implicit none
        integer, intent(in) :: DimX, DimY, DimZ
        real(real64), dimension(:,:,:),intent(inout) :: fd
        real(real64), dimension(:,:,:), intent(in) :: foncad
        real(real64), intent(in) :: da
 
! Possibilité #2
CALL dfonc3dxd(rhoE_inter, rhoE,Nbx, Nby, Nbz, dx) 
...
subroutine dfonc3dxd(fd,foncad,DimX, DimY,DimZ,da)
        implicit none
        integer, intent(in) :: DimX, DimY, DimZ
        real(real64), dimension(:,:,:),intent(inout) :: fd
        real(real64), dimension(:,:,:), intent(in) :: foncad
        real(real64), intent(in) :: da
 
! Possibilité #3
CALL dfonc3dxd(rhoE_inter, rhoE, dx) 
...
subroutine dfonc3dxd(fd,foncad,DimX, DimY,DimZ,da)
        implicit none
        real(real64), dimension(:,:,:),intent(inout) :: fd
        real(real64), dimension(:,:,:), intent(in) :: foncad
        real(real64), intent(in) :: d
        integer :: DimX, DimY, DimZ
 
        DimX = size(fd,1)
        DimY = size(fd,2)
        DimZ = size(fd,3)
 
! Possibilité #4
CALL dfonc3dxd(rhoE_inter(XXor:XXfin,YYor:YYfin,ZZor:ZZfin),&
           rhoE(XXor:XXfin,YYor:YYfin,ZZor:ZZfin), dx) 
...
subroutine dfonc3dxd(fd,foncad,da)
        implicit none
        real(real64), dimension(:,:,:),intent(inout) :: fd
        real(real64), dimension(:,:,:), intent(in) :: foncad
        real(real64), intent(in) :: da
        integer :: DimX, DimY, DimZ
 
        DimX = size(fd,1)
        DimY = size(fd,2)
        DimZ = size(fd,3)
 
! Autre combinaison ?

Bonjour,
Tout d'abord, merci de prendre le temps de m'aider. Effectivement, je ne pensais pas qu'une section de tableau et un tableau pourrait être traités différemment par le compilateur.

Le but de mettre en place quelque chose d'aussi lourd est de pouvoir appliquer mes différences finies seulement sur une partie du domaine et donc du tableau rhoE, mon exemple est ambigüe car j'ai appliqué mes différences finies sur tout le domaine...

La solution 4 me semble très intéressante, je vais commencer à creuser de ce côté là.

J'ai cependant une question:
Mes fonctions de différences finies seront ensuite ciblées par des pointeurs de procédure (afin de choisir quelle type de différences finies appliquer à chaque portion du domaine), le fait de ne pas connaitre la taille des vecteur en argument ne va t'il pas poser problème?
L'idée étant de faire quelque chose du type:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 abstract interface subroutine subdf( fd,foncad,da) implicit none real(real64), dimension(:,:,:),intent(inout) :: fd real(real64), dimension(:,:,:), intent(in) :: foncad real(real64), intent(in) :: da integer :: DimX, DimY, DimZ end subroutine end interface procedure(subdef), pointer :: pointer_diff => dfonc3dxd
Je ne pourrais faire mes tests que lundi.
Bon week end