visualiser maillage simple régulier d'un fichier fortran

**mgoumine** · 26/09/2014, 18h46

bonjour tout le monde,

toutes vos propositions sont les biens venues !!

j'ai crée un maillage 2D régulier sous fortran avec ce fichier :

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
 
       program Maillage_2D_regulier
 
       implicit none 
 
 
       integer          :: i , j , k , l
       integer          :: imin,imax,jmin,jmax
       integer          :: xmin,xmax,ymin,ymax
 
       integer          :: alloc_stat
 
       real      ,  dimension (:)   , allocatable :: xx,yy
       real      ,  dimension (:,:) , allocatable :: Temp
 
 
       real             :: dx,dy
 
 
 
        !l'affinite de maillage
        imax=100 
        jmax=100
 
 
 
 
 
       !Allocation des tableaux (xx) et (yy) pour le maillage dans les deux direction X et Y
 
       allocate (xx(1:imax)                      , stat = alloc_stat )
                 if (.not.(alloc_stat.eq.0)) then
                      write(*,*) 'Erreur d''allocation tableau dynamique xx(i)'
                      stop
                 endif
 
       allocate (yy(1:jmax)                      , stat = alloc_stat )
                 if (.not.(alloc_stat.eq.0)) then
                      write(*,*) 'Erreur d''allocation tableau dynamique yy(i)'
                      stop
                 endif
 
 
 
        ! le domaine d'étude
        xmin=0.0; xmax=500.0 
        ymin=0.0; ymax=500.0       
 
 
 
 
        dx=xmax/(imax-1)                             ! dx  : c'ets le pas de maillage
        do i=1,imax                                  !imax : c'est le nombre de noeuds souhaité       
            xx(i)=(real(i-1)/real(imax-1)) * xmax    !dx   = real(i-1)/(imax-1)*xmax
            write(6,*) 'xx(i)=' , xx(i) , i , dx
        enddo
 
 
        !call REGUM(yy,20)
        yy(1)=0 ; yy(jmax)=ymax 
 
        dy=(yy(jmax)-yy(1))/(jmax-1)
 
        do j=1,jmax-1
           yy(j+1)=yy(j)+dy
           write(6,*)'yy(j)', yy(j) ,j  , dy
        enddo
 
 
 
 
       deallocate (Temp,xx,yy)
       end program  Maillage_2D_regulier
 
 
!---------------------------------------------------------------------------------------------------------------------
!---------------------------------------------------------------------------------------------------------------------
!------------------------------------Fin du programme pricipale---------------------------------------------------------
!---------------------------------------------------------------------------------------------------------------------
!---------------------------------------------------------------------------------------------------------------------
 
 
 
 
 
 
 
!-------------------------------------------------------------------------------------------------------------
 
!***********************************************************************
subroutine REGUM(nx,x)
!***********************************************************************
!                                                                      *
!                  MAILLAGE AUTOMATIQUE REGULIER                       *
!                  L. THAIS, VERSION OPENMP - DECEMBRE 2009            *
!                                                                      *
!***********************************************************************
   implicit none
!    integer, parameter :: dp = kind(1.0d0)
! DECLARATIONS DES ARGUMENTS
!
   integer,                    intent(in)   :: nx
   real   ,  dimension(1:nx), intent(inout) :: x
!
! VARIABLES LOCALES
!
   integer  :: i,nxm1
   real     :: dx
!-----------------------------------------------------------------------
 
   nxm1 = nx-1
   dx   = (x(nx)-x(1))/(nx-1) ![x(nx) - x(1)]/[nx -1]
 
   do i=1,(nx-1)
     x(i+1)=x(i)+dx
   enddo
 
end subroutine REGUM
 
!      write(1,*) "# ","x                         ", "z"
!      write(3,*) "# ","xp                         ", "zp"
! 
!          do i = 1, ix
!           do j = 1, iz
!            write(1,*)  x(i) , z(j)
!            write(2,*)  x(i) , z(j)
!            write(3,*)  xp(i), zp(j)
!           enddo
!         enddo
! 
! ! !
! ! !--- DIRECTION-X
! ! !
! !    do i=1,nx
! !       dx(i)  = x(i+1)-x(i)
! !       xp(i) = x(i)+dx(i)*0.5_wp
! !    enddo
! ! 
! !    do i=2,nx
! !       dxp(i) = xp(i)-xp(i-1)
! !    enddo
! ! 
! !    dxp(1)  = dx(1)
! !    dxp(ix) = dx(nx)
! !    xp(ix) = xp(nx)+dxp(ix)

Mais la question c'est d'abord comment visualiser ce maillage sous Gnuplot SVP !!

N.B:Je connais tracer les fonction avec Gnuplot mais pas trouver sur le Net des outils pour tracer le maillage

J'attends toutes vos propositions Merci d'avance

**FR119492** · 27/09/2014, 18h37

Bonjour.
Je travaille très souvent avec la méthode des éléments finis. Je dois donc réaliser des maillages, généralement pas réguliers, puis les représenter dans les rapports concernant mes projets. Pour écrire les rapports, j'utilise LaTeX, que je considère comme la meilleure solution. Pour les figures, et en particulier la représentation des maillages, j'utilise l'outil PSTricks et je génère le code source par un programme en fortran; ça peut sembler un peu archaïque, mais c'est très simple et ça marche très bien.
Jean-Marc Blanc

**mgoumine** · 06/10/2014, 11h17

Merci pour votre réponse , par contre je voudrais passer par Gnuplot en fête!!

il parait qu'il y a une commande et un moyen pour Visualiser le Maillage !!

Vous seriez pas une idée SVP

Merci car après je dois visualiser la température sur chaque point

Bien cordialement