Changeset 17602

Timestamp:

03/31/14 09:24:22 (11 years ago)

Author:

Mathieu Morlighem

Message:

BUG: do not use mesh variable

File:

• issm/trunk-jpl/src/m/parameterization/contourenvelope.py (modified) (4 diffs)

issm/trunk-jpl/src/m/parameterization/contourenvelope.py

@@ -46 +46 @@
 
         #get nodes inside profile
-        mesh.elementconnectivity=copy.deepcopy(md.mesh.elementconnectivity)
+        elementconnectivity=copy.deepcopy(md.mesh.elementconnectivity)
         if m.strcmp(md.mesh.meshtype(),'2Dhorizontal'):
-                mesh.elements=copy.deepcopy(md.mesh.elements)
-                mesh.x=copy.deepcopy(md.mesh.x)
-                mesh.y=copy.deepcopy(md.mesh.y)
-                mesh.numberofvertices=copy.deepcopy(md.mesh.numberofvertices)
-                mesh.numberofelements=copy.deepcopy(md.mesh.numberofelements)
+                elements=copy.deepcopy(md.mesh.elements)
+                x=copy.deepcopy(md.mesh.x)
+                y=copy.deepcopy(md.mesh.y)
+                numberofvertices=copy.deepcopy(md.mesh.numberofvertices)
+                numberofelements=copy.deepcopy(md.mesh.numberofelements)
         else:
-                mesh.elements=copy.deepcopy(md.mesh.elements2d)
-                mesh.x=copy.deepcopy(md.mesh.x2d)
-                mesh.y=copy.deepcopy(md.mesh.y2d)
-                mesh.numberofvertices=copy.deepcopy(md.mesh.numberofvertices2d)
-                mesh.numberofelements=copy.deepcopy(md.mesh.numberofelements2d)
+                elements=copy.deepcopy(md.mesh.elements2d)
+                x=copy.deepcopy(md.mesh.x2d)
+                y=copy.deepcopy(md.mesh.y2d)
+                numberofvertices=copy.deepcopy(md.mesh.numberofvertices2d)
+                numberofelements=copy.deepcopy(md.mesh.numberofelements2d)
 
         if len(args)==1:
@@ -64 +64 @@
                 if isfile:
                         #get flag list of elements and nodes inside the contour
-                        nodein=ContourToMesh(mesh.elements,mesh.x,mesh.y,file,'node',1)
-                        elemin=(numpy.sum(nodein(mesh.elements),axis=1)==numpy.size(mesh.elements,axis=1))
+                        nodein=ContourToMesh(elements,x,y,file,'node',1)
+                        elemin=(numpy.sum(nodein(elements),axis=1)==numpy.size(elements,axis=1))
                         #modify element connectivity
                         elemout=numpy.nonzero(numpy.logical_not(elemin))[0]
-                        mesh.elementconnectivity[elemout,:]=0
-                        mesh.elementconnectivity[numpy.nonzero(m.ismember(mesh.elementconnectivity,elemout+1))]=0
+                        elementconnectivity[elemout,:]=0
+                        elementconnectivity[numpy.nonzero(m.ismember(elementconnectivity,elemout+1))]=0
                 else:
                         #get flag list of elements and nodes inside the contour
-                        nodein=numpy.zeros(mesh.numberofvertices)
-                        elemin=numpy.zeros(mesh.numberofelements)
+                        nodein=numpy.zeros(numberofvertices)
+                        elemin=numpy.zeros(numberofelements)
 
                         pos=numpy.nonzero(flags)
                         elemin[pos]=1
-                        nodein[mesh.elements[pos,:]-1]=1
+                        nodein[elements[pos,:]-1]=1
 
                         #modify element connectivity
                         elemout=numpy.nonzero(numpy.logical_not(elemin))[0]
-                        mesh.elementconnectivity[elemout,:]=0
-                        mesh.elementconnectivity[numpy.nonzero(m.ismember(mesh.elementconnectivity,elemout+1))]=0
+                        elementconnectivity[elemout,:]=0
+                        elementconnectivity[numpy.nonzero(m.ismember(elementconnectivity,elemout+1))]=0
 
         #Find element on boundary
         #First: find elements on the boundary of the domain
-        flag=copy.deepcopy(mesh.elementconnectivity)
+        flag=copy.deepcopy(elementconnectivity)
         if len(args)==1:
                 flag[numpy.nonzero(flag)]=elemin[flag[numpy.nonzero(flag)]]
@@ -98 +98 @@
 
         for el1 in pos:
-                els2=mesh.elementconnectivity[el1,numpy.nonzero(mesh.elementconnectivity[el1,:])[0]]-1
+                els2=elementconnectivity[el1,numpy.nonzero(elementconnectivity[el1,:])[0]]-1
                 if numpy.size(els2)>1:
-                        flag=numpy.intersect1d(numpy.intersect1d(mesh.elements[els2[0],:],mesh.elements[els2[1],:]),mesh.elements[el1,:])
-                        nods1=mesh.elements[el1,:]
+                        flag=numpy.intersect1d(numpy.intersect1d(elements[els2[0],:],elements[els2[1],:]),elements[el1,:])
+                        nods1=elements[el1,:]
                         nods1=numpy.delete(nods1,numpy.nonzero(nods1==flag))
                         segments[count,:]=[nods1[0],nods1[1],el1+1]
 
-                        ord1=numpy.nonzero(nods1[0]==mesh.elements[el1,:])[0][0]
-                        ord2=numpy.nonzero(nods1[1]==mesh.elements[el1,:])[0][0]
+                        ord1=numpy.nonzero(nods1[0]==elements[el1,:])[0][0]
+                        ord2=numpy.nonzero(nods1[1]==elements[el1,:])[0][0]
 
                         #swap segment nodes if necessary
@@ -116 +116 @@
                         count+=1
                 else:
-                        nods1=mesh.elements[el1,:]
-                        flag=numpy.setdiff1d(nods1,mesh.elements[els2,:])
+                        nods1=elements[el1,:]
+                        flag=numpy.setdiff1d(nods1,elements[els2,:])
                         for j in xrange(0,3):
                                 nods=numpy.delete(nods1,j)
                                 if numpy.any(m.ismember(flag,nods)):
                                         segments[count,:]=[nods[0],nods[1],el1+1]
-                                        ord1=numpy.nonzero(nods[0]==mesh.elements[el1,:])[0][0]
-                                        ord2=numpy.nonzero(nods[1]==mesh.elements[el1,:])[0][0]
+                                        ord1=numpy.nonzero(nods[0]==elements[el1,:])[0][0]
+                                        ord2=numpy.nonzero(nods[1]==elements[el1,:])[0][0]
                                         if ( (ord1==0 and ord2==1) or (ord1==1 and ord2==2) or (ord1==2 and ord2==0) ):
                                                 temp=segments[count,0]