Comment utiliser les données du module Fortran 90

j'avais l'habitude de juste faire use modulename - puis, comme mon application a grandi, je l'ai trouvé de plus en plus difficile de trouver la source aux fonctions (sans se tourner vers grep) - certains de l'autre code flottant autour du bureau utilise toujours un un-sous-programme-par-dossier, qui a son propre ensemble de problèmes, mais il rend beaucoup plus facile d'utiliser un éditeur de texte pour se déplacer dans le code et trouver rapidement ce dont vous avez besoin.

après avoir expérimenté ceci, je suis devenu un converti en utilisant use ... only dans la mesure du possible. J'ai aussi commencé à prendre Python, et le voir de la même façon que from modulename import * . Il y a beaucoup de bonnes choses que les modules vous donnent, mais je préfère garder mon espace de nom global étroitement contrôlé.

pas exactement répondre à la question ici, juste jeter dans une autre solution que j'ai trouvé utile dans certaines circonstances, si pour une raison quelconque, vous ne voulez pas diviser votre module et commencer à obtenir des conflits namespace. Vous pouvez utiliser des types dérivés pour stocker plusieurs espaces de noms dans un même module.

S'il y a un groupement logique des variables, vous pouvez créer votre propre type dérivé pour chaque groupe, stocker une instance de ce type dans le module et puis vous pouvez importez juste le groupe dont vous avez besoin.

petit exemple: nous avons beaucoup de données dont certaines sont entrées par l'utilisateur et d'autres sont le résultat de diverses initialisations.

module basicdata
   implicit none
   ! First the data types...
   type input_data
      integer :: a, b
   end type input_data
   type init_data
      integer :: b, c
   end type init_data

   ! ... then declare the data
   type(input_data) :: input
   type(init_data) :: init
end module basicdata

maintenant si un sous-programme utilise seulement des données de init , vous importez juste cela:

subroutine doesstuff
   use basicdata, only : init
   ...
   q = init%b
end subroutine doesstuff

ce n'est certainement pas une solution universellement applicable, vous obtenez un peu de verbosité supplémentaire de la syntaxe de type dérivé et puis il sera de cours à peine aider si votre module n'est pas le basicdata trier ci-dessus, mais plutôt d'une variété allthestuffivebeenmeaningtosortout . De toute façon, j'ai eu un peu de chance en obtenant un code qui s'intègre plus facilement dans le cerveau de cette façon.

le principal avantage de L'utilisation, seulement pour moi est qu'il évite de polluer mon espace de nom mondial avec des choses dont je n'ai pas besoin.

est D'accord avec la plupart des réponses données précédemment, use ..., only: ... est la façon d'aller, utiliser des types quand il a du sens, appliquer Python penser autant que possible. Une autre suggestion est d'utiliser les conventions de nommage appropriées dans votre module importé, ainsi que les énoncés private / public .

par exemple, la netcdf bibliothèque utilise nf90_<some name> , qui limite la pollution de l'espace de nom du côté de l'importateur.

use netcdf  ! imported names are prefixed with "nf90_"

nf90_open(...)
nf90_create(...)
nf90_get_var(...)
nf90_close(...)

de même ,le ncio wrapper à cette bibliothèque utilise nc_<some name> ( nc_read , nc_write ...).

fait important, avec de telles conceptions où use: ..., only: ... est rendu moins pertinent, vous feriez mieux de contrôler l'espace de nom du module importé en mettant approprié private / public attributs dans l'en-tête, de sorte qu'un coup d'oeil rapide à elle sera suffisante pour les lecteurs d'évaluer le niveau de "pollution" ils sont face. C'est fondamentalement le même que use ..., only: ... , mais sur le côté du module importé - donc à écrire seulement une fois, pas à chaque importation).

encore une chose: en ce qui concerne l'orientation objet et python, une différence à mon avis est que fortran n'encourage pas vraiment les procédures liées au type, en partie parce qu'il s'agit d'une norme relativement nouvelle (par exemple, non compatible avec un certain nombre d'outils, et moins rationnellement, c'est tout simplement inhabituel) et parce qu'il casse les comportements pratiques par exemple, copie de type dérivée sans procédure ( type(mytype) :: t1, t2 et t2 = t1 ). Cela signifie que vous devez souvent importer le type et toutes les procédures liées au type, au lieu de simplement la classe. Cela seul rend le code fortran plus verbeux par rapport à python, et des solutions pratiques comme une convention de nommage des préfixes peuvent s'avérer utiles.

IMO, la ligne de fond est: choisissez votre style de codage pour les gens qui liront (ce qui inclut votre auto plus tard), comme enseigné par python. Best est le plus verbeux use ..., only: ... à chaque importation, mais dans certains cas une simple convention d'appellation le fera (si vous êtes assez discipliné...).

oui, veuillez utiliser use module, only: ... . Pour de grandes bases de code avec plusieurs programmeurs, il rend le code plus facile à suivre par tout le monde (ou utilisez simplement grep ).

N'utilisez pas include, utilisez plutôt un module plus petit. Include est un insert de texte du code source qui n'est pas vérifié par le compilateur au même niveau que le module d'utilisation, voir: FORTRAN: différence entre INCLUDE et les modules . Include rend généralement plus difficile pour les humains et l'ordinateur d'utiliser le code, ce qui signifie qu'il ne doit pas être utilisé. Ex. de mpi-forum: "l'utilisation du mpif.h le fichier include est fortement déconseillé et peut être déprécié dans une version future de MPI."( http://mpi-forum.org/docs/mpi-3.1/mpi31-report/node411.htm ).

je sais que je suis un peu en retard pour le parti, mais si vous êtes seulement après un ensemble de constantes et pas nécessairement des valeurs calculées, vous pourriez faire comme C et créer un fichier include:

dans un fichier, par exemple, les constantes.au lieu de

real, parameter :: pi = 3.14
real, parameter :: g = 6.67384e-11
...


program main
    use module1, only : func1, subroutine1, func2 
    implicit none

    include 'constants.for'
    ...
end program main

Édité pour enlever le "réel(4)" comme certains le pensent, c'est une mauvaise pratique.