Changeset 13030

Timestamp:

08/14/12 12:09:35 (13 years ago)

Author:

jschierm

Message:

NEW: Last bunch more python checkconsistency and marshall methods for sub-classes (plus other minor changes and fixes to keep up with Matlab changes).

Location:

issm/trunk-jpl/src/m

Files:

• boundaryconditions/SetIceShelfBC.py (modified) (1 diff)
• classes/diagnostic.py (modified) (1 diff)
• classes/inversion.py (modified) (3 diffs)
• classes/miscellaneous.m (modified) (1 diff)
• classes/miscellaneous.py (modified) (2 diffs)
• classes/model/model.py (modified) (1 diff)
• classes/private.py (modified) (2 diffs)
• classes/qmu.m (modified) (2 diffs)
• classes/qmu.py (modified) (2 diffs)
• classes/radaroverlay.py (modified) (2 diffs)
• consistency/checkfield.py (modified) (3 diffs)
• consistency/ismodelselfconsistent.py (modified) (1 diff)
• parameterization/parameterize.py (modified) (2 diffs)
• parameterization/setflowequation.py (modified) (12 diffs)

issm/trunk-jpl/src/m/boundaryconditions/SetIceShelfBC.py

@@ -69 +69 @@
 
         #Create zeros basalforcings and surfaceforcings
-        if numpy.isnan(md.surfaceforcings.precipitation).all():
+        if all(numpy.isnan(md.surfaceforcings.precipitation)):
                 md.surfaceforcings.precipitation=numpy.zeros(md.mesh.numberofvertices)
                 print '      no surfaceforcings.precipitation specified: values set as zero'
-        if numpy.isnan(md.surfaceforcings.mass_balance).all():
+        if all(numpy.isnan(md.surfaceforcings.mass_balance)):
                 md.surfaceforcings.mass_balance=numpy.zeros(md.mesh.numberofvertices)
                 print '      no surfaceforcings.mass_balance specified: values set as zero'
-        if numpy.isnan(md.basalforcings.melting_rate).all():
+        if all(numpy.isnan(md.basalforcings.melting_rate)):
                 md.basalforcings.melting_rate=numpy.zeros(md.mesh.numberofvertices)
                 print '      no basalforcings.melting_rate specified: values set as zero'
-        if numpy.isnan(md.balancethickness.thickening_rate).all():
+        if all(numpy.isnan(md.balancethickness.thickening_rate)):
                 md.balancethickness.thickening_rate=numpy.zeros(md.mesh.numberofvertices)
                 print '      no balancethickness.thickening_rate specified: values set as zero'

issm/trunk-jpl/src/m/classes/diagnostic.py

@@ -139 +139 @@
 
                 #singular solution
-                #if ~any((~isnan(md.diagnostic.spcvx)+~isnan(md.diagnostic.spcvy))==2),
-                if not any((numpy.logical_not(numpy.isnan(md.diagnostic.spcvx))+numpy.logical_not(numpy.isnan(md.diagnostic.spcvy)))==2):
+                if not any(numpy.logical_and(numpy.logical_not(numpy.isnan(md.diagnostic.spcvx)),numpy.logical_not(numpy.isnan(md.diagnostic.spcvy)))):
                         md.checkmessage("model is not well posed (singular). You need at least one node with fixed velocity!")
                 #CHECK THAT EACH LINES CONTAINS ONLY NAN VALUES OR NO NAN VALUES

issm/trunk-jpl/src/m/classes/inversion.py

@@ -111 +111 @@
                 return self
         #}}}
+
         def checkconsistency(self,md,solution,analyses):    # {{{
 
@@ -142 +143 @@
                 return md
         # }}}
+
         def marshall(self,fid):    # {{{
 
@@ -184 +186 @@
                 WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum(),'format','Integer')
         # }}}
+

issm/trunk-jpl/src/m/classes/miscellaneous.m

@@ -1 @@
-%MISCELANEOUS class definition
+%MISCELLANEOUS class definition
 %
 %   Usage:

issm/trunk-jpl/src/m/classes/miscellaneous.py

