Use different mesh for disc without interaction domain

Signed-off-by: Christian Glusa <caglusa@sandia.gov>

Author: cgcgcg

base/PyNucleus_base/DenseLinearOperator_{SCALAR}.pxi

@@ -196,6 +196,30 @@ cdef class {SCALAR_label}Dense_VectorLinearOperator({SCALAR_label}VectorLinearOp
                     y[i, k] += self.data[i, j, k]*x[j]
         return 0
 
+    cdef INDEX_t matvecTrans(self,
+                             {SCALAR}_t[::1] x,
+                             {SCALAR}_t[:, ::1] y) except -1:
+        cdef:
+            INDEX_t i, j, k
+        for i in range(self.num_rows):
+            for k in range(self.vectorSize):
+                y[i, k] = 0.
+            for j in range(self.num_columns):
+                for k in range(self.vectorSize):
+                    y[i, k] += self.data[j, i, k]*x[j]
+        return 0
+
+    cdef INDEX_t matvecTrans_no_overwrite(self,
+                                          {SCALAR}_t[::1] x,
+                                          {SCALAR}_t[:, ::1] y) except -1:
+        cdef:
+            INDEX_t i, j, k
+        for i in range(self.num_rows):
+            for j in range(self.num_columns):
+                for k in range(self.vectorSize):
+                    y[i, k] += self.data[j, i, k]*x[j]
+        return 0
+
     def isSparse(self):
         return False
 

base/PyNucleus_base/utilsFem.py

@@ -1073,10 +1073,8 @@ def process(self, override={}):
         if params['test']:
             import psutil
             p = psutil.Process()
-            try:
+            if hasattr(p, 'cpu_affinity'):
                 p.cpu_affinity(list(range(psutil.cpu_count())))
-            except AttributeError:
-                pass
         self._timer = TimerManager(self.logger, comm=self.comm, memoryProfiling=params['showMemory'])
 
         for fun in self.processHook:
@@ -1450,12 +1448,12 @@ def __init__(self, name, params=[]):
             elif p == int:
                 fields.append('[+-]?[0-9]+')
             elif p == float:
-                fields.append('[+-]?[0-9]+\.[0-9]*')
+                fields.append(r'[+-]?[0-9]+\.[0-9]*')
             elif p == bool:
                 fields.append('True|False')
             else:
                 raise NotImplementedError()
-        self.regexp = re.compile(name+'\(?'+','.join(['\s*(' + f + ')\s*' for f in fields])+'\)?')
+        self.regexp = re.compile(name+r'\(?'+','.join([r'\s*(' + f + r')\s*' for f in fields])+r'\)?')
 
     def match(self, s):
         return self.regexp.match(s) is not None
@@ -1516,6 +1514,8 @@ def __call__(self):
                             needToBuild = True
                         else:
                             dependencyLogger.log(self.logLevel, 'Values for {} are identical: \'{}\' == \'{}\''.format(prop, oldValue, newValue))
+                    elif newValue is None and oldValue is None:
+                        dependencyLogger.log(self.logLevel, 'Values for {} are identical: \'{}\' == \'{}\''.format(prop, oldValue, newValue))
                     elif newValue != oldValue:
                         cached_args[prop] = newValue
                         dependencyLogger.log(self.logLevel, 'Values for {} differ: \'{}\' != \'{}\', calling \'{}\''.format(prop, oldValue,

drivers/testDistOp.py

@@ -69,13 +69,13 @@
                                       h=h)
     elif nPP.domain == 'disc':
         if d.horizonToMeshSize <= 0. or nPP.kernel.horizon.value == np.inf:
-            h = 0.04/2**(nPP.noRef-3)
+            h = 0.04/2**(nPP.noRef-4)
         else:
             h = nPP.kernel.horizon.value/d.horizonToMeshSize/np.sqrt(2)
         mesh, _ = nonlocalMeshFactory(nPP.domain,
                                       kernel=nPP.kernel,
                                       boundaryCondition=HOMOGENEOUS_DIRICHLET,
-                                      h=h,
+                                      hTarget=h,
                                       max_volume=h**2/2,
                                       projectNodeToOrigin=False)
     elif d.domain == 'gradedDisc':

fem/PyNucleus_fem/factories.py

@@ -145,7 +145,7 @@ def __call__(self, mesh, *args, **kwargs):
 
 # meshes
 from . mesh import (simpleInterval, simpleSquare, simpleLshape, simpleBox, box,
-                    circle, graded_circle, cutoutCircle, twinDisc, dumbbell, wrench,
+                    uniform_disc, circle, graded_circle, cutoutCircle, twinDisc, dumbbell, wrench,
                     Hshape, ball, rectangle, crossSquare,
                     gradedSquare, gradedBox,
                     squareWithCircularCutout, boxWithBallCutout,
@@ -178,6 +178,7 @@ def __call__(self, mesh, *args, **kwargs):
 meshFactory.register('squareWithInteraction', squareWithInteractions, 2)
 meshFactory.register('simpleLshape', simpleLshape, 2, aliases=['Lshape', 'L-shape'])
 meshFactory.register('circle', circle, 2, aliases=['disc', 'unitDisc', 'ball2d', '2dball'])
+meshFactory.register('uniform_disc', uniform_disc, 2, aliases=['uniform_ball2d', '2dball_uniform'])
 meshFactory.register('graded_circle', graded_circle, 2, aliases=['gradedCircle'])
 meshFactory.register('discWithInteraction', discWithInteraction, 2)
 meshFactory.register('twinDisc', twinDisc, 2)

fem/PyNucleus_fem/mesh.py

@@ -720,10 +720,7 @@ def discWithInteraction(radius, horizon, h=0.25, max_volume=None, projectNodeToO
                                      innerRadius=radius,
                                      max_volume=max_volume)
     else:
-        return circle(n,
-                      radius=radius,
-                      max_volume=max_volume,
-                      projectNodeToOrigin=projectNodeToOrigin)
+        return uniform_disc(radius=radius)
 
 
 def gradedDiscWithInteraction(radius, horizon, mu=2., h=0.25, max_volume=None, projectNodeToOrigin=True):
@@ -946,6 +943,23 @@ def Lshape(d):
     return mesh2d(vertices, cells)
 
 
+def uniform_disc(radius=1., **kwargs):
+    points = [(0., 0.)]
+    cells = []
+    n = 6
+    for i in range(n):
+        points.append((radius*np.cos(i*2*np.pi/n), radius*np.sin(i*2*np.pi/n)))
+    for i in range(1, len(points)-1):
+        cells.append((0, i, i+1))
+    cells.append((0, len(points)-1, 1))
+
+    mesh = mesh2d(np.array(points, dtype=REAL),
+                  np.array(cells, dtype=INDEX))
+    from . meshCy import radialMeshTransformer
+    mesh.setMeshTransformation(radialMeshTransformer())
+    return mesh
+
+
 def circle(n, radius=1., returnFacets=False, projectNodeToOrigin=True, **kwargs):
     from meshpy.triangle import MeshInfo, build
     mesh_info = MeshInfo()

nl/PyNucleus_nl/clusterMethodCy.pyx

@@ -1193,7 +1193,7 @@ cdef class tree_node:
                 for i in range(self.coefficientsDownVec.shape[0]):
                     for l in range(self.coefficientsDownVec.shape[1]):
                         y[dof, l] += self.value[componentNo, k, i]*self.coefficientsDownVec[i, l]
-            k += 1
+                k += 1
         else:
             for c in self.children:
                 for i in range(c.transferOperator.shape[0]):

tests/cache_runFractional.py--domaindisc--sconst(0.25)--problemconstant--elementP0--solvercg-mg--matrixFormatH2

@@ -1,13 +1,13 @@
 Timers: {}
 errors:
-  Hs error: 0.13400055486309811
-  L2 error: 0.0530257052232404
-  L2 error interpolated: 0.017212921206495174
-  Linf error interpolated: 0.04041162523460817
-  relative Hs error: 0.09110983276196648
-  relative L2 error: 0.04257104506006856
-  relative interpolated L2 error: 0.013812422648097445
-  relative interpolated Linf error: 0.0469573643243436
+  Hs error: 0.13190712640577038
+  L2 error: 0.05014710987068258
+  L2 error interpolated: 0.01711413239312614
+  Linf error interpolated: 0.042577264837976025
+  relative Hs error: 0.08968646614351379
+  relative L2 error: 0.04025999965392971
+  relative interpolated L2 error: 0.013732997326192832
+  relative interpolated Linf error: 0.04947323085350075
 meshes: {}
 results: {}
 sysInfo: {}

tests/cache_runFractional.py--domaindisc--sconst(0.25)--problemconstant--elementP0--solvercg-mg--matrixFormatdense

@@ -1,13 +1,13 @@
 Timers: {}
 errors:
-  Hs error: 0.1413324571924916
-  L2 error: 0.05318118990883034
-  L2 error interpolated: 0.017767471098211238
-  Linf error interpolated: 0.0402337391432151
-  relative Hs error: 0.0960949493963012
-  relative L2 error: 0.042695874056279615
-  relative interpolated L2 error: 0.014257418438872843
-  relative interpolated Linf error: 0.046750664842368186
+  Hs error: 0.1403179566911808
+  L2 error: 0.050326820499312745
+  L2 error interpolated: 0.01771990305453638
+  Linf error interpolated: 0.042613546494036036
+  relative Hs error: 0.09540516888676681
+  relative L2 error: 0.0404042781550261
+  relative interpolated L2 error: 0.014219089561682037
+  relative interpolated Linf error: 0.04951538881627348
 meshes: {}
 results: {}
 sysInfo: {}

tests/cache_runFractional.py--domaindisc--sconst(0.25)--problemconstant--elementP1--solvercg-mg--matrixFormatH2

@@ -1,13 +1,13 @@
 Timers: {}
 errors:
-  Hs error: 0.180573736324132
-  L2 error: 0.05758412182442717
-  L2 error interpolated: 0.017270441090162007
-  Linf error interpolated: 0.08537962523475567
-  relative Hs error: 0.12277593129747377
-  relative L2 error: 0.04623071460552205
-  relative interpolated L2 error: 0.013926906465042695
-  relative interpolated Linf error: 0.09919993999254309
+  Hs error: 0.18185981625380002
+  L2 error: 0.05782159835474865
+  L2 error interpolated: 0.017338240822480377
+  Linf error interpolated: 0.08846749274971044
+  relative Hs error: 0.12365036444762217
+  relative L2 error: 0.04642136976098792
+  relative interpolated L2 error: 0.013982271432707184
+  relative interpolated Linf error: 0.1027876375415333
 meshes: {}
 results: {}
 sysInfo: {}

tests/cache_runFractional.py--domaindisc--sconst(0.25)--problemconstant--elementP1--solvercg-mg--matrixFormatdense

@@ -1,13 +1,13 @@
 Timers: {}
 errors:
-  Hs error: 0.18352538491659642
-  L2 error: 0.05767242742488538
-  L2 error interpolated: 0.01741375173232188
-  Linf error interpolated: 0.08492371703495766
-  relative Hs error: 0.12478282007421258
-  relative L2 error: 0.04630160968707422
-  relative interpolated L2 error: 0.014042472355826032
-  relative interpolated Linf error: 0.09867023438728048
+  Hs error: 0.1839933908571473
+  L2 error: 0.057885119791182965
+  L2 error interpolated: 0.017437708550776834
+  Linf error interpolated: 0.08802653240222696
+  relative Hs error: 0.12510102728625555
+  relative L2 error: 0.046472367176700564
+  relative interpolated L2 error: 0.014062486305142948
+  relative interpolated Linf error: 0.10227529938252666
 meshes: {}
 results: {}
 sysInfo: {}