Changeset 23670 for issm/trunk-jpl/src/py3/parameterization/contourenvelope.py

Timestamp:

01/31/19 07:34:11 (6 years ago)

Author:

bdef

Message:

CHG: python scripts after 2to3 and indentation fix

File:

• issm/trunk-jpl/src/py3/parameterization/contourenvelope.py (modified) (5 diffs)

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

@@ -1 +1 @@
 import os.path
-import numpy
+import numpy as np
 import copy
 from NodeConnectivity import NodeConnectivity
@@ -40 +40 @@
         #Now, build the connectivity tables for this mesh.
         #Computing connectivity
-        if numpy.size(md.mesh.vertexconnectivity,axis=0)!=md.mesh.numberofvertices and numpy.size(md.mesh.vertexconnectivity,axis=0)!=md.mesh.numberofvertices2d:
-                [md.mesh.vertexconnectivity]=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices)
-        if numpy.size(md.mesh.elementconnectivity,axis=0)!=md.mesh.numberofelements and numpy.size(md.mesh.elementconnectivity,axis=0)!=md.mesh.numberofelements2d:
-                [md.mesh.elementconnectivity]=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity)
+        if np.size(md.mesh.vertexconnectivity,axis=0)!=md.mesh.numberofvertices and np.size(md.mesh.vertexconnectivity,axis=0)!=md.mesh.numberofvertices2d:
+                md.mesh.vertexconnectivity=NodeConnectivity(md.mesh.elements,md.mesh.numberofvertices)[0]
+        if np.size(md.mesh.elementconnectivity,axis=0)!=md.mesh.numberofelements and np.size(md.mesh.elementconnectivity,axis=0)!=md.mesh.numberofelements2d:
+                md.mesh.elementconnectivity=ElementConnectivity(md.mesh.elements,md.mesh.vertexconnectivity)[0]
 
         #get nodes inside profile
@@ -65 +65 @@
                         #get flag list of elements and nodes inside the contour
                         nodein=ContourToMesh(elements,x,y,file,'node',1)
-                        elemin=(numpy.sum(nodein(elements),axis=1)==numpy.size(elements,axis=1))
+                        elemin=(np.sum(nodein(elements),axis=1)==np.size(elements,axis=1))
                         #modify element connectivity
-                        elemout=numpy.nonzero(numpy.logical_not(elemin))[0]
+                        elemout=np.nonzero(np.logical_not(elemin))[0]
                         elementconnectivity[elemout,:]=0
-                        elementconnectivity[numpy.nonzero(m.ismember(elementconnectivity,elemout+1))]=0
+                        elementconnectivity[np.nonzero(m.ismember(elementconnectivity,elemout+1))]=0
                 else:
                         #get flag list of elements and nodes inside the contour
-                        nodein=numpy.zeros(numberofvertices)
-                        elemin=numpy.zeros(numberofelements)
+                        nodein=np.zeros(numberofvertices)
+                        elemin=np.zeros(numberofelements)
 
-                        pos=numpy.nonzero(flags)
+                        pos=np.nonzero(flags)
                         elemin[pos]=1
                         nodein[elements[pos,:]-1]=1
 
                         #modify element connectivity
-                        elemout=numpy.nonzero(numpy.logical_not(elemin))[0]
+                        elemout=np.nonzero(np.logical_not(elemin))[0]
                         elementconnectivity[elemout,:]=0
-                        elementconnectivity[numpy.nonzero(m.ismember(elementconnectivity,elemout+1))]=0
+                        elementconnectivity[np.nonzero(m.ismember(elementconnectivity,elemout+1))]=0
 
         #Find element on boundary
@@ -88 +88 @@
         flag=copy.deepcopy(elementconnectivity)
         if len(args)==1:
-                flag[numpy.nonzero(flag)]=elemin[flag[numpy.nonzero(flag)]]
-        elementonboundary=numpy.logical_and(numpy.prod(flag,axis=1)==0,numpy.sum(flag,axis=1)>0)
+                flag[np.nonzero(flag)]=elemin[flag[np.nonzero(flag)]]
+        elementonboundary=np.logical_and(np.prod(flag,axis=1)==0,np.sum(flag,axis=1)>0)
 
         #Find segments on boundary
-        pos=numpy.nonzero(elementonboundary)[0]
-        num_segments=numpy.size(pos)
-        segments=numpy.zeros((num_segments*3,3),int)
+        pos=np.nonzero(elementonboundary)[0]
+        num_segments=np.size(pos)
+        segments=np.zeros((num_segments*3,3),int)
         count=0
 
         for el1 in pos:
-                els2=elementconnectivity[el1,numpy.nonzero(elementconnectivity[el1,:])[0]]-1
-                if numpy.size(els2)>1:
-                        flag=numpy.intersect1d(numpy.intersect1d(elements[els2[0],:],elements[els2[1],:]),elements[el1,:])
+                els2=elementconnectivity[el1,np.nonzero(elementconnectivity[el1,:])[0]]-1
+                if np.size(els2)>1:
+                        flag=np.intersect1d(np.intersect1d(elements[els2[0],:],elements[els2[1],:]),elements[el1,:])
                         nods1=elements[el1,:]
-                        nods1=numpy.delete(nods1,numpy.nonzero(nods1==flag))
+                        nods1=np.delete(nods1,np.nonzero(nods1==flag))
                         segments[count,:]=[nods1[0],nods1[1],el1+1]
 
-                        ord1=numpy.nonzero(nods1[0]==elements[el1,:])[0][0]
-                        ord2=numpy.nonzero(nods1[1]==elements[el1,:])[0][0]
+                        ord1=np.nonzero(nods1[0]==elements[el1,:])[0][0]
+                        ord2=np.nonzero(nods1[1]==elements[el1,:])[0][0]
 
                         #swap segment nodes if necessary
@@ -113 +113 @@
                                 segments[count,0]=segments[count,1]
                                 segments[count,1]=temp
-                        segments[count,0:2]=numpy.flipud(segments[count,0:2])
+                        segments[count,0:2]=np.flipud(segments[count,0:2])
                         count+=1
                 else:
                         nods1=elements[el1,:]
-                        flag=numpy.setdiff1d(nods1,elements[els2,:])
+                        flag=np.setdiff1d(nods1,elements[els2,:])
                         for j in range(0,3):
-                                nods=numpy.delete(nods1,j)
-                                if numpy.any(m.ismember(flag,nods)):
+                                nods=np.delete(nods1,j)
+                                if np.any(m.ismember(flag,nods)):
                                         segments[count,:]=[nods[0],nods[1],el1+1]
-                                        ord1=numpy.nonzero(nods[0]==elements[el1,:])[0][0]
-                                        ord2=numpy.nonzero(nods[1]==elements[el1,:])[0][0]
+                                        ord1=np.nonzero(nods[0]==elements[el1,:])[0][0]
+                                        ord2=np.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]
                                                 segments[count,0]=segments[count,1]
                                                 segments[count,1]=temp
-                                        segments[count,0:2]=numpy.flipud(segments[count,0:2])
+                                        segments[count,0:2]=np.flipud(segments[count,0:2])
                                         count+=1
         segments=segments[0:count,:]