@@ -1 +1 @@
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
 
 class miscellaneous(object):
+        """
+        MISCELLANEOUS class definition
+
+           Usage:
+              miscellaneous=miscellaneous();
+        """
+
         #properties
         def __init__(self):
@@ -14 +24 @@
 
                 #}}}
-        def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   miscellaneous parameters:'
 
-                string="%s\n\n%s"%(string,fielddisplay(obj,'notes','notes in a cell of strings'))
-                string="%s\n%s"%(string,fielddisplay(obj,'name','model name'))
-                string="%s\n%s"%(string,fielddisplay(obj,'dummy','empty field to store some data'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'notes','notes in a cell of strings'))
+                string="%s\n%s"%(string,fielddisplay(self,'name','model name'))
+                string="%s\n%s"%(string,fielddisplay(self,'dummy','empty field to store some data'))
                 return string
                 #}}}
                 
-        def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
-                return obj
+                return self
         #}}}
 
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                md = checkfield(md,'miscellaneous.name','empty',1)
+                return md
+        # }}}
+
+        def marshall(self,fid):    #  {{{
+                WriteData(fid,'object',self,'fieldname','name','format','String')
+        # }}}
+

issm/trunk-jpl/src/m/classes/model/model.py

@@ -116 +116 @@
                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("inversion","[%s,%s]" % ("1x1",obj.inversion.__class__.__name__),"parameters for inverse methods"))
                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("qmu","[%s,%s]" % ("1x1",obj.qmu.__class__.__name__),"dakota properties"))
-                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("results","[%s,%s]" % ("1x1",obj.results.__class__.__name__),"model results'"))
+                string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("results","[%s,%s]" % ("1x1",obj.results.__class__.__name__),"model results"))
                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("radaroverlay","[%s,%s]" % ("1x1",obj.radaroverlay.__class__.__name__),"radar image for plot overlay"))
                 string="%s\n%s" % (string,"%19s: %-22s -- %s" % ("miscellaneous","[%s,%s]" % ("1x1",obj.miscellaneous.__class__.__name__),"miscellaneous fields"))

issm/trunk-jpl/src/m/classes/private.py

@@ -1 +1 @@
 #module imports
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
 
 class private(object):
+        """
+        PRIVATE class definition
+
+           Usage:
+              private=private();
+        """
+
         #properties
         def __init__(self):
@@ -15 +24 @@
 
                 #}}}
-        def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   private parameters: do not change'
 
-                string="%s\n%s"%(string,fielddisplay(obj,'isconsistent','is model self consistent'))
-                string="%s\n%s"%(string,fielddisplay(obj,'runtimename','name of the run launched'))
-                string="%s\n%s"%(string,fielddisplay(obj,'bamg','structure with mesh properties constructed if bamg is used to mesh the domain'))
-                string="%s\n%s"%(string,fielddisplay(obj,'solution','type of solution launched'))
+                string="%s\n%s"%(string,fielddisplay(self,'isconsistent','is model self consistent'))
+                string="%s\n%s"%(string,fielddisplay(self,'runtimename','name of the run launched'))
+                string="%s\n%s"%(string,fielddisplay(self,'bamg','structure with mesh properties constructed if bamg is used to mesh the domain'))
+                string="%s\n%s"%(string,fielddisplay(self,'solution','type of solution launched'))
                 return string
                 #}}}
                 
-        def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
-                return obj
+                return self
         #}}}
 
+        def checkconsistency(self,md,solution,analyses):    # {{{
+                return md
+        # }}}
+

issm/trunk-jpl/src/m/classes/qmu.m

@@ -47 +47 @@
                                         md = checkmessage(md,['user supplied partition for qmu analysis should have size md.mesh.numberofvertices x 1 ']);
                                 end
-                                if find(md.qmu.partition)>=md.mesh.numberofvertices,
-                                        md = checkmessage(md,['user supplied partition should be indexed from 0 (c-convention)']);
-                                end
                                 if min(md.qmu.partition)~=0,
                                         md = checkmessage(md,['partition vector not indexed from 0 on']);
