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