// PlotFltFlt plots flt-flt contour
// use iFlt==-1 || jFlt==-1 to plot all combinations
func (o *Optimiser) PlotFltFltContour(sols0 []*Solution, iFlt, jFlt, iOva int, pp *PlotParams) {
best, _ := GetBestFeasible(o, iOva)
plotAll := iFlt < 0 || jFlt < 0
plotCommands := func(i, j int) {
o.PlotContour(i, j, iOva, pp)
if sols0 != nil {
o.PlotAddFltFlt(i, j, sols0, &pp.FmtSols0)
}
o.PlotAddFltFlt(i, j, o.Solutions, &pp.FmtSols)
if best != nil {
plt.PlotOne(best.Flt[i], best.Flt[j], pp.FmtBest.GetArgs(""))
}
if pp.Extra != nil {
pp.Extra()
}
if pp.AxEqual {
plt.Equal()
}
}
if plotAll {
idx := 1
ncol := o.Nflt - 1
for row := 0; row < o.Nflt; row++ {
idx += row
for col := row + 1; col < o.Nflt; col++ {
plt.Subplot(ncol, ncol, idx)
plt.SplotGap(0.0, 0.0)
plotCommands(col, row)
if col > row+1 {
plt.SetXnticks(0)
plt.SetYnticks(0)
} else {
plt.Gll(io.Sf("$x_{%d}$", col), io.Sf("$x_{%d}$", row), "leg=0")
}
idx++
}
}
idx = ncol*(ncol-1) + 1
plt.Subplot(ncol, ncol, idx)
plt.AxisOff()
// TODO: fix formatting of open marker, add star to legend
plt.DrawLegend([]plt.Fmt{pp.FmtSols0, pp.FmtSols, pp.FmtBest}, 8, "center", false, "")
} else {
plotCommands(iFlt, jFlt)
if pp.Xlabel == "" {
plt.Gll(io.Sf("$x_{%d}$", iFlt), io.Sf("$x_{%d}$", jFlt), pp.LegPrms)
} else {
plt.Gll(pp.Xlabel, pp.Ylabel, pp.LegPrms)
}
}
plt.SaveD(pp.DirOut, pp.FnKey+pp.FnExt)
}
// 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()
}
func (o *Plotter) Plot_oct(x, y []float64, res []*State, sts [][]float64, last bool) {
// stress path
nr := len(res)
k := nr - 1
var σa, σb, xmi, xma, ymi, yma float64
for i := 0; i < nr; i++ {
σa, σb, _ = tsr.PQW2O(o.P[i], o.Q[i], o.W[i])
x[i], y[i] = σa, σb
o.maxR = max(o.maxR, math.Sqrt(σa*σa+σb*σb))
if i == 0 {
xmi, xma = x[i], x[i]
ymi, yma = y[i], y[i]
} else {
xmi = min(xmi, x[i])
xma = max(xma, x[i])
ymi = min(ymi, y[i])
yma = max(yma, y[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))
// fix range and max radius
xmi, xma, ymi, yma = o.fix_range(0, xmi, xma, ymi, yma)
rr := math.Sqrt((xma-xmi)*(xma-xmi) + (yma-ymi)*(yma-ymi))
if o.maxR < rr {
o.maxR = rr
}
if o.maxR < 1e-10 {
o.maxR = 1
}
if yma > -xmi {
xmi = -yma
}
if o.OctLims != nil {
xmi, xma, ymi, yma = o.OctLims[0], o.OctLims[1], o.OctLims[2], o.OctLims[3]
}
//xmi, xma, ymi, yma = -20000, 20000, -20000, 20000
// yield surface
var σcmax float64
if o.WithYs && o.m != nil {
//io.Pforan("xmi,xma ymi,yma = %v,%v %v,%v\n", xmi,xma, ymi,yma)
dx := (xma - xmi) / float64(o.NptsOct-1)
dy := (yma - ymi) / float64(o.NptsOct-1)
xx := la.MatAlloc(o.NptsOct, o.NptsOct)
yy := la.MatAlloc(o.NptsOct, o.NptsOct)
zz := la.MatAlloc(o.NptsOct, o.NptsOct)
var λ0, λ1, λ2, σc float64
v := NewState(len(res[0].Sig), len(res[0].Alp), false, len(res[0].EpsE) > 0)
for k := 0; k < nr; k++ {
copy(v.Alp, res[k].Alp)
v.Dgam = res[k].Dgam
σc = tsr.M_p(res[k].Sig) * tsr.SQ3
//σc = 30000
σcmax = max(σcmax, σc)
for i := 0; i < o.NptsOct; i++ {
for j := 0; j < o.NptsOct; j++ {
xx[i][j] = xmi + float64(i)*dx
yy[i][j] = ymi + float64(j)*dy
λ0, λ1, λ2 = tsr.O2L(xx[i][j], yy[i][j], σc)
v.Sig[0], v.Sig[1], v.Sig[2] = λ0, λ1, λ2
ys := o.m.YieldFuncs(v)
zz[i][j] = ys[0]
}
}
plt.ContourSimple(xx, yy, zz, io.Sf("colors=['%s'], levels=[0], linestyles=['%s'], linewidths=[%g], clip_on=0", o.YsClr0, o.YsLs0, o.YsLw0)+o.ArgsYs)
}
}
// predictor-corrector
if len(o.PreCor) > 1 {
var σa, σb, σanew, σbnew float64
for i := 1; i < len(o.PreCor); i++ {
σa, σb, _ = tsr.M_oct(o.PreCor[i-1])
σanew, σbnew, _ = tsr.M_oct(o.PreCor[i])
if math.Abs(σanew-σa) > 1e-7 || math.Abs(σbnew-σb) > 1e-7 {
//plt.Plot([]float64{σa,σanew}, []float64{σb,σbnew}, "'k+', ms=3, color='k'")
plt.Arrow(σa, σb, σanew, σbnew, io.Sf("sc=%d, fc='%s', ec='%s'", o.ArrWid, o.ClrPC, o.ClrPC))
}
o.maxR = max(o.maxR, math.Sqrt(σa*σa+σb*σb))
o.maxR = max(o.maxR, math.Sqrt(σanew*σanew+σbnew*σbnew))
}
}
// rosette and settings
if last {
tsr.PlotRefOct(o.Phi, σcmax, true)
tsr.PlotRosette(o.maxR, false, true, true, 6)
if o.OctAxOff {
plt.AxisOff()
}
plt.Gll("$\\sigma_a$", "$\\sigma_b$", "")
if lims, ok := o.Lims["oct"]; ok {
plt.AxisLims(lims)
}
if lims, ok := o.Lims["oct,ys"]; ok {
plt.AxisLims(lims)
}
}
}
func (o *Plotter) set_empty() {
plt.AxisOff()
}
// Draw draws grid
// r -- radius of circles
// W -- width of paths
// dwt -- δwt for positioning text (w = W/2)
// arrow_scale -- scale for arrows. use 0 for default value
func (o *Graph) Draw(dirout, fname string, r, W, dwt, arrow_scale float64,
verts_lbls map[int]string, verts_fsz float64, verts_clr string,
edges_lbls map[int]string, edges_fsz float64, edges_clr string) {
if len(o.Verts) < 1 {
return
}
xmin, ymin := o.Verts[0][0], o.Verts[0][1]
xmax, ymax := xmin, ymin
var lbl string
for i, v := range o.Verts {
if verts_lbls == nil {
lbl = io.Sf("%d", i)
} else {
lbl = verts_lbls[i]
}
plt.Text(v[0], v[1], lbl, io.Sf("clip_on=0, color='%s', fontsize=%g, ha='center', va='center'", verts_clr, verts_fsz))
plt.Circle(v[0], v[1], r, "clip_on=0, ec='k', lw=0.8")
xmin, ymin = utl.Min(xmin, v[0]), utl.Min(ymin, v[1])
xmax, ymax = utl.Max(xmax, v[0]), utl.Max(ymax, v[1])
}
if W > 2*r {
W = 1.8 * r
}
w := W / 2.0
xa, xb := make([]float64, 2), make([]float64, 2)
xc, dx := make([]float64, 2), make([]float64, 2)
mu, nu := make([]float64, 2), make([]float64, 2)
xi, xj := make([]float64, 2), make([]float64, 2)
l := math.Sqrt(r*r - w*w)
var L float64
if arrow_scale <= 0 {
arrow_scale = 20
}
for k, e := range o.Edges {
L = 0.0
for i := 0; i < 2; i++ {
xa[i] = o.Verts[e[0]][i]
xb[i] = o.Verts[e[1]][i]
xc[i] = (xa[i] + xb[i]) / 2.0
dx[i] = xb[i] - xa[i]
L += dx[i] * dx[i]
}
L = math.Sqrt(L)
mu[0], mu[1] = dx[0]/L, dx[1]/L
nu[0], nu[1] = -dx[1]/L, dx[0]/L
for i := 0; i < 2; i++ {
xi[i] = xa[i] + l*mu[i] - w*nu[i]
xj[i] = xb[i] - l*mu[i] - w*nu[i]
xc[i] = (xi[i]+xj[i])/2.0 - dwt*nu[i]
}
plt.Arrow(xi[0], xi[1], xj[0], xj[1], io.Sf("st='->', sc=%g", arrow_scale))
if edges_lbls == nil {
lbl = io.Sf("%d", k)
} else {
lbl = edges_lbls[k]
}
plt.Text(xc[0], xc[1], lbl, io.Sf("clip_on=0, color='%s', fontsize=%g, ha='center', va='center'", edges_clr, edges_fsz))
}
xmin -= r
xmax += r
ymin -= r
ymax += r
plt.AxisOff()
plt.Equal()
plt.AxisRange(xmin, xmax, ymin, ymax)
plt.SaveD(dirout, fname)
}
// PlotOct plots a function cross-section and gradients projections on octahedral plane
func PlotOct(filename string, σcCte, rmin, rmax float64, nr, nα int, φ float64, F Cb_F_t, G Cb_G_t,
notpolarc, simplec, only0, grads, showpts, first, last bool, ferr float64, args ...interface{}) {
A := make([]float64, 6)
dfdA := make([]float64, 6)
dα := 2.0 * math.Pi / float64(nα)
dr := (rmax - rmin) / float64(nr-1)
αmin := -math.Pi / 6.0
if notpolarc {
rmin = -rmax
dr = (rmax - rmin) / float64(nr-1)
nα = nr
dα = dr
αmin = rmin
}
x, y, f := la.MatAlloc(nα, nr), la.MatAlloc(nα, nr), la.MatAlloc(nα, nr)
//var gx, gy, L [][]float64
var gx, gy [][]float64
if grads {
gx, gy = la.MatAlloc(nα, nr), la.MatAlloc(nα, nr)
//L = O2Lmat()
}
var σa, σb []float64
if showpts {
σa, σb = make([]float64, nα*nr), make([]float64, nα*nr)
}
k := 0
var err error
for i := 0; i < nα; i++ {
for j := 0; j < nr; j++ {
α := αmin + float64(i)*dα
r := rmin + float64(j)*dr
if notpolarc {
x[i][j] = α // σa
y[i][j] = r // σb
} else {
x[i][j] = r * math.Cos(α) // σa
y[i][j] = r * math.Sin(α) // σb
}
A[0], A[1], A[2] = O2L(x[i][j], y[i][j], σcCte)
if showpts {
σa[k] = x[i][j]
σb[k] = y[i][j]
}
f[i][j], err = F(A, args...)
if err != nil {
if ferr > 0 {
f[i][j] = ferr
} else {
chk.Panic(_octahedral_err1, "func", err)
}
}
if grads {
_, err = G(dfdA, A, args...)
if err != nil {
chk.Panic(_octahedral_err1, "grads", err)
}
/*
gx[i][j] = -o.dfdλ[0]*L[0][0] - o.dfdλ[1]*L[1][0] - o.dfdλ[2]*L[2][0]
gy[i][j] = -o.dfdλ[0]*L[0][1] - o.dfdλ[1]*L[1][1] - o.dfdλ[2]*L[2][1]
*/
}
k += 1
}
}
if first {
plt.Reset()
plt.SetForPng(1, 500, 125)
PlotRosette(1.1*rmax, true, true, true, 7)
PlotRefOct(φ, σcCte, false)
if showpts {
plt.Plot(σa, σb, "'k.', ms=5")
}
}
if simplec {
if !only0 {
plt.ContourSimple(x, y, f, false, 8, "")
}
plt.ContourSimple(x, y, f, false, 8, "levels=[0], colors=['blue'], linewidths=[2]")
} else {
plt.Contour(x, y, f, "fsz=8")
}
if grads {
plt.Quiver(x, y, gx, gy, "")
}
if last {
plt.AxisOff()
plt.Equal()
plt.SaveD("/tmp", filename)
}
}
// Draw2d draws 2D mesh
func (o *Mesh) Draw2d() {
// auxiliary
type triple struct{ a, b, c int } // points on edge
edgesdrawn := make(map[triple]bool) // edges drawn already
var tri triple
// loop over cells
for _, cell := range o.Cells {
// loop edges of cells
for _, lvids := range cell.Shp.FaceLocalVerts {
// set triple of nodes
tri.a = cell.Verts[lvids[0]]
tri.b = cell.Verts[lvids[1]]
nv := len(lvids)
if nv > 2 {
tri.c = cell.Verts[lvids[2]]
} else {
tri.c = len(o.Verts) + 1 // indicator of not-available
}
utl.IntSort3(&tri.a, &tri.b, &tri.c)
// draw edge if not drawn yet
if _, drawn := edgesdrawn[tri]; !drawn {
x := make([]float64, nv)
y := make([]float64, nv)
x[0] = o.Verts[tri.a].C[0]
y[0] = o.Verts[tri.a].C[1]
if nv == 3 {
x[1] = o.Verts[tri.c].C[0]
y[1] = o.Verts[tri.c].C[1]
x[2] = o.Verts[tri.b].C[0]
y[2] = o.Verts[tri.b].C[1]
} else {
x[1] = o.Verts[tri.b].C[0]
y[1] = o.Verts[tri.b].C[1]
}
plt.Plot(x, y, "'k-o', ms=3, clip_on=0")
edgesdrawn[tri] = true
}
}
// add middle node
if cell.Type == "qua9" {
vid := cell.Verts[8]
x := o.Verts[vid].C[0]
y := o.Verts[vid].C[1]
plt.PlotOne(x, y, "'ko', ms=3, clip_on=0")
}
// linear cells
if strings.HasPrefix(cell.Type, "lin") {
nv := len(cell.Verts)
x := make([]float64, nv)
y := make([]float64, nv)
for i, vid := range cell.Verts {
x[i] = o.Verts[vid].C[0]
y[i] = o.Verts[vid].C[1]
}
plt.Plot(x, y, "'-o', ms=3, clip_on=0, color='#41045a', lw=2")
}
}
// set up
plt.Equal()
plt.AxisRange(o.Xmin, o.Xmax, o.Ymin, o.Ymax)
plt.AxisOff()
}