-                                end
-                                if max(md.qmu.partition)>=md.mesh.numberofvertices,
-                                        md = checkmessage(md,['partition vector cannot have maximum index larger than number of nodes']);
-                                end
-                                if ~isempty(find(md.qmu.partition<0)),
-                                        md = checkmessage(md,['partition vector cannot have values less than 0']);
-                                end
-                                if ~isempty(find(md.qmu.partition>=md.qmu.numberofpartitions)),
-                                        md = checkmessage(md,['partition vector cannot have values more than md.qmu.numberofpartitions-1']);
                                 end
                                 if max(md.qmu.partition)>=md.qmu.numberofpartitions,
@@ -140 +128 @@
                                 end
                         end
-                        fielddisplay(obj,'partition','user provided mesh partitionition, defaults to metis if not specified') 
-                        fielddisplay(obj,'numberofpartitions','number of partitions for semi-descrete qmu') 
+                        fielddisplay(obj,'partition','user provided mesh partitioning, defaults to metis if not specified') 
+                        fielddisplay(obj,'numberofpartitions','number of partitions for semi-discrete qmu') 
                         fielddisplay(obj,'variabledescriptors','');
                         fielddisplay(obj,'responsedescriptors','');

issm/trunk-jpl/src/m/classes/qmu.py

@@ -1 +1 @@
 #module imports
+import numpy
 from fielddisplay import fielddisplay
+from EnumDefinitions import *
+from checkfield import *
+from WriteData import *
+from MatlabFuncs import *
 
 class qmu(object):
+        """
+        QMU class definition
+
+           Usage:
+              qmu=qmu();
+        """
+
         #properties
         def __init__(self):
@@ -27 +39 @@
 
                 #}}}
-        def __repr__(obj):
-                # {{{ Display
-                string="   qmu parameters: not implemented yet!"
-                return string
-                #}}}
-                
-        def setdefaultparameters(obj):
+
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
-                return obj
+                return self
         #}}}
 
