// Plot plots retention model // args1 -- arguments for model computed by solving differential equation; e.g. "'b*-'" // if args1 == "", plot is skiped // args2 -- arguments for model computed by directly calling sl(pc), if available // if args2 == "", plot is skiped func Plot(mdl Model, pc0, sl0, pcf float64, npts int, args1, args2, label string) (err error) { // plot using Update Pc := utl.LinSpace(pc0, pcf, npts) Sl := make([]float64, npts) if args1 != "" { Sl[0] = sl0 for i := 1; i < npts; i++ { Sl[i], err = Update(mdl, Pc[i-1], Sl[i-1], Pc[i]-Pc[i-1]) if err != nil { return } } plt.Plot(Pc, Sl, io.Sf("%s, label='%s', clip_on=0", args1, label)) } // plot using Sl function if args2 != "" { if m, ok := mdl.(Nonrate); ok { Pc = utl.LinSpace(pc0, pcf, 101) Sl = make([]float64, 101) for i, pc := range Pc { Sl[i] = m.Sl(pc) } plt.Plot(Pc, Sl, io.Sf("%s, label='%s_direct', clip_on=0", args2, label)) } } return }
func Test_functions03(tst *testing.T) { //verbose() chk.PrintTitle("functions03") eps := 1e-2 f := func(x float64) float64 { return Sabs(x, eps) } ff := func(x float64) float64 { return SabsD1(x, eps) } np := 401 //x := utl.LinSpace(-5e5, 5e5, np) //x := utl.LinSpace(-5e2, 5e2, np) x := utl.LinSpace(-5e1, 5e1, np) Y := make([]float64, np) y := make([]float64, np) g := make([]float64, np) h := make([]float64, np) tolg, tolh := 1e-6, 1e-5 with_err := false for i := 0; i < np; i++ { Y[i] = math.Abs(x[i]) y[i] = Sabs(x[i], eps) g[i] = SabsD1(x[i], eps) h[i] = SabsD2(x[i], eps) gnum := numderiv(f, x[i]) hnum := numderiv(ff, x[i]) errg := math.Abs(g[i] - gnum) errh := math.Abs(h[i] - hnum) clrg, clrh := "[1;32m", "[1;32m" if errg > tolg { clrg, with_err = "[1;31m", true } if errh > tolh { clrh, with_err = "[1;31m", true } io.Pf("errg = %s%23.15e errh = %s%23.15e[0m\n", clrg, errg, clrh, errh) } if with_err { chk.Panic("errors found") } if false { //if true { plt.Subplot(3, 1, 1) plt.Plot(x, y, "'k--', label='abs'") plt.Plot(x, y, "'b-', label='sabs'") plt.Gll("x", "y", "") plt.Subplot(3, 1, 2) plt.Plot(x, g, "'b-', label='sabs'") plt.Gll("x", "dy/dx", "") plt.Subplot(3, 1, 3) plt.Plot(x, h, "'b-', label='sabs'") plt.Gll("x", "d2y/dx2", "") plt.Show() } }
func (o *Plotter) Plot_i_f(x, y []float64, res []*State, sts [][]float64, last bool) { if o.m == nil { o.set_empty() return } nr := len(res) var y2 []float64 if o.nsurf > 1 { y2 = make([]float64, nr) } for i := 0; i < nr; i++ { ys := o.m.YieldFuncs(res[i]) y[i] = ys[0] if o.nsurf > 1 { y2[i] = ys[1] } x[i] = float64(i) } lbl := "f " + o.Lbl plt.Plot(x, y, io.Sf("'r.', ls='-', clip_on=0, color='%s', marker='%s', label=r'%s'", o.Clr, o.Mrk, lbl)) if o.nsurf > 1 { lbl = "F " + o.Lbl plt.Plot(x, y2, io.Sf("'b+', ls=':', lw=2, clip_on=0, color='%s', marker='%s', label=r'%s'", o.Clr, o.Mrk, lbl)) } if last { plt.Gll("$i$", "$f,\\;F$", "leg_out=1, leg_ncol=4, leg_hlen=2") if lims, ok := o.Lims["i,f"]; ok { plt.AxisLims(lims) } } }
func main() { // filename filename, fnkey := io.ArgToFilename(0, "sg111", ".sim", true) // fem if !fem.Start(filename, false, false, false) { io.PfRed("Start failed\n") return } dom, sum, ok := fem.AllocSetAndInit(0, true, true) if !ok { io.PfRed("AllocSetAndInit failed\n") return } // selected node and dof index nidx := 1 didx := 1 // gofem ntout := len(sum.OutTimes) uy := make([]float64, ntout) for tidx, _ := range sum.OutTimes { // read results from file if !dom.In(sum, tidx, true) { io.PfRed("plot_spo751: cannot read solution\n") return } // collect results for load versus time plot nod := dom.Nodes[nidx] eq := nod.Dofs[didx].Eq uy[tidx] = dom.Sol.Y[eq] // check if math.Abs(dom.Sol.T-sum.OutTimes[tidx]) > 1e-14 { io.PfRed("output times do not match time in solution array\n") return } } // plot fem results plt.SetForPng(0.8, 400, 200) plt.Plot(sum.OutTimes, uy, "'ro-', clip_on=0, label='gofem'") // analytical solution tAna := utl.LinSpace(0, 5, 101) uyAna := make([]float64, len(tAna)) for i, t := range tAna { uyAna[i] = solution_uy(t, 1.0) } plt.Plot(tAna, uyAna, "'g-', clip_on=0, label='analytical'") // save plt.Gll("$t$", "$u_y$", "") plt.SaveD("/tmp", fnkey+".png") }
func main() { // GA parameters C := goga.ReadConfParams("tsp-simple.json") rnd.Init(C.Seed) // location / coordinates of stations locations := [][]float64{ {60, 200}, {180, 200}, {80, 180}, {140, 180}, {20, 160}, {100, 160}, {200, 160}, {140, 140}, {40, 120}, {100, 120}, {180, 100}, {60, 80}, {120, 80}, {180, 60}, {20, 40}, {100, 40}, {200, 40}, {20, 20}, {60, 20}, {160, 20}, } nstations := len(locations) C.SetIntOrd(nstations) C.CalcDerived() // objective value function C.OvaOor = func(ind *goga.Individual, idIsland, time int, report *bytes.Buffer) { L := locations ids := ind.Ints dist := 0.0 for i := 1; i < nstations; i++ { a, b := ids[i-1], ids[i] dist += math.Sqrt(math.Pow(L[b][0]-L[a][0], 2.0) + math.Pow(L[b][1]-L[a][1], 2.0)) } a, b := ids[nstations-1], ids[0] dist += math.Sqrt(math.Pow(L[b][0]-L[a][0], 2.0) + math.Pow(L[b][1]-L[a][1], 2.0)) ind.Ovas[0] = dist return } // evolver nova, noor := 1, 0 evo := goga.NewEvolver(nova, noor, C) evo.Run() // results io.Pfgreen("best = %v\n", evo.Best.Ints) io.Pfgreen("best OVA = %v (871.117353844847)\n\n", evo.Best.Ovas[0]) // plot travelling salesman path if C.DoPlot { plt.SetForEps(1, 300) X, Y := make([]float64, nstations), make([]float64, nstations) for k, id := range evo.Best.Ints { X[k], Y[k] = locations[id][0], locations[id][1] plt.PlotOne(X[k], Y[k], "'r.', ms=5, clip_on=0, zorder=20") plt.Text(X[k], Y[k], io.Sf("%d", id), "fontsize=7, clip_on=0, zorder=30") } plt.Plot(X, Y, "'b-', clip_on=0, zorder=10") plt.Plot([]float64{X[0], X[nstations-1]}, []float64{Y[0], Y[nstations-1]}, "'b-', clip_on=0, zorder=10") plt.Equal() plt.AxisRange(10, 210, 10, 210) plt.Gll("$x$", "$y$", "") plt.SaveD("/tmp/goga", "test_evo04.eps") } }
// DrawCtrl2d draws control net func (o *Nurbs) DrawCtrl2d(ids bool, args, idargs string) { if len(idargs) == 0 { idargs = "color='r', size=7" } switch o.gnd { // curve case 1: xa := make([]float64, o.n[0]) ya := make([]float64, o.n[0]) j, k := 0, 0 for i := 0; i < o.n[0]; i++ { xa[i] = o.Q[i][j][k][0] / o.Q[i][j][k][3] ya[i] = o.Q[i][j][k][1] / o.Q[i][j][k][3] } plt.Plot(xa, ya, "'k.--', clip_on=0"+args) if ids { for i := 0; i < o.n[0]; i++ { x := o.Q[i][j][k][0] / o.Q[i][j][k][3] y := o.Q[i][j][k][1] / o.Q[i][j][k][3] plt.Text(x, y, io.Sf("%d", i), idargs) } } // surface case 2: xa := make([]float64, o.n[1]) ya := make([]float64, o.n[1]) k := 0 for i := 0; i < o.n[0]; i++ { for j := 0; j < o.n[1]; j++ { xa[j] = o.Q[i][j][k][0] / o.Q[i][j][k][3] ya[j] = o.Q[i][j][k][1] / o.Q[i][j][k][3] } plt.Plot(xa, ya, "'k.--', clip_on=0"+args) } xb := make([]float64, o.n[0]) yb := make([]float64, o.n[0]) for j := 0; j < o.n[1]; j++ { for i := 0; i < o.n[0]; i++ { xb[i] = o.Q[i][j][k][0] / o.Q[i][j][k][3] yb[i] = o.Q[i][j][k][1] / o.Q[i][j][k][3] } plt.Plot(xb, yb, "'k.--', clip_on=0"+args) } if ids { for i := 0; i < o.n[0]; i++ { for j := 0; j < o.n[1]; j++ { x := o.Q[i][j][k][0] / o.Q[i][j][k][3] y := o.Q[i][j][k][1] / o.Q[i][j][k][3] l := i + j*o.n[0] plt.Text(x, y, io.Sf("%d", l), idargs) } } } } }
func main() { // filename filename, fnkey := io.ArgToFilename(0, "rjoint01", ".sim", true) // fem if !fem.Start(filename, false, false, false) { io.PfRed("Start failed\n") return } dom, sum, ok := fem.AllocSetAndInit(0, true, true) if !ok { io.PfRed("AllocSetAndInit failed\n") return } // rjoint element eid := 2 ele := dom.Elems[eid].(*fem.Rjoint) ipd := ele.OutIpsData() // load results from file n := len(sum.OutTimes) mtau0 := make([]float64, n) mtau1 := make([]float64, n) mtau2 := make([]float64, n) ompb0 := make([]float64, n) ompb1 := make([]float64, n) ompb2 := make([]float64, n) for i, _ := range sum.OutTimes { if !dom.In(sum, i, true) { io.PfRed("cannot read solution\n") return } res0 := ipd[0].Calc(dom.Sol) res1 := ipd[1].Calc(dom.Sol) res2 := ipd[2].Calc(dom.Sol) mtau0[i] = -res0["tau"] mtau1[i] = -res1["tau"] mtau2[i] = -res2["tau"] ompb0[i] = res0["ompb"] ompb1[i] = res1["ompb"] ompb2[i] = res2["ompb"] } // plot plt.SetForPng(0.8, 400, 200) plt.Plot(ompb0, mtau0, "'r-', marker='.', label='p0', clip_on=0") plt.Plot(ompb1, mtau1, "'g-', marker='.', label='p1', clip_on=0") plt.Plot(ompb2, mtau2, "'b-', marker='.', label='p2', clip_on=0") plt.Gll("$\\bar{\\omega}_p$", "$-\\tau$", "") plt.SaveD("/tmp", fnkey+".png") }
// PlotStar plots star with normalised OVAs func (o *Optimiser) PlotStar() { nf := o.Nf dθ := 2.0 * math.Pi / float64(nf) θ0 := 0.0 if nf == 3 { θ0 = -math.Pi / 6.0 } for _, ρ := range []float64{0.25, 0.5, 0.75, 1.0} { plt.Circle(0, 0, ρ, "ec='gray',lw=0.5,zorder=5") } arrowM, textM := 1.1, 1.15 for i := 0; i < nf; i++ { θ := θ0 + float64(i)*dθ xi, yi := 0.0, 0.0 xf, yf := arrowM*math.Cos(θ), arrowM*math.Sin(θ) plt.Arrow(xi, yi, xf, yf, "sc=10,st='->',lw=0.7,zorder=10,clip_on=0") plt.PlotOne(xf, yf, "'k+', ms=0") xf, yf = textM*math.Cos(θ), textM*math.Sin(θ) plt.Text(xf, yf, io.Sf("%d", i), "size=6,zorder=10,clip_on=0") } X, Y := make([]float64, nf+1), make([]float64, nf+1) clr := false neg := false step := 1 count := 0 colors := []string{"m", "orange", "g", "r", "b", "k"} var ρ float64 for i, sol := range o.Solutions { if sol.Feasible() && sol.FrontId == 0 && i%step == 0 { for j := 0; j < nf; j++ { if neg { ρ = 1.0 - sol.Ova[j]/(o.RptFmax[j]-o.RptFmin[j]) } else { ρ = sol.Ova[j] / (o.RptFmax[j] - o.RptFmin[j]) } θ := θ0 + float64(j)*dθ X[j], Y[j] = ρ*math.Cos(θ), ρ*math.Sin(θ) } X[nf], Y[nf] = X[0], Y[0] if clr { j := count % len(colors) plt.Plot(X, Y, io.Sf("'k-',color='%s',markersize=3,clip_on=0", colors[j])) } else { plt.Plot(X, Y, "'r-',marker='.',markersize=3,clip_on=0") } count++ } } plt.Equal() plt.AxisOff() }
// Plot plot results func Plot(dirout, fn string, res *Results, yfcn Cb_ycorr, xa, xb float64, argsAna, argsNum string, extra func()) { // data if res == nil { return } ndim := len(res.Y) if ndim < 1 { return } // closed-form solution var xc []float64 var Yc [][]float64 if yfcn != nil { np := 101 dx := (xb - xa) / float64(np-1) xc = make([]float64, np) Yc = utl.DblsAlloc(np, ndim) for i := 0; i < np; i++ { xc[i] = xa + dx*float64(i) yfcn(Yc[i], xc[i]) } } // plot if argsAna == "" { argsAna = "'y-', lw=6, label='analytical', clip_on=0" } if argsNum == "" { argsNum = "'b-', marker='.', lw=1, clip_on=0" } for j := 0; j < ndim; j++ { plt.Subplot(ndim+1, 1, j+1) if yfcn != nil { plt.Plot(xc, Yc[j], argsAna) } plt.Plot(res.X, res.Y[j], argsNum+","+io.Sf("label='%s'", res.Method)) plt.Gll("$x$", "$y$", "") } plt.Subplot(ndim+1, 1, ndim+1) plt.Plot(res.X, res.Dx, io.Sf("'b-', marker='.', lw=1, clip_on=0, label='%s'", res.Method)) plt.SetYlog() plt.Gll("$x$", "$\\log(\\delta x)$", "") // write file if extra != nil { extra() } plt.SaveD(dirout, fn) }
// PlotT plots F, G and H for varying t and fixed coordinates x func PlotT(o Func, dirout, fname string, t0, tf float64, xcte []float64, np int, args string, withG, withH, save, show bool, extra func()) { t := utl.LinSpace(t0, tf, np) y := make([]float64, np) for i := 0; i < np; i++ { y[i] = o.F(t[i], xcte) } var g, h []float64 nrow := 1 if withG { g = make([]float64, np) for i := 0; i < np; i++ { g[i] = o.G(t[i], xcte) } nrow += 1 } if withH { h = make([]float64, np) for i := 0; i < np; i++ { h[i] = o.H(t[i], xcte) } nrow += 1 } os.MkdirAll(dirout, 0777) if withG || withH { plt.Subplot(nrow, 1, 1) } plt.Plot(t, y, args) if extra != nil { extra() } plt.Gll("t", "y", "") pidx := 2 if withG { plt.Subplot(nrow, 1, pidx) plt.Plot(t, g, args) plt.Gll("t", "dy/dt", "") pidx += 1 } if withH { plt.Subplot(nrow, 1, pidx) plt.Plot(t, h, args) plt.Gll("t", "d2y/dt2", "") } if save { plt.Save(dirout + "/" + fname) } if show { plt.Show() } }
func Test_Mw02(tst *testing.T) { //verbose() chk.PrintTitle("Mw02") prms := []string{"φ", "Mfix"} vals := []float64{32, 0} var o NcteM o.Init(prms, vals) if SAVE_FIG { // rosette full, ref := false, true r := 1.1 * SQ2 * o.M(1) / 3.0 PlotRosette(r, full, ref, true, 7) // NcteM npts := 201 X := make([]float64, npts) Y := make([]float64, npts) W := utl.LinSpace(-1, 1, npts) for i, w := range W { θ := math.Asin(w) / 3.0 r := SQ2 * o.M(w) / 3.0 X[i] = -r * math.Sin(math.Pi/6.0-θ) Y[i] = r * math.Cos(math.Pi/6.0-θ) //plt.Text(X[i], Y[i], io.Sf("$\\\\theta=%.2f$", θ*180.0/math.Pi), "size=8, ha='center', color='red'") //plt.Text(X[i], Y[i], io.Sf("$w=%.2f$", w), "size=8, ha='center', color='red'") } plt.Plot(X, Y, "'b-'") // MC g := func(θ float64) float64 { return SQ2 * o.Sinφ / (SQ3*math.Cos(θ) - o.Sinφ*math.Sin(θ)) } io.Pforan("M( 1) = %v\n", SQ2*o.M(1)/3.0) io.Pforan("g(30) = %v\n", g(math.Pi/6.0)) for i, w := range W { θ := math.Asin(w) / 3.0 r := g(θ) X[i] = -r * math.Sin(math.Pi/6.0-θ) Y[i] = r * math.Cos(math.Pi/6.0-θ) } plt.Plot(X, Y, "'k-'") // save plt.Equal() plt.SaveD("/tmp/gosl", "mw02.eps") } }
// PlotDerivs plots derivatives of basis functions in I // option = 0 : use CalcBasisAndDerivs // 1 : use NumericalDeriv func (o *Bspline) PlotDerivs(args string, npts, option int) { nmks := 10 tt := utl.LinSpace(o.tmin, o.tmax, npts) I := utl.IntRange(o.NumBasis()) f := make([]float64, len(tt)) lbls := []string{"N\\&dN", "numD"} var cmd string for _, i := range I { for j, t := range tt { switch option { case 0: o.CalcBasisAndDerivs(t) f[j] = o.GetDeriv(i) case 1: f[j] = o.NumericalDeriv(t, i) } } if strings.Contains(args, "marker") { cmd = io.Sf("label=r'%s:%d', color=GetClr(%d, 2) %s", lbls[option], i, i, args) } else { cmd = io.Sf("label=r'%s:%d', marker=(None if %d %%2 == 0 else GetMrk(%d/2,1)), markevery=(%d-1)/%d, clip_on=0, color=GetClr(%d, 2) %s", lbls[option], i, i, i, npts, nmks, i, args) } plt.Plot(tt, f, cmd) } plt.Gll("$t$", io.Sf(`$\frac{\mathrm{d}N_{i,%d}}{\mathrm{d}t}$`, o.p), io.Sf("leg=1, leg_out=1, leg_ncol=%d, leg_hlen=1.5, leg_fsz=7", o.NumBasis())) o.plt_ticks_spans() }
func (o *Plotter) Plot_Dgam_f(x, y []float64, res []*State, sts [][]float64, last bool) { if o.m == nil { o.set_empty() return } nr := len(res) k := nr - 1 ys := o.m.YieldFuncs(res[0]) fc0 := ys[0] xmi, xma, ymi, yma := res[0].Dgam, res[0].Dgam, fc0, fc0 for i := 0; i < nr; i++ { x[i] = res[i].Dgam ys = o.m.YieldFuncs(res[i]) y[i] = ys[0] xmi = min(xmi, x[i]) xma = max(xma, x[i]) ymi = min(ymi, y[i]) yma = max(yma, y[i]) } //o.DrawRamp(xmi, xma, ymi, yma) plt.Plot(x, y, io.Sf("'r.', ls='%s', clip_on=0, color='%s', marker='%s', label=r'%s'", o.Ls, o.Clr, o.Mrk, o.Lbl)) plt.PlotOne(x[0], y[0], io.Sf("'bo', clip_on=0, color='%s', marker='%s', ms=%d", o.SpClr, o.SpMrk, o.SpMs)) plt.PlotOne(x[k], y[k], io.Sf("'bs', clip_on=0, color='%s', marker='%s', ms=%d", o.SpClr, o.EpMrk, o.EpMs)) if last { plt.Gll("$\\Delta\\gamma$", "$f$", "") if lims, ok := o.Lims["Dgam,f"]; ok { plt.AxisLims(lims) } } }
// PlotFltOva plots flt-ova points func (o *Optimiser) PlotFltOva(sols0 []*Solution, iFlt, iOva int, ovaMult float64, pp *PlotParams) { if pp.YfuncX != nil { X := utl.LinSpace(o.FltMin[iFlt], o.FltMax[iFlt], pp.NptsYfX) Y := make([]float64, pp.NptsYfX) for i := 0; i < pp.NptsYfX; i++ { Y[i] = pp.YfuncX(X[i]) } plt.Plot(X, Y, pp.FmtYfX.GetArgs("")) } if sols0 != nil { o.PlotAddFltOva(iFlt, iOva, sols0, ovaMult, &pp.FmtSols0) } o.PlotAddFltOva(iFlt, iOva, o.Solutions, ovaMult, &pp.FmtSols) best, _ := GetBestFeasible(o, iOva) if best != nil { plt.PlotOne(best.Flt[iFlt], best.Ova[iOva]*ovaMult, pp.FmtBest.GetArgs("")) } if pp.Extra != nil { pp.Extra() } if pp.AxEqual { plt.Equal() } plt.Gll(io.Sf("$x_{%d}$", iFlt), io.Sf("$f_{%d}$", iOva), "leg_out=1, leg_ncol=4, leg_hlen=1.5") plt.SaveD(pp.DirOut, pp.FnKey+pp.FnExt) }
func main() { // filename filename, fnkey := io.ArgToFilename(0, "sg111", ".sim", true) // results out.Start(filename, 0, 0) out.Define("tip", out.N{1}) out.LoadResults(nil) // plot FEM results out.Plot("t", "uy", "tip", plt.Fmt{C: "r", Ls: "None", M: ".", L: "gofem"}, -1) // analytical solution tAna := utl.LinSpace(0, 5, 101) uyAna := make([]float64, len(tAna)) for i, t := range tAna { uyAna[i] = solution_uy(t, 1.0) } // save plt.SetForPng(0.8, 400, 200) out.Draw("/tmp", fnkey+".png", false, func(i, j, n int) { plt.Plot(tAna, uyAna, "'g-', clip_on=0, label='analytical'") }) }
func (o *Plotter) Plot_i_alp(x, y []float64, res []*State, sts [][]float64, last bool) { nr := len(res) nα := len(res[0].Alp) if nα == 0 { o.set_empty() return } yy := la.MatAlloc(nα, nr) for i := 0; i < nr; i++ { x[i] = float64(i) for j := 0; j < nα; j++ { yy[j][i] = res[i].Alp[j] } } for j := 0; j < nα; j++ { lbl := io.Sf("$\\alpha_%d$ "+o.Lbl, j) plt.Plot(x, yy[j], io.Sf("'r-', ls='-', clip_on=0, color='%s', marker='%s', label=r'%s'", o.Clr, o.Mrk, lbl)) } if last { plt.Gll("$i$", "$\\alpha_k$", "leg_out=1, leg_ncol=4, leg_hlen=2") if lims, ok := o.Lims["i,alp"]; ok { plt.AxisLims(lims) } } }
func (o *Plotter) Plot_ed_q(x, y []float64, res []*State, sts [][]float64, last bool) { nr := len(res) if len(sts) != nr { return } k := nr - 1 for i := 0; i < nr; i++ { x[i] = o.Ed[i] * 100.0 if o.QdivP { y[i] = o.Q[i] / o.P[i] } else { y[i] = o.Q[i] } if o.Multq { y[i] *= fun.Sign(o.W[i]) } } plt.Plot(x, y, io.Sf("'r.', ls='%s', clip_on=0, color='%s', marker='%s', label=r'%s'", o.Ls, o.Clr, o.Mrk, o.Lbl)) plt.PlotOne(x[0], y[0], io.Sf("'bo', clip_on=0, color='%s', marker='%s', ms=%d", o.SpClr, o.SpMrk, o.SpMs)) plt.PlotOne(x[k], y[k], io.Sf("'bs', clip_on=0, color='%s', marker='%s', ms=%d", o.SpClr, o.EpMrk, o.EpMs)) if last { ylbl := "$q$" if o.QdivP { ylbl = "$q/p$" } plt.Gll("$\\varepsilon_d\\;[\\%]$", ylbl, "leg_out=1, leg_ncol=4, leg_hlen=1.5") if lims, ok := o.Lims["ed,q"]; ok { plt.AxisLims(lims) } } }
func main() { // finalise analysis process and catch errors upon exit defer out.End() // start analysis process out.Start("o2elast.sim", 0, 0) // define entities out.Define("rod", out.Along{{0.05, 0.2, 0.05}, {0.05, 0.6, 0.05}}) // load results out.LoadResults([]float64{0.2, 0.4, 0.6, 0.8, 0.9, 0.98, 1}) // read comparison results rcmp_nod := read_pyfem_rod_data("cmp/pyfem_o2_rod_nod.dat") // plot uy along y for selected times out.Splot("rod displacements") for i, _ := range out.TimeInds { out.Plot("y", "uy", "rod", plt.Fmt{}, i) } for _, d := range rcmp_nod { plt.Plot(d.Y, d.Uy, "'k+', ms=5") } // show out.Draw("", "", true, nil) }
// PlotYxe plots the function y(x) implemented by Cb_yxe func PlotYxe(ffcn Cb_yxe, dirout, fname string, xsol, xa, xb float64, np int, xsolLbl, args string, save, show bool, extra func()) (err error) { if !save && !show { return } x := utl.LinSpace(xa, xb, np) y := make([]float64, np) for i := 0; i < np; i++ { y[i], err = ffcn(x[i]) if err != nil { return } } var ysol float64 ysol, err = ffcn(xsol) if err != nil { return } plt.Cross("") plt.Plot(x, y, args) plt.PlotOne(xsol, ysol, io.Sf("'ro', label='%s'", xsolLbl)) if extra != nil { extra() } plt.Gll("x", "y(x)", "") if save { os.MkdirAll(dirout, 0777) plt.Save(dirout + "/" + fname) } if show { plt.Show() } return }
// Draw2d draws bins' grid func (o *Bins) Draw2d(withtxt bool) { // horizontal lines x := []float64{o.Xi[0], o.Xi[0] + o.L[0] + o.S} y := make([]float64, 2) for j := 0; j < o.N[1]+1; j++ { y[0] = o.Xi[1] + float64(j)*o.S y[1] = y[0] plt.Plot(x, y, "'-', color='#4f3677', clip_on=0") } // vertical lines y[0] = o.Xi[1] y[1] = o.Xi[1] + o.L[1] + o.S for i := 0; i < o.N[0]+1; i++ { x[0] = o.Xi[0] + float64(i)*o.S x[1] = x[0] plt.Plot(x, y, "'k-', color='#4f3677', clip_on=0") } // plot items for _, bin := range o.All { if bin == nil { continue } for _, entry := range bin.Entries { plt.PlotOne(entry.X[0], entry.X[1], "'r.', clip_on=0") } } // labels if withtxt { for j := 0; j < o.N[1]; j++ { for i := 0; i < o.N[0]; i++ { idx := i + j*o.N[0] x := o.Xi[0] + float64(i)*o.S + 0.02*o.S y := o.Xi[1] + float64(j)*o.S + 0.02*o.S plt.Text(x, y, io.Sf("%d", idx), "size=7") } } } // setup plt.Equal() plt.AxisRange(o.Xi[0]-0.1, o.Xf[0]+o.S+0.1, o.Xi[1]-0.1, o.Xf[1]+o.S+0.1) }
// PlotAddFltFlt adds flt-flt points to existent plot func (o *Optimiser) PlotAddFltFlt(iFlt, jFlt int, sols []*Solution, fmt *plt.Fmt) { nsol := len(sols) x, y := make([]float64, nsol), make([]float64, nsol) for i, sol := range sols { x[i], y[i] = sol.Flt[iFlt], sol.Flt[jFlt] } plt.Plot(x, y, fmt.GetArgs("")) }
// PlotAddFltOva adds flt-ova points to existent plot func (o *Optimiser) PlotAddFltOva(iFlt, iOva int, sols []*Solution, ovaMult float64, fmt *plt.Fmt) { nsol := len(sols) x, y := make([]float64, nsol), make([]float64, nsol) for i, sol := range sols { x[i], y[i] = sol.Flt[iFlt], sol.Ova[iOva]*ovaMult } plt.Plot(x, y, fmt.GetArgs("")) }
func main() { Nf := []float64{5, 7, 10, 13, 15, 20} Eave := []float64{3.5998e-12, 2.9629e-10, 6.0300e-8, 3.3686e-6, 2.5914e-5, 1.1966e-3} plt.SetForEps(0.75, 200) plt.Plot(Nf, Eave, "'b-', marker='.', clip_on=0") plt.SetYlog() plt.Gll("$N_f$", "$E_{ave}$", "") plt.SaveD("/tmp/goga", "multierror.eps") }
// PlotBasis plots basis function (2D only) // option = 0 : use CalcBasis // 1 : use CalcBasisAndDerivs // 2 : use RecursiveBasis func (o *Nurbs) PlotBasis(l int, args string, npts, option int) { lbls := []string{"CalcBasis function", "CalcBasisAndDerivs function", "RecursiveBasis function"} switch o.gnd { // curve case 1: U := make([]float64, npts) S := make([]float64, npts) du := (o.b[0].tmax - o.b[0].tmin) / float64(npts-1) uvec := []float64{0} for m := 0; m < npts; m++ { U[m] = o.b[0].tmin + float64(m)*du uvec[0] = U[m] switch option { case 0: o.CalcBasis(uvec) S[m] = o.GetBasisL(l) case 1: o.CalcBasisAndDerivs(uvec) S[m] = o.GetBasisL(l) case 2: S[m] = o.RecursiveBasis(uvec, l) } } plt.Plot(U, S, args) plt.Gll("$u$", io.Sf("$S_%d$", l), "") // surface case 2: xx := la.MatAlloc(npts, npts) yy := la.MatAlloc(npts, npts) zz := la.MatAlloc(npts, npts) du0 := (o.b[0].tmax - o.b[0].tmin) / float64(npts-1) du1 := (o.b[1].tmax - o.b[1].tmin) / float64(npts-1) for m := 0; m < npts; m++ { u0 := o.b[0].tmin + float64(m)*du0 for n := 0; n < npts; n++ { u1 := o.b[1].tmin + float64(n)*du1 u := []float64{u0, u1} x := o.Point(u) xx[m][n] = x[0] yy[m][n] = x[1] switch option { case 0: o.CalcBasis(u) zz[m][n] = o.GetBasisL(l) case 1: o.CalcBasisAndDerivs(u) zz[m][n] = o.GetBasisL(l) case 2: zz[m][n] = o.RecursiveBasis(u, l) } } } plt.Contour(xx, yy, zz, "fsz=7") } plt.Title(io.Sf("%s @ %d", lbls[option], l), "size=7") }
func Test_igd01(tst *testing.T) { //verbose() chk.PrintTitle("igd. igd metric with star equal to trial => igd=0") // load star values prob := "UF1" fStar, err := io.ReadMatrix(io.Sf("./examples/mulobj-cec09/cec09/pf_data/%s.dat", prob)) if err != nil { tst.Errorf("cannot read fStar matrix:\n%v", err) return } npts := len(fStar) // optimiser var opt Optimiser opt.Default() opt.Nsol = npts opt.Ncpu = 1 opt.FltMin = []float64{0, 0} // used to store fStar opt.FltMax = []float64{1, 1} // used to store fStar nf, ng, nh := 2, 0, 0 // generator (store fStar into Flt) gen := func(sols []*Solution, prms *Parameters) { for i, sol := range sols { sol.Flt[0], sol.Flt[1] = fStar[i][0], fStar[i][1] } } // objective function (copy fStar from Flt into Ova) obj := func(f, g, h, x []float64, ξ []int, cpu int) { f[0], f[1] = x[0], x[1] } // initialise optimiser opt.Init(gen, nil, obj, nf, ng, nh) // compute igd igd := StatIgd(&opt, fStar) io.Pforan("igd = %v\n", igd) chk.Scalar(tst, "igd", 1e-15, igd, 0) // plot if chk.Verbose { fmt := &plt.Fmt{C: "red", M: ".", Ms: 1, Ls: "None", L: "solutions"} fS0 := utl.DblsGetColumn(0, fStar) fS1 := utl.DblsGetColumn(1, fStar) io.Pforan("len(fS0) = %v\n", len(fS0)) plt.SetForEps(0.75, 300) opt.PlotAddOvaOva(0, 1, opt.Solutions, true, fmt) plt.Plot(fS0, fS1, io.Sf("'b.', ms=2, label='star(%s)', clip_on=0", prob)) plt.Gll("$f_0$", "$f_1$", "") plt.SaveD("/tmp/goga", "igd01.eps") } }
// PlotBasis plots basis function (2D only) // option = 0 : use CalcBasis // 1 : use CalcBasisAndDerivs // 2 : use RecursiveBasis func (o *Nurbs) PlotBasis(l int, args string, npts, option int) { lbls := []string{"Nonly", "N\\&dN", "recN"} switch o.gnd { // curve case 1: xx := make([]float64, npts) yy := make([]float64, npts) du0 := (o.b[0].tmax - o.b[0].tmin) / float64(npts-1) for m := 0; m < npts; m++ { u0 := o.b[0].tmin + float64(m)*du0 u := []float64{u0} x := o.Point(u) xx[m] = x[0] switch option { case 0: o.CalcBasis(u) yy[m] = o.GetBasisL(l) case 1: o.CalcBasisAndDerivs(u) yy[m] = o.GetBasisL(l) case 2: yy[m] = o.RecursiveBasis(u, l) } } plt.Plot(xx, yy, "fsz=8") // surface case 2: xx := la.MatAlloc(npts, npts) yy := la.MatAlloc(npts, npts) zz := la.MatAlloc(npts, npts) du0 := (o.b[0].tmax - o.b[0].tmin) / float64(npts-1) du1 := (o.b[1].tmax - o.b[1].tmin) / float64(npts-1) for m := 0; m < npts; m++ { u0 := o.b[0].tmin + float64(m)*du0 for n := 0; n < npts; n++ { u1 := o.b[1].tmin + float64(n)*du1 u := []float64{u0, u1} x := o.Point(u) xx[m][n] = x[0] yy[m][n] = x[1] switch option { case 0: o.CalcBasis(u) zz[m][n] = o.GetBasisL(l) case 1: o.CalcBasisAndDerivs(u) zz[m][n] = o.GetBasisL(l) case 2: zz[m][n] = o.RecursiveBasis(u, l) } } } plt.Contour(xx, yy, zz, "fsz=8") } plt.Title(io.Sf("%d:%s", l, lbls[option]), "size=10") }
// PlotAddOvaOva adds ova-ova points to existent plot func (o *Optimiser) PlotAddOvaOva(iOva, jOva int, sols []*Solution, feasibleOnly bool, fmt *plt.Fmt) { var x, y []float64 for _, sol := range sols { if sol.Feasible() || !feasibleOnly { x = append(x, sol.Ova[iOva]) y = append(y, sol.Ova[jOva]) } } plt.Plot(x, y, fmt.GetArgs("")) }
func Test_data2d(tst *testing.T) { prob := "CF4" dat := PFdata(prob) X := utl.DblsGetColumn(0, dat) Y := utl.DblsGetColumn(1, dat) plt.SetForEps(1.0, 250) plt.Plot(X, Y, "'r.'") plt.Gll("$f_1$", "$f_2$", "") plt.SaveD("/tmp/goga", io.Sf("cec09-%s.eps", prob)) }
func main() { // filename filename, fnkey := io.ArgToFilename(0, "sg1121", ".sim", true) // results out.Start(filename, 0, 0) out.Define("A", out.N{30}) out.LoadResults(nil) // plot FEM results out.Plot("t", "uy", "A", plt.Fmt{C: "k", Ls: "-", L: "gofem"}, -1) // old results b, err := io.ReadFile("cmp/sg1121gofemold.json") if err != nil { io.PfRed("cannot read comparison file\n") return } var gofemold struct { Time, Uy30 []float64 } err = json.Unmarshal(b, &gofemold) if err != nil { io.PfRed("cannot unmarshal comparison file\n") return } // mechsys results _, res, err := io.ReadTable("cmp/sg1121mechsysN30.cmp") if err != nil { io.PfRed("cannot read mechsys comparison file\n") return } // save plt.SetForPng(0.8, 400, 200) out.Draw("/tmp", fnkey+".png", false, func(i, j, n int) { plt.Plot(gofemold.Time, gofemold.Uy30, "'r-', lw=2, label='gofemOld'") plt.Plot(res["Time"], res["uy"], "'b-', label='mechsys'") }) }
func plot_normal(μ, σ float64) { var dist DistNormal dist.Init(&VarData{M: μ, S: σ}) n := 101 x := utl.LinSpace(-2, 2, n) y := make([]float64, n) Y := make([]float64, n) for i := 0; i < n; i++ { y[i] = dist.Pdf(x[i]) Y[i] = dist.Cdf(x[i]) } plt.Subplot(2, 1, 1) plt.Plot(x, y, io.Sf("clip_on=0,zorder=10,label=r'$\\mu=%g,\\;\\sigma=%g$'", μ, σ)) plt.Gll("$x$", "$f(x)$", "leg_out=1, leg_ncol=2") plt.Subplot(2, 1, 2) plt.Plot(x, Y, io.Sf("clip_on=0,zorder=10,label=r'$\\mu=%g,\\;\\sigma=%g$'", μ, σ)) plt.Gll("$x$", "$F(x)$", "leg_out=1, leg_ncol=2") }