def generateBricks(self, a, b, c): brickX = Brick(self.longEdge, 5, 5, l0=self.longEdge, l1=5, l2=5, d0=self.numRanks, diracPoints=[(a, b, c)], diracTags=["test"]) brickY = Brick(5, self.longEdge, 5, l0=5, l1=self.longEdge, l2=self.shortEdge, d1=self.numRanks, diracPoints=[(c, a, b)], diracTags=["test"]) brickZ = Brick(5, 5, self.longEdge, l0=5, l1=5, l2=self.longEdge, d2=self.numRanks, diracPoints=[(b, c, a)], diracTags=["test"]) dims = [[self.longEdge, 5, 5], [5, self.longEdge, 5], [5, 5, self.longEdge]] return [brickX, brickY, brickZ], dims
def test_CartesianTransformation3D(self): dom=Brick(NE,NE,NE, l0=10, l1=10, l2=10) cs=CartesianReferenceSystem() tf=cs.createTransformation(dom) self.assertEqual(tf.getReferenceSystem(),cs , "wrong reference") self.assertEqual(tf.getDomain(),dom , "wrong reference") self.assertTrue(tf.isCartesian(), "wrong isCartesian check") v=tf.getVolumeFactor() self.assertTrue(isinstance(v, esys.escript.Data), "wrong volume factor type") self.assertEqual(v.getFunctionSpace(), esys.escript.Function(dom), "wrong volume factor type") error=Lsup(v-1.) self.assertTrue(error<=RTOL, "volume factor") s=tf.getScalingFactors() self.assertTrue(isinstance(s, esys.escript.Data), "scaling factor type") self.assertEqual(s.getShape(), (dom.getDim(),), "scaling factor length") self.assertEqual(s.getFunctionSpace(), esys.escript.Function(dom), "wrong 0-th scaling factor type") error=Lsup(s[0]-1.) self.assertTrue(error<=RTOL, "0-th scaling factor") error=Lsup(s[1]-1.) self.assertTrue(error<=RTOL, "1-th scaling factor") error=Lsup(s[2]-1.) self.assertTrue(error<=RTOL, "2-th scaling factor")
def setUp(self): self.domain = Brick(self.NEX, self.NEX, self.NEZ, l0=self.xdim, l1=self.ydim, l2=self.zdim)
def setUp(self): self.domain = Brick(l0=1., l1=1., l2=1., n0=10, n1=10 * getMPISizeWorld() - 1, n2=10, d1=getMPISizeWorld())
def setUp(self): self.domain = Brick(n0=self.NEx, n1=self.NEy, n2=self.NEz, l0=self.Lx, l1=self.Ly, l2=self.Lz, diracPoints=[self.POS_node, self.NEG_node], diracTags=['e0', 'e1'])
def setUp(self): self.domain = Brick(n0=NE0 * NXb - 1, n1=NE1 * NYb - 1, n2=NE2 * NZb - 1, d0=NXb, d1=NYb, d2=NZb) self.package = SolverOptions.MKL self.method = SolverOptions.DIRECT
def setUp(self): self.domain = Brick(10, 10, 10, l0=100., l1=100., l2=100., diracTags=["source"], diracPoints=[(0, 0, 0)]) self.wavelet = Ricker(100.)
def setUp(self): self.domain = Brick(n0=NE0 * NXb - 1, n1=NE1 * NYb - 1, n2=NE2 * NZb - 1, d0=NXb, d1=NYb, d2=NZb) self.package = SolverOptions.TRILINOS self.method = SolverOptions.PCG self.preconditioner = SolverOptions.ILUT
def __createDomain(self): """ Creates and returns an escript domain that spans the entire area of available data plus a padding zone. This method is called only once the first time `getDomain()` is invoked. :return: The escript domain :rtype: `esys.escript.Domain` """ X0, NX, DX = self.__getTotalExtentsWithPadding() # number of domain elements NE = NX + [self._v_num_cells] # origin of domain origin = X0 + [-self._v_depth * self.__v_scale] if self.getReferenceSystem().isCartesian(): # rounding will give us about meter-accuracy with UTM coordinates self._dom_origin = [np.floor(oi) for oi in origin] else: # this should give us about meter-accuracy with lat/lon coords self._dom_origin = [1e-5 * np.floor(oi * 1e5) for oi in origin] # cell size / point spacing spacing = DX + [ self.__v_scale * np.floor( (self._v_depth + self._v_air_layer) / self._v_num_cells) ] #self._spacing = [float(np.floor(si)) for si in spacing] self._spacing = spacing lo = [(self._dom_origin[i], self._dom_origin[i] + NE[i] * self._spacing[i]) for i in range(self.__dim)] if self.__dim == 3: dom = Brick(*NE, l0=lo[0], l1=lo[1], l2=lo[2]) else: dom = Rectangle(*NE, l0=lo[0], l1=lo[1]) # ripley may internally adjust NE and length, so recompute self._dom_len = [ esu.sup(dom.getX()[i]) - esu.inf(dom.getX()[i]) for i in range(self.__dim) ] self._dom_NE = [ int(self._dom_len[i] / self._spacing[i]) for i in range(self.__dim) ] self.logger.debug("Domain size: " + str(self._dom_NE)) self.logger.debug(" length: " + str(self._dom_len)) self.logger.debug(" origin: " + str(self._dom_origin)) return dom
def setUp(self): self.order = 1 self.domain = Brick(n0=NE * NXb - 1, n1=NE * NYb - 1, n2=NE * NZb - 1, l0=1., l1=1., l2=1., d0=NXb, d1=NYb, d2=NZb)
def test_FillBrick(self): # If we are going to do really big tests of this, the size of this brick will need to be reduced fs = ContinuousFunction(Brick(10 * mpiSize, 10 * mpiSize, 10 * mpiSize)) RandomData((), fs, 2, ("gaussian", 1, 0.5)) RandomData((), fs, 0, ("gaussian", 2, 0.76)) self.assertRaises(NotImplementedError, RandomData, (2, 2), fs, 0, ("gaussian", 2, 0.76)) #data not scalar self.assertRaises(ValueError, RandomData, (), fs, 0, ("gaussian", 20, 0.1)) #radius too large RandomData((2, 3), fs)
def test_Creation(self): r = self.numRanks el = self.numRanks * 3 - 1 #test bad types with self.assertRaises(TypeError): Rectangle(5, el, d1=r, diracPoints=(.0, 0.), diracTags=["test"]) with self.assertRaises(TypeError): Rectangle(5, el, d1=r, diracPoints=[(.0, 0.)], diracTags=("test")) with self.assertRaises(TypeError): Rectangle(5, el, d1=r, diracPoints=[.0], diracTags=["test"]) with self.assertRaises(TypeError): Rectangle(5, el, d1=r, diracPoints=[.0, .0], diracTags=["test"]) with self.assertRaises(TypeError): Brick(5, el, 5, d1=r, diracPoints=(.0, 0., 0.), diracTags=["test"]) with self.assertRaises(TypeError): Brick(5, el, 5, d1=r, diracPoints=[(.0, 0., 0.)], diracTags=("test")) with self.assertRaises(TypeError): Brick(5, el, 5, d1=r, diracPoints=[.0, 0.], diracTags=["test"]) #test bad arg lengths with self.assertRaises(RuntimeError): Rectangle(5, el, d1=r, diracPoints=[(.0, )], diracTags=["test"]) with self.assertRaises(RuntimeError): Rectangle(5, el, d1=r, diracPoints=[(.0, 1.)], diracTags=[]) with self.assertRaises(RuntimeError): Rectangle(5, el, d1=r, diracPoints=[(.0, 0.)], diracTags=["test", "break"]) with self.assertRaises(RuntimeError): Rectangle(5, el, d1=r, diracPoints=[(.0, 0., 0.)], diracTags=["test"]) with self.assertRaises(RuntimeError): Brick(5, el, 5, d1=r, diracPoints=[(.0, 0., 0., 0.)], diracTags=["test"]) with self.assertRaises(RuntimeError): Brick(5, el, 5, d1=r, diracPoints=[( .0, 0., )], diracTags=["test"]) with self.assertRaises(RuntimeError): Brick(5, el, 5, d1=r, diracPoints=[(.0, )], diracTags=["test"])
def setUp(self): self.domain = Brick(n0=NE * NXb - 1, n1=NE * NYb - 1, n2=NE * NZb - 1, l0=1., l1=1., l2=1., d0=NXb, d1=NYb, d2=NZb) self.functionspaces = [ ContinuousFunction(self.domain), Function(self.domain), ReducedFunction(self.domain), FunctionOnBoundary(self.domain), ReducedFunctionOnBoundary(self.domain) ]
def setUp(self): for x in [(int(mpiSize**(1 / 3.)), int(mpiSize**(1 / 3.))), (2, 3), (2, 2), (1, 2), (1, 1)]: NX = x[0] NY = x[1] NZ = mpiSize // (x[0] * x[1]) if NX * NY * NZ == mpiSize: break self.domain = Brick(n0=NE * NX - 1, n1=NE * NY - 1, n2=NE * NZ - 1, l0=1., l1=1., l2=1., d0=NX, d1=NY, d2=NZ) self.order = 1
def setUp(self): self.domain = Brick(n0=NE * NXb - 1, n1=NE * NYb - 1, n2=NE * NZb - 1, l0=1., l1=1., l2=1., d0=NXb, d1=NYb, d2=NZb) self.functionspaces = [ ContinuousFunction(self.domain), Function(self.domain), ReducedFunction(self.domain), FunctionOnBoundary(self.domain), ReducedFunctionOnBoundary(self.domain) ] #We aren't testing DiracDeltaFunctions self.xn = 5 # number of grids on x axis self.yn = 5 # number of grids on y axis self.zn = 5
def test_SphericalTransformation3D(self): dom=Brick(NE,NE,NE, l0=90, l1=45, l2=10.) cs=SphericalReferenceSystem() tf=cs.createTransformation(dom) self.assertEqual(tf.getReferenceSystem(),cs , "wrong reference") self.assertEqual(tf.getDomain(),dom , "wrong reference") self.assertFalse(tf.isCartesian(), "wrong isCartesian check") R=6378137.0 x=esys.escript.Function(dom).getX() phi=(90.-x[1])/180.*pi lam=x[0]/180.*pi h=x[2]*1000. r=h+R v=tf.getVolumeFactor() self.assertTrue(isinstance(v, esys.escript.Data), "wrong volume factor type") self.assertEqual(v.getFunctionSpace(), esys.escript.Function(dom), "wrong volume factor type") error=Lsup(v- r**2*sin(phi)*(pi/180.)**2*1000. ) self.assertTrue(error<=RTOL * R*R*(pi/180.)**2*1000., "volume factor") s=tf.getScalingFactors() self.assertTrue(isinstance(s, esys.escript.Data), "scaling factor type") self.assertEqual(s.getShape(), (dom.getDim(),), "scaling factor length") self.assertEqual(s.getFunctionSpace(), esys.escript.Function(dom), "wrong 0-th scaling factor type") error=Lsup(s[1]-1/r/pi*180.) self.assertTrue(error<=RTOL/R/pi*180., "0-th scaling factor") error=Lsup(s[0]-1/(r*sin(phi))/pi*180.) self.assertTrue(error<=RTOL/R/pi*180., "1-th scaling factor") error=Lsup(s[2]-1./1000.) self.assertTrue(error<=RTOL/1000., "2-th scaling factor")
if __name__ == "__main__": try: from esys.ripley import Brick HAVE_RIPLEY = True except ImportError: HAVE_RIPLEY = False print("Ripley module not available") if HAVE_RIPLEY: from esys.escript import * from esys.escript.linearPDEs import Poisson from esys.weipa import saveSilo, saveVoxet import tempfile dom = Brick(l0=1., l1=1., n0=9, n1=9, n2=9) x = dom.getX() gammaD = whereZero(x[0]) + whereZero(x[1]) pde = Poisson(dom) q = gammaD pde.setValue(f=1, q=q) u = pde.getSolution() u = interpolate(u + dom.getX()[2], ReducedFunction(dom)) print(u) handle, filename = tempfile.mkstemp(suffix='.vo', prefix='poisson') saveVoxet(filename, u=u) print("-------") dom = Brick(l0=1., l1=1., l2=4., n0=18, n1=18, n2=36) v = readVoxet(dom, filename, 'u', fillValue=0.5) print(v) os.remove(filename)
def setUp(self): Stations = [ (0.,0.,0.), (1.,0,0.), (0,1,0.), (1,1,0.) ] StationsTags = ["A1", "A2", "A3", "A4" ] self.domain=Brick(n0=5,n1=5,n2=5,diracPoints=Stations,diracTags=StationsTags)
def setUp(self): self.domain = Brick(10, 10, 10)
def setUp(self): self.domain = Brick(n0=NE0*NXb-1, n1=NE1*NYb-1, n2=NE2*NZb-1, d0=NXb, d1=NYb, d2=NZb) self.package = SolverOptions.PASO self.method = SolverOptions.BICGSTAB self.preconditioner = SolverOptions.JACOBI
rg.append((mid_point, receiver_line[iy])) # # create domain: # if DIM == 2: domain = Rectangle(ne_x, ne_z, l0=width_x, l1=depth, diracPoints=src_locations, diracTags=src_tags) else: domain = Brick(ne_x, ne_x, ne_z, l0=width_x, l1=width_y, l2=depth, diracPoints=src_locations, diracTags=src_tags) wl = Ricker(frq, tcenter) #====================================================================== z = Function(domain).getX()[DIM - 1] z_bottom = 0 v_p = 0 delta = 0 vareps = 0 azmth = 0 rho = 0 for l in range(len(layers)): m = wherePositive(z -