+        def checkconsistency(self,md,solution,analyses):    # {{{
+
+                #Early return
+                if not md.qmu.isdakota:
+                        return
+
+                if not md.qmu.params.evaluation_concurrency==1:
+                        md.checkmessage("concurrency should be set to 1 when running dakota in library mode")
+                if md.qmu.partition:
+                        if not numpy.size(md.qmu.partition)==md.mesh.numberofvertices:
+                                md.checkmessage("user supplied partition for qmu analysis should have size md.mesh.numberofvertices x 1")
+                        if not min(md.qmu.partition)==0:
+                                md.checkmessage("partition vector not indexed from 0 on")
+                        if max(md.qmu.partition)>=md.qmu.numberofpartitions:
+                                md.checkmessage("for qmu analysis, partitioning vector cannot go over npart, number of partition areas")
+
+                if not strcmpi(md.cluster.name,'none'):
+                        if not md.settings.waitonlock:
+                                md.checkmessage("waitonlock should be activated when running qmu in parallel mode!")
+
+                return md
+        # }}}
+
+        def __repr__(self):    # {{{
+                s ='   qmu parameters:\n'
+
+                s+="%s\n" % fielddisplay(self,'isdakota','is qmu analysis activated?')
+                for i,variable in enumerate(self.variables):
+                        s+="         variables%s:  (arrays of each variable class)\n" % \
+                                string_dim(self.variables,i)
+                        fnames=vars(variable)
+                        maxlen=0
+                        for fname in fnames:
+                                maxlen=max(maxlen,len(fname))
+
+                        for fname in fnames:
+                                s+="'            %-*s:    [%ix%i]    '%s'\n" % \
+                                        (maxlen+1,fname,size(getattr(variable,fname)),type(getattr(variable,fname)))
+
+                for i,response in enumerate(self.responses):
+                        s+="         responses%s:  (arrays of each response class)\n" % \
+                                string_dim(self.responses,i)
+                        fnames=vars(response)
+                        maxlen=0
+                        for fname in fnames:
+                                maxlen=max(maxlen,len(fname))
+
+                        for fname in fnames:
+                                s+="            %-*s:    [%ix%i]    '%s'\n" % \
+                                        (maxlen+1,fname,size(getattr(response,fname)),type(getattr(response,fname)))
+
+                s+="%s\n" % fielddisplay(self,'numberofresponses','number of responses') 
+
+                for i,method in enumerate(self.method):
+                        if isinstance(method,'dakota_method'):
+                                s+="            method%s :    '%s'\n" % \
+                                        (string_dim(method,i),method.method)
+
+                for i,param in enumerate(self.params):
+                        s+="         params%s:  (array of method-independent parameters)\n" % \
+                                string_dim(self.params,i)
+                        fnames=vars(param)
+                        maxlen=0
+                        for fname in fnames:
+                                maxlen=max(maxlen,len(fname))
+
+                        for fname in fnames:
+                                s+="            %-*s: %s\n" % \
+                                        (maxlen+1,fname,any2str(getattr(param,fname)))
+
+                for i,result in enumerate(self.results):
+                        s+="         results%s:  (information from dakota files)\n" % \
+                                string_dim(self.results,i)
+                        fnames=vars(result)
+                        maxlen=0
+                        for fname in fnames:
+                                maxlen=max(maxlen,len(fname))
+
+                        for fname in fnames:
+                                s+="            %-*s:    [%ix%i]    '%s'\n" % \
+                                        (maxlen+1,fname,size(getattr(result,fname)),type(getattr(result,fname)))
+
+                s+="%s\n" % fielddisplay(self,'partition','user provided mesh partitioning, defaults to metis if not specified') 
+                s+="%s\n" % fielddisplay(self,'numberofpartitions','number of partitions for semi-discrete qmu') 
+                s+="%s\n" % fielddisplay(self,'variabledescriptors','')
+                s+="%s\n" % fielddisplay(self,'responsedescriptors','')
+                s+="%s\n" % fielddisplay(self,'method','array of dakota_method class')
+                s+="%s\n" % fielddisplay(self,'mass_flux_profile_directory','directory for mass flux profiles')
+                s+="%s\n" % fielddisplay(self,'mass_flux_profiles','list of mass_flux profiles')
+                s+="%s\n" % fielddisplay(self,'mass_flux_segments','')
+                s+="%s\n" % fielddisplay(self,'adjacency','')
+                s+="%s\n" % fielddisplay(self,'vertex_weight','weight applied to each mesh vertex')
+
+                return s
+        # }}}
+                
+        def marshall(self,fid):    # {{{
+                WriteData(fid,'object',self,'fieldname','isdakota','format','Boolean')
+                if not self.isdakota:
+                        return
+                WriteData(fid,'object',self,'fieldname','partition','format','DoubleMat','mattype',2)
+                WriteData(fid,'object',self,'fieldname','numberofpartitions','format','Integer')
+                WriteData(fid,'object',self,'fieldname','numberofresponses','format','Integer')
+                WriteData(fid,'object',self,'fieldname','variabledescriptors','format','StringArray')
+                WriteData(fid,'object',self,'fieldname','responsedescriptors','format','StringArray')
+                WriteData(fid,'object',self,'fieldname','mass_flux_segments','format','MatArray')
+        # }}}
+

issm/trunk-jpl/src/m/classes/radaroverlay.py

@@ -3 +3 @@
 
 class radaroverlay(object):
+        """
+        RADAROVERLAY class definition
+
+           Usage:
+              radaroverlay=radaroverlay();
+        """
+
         #properties
         def __init__(self):
@@ -14 +21 @@
 
                 #}}}
-        def __repr__(obj):
+        def __repr__(self):
                 # {{{ Display
                 string='   radaroverlay parameters:'
-                string="%s\n\n%s"%(string,fielddisplay(obj,'pwr','radar power image (matrix)'))
-                string="%s\n%s"%(string,fielddisplay(obj,'x','corresponding x coordinates'))
-                string="%s\n%s"%(string,fielddisplay(obj,'y','corresponding y coordinates'))
+                string="%s\n\n%s"%(string,fielddisplay(self,'pwr','radar power image (matrix)'))
+                string="%s\n%s"%(string,fielddisplay(self,'x','corresponding x coordinates'))
+                string="%s\n%s"%(string,fielddisplay(self,'y','corresponding y coordinates'))
                 return string
                 #}}}
                 
