In [1]:
import gstlearn as gl
In [2]:
db = gl.DbGrid.create([50, 50], [2, 2])
mesh = gl.MeshETurbo([100, 100])
proj = gl.ProjMatrix.create(db, mesh)
In [3]:
A = gl.TestInheritance()
A.setIproj(proj)
In [4]:
class SpecializedProj(gl.IProj):
    def __init__(self, n):
        super(SpecializedProj, self).__init__()
        self.n = n

    def mesh2point(self, inv, outv):
        for i in range(inv.size):
            outv[i] = inv[i]

    def point2mesh(self, outv, inv):
        for i in range(inv.size):
            outv[i] = inv[i]

    def getNApex(self):
        return self.n

    def getNPoint(self):
        return self.n
In [5]:
newproj = SpecializedProj(12)
In [6]:
A.setIproj(newproj)
In [7]:
A.display()

Number of Apices: 12
Number of Points: 12

Inheritance of an ICloneable class.¶

Add a clone method as follows:

In [8]:
import numpy as np


class MyCov(gl.ACov):
    def __init__(self, range):
        super(MyCov, self).__init__()
        self.range = np.copy(range)
        # space is needed to compute the distance in _eval
        self.space = gl.getDefaultSpace()

    # Specify the number of variables
    def getNVar(self):
        return 1

    # clone method
    def clone(self):
        return MyCov(self.range).__disown__()

    # _eval method (which is pure virtual in ACov)
    def _eval(self, p1, p2, ivar, jvar, mode):
        dist = self.space.getDistance(p1, p2)
        return np.exp(-dist / self.range)
In [9]:
cov = MyCov(0.2)
p1 = gl.SpacePoint([1.0, 1.0])
p2 = gl.SpacePoint([0.95, 0.95])

print(cov.isNoStat())
cov.evalCov(p1, p2)

False
Out[9]:
0.7021885013265594
In [10]:
db = gl.Db.createFillRandom(5, 2, 1)
grid = gl.DbGrid.create([100, 100], [0.01, 0.01])

model = gl.ModelGeneric()
model.setCov(cov)

modelgst = gl.Model.createFromParam(
    gl.ECov.EXPONENTIAL, range=cov.range, flagRange=False
)

neigh = gl.NeighUnique()
In [11]:
gl.OptCustom.define(
    "NotOptimSimpleCase", 1
)  # Multithread version doesn't seem possible yet from custom covariances from outside.
gl.kriging(db, grid, model, neigh)
gl.OptCustom.define("NotOptimSimpleCase", 0)
gl.kriging(db, grid, modelgst, neigh)
Out[11]:
0

Comparison of kriging with custom class and gstlearn class

In [12]:
print(np.round(np.max(np.abs(grid["*estim"] - grid["*estim.1"])), 5))

0.0