Discussion :

[Profix]

Bonjour à tous !

Je vous écrits aujourd'hui pour vous poser une question concernant la gestion de paramètres passés en arguments d'une sous-routine.

Mon programme se décompose en deux modules. Le premier module contient une sous-routine de lecture de fichier, hread(). Le second, faisant office de programme principal, récupère les données lues dans le fichier d'entrée via hread() pour les utiliser dans une sous-routine de calcul : volume(temp,VT,ratom2,VV,xxx,yyy,zzz,mxatms,cell,atomindex).

Ce sont les paramètres en rouge qui nous intéressent en l'occurrence. Il s'agit de tableaux, de tailles identiques, à une dimension : xxx(i), i = 1, N. Ce que j'aimerais faire, c'est remplacer ces trois tableaux par un seul, de la manière suivante :
xxx(i) = p(i,1) ; yyy(i) = p(i,2) et zzz(i) = p(i,3).

Après avoir effectué toutes les modifications nécessaires, j'ai pu constater que la lecture du fichier se faisait normalement et que le programme principal avait bien accès aux bonnes valeurs des tableaux aux bons indices. Le soucis se place au niveau de l'appel de la sous-routine volume() défini dans le module principal.

Mon premier essai ne prenait en compte que la première colonne du tableau, p(i,1) et affectait l'ensemble des valeurs des autres colonnes à 0 (impression réalisée au niveau de la sous-routine) : volume(temp,VT,ratom2,VV,p,mxatms,cell,atomindex).

Mon deuxième essai calcule bien des volumes (puisqu'il s'agit de l'objet de la sous-routine) mais d'une manière pseudo-aléatoire (on va dire ça comme ça^^) puisqu'à chaque fois que je lance le programme, les volumes calculés sont différents : volume(temp,VT,ratom2,VV,p(:,1),p(:,2),p(:,3),mxatms,cell,atomindex). Si le tableau p est rempli, il doit donc rester un problème d'initialisation quelque part.

J'en déduis qu'il est primordial de conserver les trois arguments et en arrive donc à ma question : comment passer en paramètres les trois colonnes de mon tableau en deux dimensions ?

[Sylvain Bergeron]

Pour qu'on puisse t'aider, tu dois nous fournir la déclaration de la routine, et nous dire si elle est externe, ou contenu dans un module.

[Profix]

Voici la déclaration de la routine volume() contenue effectivement dans un module. Le programme complet en comporte une dizaine mais seul un d'entre eux est appelé dans le module qui nous intéresse (celui contenant les déclarations des tableaux, des paramètres et la sous-routine de lecture hread()).

Code :

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

1
2
3
4
5
6
7
8
9
subroutine volume(DT,VT,ratom2,VV,RX,RY,RZ,mxatms,cell,atomindex)
               ! Declaration
		integer		:: mxatms
		integer, dimension(mxatms)	:: atomindex
		integer, dimension(4)		:: DT
	        real(kind=e)	:: VT, VV
		real(kind=e), dimension(mxatms)	:: RX, RY, RZ
		real(kind=e), dimension(9)	:: cell
		real(kind=e), dimension(4)	:: ratom2

Je fais appel à elle de la manière suivante pour le moment :

Code :

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

volume(temp,VT,ratom2,VV,xxx,yyy,zzz,mxatms,cell,atomindex)

En ayant procédé au préalable aux affectations suivantes :

Code :

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

xxx(i) = p(i,1) ; yyy(i) = p(i,2) ; zzz(i) = p(i,3)

mxatms est un paramètre défini dans un autre module et accessible à tous les modules du programme. Les valeurs des positions p(i,j) sont correctes à l'intérieur du module, mais pas dans la routine volume(), contenu pourtant au même endroit. Les tableaux p(i,j), tableaux dynamiques, sont également déclarés dans un autre module parent, le même où est défini le paramètre mxatms.

[genteur slayer]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
subroutine volume(DT,VT,ratom2,VV,R,mxatms,cell,atomindex)
use module,only : e
implicit none
! Declaration
integer, dimension(:),intent(in):: atomindex
integer, dimension(4),intent(in):: DT
real(kind=e),intent(out)        :: VT, VV
real(kind=e), dimension(:,3),intent(in) :: R
real(kind=e), dimension(9),intent(in):: cell
real(kind=e), dimension(4),intent(in):: ratom2
....
end subroutine volume

ça dois marcher ça... sinon c'est qu'il y a un autre pb.... mais chez moi j'ai toujours utiliser ce genre de chose...

ne pas oublier les use ... avant le implicit nonetu peux également utiliser le paramètre only:

Code :

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

use module,only :mxatms

par exemple

je recommande fortement le 'implicit none' pour developper et surtout debugger c'est bien plus simple... également, le compilo est plus à même de signaler des anomalies!!!

[Profix]

J'ai procédé aux modifications proposées sans succès. Du coup, j'ai écrit une routine plus simple, contenue dans le même module, pour procéder à des tests. La routine en question est censée afficher les valeurs contenues dans le tableau p.

La voici :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
	subroutine test(mxatms,testor)
		use mod_param,only : e
		use mod_parse,only : p
		implicit none
		integer		:: mxatms, j
		real(kind=e), dimension(mxatms,3), intent(in)	:: testor
 
		do j=1,mxatms
			write(*,*)'x=',testor(j,1)
			write(*,*)'y=',testor(j,2)
			write(*,*)'z=',testor(j,3)
		enddo
		return
	end subroutine test

mxatms est toujours un paramètre défini dans un module parent. Je ne pense pas que ce soit lui qui pose problème dans la mesure où la boucle s'effectue bien jusqu'à sa valeur.

Le résultat affiché sur la console est le suivant :

Code :

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

1
2
3
4
5
6
7
8
9
 x=  -3.06117122200000     
 y=   0.00000000000000     
 z=   0.00000000000000     
 x=  -13.7748294600000     
 y=   0.00000000000000     
 z=   0.00000000000000     
 x=   14.3233810000000     
 y=   0.00000000000000     
 z=   0.00000000000000

On constate qu'une fois encore, seules les valeurs contenues dans p(i,1) sont passées correctement dans la routine.

[Profix]

J'ai finalement trouvé d'où venait l'erreur... Et il s'agissait bien du mxatms ! Comme quoi, il vaut mieux éviter de vendre la peau de l'ours^^

Quoi qu'il en soit, après un petit rappel sur le fonctionnent de l'allocation de mémoire, la lumière s'est faite d'elle-même. Les tailles des tableaux ne correspondaient tout simplement pas entre les différents modules, d'où un décalage des valeurs dans l'appel de la sous-routine.

Je vous remercie d'avoir réfléchi avec moi sur ce problème qui n'était finalement pas bien méchant.

A bientôt !

[genteur slayer]

il faut également faire attention dans certain programme (ancien généralement) on mélange alègrement les tableau à une ou plusieur dimension... genre on déclare un tableau à 2 dim et on l'envoie dans une routine qui demande un tableau à 1dim... cela fonctionne, mais il faut faire attention à l'indiçage!!!