-        def setdefaultparameters(obj):
+        def setdefaultparameters(self):
                 # {{{setdefaultparameters
-                return obj
+                return self
         #}}}
 

issm/trunk-jpl/src/m/consistency/checkfield.py

@@ -112 +112 @@
         if options.exist('>='):
                 lowerbound=options.getfieldvalue('>=')
-                if numpy.any(field<lowerbound):
+                if any(field<lowerbound):
                         md = md.checkmessage(options.getfieldvalue('message',\
                                 "field '%s' should have values above %d" % (fieldname,lowerbound)))
         if options.exist('>'):
                 lowerbound=options.getfieldvalue('>')
-                if numpy.any(field<=lowerbound):
+                if any(field<=lowerbound):
                         md = md.checkmessage(options.getfieldvalue('message',\
                                 "field '%s' should have values above %d" % (fieldname,lowerbound)))
@@ -124 +124 @@
         if options.exist('<='):
                 upperbound=options.getfieldvalue('<=')
-                if numpy.any(field>upperbound):
+                if any(field>upperbound):
                         md = md.checkmessage(options.getfieldvalue('message',\
                                 "field '%s' should have values below %d" % (fieldname,upperbound)))
         if options.exist('<'):
                 upperbound=options.getfieldvalue('<')
-                if numpy.any(field>=upperbound):
+                if any(field>=upperbound):
                         md = md.checkmessage(options.getfieldvalue('message',\
                                 "field '%s' should have values below %d" % (fieldname,upperbound)))
@@ -145 +145 @@
                                         "field '%s' should have only one column as there are md.mesh.numberofvertices lines" % fieldname))
                 elif numpy.size(field,0)==md.mesh.numberofvertices+1:
-                        if not numpy.all(field[-1,:]==numpy.sort(field[-1,:])):
+                        if not all(field[-1,:]==numpy.sort(field[-1,:])):
                                 md = md.checkmessage(options.getfieldvalue('message',\
                                         "field '%s' columns should be sorted chronologically" % fieldname))
-                        if nump.any(field[-1,0:-1]==field[-1,1:]):
+                        if any(field[-1,0:-1]==field[-1,1:]):
                                 md = md.checkmessage(options.getfieldvalue('message',\
                                         "field '%s' columns must not contain duplicate timesteps" % fieldname))

issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.py

@@ -1 @@
-from AnalysisConfiguration import *
 from EnumDefinitions import *
 

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

@@ -1 +1 @@
 import os
 import datetime
-from addnote import *
 
 def parameterize(md,parametername):
@@ -29 +28 @@
                 md.miscellaneous.name=os.path.basename(parametername).split('.')[0]
 
-        md=addnote(md,"Model created by using parameter file: '%s' on: %s." % (parametername,datetime.datetime.strftime(datetime.datetime.now(),'%c') ))
+        md.miscellaneous.notes="Model created by using parameter file: '%s' on: %s." % (parametername,datetime.datetime.strftime(datetime.datetime.now(),'%c'))
 
         return md

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

@@ -63 +63 @@
 
         #check that each element has at least one flag
-        if not numpy.any(hutterflag+macayealflag+pattynflag+stokesflag):
+        if not any(hutterflag+macayealflag+pattynflag+stokesflag):
                 raise TypeError("setflowequation error message: elements type not assigned, must be specified")
 
         #check that each element has only one flag
-        if numpy.any(hutterflag+macayealflag+pattynflag+stokesflag>1):
+        if any(hutterflag+macayealflag+pattynflag+stokesflag>1):
                 print "setflowequation warning message: some elements have several types, higher order type is used for them"
                 hutterflag[numpy.nonzero(numpy.logical_and(hutterflag,macayealflag))]=0
