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") }