]> SALOME platform Git repositories - tools/medcoupling.git/blob - doc/tutorial/atestMEDCouplingCube.rst
Salome HOME
Merge branch 'master' of https://codev-tuleap.cea.fr/plugins/git/salome/medcoupling
[tools/medcoupling.git] / doc / tutorial / atestMEDCouplingCube.rst
1
2 .. _python_testMEDCouplingcube_solution:
3
4 3D cube meshing
5 ~~~~~~~~~~~~~~~
6
7 ::
8
9         from MEDCoupling import *
10         from MEDLoader import *
11         import MEDLoaderDataForTest
12
13         from math import *
14
15         # Definition of environnement variables
16         spaceDimension = 3
17         N = 4
18         nbOfNodes = N*N*N
19         nbOfCells = (N-1)*(N-1)*(N-1)
20         nbOfCells2D = (N-1)*(N-1)
21
22         print "1 ********************"
23         # Initialisation of coordinates
24         coordinates = []
25         for k in range(N):
26                 for j in range(N):
27                         for i in range(N):
28                                 coordinates.append(float(i))
29                                 coordinates.append(float(j))
30                                 coordinates.append(float(k))
31                                 
32         print "2 ********************"
33         # Creation of meshing : need following initialisations
34         # => Definition of the mesh dimension
35         # => Definition of number of cells
36         # => Definition of name of meshing
37         mesh=MEDCouplingUMesh.New()
38         mesh.setMeshDimension(3)
39         mesh.allocateCells(nbOfCells+nbOfCells2D)
40         mesh.setName("3Dcube")
41
42         print "3 ********************"
43         # One remark : only one dimension cells by meshing
44         # Construction of volumic meshing
45         # => Definition of connectivity
46         # => Definition of type of cells
47         connectivity = []
48         for k in range(N-1):
49                 for j in range(N-1):
50                         for i in range(N-1):
51                                 inode = N*N*(k+1)+ N*(j+1)+i
52                                 connectivity.append(inode)
53                                 connectivity.append(inode-N)
54                                 connectivity.append(inode-N+1)
55                                 connectivity.append(inode+1)
56                                 connectivity.append(inode-N*N)
57                                 connectivity.append(inode-N*N-N)
58                                 connectivity.append(inode-N*N-N+1)
59                                 connectivity.append(inode-N*N+1)
60         print len(connectivity)
61         print 8*(nbOfCells)
62
63         print "4 ********************"
64         # Adding cells in meshing
65         for i in range(nbOfCells):
66                 mesh.insertNextCell(NORM_HEXA8,8,connectivity[8*i:8*(i+1)])
67                 pass
68
69         print "5 ********************"
70         # Settings of coordinates and verify if it's OK
71         myCoords = DataArrayDouble.New()
72         myCoords.setValues(coordinates,nbOfNodes,3)
73         mesh.setCoords(myCoords)
74         mesh.checkConsistencyLight()
75
76         print "6 ********************"
77         # Extraction of surfacic meshing
78         pt=[0.,0.,0.]
79         vec=[0.,0.,1.]
80         nodes = mesh.findNodesOnPlane(pt,vec,1e-12)
81         mesh2D = mesh.buildFacePartOfMySelfNode(nodes,True)
82         #print mesh2D
83         mesh2D.setName("3Dcube")
84         mesh2D.checkConsistencyLight()
85
86         print "7 ********************"
87         # Creation of field : with following definition
88         # => Definition of the mesh support
89         # => Definition of field name
90         # => Definition of field nature
91         field = MEDCouplingFieldDouble.New(ON_CELLS)
92         field.setMesh(mesh)
93         field.setName("field")
94         field.setNature(ExtensiveMaximum)
95
96         # Computing and setting field values
97         myCoords=DataArrayDouble.New()
98         sampleTab=[]
99         bar = mesh.computeCellCenterOfMass()
100         print bar.getNbOfElems()
101         for i in range(nbOfCells):
102                 x = bar.getIJ(i+1,1)
103                 y = bar.getIJ(i+1,2)
104                 z = bar.getIJ(i+1,3)
105                 d = sqrt(x*x+y*y+z*z)
106                 sinus = sin(d)
107                 #f.setValueIJ(i+1,1,sin(d))
108                 sampleTab.append(sinus)
109
110         myCoords.setValues(sampleTab,nbOfCells,1)
111         field.setArray(myCoords)
112
113         fBF = MEDCouplingFieldDouble.New(ON_CELLS)
114         fBF.setMesh(mesh2D)
115         fBF.setName("fieldBottomFace")
116         fBF.setNature(ExtensiveMaximum)
117         Cval = 10.
118         myCoords2D=DataArrayDouble.New()
119         sampleTab=[]
120         for i in range(nbOfCells2D):
121                 sampleTab.append(Cval)
122         myCoords2D.setValues(sampleTab,nbOfCells2D,1)
123         fBF.setArray(myCoords2D)
124
125         medFileName = "MEDCoupling_cube3D.med"
126         # For note : True / False in Write* functions
127         # => True : overwriting existing file
128         # => False : add in existing file 
129         meshes=[mesh2D,mesh]
130         MEDLoader.WriteUMeshes(medFileName,meshes,True);
131         MEDLoader.WriteField(medFileName,field,False)
132         MEDLoader.WriteField(medFileName,fBF,False)
133
134
135 ::
136
137         from MEDCoupling import *
138         from MEDLoader import *
139         import MEDLoaderDataForTest
140
141         from math import *
142
143         spaceDim3D = 3
144         MeshDim2D  = 2
145         N = 4
146         NbCell2D = (N-1)*(N-1)
147         NbCell3D = NbCell2D*(N-1)
148         NbNode2D = N*N
149         NbNode3D = NbNode2D*N
150
151         # Creation of a extruded meshing
152         # input : a 2D meshing and a 1D meshing
153         # Creation of 2D meshing
154         coordinates = []
155         for j in range(N):
156                 for i in range(N):
157                         coordinates.append(float(i))
158                         coordinates.append(float(j))
159         Connectivities = [0,4,5,1, 1,5,6,2, 2,6,7,3, 4,8,9,5, 5,9,10,6, 6,10,11,7, 8,12,13,9, 9,13,14,10, 10,14,15,11]
160         myCoords = DataArrayDouble.New()
161         myCoords.setValues(coordinates,NbNode2D,MeshDim2D)
162
163         m1 = MEDCouplingUMesh.New()
164         m1.setMeshDimension(MeshDim2D)
165         m1.allocateCells(NbCell2D)
166         m1.setCoords(myCoords)
167         m1.setName("2D_Support")
168
169         for i in range(NbCell2D):
170                 m1.insertNextCell(NORM_QUAD4,4,Connectivities[4*i:4*(i+1)])
171         m1.changeSpaceDimension(3)
172
173         # Creation of 1D meshing
174         coords = [ 0.0, 1.0, 2.0, 3.0 ]
175         conn   = [ 0,1, 1,2, 2,3 ]
176         m2 = MEDCouplingUMesh.New()
177         m2.setMeshDimension(1)
178         m2.allocateCells(3)
179         m2.insertNextCell(NORM_SEG2,2,conn[0:2])
180         m2.insertNextCell(NORM_SEG2,2,conn[2:4])
181         m2.insertNextCell(NORM_SEG2,2,conn[4:6])
182         myCoords1D=DataArrayDouble.New()
183         myCoords1D.setValues(coords,4,1)
184         m2.setCoords(myCoords1D)
185         m2.changeSpaceDimension(3)
186
187         # Construction of extruded meshing
188         center = [0.,0.,0.]
189         vector = [0.,1.,0.]
190         m2.rotate(center,vector,pi/2.)
191         m3 = m1.buildExtrudedMesh(m2,0)
192         m3.setName("Extrusion")
193
194         # Construction of group : old fashion mode
195         part=[1]
196         meshGroup=m3.buildPartOfMySelf(part,True);
197         meshGroup.setName("meshGroup");
198
199         medFileName = "MEDCoupling_Extrudedcube3D.med"
200         MEDLoader.WriteUMeshesPartition(medFileName,"Extrusion",[m3,meshGroup],True)
201         
202
203 ::
204
205         from MEDCoupling import *
206         from MEDLoader import *
207         import MEDLoaderDataForTest
208
209         from math import *
210
211         spaceDim3D = 3
212         MeshDim2D  = 2
213         N = 4
214         NbCell2D = (N-1)*(N-1)
215         NbCell3D = NbCell2D*(N-1)
216         NbNode2D = N*N
217         NbNode3D = NbNode2D*N
218
219         # Creation of a grid => Structured mesh
220         # Need directions definition
221         mesh=MEDCouplingCMesh.New()
222         coordsX=DataArrayDouble.New()
223         arrX=[ 0., 1., 2., 3. ]
224         coordsX.setValues(arrX,4,1)
225         coordsY=DataArrayDouble.New()
226         arrY=[ 0., 1., 2., 3. ]
227         coordsY.setValues(arrY,4,1)
228         coordsZ=DataArrayDouble.New()
229         arrZ=[ 0., 1., 2., 3. ]
230         coordsZ.setValues(arrZ,4,1)
231         mesh.setCoords(coordsX,coordsY,coordsZ)
232         # Passing structured meshing to unstructured
233         # necessary to save meshing
234         meshU=mesh.buildUnstructured()
235         meshU.setName("Grid")
236
237         # Creation of group : fashion mode
238         # if ids cells are known, this step is not to be made
239         pt=[1]
240         m2 = meshU.buildPartOfMySelf(pt,True);
241         ret,tabIdCells = meshU.areCellsIncludedIn(m2,0)
242         print ret
243         print tabIdCells
244         # Definition of the name group
245         tabIdCells.setName("meshGroup")
246
247         # Passing MEDCoupling to MEDFile
248         fmeshU = MEDFileUMesh.New()
249         fmeshU.setName("Grid")
250         fmeshU.setDescription("IHopeToConvinceLastMEDMEMUsers")
251         myCoords = meshU.getCoords()
252         print myCoords
253         fmeshU.setCoords(myCoords)
254         print "**************************"
255         fmeshU.setMeshAtLevel(0,meshU)
256         print "**************************"
257         fmeshU.setGroupsAtLevel(0,[tabIdCells],False)
258         print "**************************"
259
260         medFileName = "MEDCoupling_Gridcube3D.med"
261         fmeshU.write(medFileName,2)
262