@@ -75 +75 @@
         #Check that no pattyn or stokes for 2d mesh
         if md.mesh.dimension==2:
-                if numpy.any(numpy.logical_or(stokesflag,pattynflag)):
+                if any(numpy.logical_or(stokesflag,pattynflag)):
                         raise TypeError("setflowequation error message: stokes and pattyn elements not allowed in 2d mesh, extrude it first")
 
         #Stokes can only be used alone for now:
-        if numpy.any(stokesflag) and numpy.any(hutterflag):
+        if any(stokesflag) and any(hutterflag):
                 raise TypeError("setflowequation error message: stokes cannot be used with any other model for now, put stokes everywhere")
 
@@ -130 +130 @@
 
                 #initialize and fill in penalties structure
-                if numpy.all(numpy.logical_not(numpy.isnan(bordernodes2d))):
+                if all(numpy.logical_not(numpy.isnan(bordernodes2d))):
                         penalties=numpy.zeros((0,2))
                         for     i in xrange(1,numlayers):
@@ -137 +137 @@
 
         elif strcmpi(coupling_method,'tiling'):
-                if   numpy.any(macayealflag) and numpy.any(pattynflag):    #coupling macayeal pattyn
+                if   any(macayealflag) and any(pattynflag):    #coupling macayeal pattyn
                         #Find node at the border
                         nodeonmacayealpattyn[numpy.nonzero(numpy.logical_and(nodeonmacayeal,nodeonpattyn))]=1
@@ -152 +152 @@
                         pos=numpy.nonzero(macayealpattynflag)
                         elist=numpy.zeros(len(pos))
-                        elist = elist + numpy.any(numpy.sum(nodeonmacayeal[md.mesh.elements[pos,:].astype(int)-1],axis=1),axis=1)
-                        elist = elist - numpy.any(numpy.sum(nodeonpattyn[md.mesh.elements[pos,:].astype(int)-1]  ,axis=1),axis=1)
+                        elist = elist + any(numpy.sum(nodeonmacayeal[md.mesh.elements[pos,:].astype(int)-1],axis=1),axis=1)
+                        elist = elist - any(numpy.sum(nodeonpattyn[md.mesh.elements[pos,:].astype(int)-1]  ,axis=1),axis=1)
                         pos1=[i for i,item in enumerate(elist) if item==1]
                         macayealflag[pos[pos1]]=1
@@ -169 +169 @@
                         nodeonmacayealpattyn[md.mesh.elements[numpy.nonzero(macayealpattynflag),:].astype(int)-1]=1
 
-                elif numpy.any(pattynflag) and numpy.any(stokesflag):    #coupling pattyn stokes
+                elif any(pattynflag) and any(stokesflag):    #coupling pattyn stokes
                         #Find node at the border
                         nodeonpattynstokes[numpy.nonzero(numpy.logical_and(nodeonpattyn,nodeonstokes))]=1
@@ -184 +184 @@
                         pos=numpy.nonzero(pattynstokesflag)
                         elist=numpy.zeros(len(pos))
-                        elist = elist + numpy.any(numpy.sum(nodeonstokes[md.mesh.elements[pos,:].astype(int)-1],axis=1),axis=1)
-                        elist = elist - numpy.any(numpy.sum(nodeonpattyn[md.mesh.elements[pos,:].astype(int)-1],axis=1),axis=1)
+                        elist = elist + any(numpy.sum(nodeonstokes[md.mesh.elements[pos,:].astype(int)-1],axis=1),axis=1)
+                        elist = elist - any(numpy.sum(nodeonpattyn[md.mesh.elements[pos,:].astype(int)-1],axis=1),axis=1)
                         pos1=[i for i,item in enumerate(elist) if item==1]
                         stokesflag[pos[pos1]]=1
@@ -201 +201 @@
                         nodeonpattynstokes[md.mesh.elements[numpy.nonzero(pattynstokesflag),:].astype(int)-1]=1
 
-                elif numpy.any(stokesflag) and numpy.any(macayealflag):
+                elif any(stokesflag) and any(macayealflag):
                         #Find node at the border
                         nodeonmacayealstokes[numpy.nonzero(numpy.logical_and(nodeonmacayeal,nodeonstokes))]=1
