func Test_fun12(tst *testing.T) {
//verbose()
chk.PrintTitle("fun12. mul")
cos, err := New("cos", []*Prm{
&Prm{N: "a", V: 1},
&Prm{N: "b/pi", V: 2},
&Prm{N: "c", V: 1},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
lin, err := New("lin", []*Prm{
&Prm{N: "m", V: 0.5},
&Prm{N: "ts", V: 0},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
mul, err := New("mul", []*Prm{
&Prm{N: "fa", Fcn: cos},
&Prm{N: "fb", Fcn: lin},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := 0.0
tmax := 1.0
xcte := []float64{0, 0, 0}
//if true {
if false {
withG, withH, save, show := true, true, false, true
plt.Reset()
PlotT(cos, "/tmp/gosl", "fun-cos-12.png", tmin, tmax, xcte, 41, "", withG, withH, save, show, nil)
plt.Reset()
PlotT(lin, "/tmp/gosl", "fun-lin-12.png", tmin, tmax, xcte, 41, "", withG, withH, save, show, nil)
plt.Reset()
PlotT(mul, "/tmp/gosl", "fun-mul-12.png", tmin, tmax, xcte, 41, "", withG, withH, save, show, nil)
}
sktol := 1e-10
dtol := 1e-9
dtol2 := 1e-8
ver := chk.Verbose
tskip := []float64{tmin, tmax}
CheckDerivT(tst, cos, tmin, tmax, xcte, 11, nil, sktol, dtol, dtol2, ver)
io.Pf("\n")
CheckDerivT(tst, lin, tmin, tmax, xcte, 11, tskip, sktol, dtol, dtol2, ver)
io.Pf("\n")
CheckDerivT(tst, mul, tmin, tmax, xcte, 11, tskip, sktol, dtol, dtol2, ver)
}
func Test_fun03(tst *testing.T) {
//verbose()
chk.PrintTitle("fun03. add, cte, srmps")
cte, err := New("cte", []*Prm{&Prm{N: "C", V: 30}})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
srmps, err := New("srmps", []*Prm{
&Prm{N: "ca", V: 0},
&Prm{N: "cb", V: 1},
&Prm{N: "ta", V: 0},
&Prm{N: "tb", V: 1},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
add, err := New("add", []*Prm{
&Prm{N: "a", V: 1},
&Prm{N: "b", V: 1},
&Prm{N: "fa", Fcn: cte},
&Prm{N: "fb", Fcn: srmps},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := 0.0
tmax := 1.0
xcte := []float64{0, 0, 0}
if false {
withG, withH, save, show := true, true, false, true
plt.Reset()
PlotT(cte, "/tmp/gosl", "fun-cte-01.png", tmin, tmax, xcte, 41, "", withG, withH, save, show, nil)
plt.Reset()
PlotT(srmps, "/tmp/gosl", "fun-srmps-01.png", tmin, tmax, xcte, 41, "", withG, withH, save, show, nil)
plt.Reset()
PlotT(add, "/tmp/gosl", "fun-add-01.png", tmin, tmax, xcte, 41, "", withG, withH, save, show, nil)
}
sktol := 1e-10
dtol := 1e-10
dtol2 := 1e-9
ver := chk.Verbose
tskip := []float64{tmin, tmax}
CheckDerivT(tst, cte, tmin, tmax, xcte, 11, nil, sktol, dtol, dtol2, ver)
io.Pf("\n")
CheckDerivT(tst, srmps, tmin, tmax, xcte, 11, tskip, sktol, dtol, dtol2, ver)
io.Pf("\n")
CheckDerivT(tst, add, tmin, tmax, xcte, 11, tskip, sktol, dtol, dtol2, ver)
}
// PlotTwoNurbs plots two NURBS for comparison
func PlotTwoNurbs(dirout, fn string, b, c *Nurbs, npts int, ids bool, extra func()) {
plt.Reset()
if io.FnExt(fn) == ".eps" {
plt.SetForEps(1.5, 500)
} else {
plt.SetForPng(1.5, 500, 150)
}
plt.Subplot(3, 1, 1)
b.DrawCtrl2d(ids, "", "")
b.DrawElems2d(npts, ids, "", "")
if extra != nil {
extra()
}
plt.Equal()
plt.Subplot(3, 1, 2)
c.DrawCtrl2d(ids, "", "")
c.DrawElems2d(npts, ids, "", "")
plt.Equal()
plt.Subplot(3, 1, 3)
b.DrawElems2d(npts, ids, ", lw=3", "")
c.DrawElems2d(npts, ids, ", color='red', marker='+', markevery=10", "color='green', size=7, va='bottom'")
plt.Equal()
plt.SaveD(dirout, fn)
}
// PlotAll plot all functions
func (o FuncsData) PlotAll(pd *PlotFdata, dirout, fnkey string) {
ext := "png"
if pd.Eps {
ext = "eps"
}
fn := io.Sf("functions-%s.%s", fnkey, ext)
plt.Reset()
for k, f := range o {
if utl.StrIndexSmall(pd.Skip, f.Name) >= 0 {
continue
}
save := (k == len(o)-1)
args := io.Sf("label='%s', clip_on=0", f.Name)
ff := o.Get(f.Name)
if ff != nil {
if pd.WithTxt {
x := pd.Ti
y := ff.F(x, nil)
plt.Text(x, y, io.Sf("%g", y), "fontsize=8")
x = pd.Tf
y = ff.F(x, nil)
plt.Text(x, y, io.Sf("%g", y), "fontsize=8, ha='right'")
}
fun.PlotT(ff, dirout, fn, pd.Ti, pd.Tf, nil, pd.Np, args, pd.WithG, pd.WithH, save, false, nil)
}
}
}
func Test_fun11(tst *testing.T) {
//verbose()
chk.PrintTitle("fun11. ref-inc-rl1")
fun, err := New("ref-inc-rl1", []*Prm{
&Prm{N: "lam0", V: 0.001},
&Prm{N: "lam1", V: 1.2},
&Prm{N: "alp", V: 0.01},
&Prm{N: "bet", V: 10},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := 0.0
tmax := 1.0
xcte := []float64{0, 0, 0}
if false {
plt.Reset()
withG, withH, save, show := true, true, false, true
PlotT(fun, "/tmp/gosl", "fun-ref-inc-rl1-01.png", tmin, tmax, xcte, 41, "'.-'", withG, withH, save, show, nil)
}
sktol := 1e-10
dtol := 1e-10
dtol2 := 1e-10
ver := chk.Verbose
CheckDerivT(tst, fun, tmin, tmax, xcte, 11, nil, sktol, dtol, dtol2, ver)
}
func Test_fun10(tst *testing.T) {
//verbose()
chk.PrintTitle("fun10. rmp")
fun, err := New("rmp", []*Prm{
&Prm{N: "ta", V: 1},
&Prm{N: "tb", V: 2},
&Prm{N: "ca", V: 0.5},
&Prm{N: "cb", V: -1.5},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := 0.0
tmax := 3.0
xcte := []float64{0, 0, 0}
if false {
plt.Reset()
withG, withH, save, show := true, true, false, true
PlotT(fun, "/tmp/gosl", "fun-rmp-01.png", tmin, tmax, xcte, 4, "'.-'", withG, withH, save, show, nil)
}
sktol := 1e-10
dtol := 1e-12
dtol2 := 1e-17
ver := chk.Verbose
CheckDerivT(tst, fun, tmin, tmax, xcte, 11, nil, sktol, dtol, dtol2, ver)
}
func Test_fun09(tst *testing.T) {
//verbose()
chk.PrintTitle("fun09. cos")
fun, err := New("cos", []*Prm{
&Prm{N: "a", V: 10},
&Prm{N: "b", V: math.Pi},
&Prm{N: "c", V: 1.0},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := 0.0
tmax := 2.0
xcte := []float64{0, 0, 0}
if false {
plt.Reset()
withG, withH, save, show := true, true, false, true
PlotT(fun, "/tmp/gosl", "fun-cos-01.png", tmin, tmax, xcte, 41, "'.-'", withG, withH, save, show, nil)
}
sktol := 1e-10
dtol := 1e-8
dtol2 := 1e-7
ver := chk.Verbose
CheckDerivT(tst, fun, tmin, tmax, xcte, 11, nil, sktol, dtol, dtol2, ver)
}
func Test_fun13(tst *testing.T) {
//verbose()
chk.PrintTitle("fun13. mul")
pulse, err := New("pulse", []*Prm{
&Prm{N: "ca", V: 0.2},
&Prm{N: "cb", V: 2.0},
&Prm{N: "ta", V: 1.0},
&Prm{N: "tb", V: 2.5},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := 0.0
tmax := 5.0
xcte := []float64{0, 0, 0}
//if true {
if false {
withG, withH, save, show := true, true, false, true
plt.Reset()
PlotT(pulse, "/tmp/gosl", "fun-pulse-13.png", tmin, tmax, xcte, 61, "", withG, withH, save, show, nil)
}
sktol := 1e-17
dtol := 1e-10
dtol2 := 1e-10
ver := chk.Verbose
tskip := []float64{1, 4}
CheckDerivT(tst, pulse, tmin, tmax, xcte, 11, tskip, sktol, dtol, dtol2, ver)
}
func Test_fun06c(tst *testing.T) {
//verbose()
chk.PrintTitle("fun06c. pts")
fun, err := New("pts", []*Prm{
// T = 0 0.05 0.1 0.2 0.3 0.5 0.75 1
&Prm{N: "y=dt", Extra: "0.05 0.05 0.1 0.1 0.2 0.25 0.25 0"},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := 0.0
tmax := 1.0
xcte := []float64{0, 0, 0}
//if true {
if false {
plt.Reset()
withG, withH, save, show := true, true, true, false
PlotT(fun, "/tmp/gosl", "fun-ptsC-01.png", tmin, tmax, xcte, 8, "'o-', clip_on=0", withG, withH, save, show, nil)
}
tmin = 0.01
tmax = 0.99
sktol := 1e-10
dtol := 1e-10
dtol2 := 1e-10
ver := chk.Verbose
CheckDerivT(tst, fun, tmin, tmax, xcte, 10, nil, sktol, dtol, dtol2, ver)
}
func Test_fun08(tst *testing.T) {
//verbose()
chk.PrintTitle("fun08. exc2")
fun, err := New("exc2", []*Prm{
&Prm{N: "ta", V: 5},
&Prm{N: "A", V: 3},
&Prm{N: "b", V: 0.2},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := 0.0
tmax := 7.0
xcte := []float64{0, 0, 0}
if false {
plt.Reset()
withG, withH, save, show := true, true, false, true
PlotT(fun, "/tmp/gosl", "fun-exc2-01.png", tmin, tmax, xcte, 41, "'o-'", withG, withH, save, show, nil)
}
sktol := 1e-10
dtol := 1e-10
dtol2 := 1e-10
ver := chk.Verbose
CheckDerivT(tst, fun, tmin, tmax, xcte, 11, nil, sktol, dtol, dtol2, ver)
}
func Test_fun04(tst *testing.T) {
//verbose()
chk.PrintTitle("fun04. lin")
lin, err := New("lin", []*Prm{
&Prm{N: "m", V: 0.5},
&Prm{N: "ts", V: 0},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := 0.0
tmax := 1.0
xcte := []float64{0, 0, 0}
if false {
plt.Reset()
withG, withH, save, show := true, true, false, true
PlotT(lin, "/tmp/gosl", "fun-lin-01.png", tmin, tmax, xcte, 11, "", withG, withH, save, show, nil)
}
sktol := 1e-10
dtol := 1e-10
dtol2 := 1e-10
ver := chk.Verbose
CheckDerivT(tst, lin, tmin, tmax, xcte, 11, nil, sktol, dtol, dtol2, ver)
}
func Test_bc01(tst *testing.T) {
doplot := false
//doplot := true
chk.PrintTitle("bc01")
mdl := GetModel("testsim", "mat1", "bc", false)
mdl.Init(mdl.GetPrms(true))
pc0 := -1.0
sl0 := 1.0
pcf := 3.0
nptsA := 11
nptsB := 11
if doplot {
plt.Reset()
Plot(mdl, pc0, sl0, pcf, nptsA, "'b.-'", "'r+-'", "bc")
}
tolCc := 1e-11
tolD1a, tolD1b := 1e-10, 1e-17
tolD2a, tolD2b := 1e-10, 1e-17
Check(tst, mdl, pc0, sl0, pcf, nptsB, tolCc, tolD1a, tolD1b, tolD2a, tolD2b, chk.Verbose, []float64{0.2}, 1e-7, doplot)
if doplot {
PlotEnd(true)
}
}
// PlotTwoVarsContour plots contour for two variables problem. len(x) == 2
// Input
// dirout -- directory to save files
// fnkey -- file name key for eps figure
// x -- solution. can be <nil>
// np -- number of points for contour
// extra -- called just before saving figure
// axequal -- axis.equal
// vmin -- min 0 values
// vmax -- max 1 values
// f -- function to plot filled contour. can be <nil>
// gs -- functions to plot contour @ level 0. can be <nil>
func PlotTwoVarsContour(dirout, fnkey string, x []float64, np int, extra func(), axequal bool,
vmin, vmax []float64, f TwoVarsFunc_t, gs ...TwoVarsFunc_t) {
if fnkey == "" {
return
}
chk.IntAssert(len(vmin), 2)
chk.IntAssert(len(vmax), 2)
V0, V1 := utl.MeshGrid2D(vmin[0], vmax[0], vmin[1], vmax[1], np, np)
var Zf [][]float64
var Zg [][][]float64
if f != nil {
Zf = la.MatAlloc(np, np)
}
if len(gs) > 0 {
Zg = utl.Deep3alloc(len(gs), np, np)
}
xtmp := make([]float64, 2)
for i := 0; i < np; i++ {
for j := 0; j < np; j++ {
xtmp[0], xtmp[1] = V0[i][j], V1[i][j]
if f != nil {
Zf[i][j] = f(xtmp)
}
for k, g := range gs {
Zg[k][i][j] = g(xtmp)
}
}
}
plt.Reset()
plt.SetForEps(0.8, 350)
if f != nil {
cmapidx := 0
plt.Contour(V0, V1, Zf, io.Sf("fsz=7, cmapidx=%d", cmapidx))
}
for k, _ := range gs {
plt.ContourSimple(V0, V1, Zg[k], false, 8, "zorder=5, levels=[0], colors=['yellow'], linewidths=[2], clip_on=0")
}
if x != nil {
plt.PlotOne(x[0], x[1], "'r*', label='optimum', zorder=10")
}
if extra != nil {
extra()
}
if dirout == "" {
dirout = "."
}
plt.Cross("clr='grey'")
plt.SetXnticks(11)
plt.SetYnticks(11)
if axequal {
plt.Equal()
}
plt.AxisRange(vmin[0], vmax[0], vmin[1], vmax[1])
args := "leg_out='1', leg_ncol=4, leg_hlen=1.5"
plt.Gll("$x_0$", "$x_1$", args)
plt.SaveD(dirout, fnkey+".eps")
}
func Test_invs05(tst *testing.T) {
//verbose()
chk.PrintTitle("invs05")
if SAVEPLOT {
plt.Reset()
plt.SetForPng(1, 500, 125)
PlotRosette(1.1, true, true, true, 7)
}
addtoplot := func(σa, σb float64, σ []float64) {
plt.PlotOne(σa, σb, "'ro', ms=5")
plt.Text(σa, σb, io.Sf("$\\sigma_{123}=(%g,%g,%g)$", σ[0], σ[1], σ[2]), "size=8")
}
dotest := func(σ []float64, σacor, σbcor, σccor, θcor, tolσ float64) {
w := M_w(σ)
θ2 := math.Asin(w) * 180.0 / (3.0 * math.Pi)
θ3 := M_θ(σ)
σa, σb, σc := L2O(σ[0], σ[1], σ[2])
σ0, σ1, σ2 := O2L(σa, σb, σc)
σI, σA := make([]float64, 3), []float64{σa, σb, σc}
la.MatVecMul(σI, 1, O2Lmat(), σA) // σI := L * σA
io.Pf("σa σb σc = %v %v %v\n", σa, σb, σc)
io.Pf("w = %v\n", w)
io.Pf("θ2, θ3 = %v, %v\n", θ2, θ3)
chk.Scalar(tst, "σa", 1e-17, σa, σacor)
chk.Scalar(tst, "σb", 1e-17, σb, σbcor)
chk.Scalar(tst, "σc", 1e-17, σc, σccor)
chk.Scalar(tst, "σ0", tolσ, σ0, σ[0])
chk.Scalar(tst, "σ1", tolσ, σ1, σ[1])
chk.Scalar(tst, "σ2", tolσ, σ2, σ[2])
chk.Scalar(tst, "σI0", tolσ, σI[0], σ[0])
chk.Scalar(tst, "σI1", tolσ, σI[1], σ[1])
chk.Scalar(tst, "σI2", tolσ, σI[2], σ[2])
chk.Scalar(tst, "θ2", 1e-6, θ2, θcor)
chk.Scalar(tst, "θ3", 1e-17, θ3, θ2)
addtoplot(σa, σb, σ)
}
dotest([]float64{-1, 0, 0, 0}, 0, 2.0/SQ6, 1.0/SQ3, 30, 1e-15)
dotest([]float64{0, -1, 0, 0}, 1.0/SQ2, -1.0/SQ6, 1.0/SQ3, 30, 1e-15)
dotest([]float64{0, 0, -1, 0}, -1.0/SQ2, -1.0/SQ6, 1.0/SQ3, 30, 1e-15)
if SAVEPLOT {
plt.Gll("$\\sigma_a$", "$\\sigma_b$", "")
plt.Equal()
plt.SaveD("/tmp/gosl", "fig_invs05.png")
}
}
// PlotNurbsBasis plots basis functions la and lb
func PlotNurbsBasis(dirout, fn string, b *Nurbs, la, lb int) {
npts := 41
plt.Reset()
if io.FnExt(fn) == ".eps" {
plt.SetForEps(1.5, 500)
} else {
plt.SetForPng(1.5, 600, 150)
}
plt.Subplot(3, 2, 1)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
t0 := time.Now()
b.PlotBasis(la, "", 11, 0) // 0 => CalcBasis
io.Pfcyan("time elapsed (calcbasis) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(3, 2, 2)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
b.PlotBasis(lb, "", 11, 0) // 0 => CalcBasis
plt.Equal()
plt.Subplot(3, 2, 3)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
b.PlotBasis(la, "", 11, 1) // 1 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(3, 2, 4)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
b.PlotBasis(lb, "", 11, 1) // 1 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(3, 2, 5)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
t0 = time.Now()
b.PlotBasis(la, "", 11, 2) // 2 => RecursiveBasis
io.Pfcyan("time elapsed (recursive) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(3, 2, 6)
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
b.PlotBasis(lb, "", 11, 2) // 2 => RecursiveBasis
plt.Equal()
plt.SaveD(dirout, fn)
}
// PlotNurbs plots a NURBS
func PlotNurbs(dirout, fn string, b *Nurbs, npts int, ids bool, extra func()) {
plt.Reset()
if io.FnExt(fn) == ".eps" {
plt.SetForEps(1.0, 500)
} else {
plt.SetForPng(1.0, 500, 150)
}
b.DrawCtrl2d(ids, "", "")
b.DrawElems2d(npts, ids, "", "")
if extra != nil {
extra()
}
plt.Equal()
plt.SaveD(dirout, fn)
}
// PlotNurbsDerivs plots derivatives of basis functions la and lb
func PlotNurbsDerivs(dirout, fn string, b *Nurbs, la, lb int) {
npts := 41
plt.Reset()
if io.FnExt(fn) == ".eps" {
plt.SetForEps(1.5, 500)
} else {
plt.SetForPng(1.5, 600, 150)
}
plt.Subplot(4, 2, 1)
t0 := time.Now()
b.PlotDeriv(la, 0, "", npts, 0) // 0 => CalcBasisAndDerivs
io.Pfcyan("time elapsed (calcbasis) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(4, 2, 2)
t0 = time.Now()
b.PlotDeriv(la, 0, "", npts, 1) // 1 => NumericalDeriv
io.Pfcyan("time elapsed (numerical) = %v\n", time.Now().Sub(t0))
plt.Equal()
plt.Subplot(4, 2, 3)
b.PlotDeriv(la, 1, "", npts, 0) // 0 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(4, 2, 4)
b.PlotDeriv(la, 1, "", npts, 1) // 0 => NumericalDeriv
plt.Equal()
plt.Subplot(4, 2, 5)
b.PlotDeriv(lb, 0, "", npts, 0) // 0 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(4, 2, 6)
b.PlotDeriv(lb, 0, "", npts, 1) // 0 => NumericalDeriv
plt.Equal()
plt.Subplot(4, 2, 7)
b.PlotDeriv(lb, 1, "", npts, 0) // 0 => CalcBasisAndDerivs
plt.Equal()
plt.Subplot(4, 2, 8)
b.PlotDeriv(lb, 1, "", npts, 1) // 0 => NumericalDeriv
plt.Equal()
plt.SaveD(dirout, fn)
}
// SetFig sets figure space for plotting
// Note: this method is optional
func (o *Plotter) SetFig(split, epsfig bool, prop, width float64, savedir, savefnk string) {
plt.Reset()
if o.PngRes < 150 {
o.PngRes = 150
}
o.Split = split
o.UseEps = epsfig
if o.UseEps {
plt.SetForEps(prop, width)
} else {
plt.SetForPng(prop, width, o.PngRes)
}
o.SaveDir = savedir
o.SaveFnk = io.FnKey(savefnk)
o.maxR = -1
// colors and markers
o.set_default_clr_mrk()
}
func Test_refm1a(tst *testing.T) {
doplot := false
//doplot := true
chk.PrintTitle("refm1a")
mdl := GetModel("testsim", "mat1", "ref-m1", false)
mdl.Init(mdl.GetPrms(true))
pc0 := -5.0
sl0 := 1.0
pcf := 20.0
nptsA := 41
nptsB := 11
if doplot {
plt.Reset()
Plot(mdl, pc0, sl0, pcf, nptsA, "'b.-'", "'r+-'", "ref-m1_drying")
}
tolCc := 1e-17
tolD1a, tolD1b := 1e-11, 1e-11
tolD2a, tolD2b := 1e-12, 1e-10
Check(tst, mdl, pc0, sl0, pcf, nptsB, tolCc, tolD1a, tolD1b, tolD2a, tolD2b, chk.Verbose, []float64{0}, 1e-7, doplot)
slf, err := Update(mdl, pc0, sl0, pcf-pc0)
if err != nil {
tst.Errorf("update failed: %v\n", err)
return
}
if doplot {
Plot(mdl, pcf, slf, pc0, nptsA, "'b*-'", "'r+:'", "ref-m1_wetting")
}
tolD1b = 1e-4
tolD2a, tolD2b = 1e-11, 1e-10
Check(tst, mdl, pcf, slf, pc0, nptsB, tolCc, tolD1a, tolD1b, tolD2a, tolD2b, chk.Verbose, []float64{0}, 1e-7, doplot)
if doplot {
PlotEnd(true)
}
}
func Test_vg01(tst *testing.T) {
doplot := false
//doplot := true
chk.PrintTitle("vg01")
mdl := GetModel("testsim", "mat1", "vg", false)
err := mdl.Init(mdl.GetPrms(true))
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
ref := GetModel("testsim", "mat1", "ref-m1", false)
err = ref.Init(ref.GetPrms(true))
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
pc0 := -5.0
sl0 := 1.0
pcf := 20.0
nptsA := 41
nptsB := 11
if doplot {
plt.Reset()
Plot(ref, pc0, sl0, pcf, nptsA, "'k--'", "'k--'", "ref-m1")
Plot(mdl, pc0, sl0, pcf, nptsA, "'b.-'", "'r+-'", "vg")
}
tolCc := 1e-10
tolD1a, tolD1b := 1e-10, 1e-17
tolD2a, tolD2b := 1e-10, 1e-17
Check(tst, mdl, pc0, sl0, pcf, nptsB, tolCc, tolD1a, tolD1b, tolD2a, tolD2b, chk.Verbose, []float64{}, 1e-7, doplot)
if doplot {
PlotEnd(true)
}
}
func Test_fun01(tst *testing.T) {
//verbose()
chk.PrintTitle("fun01. Decreasing Reference Model")
ya := 1.0
yb := -0.5
λ1 := 1.0
o, err := New("ref-dec-gen", []*Prm{
&Prm{N: "bet", V: 5.0},
&Prm{N: "a", V: -λ1},
&Prm{N: "b", V: -1.0},
&Prm{N: "c", V: ya},
&Prm{N: "A", V: 0.0},
&Prm{N: "B", V: λ1},
&Prm{N: "xini", V: 0.0},
&Prm{N: "yini", V: yb},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmax := 3.0
xcte := []float64{0, 0, 0}
if false {
plt.Reset()
withG, withH, save, show := true, true, false, true
PlotT(o, "/tmp/gosl", "ref-dec-gen-01.png", 0.0, tmax, xcte, 201, "", withG, withH, save, show, func() {
plt.Plot([]float64{0, tmax}, []float64{ya, ya - λ1*tmax}, "'k-'")
plt.Equal()
})
}
//
sktol := 1e-10
dtol := 1e-10
dtol2 := 1e-10
ver := chk.Verbose
CheckDerivT(tst, o, 0.0, tmax, xcte, 11, nil, sktol, dtol, dtol2, ver)
}
func Test_xfun02(tst *testing.T) {
//verbose()
chk.PrintTitle("xfun02. 2D circle distance")
xc := []float64{0.5, 0.5}
o, err := New("cdist", []*Prm{
&Prm{N: "r", V: 0.5},
&Prm{N: "xc", V: xc[0]},
&Prm{N: "yc", V: xc[1]},
})
if err != nil {
tst.Errorf("test failed: %v\n")
return
}
tcte := 0.0
xmin := []float64{-1, -1}
xmax := []float64{2, 2}
np := 21
if false {
//if true {
withGrad := false
hlZero := true
axEqual := true
save := true
show := false
plt.Reset()
PlotX(o, "/tmp/gosl", "xfun02.png", tcte, xmin, xmax, np, "", withGrad, hlZero, axEqual, save, show, func() {
plt.Equal()
})
}
np = 5
sktol := 1e-10
xskip := [][]float64{xc}
dtol := 1e-10
ver := chk.Verbose
CheckDerivX(tst, o, tcte, xmin, xmax, np, xskip, sktol, dtol, ver)
}
func Test_xfun03(tst *testing.T) {
//verbose()
chk.PrintTitle("xfun03. xpoly2: 2nd order polynomial with x coordinates")
o, err := New("xpoly2", []*Prm{
&Prm{N: "a0", V: 1.5}, &Prm{N: "a1", V: 0.5}, &Prm{N: "a2", V: -1.5},
&Prm{N: "b0", V: -1.5}, &Prm{N: "b1", V: -0.5}, &Prm{N: "b2", V: 1.5},
&Prm{N: "c01", V: 2.0}, &Prm{N: "c12", V: -2.0}, &Prm{N: "c20", V: 1.0},
//&Prm{N: "2D", V: 1},
})
if err != nil {
tst.Errorf("test failed: %v\n")
return
}
tcte := 0.0
xmin := []float64{-1, -1, -1}
xmax := []float64{2, 2, 2}
np := 21
if chk.Verbose && len(xmin) == 2 {
withGrad := false
hlZero := true
axEqual := true
save := true
show := false
plt.Reset()
PlotX(o, "/tmp/gosl/fun", "xpoly2.png", tcte, xmin, xmax, np, "", withGrad, hlZero, axEqual, save, show, func() {
plt.Equal()
})
}
np = 3
sktol := 1e-10
xskip := [][]float64{}
dtol := 1e-10
ver := chk.Verbose
CheckDerivX(tst, o, tcte, xmin, xmax, np, xskip, sktol, dtol, ver)
}
func plot_conv_curve(fnk string, skip int, resid *utl.DblSlist) {
R := resid.Vals
P := resid.Ptrs
plt.Reset()
plt.SetForEps(0.75, 250)
for i := 0; i < len(P)-1; i++ {
if i >= skip {
n := P[i+1] - P[i]
x := make([]float64, n)
y := make([]float64, n)
k := 0
for j := P[i]; j < P[i+1]; j++ {
x[k] = float64(k)
y[k] = math.Log10(R[j])
k += 1
}
plt.Plot(x, y, "")
}
}
plt.Gll("iteration index", "$\\mathrm{log_{10}}(R)$", "")
plt.SaveD("/tmp", "gofem_residplot_"+fnk+"_curves.eps")
}
func Test_fun02(tst *testing.T) {
//verbose()
chk.PrintTitle("fun02. Dec Ref Model (specialised)")
ya := 1.0
yb := -50.0
λ1 := 1.0
o, err := New("ref-dec-sp1", []*Prm{
&Prm{N: "bet", V: 5.0},
&Prm{N: "lam1", V: λ1},
&Prm{N: "ya", V: ya},
&Prm{N: "yb", V: yb},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := 0.0
tmax := 300.0
//tmax := 140.0
xcte := []float64{0, 0, 0}
if false {
plt.Reset()
withG, withH, save, show := true, true, false, true
PlotT(o, "/tmp/gosl", "ref-dec-sp1-01.png", tmin, tmax, xcte, 201, "lw=2,color='orange'", withG, withH, save, show, func() {
plt.Plot([]float64{0, tmax}, []float64{ya, ya - λ1*tmax}, "'k--'")
plt.Equal()
})
}
sktol := 1e-10
dtol := 1e-10
dtol2 := 1e-10
ver := chk.Verbose
CheckDerivT(tst, o, tmin, tmax, xcte, 11, nil, sktol, dtol, dtol2, ver)
}
func Test_xfun01(tst *testing.T) {
//verbose()
chk.PrintTitle("xfun01. 2D halo => circle")
o, err := New("halo", []*Prm{
&Prm{N: "r", V: 0.5},
&Prm{N: "xc", V: 0.5},
&Prm{N: "yc", V: 0.5},
})
if err != nil {
tst.Errorf("test failed: %v\n")
return
}
tcte := 0.0
xmin := []float64{-1, -1}
xmax := []float64{2, 2}
np := 21
if chk.Verbose {
withGrad := true
hlZero := true
axEqual := true
save := true
show := false
plt.Reset()
PlotX(o, "/tmp/gosl/fun", "halo.png", tcte, xmin, xmax, np, "", withGrad, hlZero, axEqual, save, show, func() {
plt.Equal()
})
}
np = 4
sktol := 1e-10
dtol := 1e-10
ver := chk.Verbose
CheckDerivX(tst, o, tcte, xmin, xmax, np, nil, sktol, dtol, ver)
}
func Test_fun06a(tst *testing.T) {
//verbose()
chk.PrintTitle("fun06a. pts")
fun, err := New("pts", []*Prm{
&Prm{N: "t", V: 0.00}, {N: "y", V: 0.50},
&Prm{N: "t", V: 1.00}, {N: "y", V: 0.20},
&Prm{N: "t", V: 2.00}, {N: "y", V: 0.20},
&Prm{N: "t", V: 3.00}, {N: "y", V: 0.05},
&Prm{N: "t", V: 4.00}, {N: "y", V: 0.01},
&Prm{N: "t", V: 5.00}, {N: "y", V: 0.00},
})
if err != nil {
tst.Errorf("test failed: %v\n", err)
return
}
tmin := -1.0
tmax := 6.0
xcte := []float64{0, 0, 0}
//if true {
if false {
plt.Reset()
withG, withH, save, show := true, true, true, false
PlotT(fun, "/tmp/gosl", "fun-ptsA-01.png", tmin, tmax, xcte, 8, "'o-', clip_on=0", withG, withH, save, show, nil)
}
tmin = 0.01
tmax = 4.99
sktol := 1e-10
dtol := 1e-10
dtol2 := 1e-10
ver := chk.Verbose
CheckDerivT(tst, fun, tmin, tmax, xcte, 11, nil, sktol, dtol, dtol2, ver)
}
func main() {
// input data file
inpfn := "data/loccmdrv1.inp"
flag.Parse()
if len(flag.Args()) > 0 {
inpfn = flag.Arg(0)
}
if io.FnExt(inpfn) == "" {
inpfn += ".inp"
}
// read and parse input data
var in Input
b, err := io.ReadFile(inpfn)
if err != nil {
io.PfRed("cannot read %s\n", inpfn)
return
}
err = json.Unmarshal(b, &in)
if err != nil {
io.PfRed("cannot parse %s\n", inpfn)
return
}
in.PostProcess()
// print input data
io.Pf("%v\n", in)
// load simulation
sim := inp.ReadSim(in.Dir, in.SimFn, "cmd_", false)
if sim == nil {
io.PfRed("cannot load simulation\n")
return
}
// get material data
mat := sim.Mdb.Get(in.MatName)
if mat == nil {
io.PfRed("cannot get material\n")
return
}
//io.Pfcyan("mat = %v\n", mat)
// get and initialise model
mdl, _ := msolid.GetModel(in.SimFn, in.MatName, mat.Model, false)
if mdl == nil {
io.PfRed("cannot allocate model\n")
return
}
ndim := 3
pstress := false
mdl.Init(ndim, pstress, mat.Prms)
//io.Pforan("mdl = %v\n", mdl)
// load path
var pth msolid.Path
err = pth.ReadJson(ndim, path.Join(in.Dir, in.PathFn))
if err != nil {
io.PfRed("cannot read path file %v\n", err)
return
}
//io.PfYel("pth = %v\n", pth)
// driver
var drv msolid.Driver
drv.InitWithModel(ndim, mdl)
// run
err = drv.Run(&pth)
if err != nil {
io.Pfred("driver: Run failed: %v\n", err)
}
// plot
//if false {
if true {
var plr msolid.Plotter
plr.SetFig(false, in.FigEps, in.FigProp, in.FigWid, "/tmp", "cmd_"+in.SimFn)
var epm msolid.EPmodel
if m, ok := mdl.(msolid.EPmodel); ok {
plr.SetModel(m)
epm = m
}
if epm != nil {
//plr.Phi = epm.Get_phi()
b := epm.Get_bsmp()
epm.Set_bsmp(0)
plr.YsClr0 = "magenta"
plr.Plot(in.PlotSet, drv.Res, nil, true, false)
epm.Set_bsmp(b)
}
plr.YsClr0 = "green"
plr.Plot(in.PlotSet, drv.Res, drv.Eps, false, true)
}
// plot ys
if false {
//if true {
plt.Reset()
m := mdl.(*msolid.SmpInvs)
φ := m.Get_phi()
σcCte := 10.0
M := tsr.Phi2M(φ, "oct")
rmin, rmax := 0.0, 1.28*M*σcCte
nr, nα := 31, 81
//nr, nα := 31, 1001
npolarc := true
simplec := false
only0 := false
grads := false
showpts := false
ferr := 10.0
tsr.PlotOct("fig_isofun02.png", σcCte, rmin, rmax, nr, nα, φ, m.Isof.Fa, m.Isof.Ga,
npolarc, simplec, only0, grads, showpts, true, true, ferr)
}
}
// Plot plots contour
func (o *SimpleFltProb) Plot(fnkey string) {
// check
if !o.C.DoPlot {
return
}
// limits and meshgrid
xmin, xmax := o.C.RangeFlt[0][0], o.C.RangeFlt[0][1]
ymin, ymax := o.C.RangeFlt[1][0], o.C.RangeFlt[1][1]
// auxiliary variables
X, Y := utl.MeshGrid2D(xmin, xmax, ymin, ymax, o.PltNpts, o.PltNpts)
Zf := utl.DblsAlloc(o.PltNpts, o.PltNpts)
var Zg [][][]float64
var Zh [][][]float64
if o.ng > 0 {
Zg = utl.Deep3alloc(o.ng, o.PltNpts, o.PltNpts)
}
if o.nh > 0 {
Zh = utl.Deep3alloc(o.nh, o.PltNpts, o.PltNpts)
}
// compute values
x := make([]float64, 2)
for i := 0; i < o.PltNpts; i++ {
for j := 0; j < o.PltNpts; j++ {
x[0], x[1] = X[i][j], Y[i][j]
o.Fcn(o.ff[0], o.gg[0], o.hh[0], x)
Zf[i][j] = o.ff[0][o.PltIdxF]
for k, g := range o.gg[0] {
Zg[k][i][j] = g
}
for k, h := range o.hh[0] {
Zh[k][i][j] = h
}
}
}
// prepare plot area
plt.Reset()
plt.SetForEps(0.8, 350)
// plot f
if o.PltArgs != "" {
o.PltArgs = "," + o.PltArgs
}
if o.PltCsimple {
plt.ContourSimple(X, Y, Zf, true, 7, "colors=['k'], fsz=7"+o.PltArgs)
} else {
plt.Contour(X, Y, Zf, io.Sf("fsz=7, cmapidx=%d"+o.PltArgs, o.PltCmapIdx))
}
// plot g
clr := "yellow"
if o.PltCsimple {
clr = "blue"
}
for _, g := range Zg {
plt.ContourSimple(X, Y, g, false, 7, io.Sf("zorder=5, levels=[0], colors=['%s'], linewidths=[%g], clip_on=0", clr, o.PltLwg))
}
// plot h
clr = "yellow"
if o.PltCsimple {
clr = "blue"
}
for _, h := range Zh {
plt.ContourSimple(X, Y, h, false, 7, io.Sf("zorder=5, levels=[0], colors=['%s'], linewidths=[%g], clip_on=0", clr, o.PltLwh))
}
// initial populations
l := "initial population"
for _, pop := range o.PopsIni {
for _, ind := range pop {
x := ind.GetFloats()
plt.PlotOne(x[0], x[1], io.Sf("'k.', zorder=20, clip_on=0, label='%s'", l))
l = ""
}
}
// final populations
l = "final population"
for _, pop := range o.PopsBest {
for _, ind := range pop {
x := ind.GetFloats()
plt.PlotOne(x[0], x[1], io.Sf("'ko', ms=6, zorder=30, clip_on=0, label='%s', markerfacecolor='none'", l))
l = ""
}
}
// extra
if o.PltExtra != nil {
o.PltExtra()
}
// best result
if o.Nfeasible > 0 {
x, _, _, _ := o.find_best()
plt.PlotOne(x[0], x[1], "'m*', zorder=50, clip_on=0, label='best', markeredgecolor='m'")
}
// save figure
plt.Cross("clr='grey'")
if o.PltAxEqual {
plt.Equal()
}
plt.AxisRange(xmin, xmax, ymin, ymax)
plt.Gll("$x_0$", "$x_1$", "leg_out=1, leg_ncol=4, leg_hlen=1.5")
plt.SaveD(o.PltDirout, fnkey+".eps")
}
func main() {
// input data
simfnA := "o2elastCO"
skip := 0
simfnB := ""
labelA := ""
labelB := ""
flag.Parse()
if len(flag.Args()) > 0 {
simfnA = flag.Arg(0)
}
if len(flag.Args()) > 1 {
skip = io.Atoi(flag.Arg(1))
}
if len(flag.Args()) > 2 {
simfnB = flag.Arg(2)
}
if len(flag.Args()) > 3 {
labelA = flag.Arg(3)
}
if len(flag.Args()) > 4 {
labelB = flag.Arg(4)
}
// print input data
io.Pf("\nInput data\n")
io.Pf("==========\n")
io.Pf(" simfnA = %30s // simulation filename\n", simfnA)
io.Pf(" skip = %30d // number of initial increments to skip\n", skip)
io.Pf(" simfnB = %30s // simulation filename for comparison\n", simfnB)
io.Pf(" labelA = %30s // label for histogram\n", labelA)
io.Pf(" labelB = %30s // label for histogram\n", labelB)
io.Pf("\n")
// read residuals
residA, fnkA := read_summary(simfnA)
residB, fnkB := read_summary(simfnB)
// residuals: it => residuals
io.Pf("\nResiduals A\n")
io.Pf("============\n")
residA.Print("%10.2e")
if simfnB != "" {
io.Pf("\nResiduals B\n")
io.Pf("============\n")
residB.Print("%10.2e")
}
io.Pf("\n")
// plot convergence curves
plot_conv_curve(fnkA, skip, residA)
if simfnB != "" {
plot_conv_curve(fnkB, skip, residB)
}
// plot histogram
io.Pf("\n")
X := [][]float64{count_iters(residA)}
labels := []string{fnkA}
if labelA != "" {
labels[0] = labelA
}
if simfnB != "" {
X = append(X, count_iters(residB))
labels = append(labels, fnkB)
if labelB != "" {
labels[1] = labelB
}
}
plt.Reset()
plt.SetForEps(0.75, 300)
plt.Hist(X, labels, "")
plt.Gll("number of iterations", "counts", "")
plt.SaveD("/tmp", "gofem_residplot_"+fnkA+"_"+fnkB+"_hist.eps")
}
