Discussion :

[Jokin]

Bonjour,

Est-il possible de manipuler des sections d'un tableau "assumed size array"
dont la taille totale reste fixe mais dont les dimensions peuvent changer?
Quand j'essaie je tombe sur un erreur de compilation qui me dit "Number of section subscripts does not agree with the rank of the part name"

[Sylvain Bergeron]

Tu peux faire référence à une section d'un "assumed size array". Si tu appelle un sous-programme sans interface explicite, tu peux aussi avoir un "dummy argument" dont les dimensions ne sont pas les mêmes que dans le programme appelant.

Mais si je me fie sur le message d'erreur, c'est que tu essaye, dans le sous-programme, d'accéder à la variable en utilisant un nombre de dimension différent de la déclaration du "dummy argument".

Il faudrait que tu illustre ce que tu veux faire pour qu'on voit où est le problème.

[Jokin]

Je n'y connais pas grand chose mais il me semble bien que je suis en interface explicite, je modifie un programme que je n'ai pas fait moi même, donc je ne maitrise pas bien. Mon problème est une subroutine (ci dessous) au sein d'un module.
la subroutine a en argument d'entrée et de sortie le tableau b, mais celui ci change de dimension après qu'il soit transformé (fft) par la fonction DZFFT. En entrée il fait (0:n1-1,0:n2), en sortie (2,0:n1/2,0:n2). C'est pour ça que la dimenion reste libre (*) dans la declaration.
Je voudrais accéder a des sections de ce tableau, mais cela semble impossible. Par exemple la ligne write(*,*) b(1,:,: ) me renvoie une erreur.
Y a t'il un moyen d'accéder a des sections au tableau b sans le déclarer avec un nbre de dimensions fixe?

Merci de votre aide.

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
! *******************************************
    subroutine fwd_fft(b,work)
! *******************************************
    !****f* fft/fwd_fft
    !  NAME
    !    fwd_fft
    !
    !  DESCRIPTION
    !    Perform a forward FFT
    !
    !  INPUTS
    !    b: field whose forward FFT is wanted
    !
    !  OUTPUT
    !    b: forward FFT of the input field
    !
    !  REM
    !    The sign in the exponential term for the forward and backward FFT
    !    is the inverse than usual
    !***
 
        implicit none
 
        double precision, dimension(*), intent(inout) :: b
        double precision, dimension(*), intent(inout) :: work
 
write(*,*) b(1,:,:)
        if (n3 /= 1) then
            call DZFFT3D(-1,n1,n2,n3,scaling,b,d1,d2,b,d1/2,d2,work(lbnd1:ubnd1),work(lbnd3:ubnd3),0)
        else
            call DZFFT2D(-1,n1,n2,scaling,b,d1,b,d1/2,work(lbnd1:ubnd1),work(lbnd3:ubnd3),0)
        end if
 
    end subroutine

[Sylvain Bergeron]

C'est beaucoup plus clair maintenant.

C'est un grand classique de Fortran 66/77 (c'est beaucoup moins utilisé depuis F90 à cause des allocatables). Ton programme émule un tableau à plusieurs dimensions en utilisant un vecteur à une dimension. Par exemple, pour représenter un tableau de 3 x 2, il faut utiliser 6 éléments d'un vecteur; les 3 premiers étant les éléments (1,1), (2,1) et (3,1), les 3 derniers contenant (1,2), (2,2) et (3,2). Il est possible que dans la logique de ton programme, l'ordre des lignes et des colonnes soit inversé.

Pour imprimer b(1,:,: ), tu dois convertir ta requête en numéros d'élément en 1 dimension. Par exemple (c'est écrit sans réfléchir, juste pour que tu comprenne l'idée) :

Code :

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

1
2
 
write(*,*) (((b(i+j*2+k*2*n1/2),i=1,2),j=0,n1/2),k=0,n2)

[Jokin]

Ok c'est clair je crois, merci beaucoup.
Est-ce qu'en utilisant des allocatable (le programme est en F90) je pourrais faire la même chose sans passer par les numéros d'élements et en conservant néanmoins un tableau avec des dimensions variables entre entrée et sortie?

[Sylvain Bergeron]

Est-ce qu'en utilisant des allocatable (le programme est en F90) je pourrais faire la même chose sans passer par les numéros d'élements et en conservant néanmoins un tableau avec des dimensions variables entre entrée et sortie?

Les allocatables ne permettent pas d'avoir un nom symbolique (une variable) dont le nombre de dimension varie en cours d'exécution. Le nombre de dimension doit être défini à la compilation.

Pour convertir "b" en allocatable, il faudrait donc que tu aies b2 et b3 (et que tu modifies le programme en conséquence).