@@ -216 +216 @@
                         pos=numpy.nonzero(macayealstokesflag)
                         elist=numpy.zeros(len(pos))
-                        elist = elist + numpy.any(numpy.sum(nodeonmacayeal[md.mesh.elements[pos,:].astype(int)-1],axis=1),axis=1)
-                        elist = elist - numpy.any(numpy.sum(nodeonstokes[md.mesh.elements[pos,:].astype(int)-1]  ,axis=1),axis=1)
+                        elist = elist + any(numpy.sum(nodeonmacayeal[md.mesh.elements[pos,:].astype(int)-1],axis=1),axis=1)
+                        elist = elist - any(numpy.sum(nodeonstokes[md.mesh.elements[pos,:].astype(int)-1]  ,axis=1),axis=1)
                         pos1=[i for i,item in enumerate(elist) if item==1]
                         macayealflag[pos[pos1]]=1
@@ -233 +233 @@
                         nodeonmacayealstokes[md.mesh.elements[numpy.nonzero(macayealstokesflag),:].astype(int)-1]=1
 
-                elif numpy.any(stokesflag) and numpy.any(hutterflag):
+                elif any(stokesflag) and any(hutterflag):
                         raise TypeError("type of coupling not supported yet")
 
@@ -266 +266 @@
         pos=numpy.nonzero(nodeonstokes)
         md.flowequation.vertex_equation[pos]=4
-        if numpy.any(stokesflag):
+        if any(stokesflag):
                 pos=numpy.nonzero(numpy.logical_not(nodeonstokes))
-                if not (numpy.any(pattynflag) or numpy.any(macayealflag)):
+                if not (any(pattynflag) or any(macayealflag)):
                         md.flowequation.vertex_equation[pos]=0
         pos=numpy.nonzero(nodeonpattynstokes)
@@ -276 +276 @@
 
         #figure out solution types
-        md.flowequation.ishutter=float(numpy.any(md.flowequation.element_equation==1))
-        md.flowequation.ismacayealpattyn=float(numpy.any(numpy.logical_or(md.flowequation.element_equation==2,md.flowequation.element_equation==3)))
-        md.flowequation.isstokes=float(numpy.any(md.flowequation.element_equation==4))
+        md.flowequation.ishutter=float(any(md.flowequation.element_equation==1))
+        md.flowequation.ismacayealpattyn=float(any(numpy.logical_or(md.flowequation.element_equation==2,md.flowequation.element_equation==3)))
+        md.flowequation.isstokes=float(any(md.flowequation.element_equation==4))
 
         return md
 
         #Check that tiling can work:
-        if numpy.any(md.flowequation.bordermacayeal) and numpy.any(md.flowequation.borderpattyn) and numpy.any(md.flowequation.borderpattyn + md.flowequation.bordermacayeal !=1):
+        if any(md.flowequation.bordermacayeal) and any(md.flowequation.borderpattyn) and any(md.flowequation.borderpattyn + md.flowequation.bordermacayeal !=1):
                 raise TypeError("error coupling domain too irregular")
-        if numpy.any(md.flowequation.bordermacayeal) and numpy.any(md.flowequation.borderstokes) and numpy.any(md.flowequation.borderstokes + md.flowequation.bordermacayeal !=1):
+        if any(md.flowequation.bordermacayeal) and any(md.flowequation.borderstokes) and any(md.flowequation.borderstokes + md.flowequation.bordermacayeal !=1):
                 raise TypeError("error coupling domain too irregular")
-        if numpy.any(md.flowequation.borderstokes) and numpy.any(md.flowequation.borderpattyn) and numpy.any(md.flowequation.borderpattyn + md.flowequation.borderstokes !=1):
+        if any(md.flowequation.borderstokes) and any(md.flowequation.borderpattyn) and any(md.flowequation.borderpattyn + md.flowequation.borderstokes !=1):
                 raise TypeError("error coupling domain too irregular")