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         mesh.finishInsertingCells()
  69
  70         print "5 ********************"
  71         # Settings of coordinates and verify if it's OK
  72         myCoords = DataArrayDouble.New()
  73         myCoords.setValues(coordinates,nbOfNodes,3)
  74         mesh.setCoords(myCoords)
  75         mesh.checkCoherency()
  76
  77         print "6 ********************"
  78         # Extraction of surfacic meshing
  79         pt=[0.,0.,0.]
  80         vec=[0.,0.,1.]
  81         nodes = mesh.findNodesOnPlane(pt,vec,1e-12)
  82         mesh2D = mesh.buildFacePartOfMySelfNode(nodes,True)
  83         #print mesh2D
  84         mesh2D.setName("3Dcube")
  85         mesh2D.checkCoherency()
  86
  87         print "7 ********************"
  88         # Creation of field : with following definition
  89         # => Definition of the mesh support
  90         # => Definition of field name
  91         # => Definition of field nature
  92         field = MEDCouplingFieldDouble.New(ON_CELLS)
  93         field.setMesh(mesh)
  94         field.setName("field")
  95         field.setNature(Integral)
  96
  97         # Computing and setting field values
  98         myCoords=DataArrayDouble.New()
  99         sampleTab=[]
 100         bar = mesh.getBarycenterAndOwner()
 101         print bar.getNbOfElems()
 102         for i in range(nbOfCells):
 103                 x = bar.getIJ(i+1,1)
 104                 y = bar.getIJ(i+1,2)
 105                 z = bar.getIJ(i+1,3)
 106                 d = sqrt(x*x+y*y+z*z)
 107                 sinus = sin(d)
 108                 #f.setValueIJ(i+1,1,sin(d))
 109                 sampleTab.append(sinus)
 110
 111         myCoords.setValues(sampleTab,nbOfCells,1)
 112         field.setArray(myCoords)
 113
 114         fBF = MEDCouplingFieldDouble.New(ON_CELLS)
 115         fBF.setMesh(mesh2D)
 116         fBF.setName("fieldBottomFace")
 117         fBF.setNature(Integral)
 118         Cval = 10.
 119         myCoords2D=DataArrayDouble.New()
 120         sampleTab=[]
 121         for i in range(nbOfCells2D):
 122                 sampleTab.append(Cval)
 123         myCoords2D.setValues(sampleTab,nbOfCells2D,1)
 124         fBF.setArray(myCoords2D)
 125
 126         medFileName = "MEDCoupling_cube3D.med"
 127         # For note : True / False in Write* functions
 128         # => True : overwriting existing file
 129         # => False : add in existing file
 130         meshes=[mesh2D,mesh]
 131         MEDLoader.WriteUMeshes(medFileName,meshes,True);
 132         MEDLoader.WriteField(medFileName,field,False)
 133         MEDLoader.WriteField(medFileName,fBF,False)
 134
 135
 136 ::
 137
 138         from MEDCoupling import *
 139         from MEDLoader import *
 140         import MEDLoaderDataForTest
 141
 142         from math import *
 143
 144         spaceDim3D = 3
 145         MeshDim2D  = 2
 146         N = 4
 147         NbCell2D = (N-1)*(N-1)
 148         NbCell3D = NbCell2D*(N-1)
 149         NbNode2D = N*N
 150         NbNode3D = NbNode2D*N
 151
 152         # Creation of a extruded meshing
 153         # input : a 2D meshing and a 1D meshing
 154         # Creation of 2D meshing
 155         coordinates = []
 156         for j in range(N):
 157                 for i in range(N):
 158                         coordinates.append(float(i))
 159                         coordinates.append(float(j))
 160         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]
 161         myCoords = DataArrayDouble.New()
 162         myCoords.setValues(coordinates,NbNode2D,MeshDim2D)
 163
 164         m1 = MEDCouplingUMesh.New()
 165         m1.setMeshDimension(MeshDim2D)
 166         m1.allocateCells(NbCell2D)
 167         m1.setCoords(myCoords)
 168         m1.setName("2D_Support")
 169
 170         for i in range(NbCell2D):
 171                 m1.insertNextCell(NORM_QUAD4,4,Connectivities[4*i:4*(i+1)])
 172         m1.finishInsertingCells()
 173         m1.changeSpaceDimension(3)
 174
 175         # Creation of 1D meshing
 176         coords = [ 0.0, 1.0, 2.0, 3.0 ]
 177         conn   = [ 0,1, 1,2, 2,3 ]
 178         m2 = MEDCouplingUMesh.New()
 179         m2.setMeshDimension(1)
 180         m2.allocateCells(3)
 181         m2.insertNextCell(NORM_SEG2,2,conn[0:2])
 182         m2.insertNextCell(NORM_SEG2,2,conn[2:4])
 183         m2.insertNextCell(NORM_SEG2,2,conn[4:6])
 184         m2.finishInsertingCells()
 185         myCoords1D=DataArrayDouble.New()
 186         myCoords1D.setValues(coords,4,1)
 187         m2.setCoords(myCoords1D)
 188         m2.changeSpaceDimension(3)
 189
 190         # Construction of extruded meshing
 191         center = [0.,0.,0.]
 192         vector = [0.,1.,0.]
 193         m2.rotate(center,vector,pi/2.)
 194         m3 = m1.buildExtrudedMesh(m2,0)
 195         m3.setName("Extrusion")
 196
 197         # Construction of group : old fashion mode
 198         part=[1]
 199         meshGroup=m3.buildPartOfMySelf(part,True);
 200         meshGroup.setName("meshGroup");
 201
 202         medFileName = "MEDCoupling_Extrudedcube3D.med"
 203         MEDLoader.WriteUMeshesPartition(medFileName,"Extrusion",[m3,meshGroup],True)
 204
 205
 206 ::
 207
 208         from MEDCoupling import *
 209         from MEDLoader import *
 210         import MEDLoaderDataForTest
 211
 212         from math import *
 213
 214         spaceDim3D = 3
 215         MeshDim2D  = 2
 216         N = 4
 217         NbCell2D = (N-1)*(N-1)
 218         NbCell3D = NbCell2D*(N-1)
 219         NbNode2D = N*N
 220         NbNode3D = NbNode2D*N
 221
 222         # Creation of a grid => Structured mesh
 223         # Need directions definition
 224         mesh=MEDCouplingCMesh.New()
 225         coordsX=DataArrayDouble.New()
 226         arrX=[ 0., 1., 2., 3. ]
 227         coordsX.setValues(arrX,4,1)
 228         coordsY=DataArrayDouble.New()
 229         arrY=[ 0., 1., 2., 3. ]
 230         coordsY.setValues(arrY,4,1)
 231         coordsZ=DataArrayDouble.New()
 232         arrZ=[ 0., 1., 2., 3. ]
 233         coordsZ.setValues(arrZ,4,1)
 234         mesh.setCoords(coordsX,coordsY,coordsZ)
 235         # Passing structured meshing to unstructured
 236         # necessary to save meshing
 237         meshU=mesh.buildUnstructured()
 238         meshU.setName("Grid")
 239
 240         # Creation of group : fashion mode
 241         # if ids cells are known, this step is not to be made
 242         pt=[1]
 243         m2 = meshU.buildPartOfMySelf(pt,True);
 244         ret,tabIdCells = meshU.areCellsIncludedIn(m2,0)
 245         print ret
 246         print tabIdCells
 247         # Definition of the name group
 248         tabIdCells.setName("meshGroup")
 249
 250         # Passing MEDCoupling to MEDFile
 251         fmeshU = MEDFileUMesh.New()
 252         fmeshU.setName("Grid")
 253         fmeshU.setDescription("IHopeToConvinceLastMEDMEMUsers")
 254         myCoords = meshU.getCoords()
 255         print myCoords
 256         fmeshU.setCoords(myCoords)
 257         print "**************************"
 258         fmeshU.setMeshAtLevel(0,meshU)
 259         print "**************************"
 260         fmeshU.setGroupsAtLevel(0,[tabIdCells],False)
 261         print "**************************"
 262
 263         medFileName = "MEDCoupling_Gridcube3D.med"
 264         fmeshU.write(medFileName,2)
 265