// 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)
}
func main() {
// finalise analysis process and catch errors
defer out.End()
// input data
simfn := "onepulse-qua9co.sim"
flag.Parse()
if len(flag.Args()) > 0 {
simfn = flag.Arg(0)
}
if io.FnExt(simfn) == "" {
simfn += ".sim"
}
// start analysis process
out.Start(simfn, 0, 0)
// define entities
out.Define("A B C D E", out.N{-5, -4, -3, -2, -1})
out.Define("a b c d e", out.P{{15, 8}, {13, 8}, {8, 8}, {4, 8}, {0, 0}})
// load results
out.LoadResults(nil)
// styles
me := 10
S := []plt.Fmt{
plt.Fmt{C: "b", M: "*", Me: me},
plt.Fmt{C: "g", M: "o", Me: me},
plt.Fmt{C: "m", M: "x", Me: me},
plt.Fmt{C: "orange", M: "+", Me: me},
plt.Fmt{C: "r", M: "^", Me: me},
}
// pl
out.Splot("liquid pressure")
for i, l := range []string{"A", "B", "C", "D", "E"} {
out.Plot("t", "pl", l, S[i], -1)
}
// uy
out.Splot("displacements")
for i, l := range []string{"A", "B", "C", "D", "E"} {
out.Plot("t", "uy", l, S[i], -1)
}
out.Splot("liquid saturation")
for i, l := range []string{"a", "b", "c", "d", "e"} {
out.Plot("t", "sl", l, S[i], -1)
}
out.Splot("stresses")
for i, l := range []string{"a", "b", "c", "d", "e"} {
out.Plot("t", "sy", l, S[i], -1)
}
// show
out.Draw("", "", true, nil)
}
func main() {
// input data
simfn := "onepulse-qua9co.sim"
flag.Parse()
if len(flag.Args()) > 0 {
simfn = flag.Arg(0)
}
if io.FnExt(simfn) == "" {
simfn += ".sim"
}
// start analysis process
out.Start(simfn, 0, 0)
// define entities
out.Define("A C E", out.N{-5, -3, -1})
out.Define("a b", out.P{{1, 8}, {0, 8}})
// load results
out.LoadResults(nil)
// styles
me := 10
Sn := []plt.Fmt{
plt.Fmt{C: "b", M: "*", Me: me},
plt.Fmt{C: "m", M: "x", Me: me},
plt.Fmt{C: "r", M: "^", Me: me},
}
Se := []plt.Fmt{
plt.Fmt{C: "b", M: "*", Me: me},
plt.Fmt{C: "g", M: "o", Me: me},
}
// pl
out.Splot("liquid pressure")
for i, l := range []string{"A", "C", "E"} {
out.Plot("t", "pl", l, Sn[i], -1)
}
// uy
out.Splot("displacements")
for i, l := range []string{"A", "C", "E"} {
out.Plot("t", "uy", l, Sn[i], -1)
}
out.Splot("liquid saturation")
for i, l := range []string{"a", "b"} {
out.Plot("t", "sl", l, Se[i], -1)
}
out.Splot("stresses")
for i, l := range []string{"a", "b"} {
out.Plot("t", "sy", l, Se[i], -1)
}
// show
out.Draw("", "", true, nil)
}
func read_summary(simfn string) (*utl.DblSlist, string) {
if simfn == "" {
return nil, ""
}
if io.FnExt(simfn) == "" {
simfn += ".sim"
}
out.Start(simfn, 0, 0)
return &out.Sum.Resids, io.FnKey(simfn)
}
// Draw draws or save figure with plot
// dirout -- directory to save figure
// fname -- file name; e.g. myplot.eps or myplot.png. Use "" to skip saving
// show -- shows figure
// extra -- is called just after Subplot command and before any plotting
// Note: subplots will be split if using 'eps' files
func Draw(dirout, fname string, show bool, extra ExtraPlt) {
var fnk string // filename key
var ext string // extension
var eps bool // is eps figure
if fname != "" {
fnk = io.FnKey(fname)
ext = io.FnExt(fname)
eps = ext == ".eps"
}
nplots := len(Splots)
nr, nc := utl.BestSquare(nplots)
var k int
for i := 0; i < nr; i++ {
for j := 0; j < nc; j++ {
if !eps {
plt.Subplot(nr, nc, k+1)
}
if extra != nil {
extra(i+1, j+1, nplots)
}
if Splots[k].Title != "" {
plt.Title(Splots[k].Title, Splots[k].Topts)
}
data := Splots[k].Data
for _, d := range data {
if d.Style.L == "" {
d.Style.L = d.Alias
}
x, y := d.X, d.Y
if math.Abs(Splots[k].Xscale) > 0 {
x = make([]float64, len(d.X))
la.VecCopy(x, Splots[k].Xscale, d.X)
}
if math.Abs(Splots[k].Yscale) > 0 {
y = make([]float64, len(d.Y))
la.VecCopy(y, Splots[k].Yscale, d.Y)
}
plt.Plot(x, y, d.Style.GetArgs("clip_on=0"))
}
plt.Gll(Splots[k].Xlbl, Splots[k].Ylbl, Splots[k].GllArgs)
if eps {
savefig(dirout, fnk, ext, k)
plt.Clf()
}
k += 1
}
}
if !eps && fname != "" {
savefig(dirout, fnk, ext, -1)
}
if show {
plt.Show()
}
}
func main() {
// finalise analysis process and catch errors
defer out.End()
// input data
simfn := "d2-simple-flux"
flag.Parse()
if len(flag.Args()) > 0 {
simfn = flag.Arg(0)
}
if io.FnExt(simfn) == "" {
simfn += ".sim"
}
// start analysis process
out.Extrap = []string{"nwlx", "nwly"}
out.Start(simfn, 0, 0)
// define entities
out.Define("top-middle", out.At{5, 3})
out.Define("section-A", out.N{-1})
out.Define("section-B", out.Along{{0, 0}, {10, 0}})
// load results
out.LoadResults(nil)
// compute water discharge along section-A
nwlx_TM := out.GetRes("ex_nwlx", "top-middle", -1)
Q := out.Integrate("ex_nwlx", "section-A", "y", -1)
io.PfYel("Q = %g m³/s [answer: 0.0003]\n", Q)
// plot
kt := len(out.Times) - 1
out.Splot("")
out.Plot("pl", "y", "section-A", plt.Fmt{L: "t=0"}, 0)
out.Plot("pl", "y", "section-A", plt.Fmt{L: io.Sf("t=%g", out.Times[kt])}, kt)
out.Splot("")
out.Plot("x", "pl", "section-B", plt.Fmt{L: "t=0"}, 0)
out.Plot("x", "pl", "section-B", plt.Fmt{L: io.Sf("t=%g", out.Times[kt])}, kt)
out.Splot("")
out.Plot("t", nwlx_TM, "top-middle", plt.Fmt{}, -1)
out.Csplot.Ylbl = "$n_{\\ell}\\cdot w_{\\ell x}$"
// show
if true {
out.Draw("", "", true, func(i, j, nplots int) {
if i == 2 && j == 1 {
plt.Plot([]float64{0, 10}, []float64{10, 9}, "'k--'")
}
})
}
}
// 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)
}
func main() {
// finalise analysis process and catch errors
defer out.End()
// input data
simfn := "a-coarse-elast-d2-q9"
flag.Parse()
if len(flag.Args()) > 0 {
simfn = flag.Arg(0)
}
if io.FnExt(simfn) == "" {
simfn += ".sim"
}
// start analysis process
out.Start(simfn, 0, 0)
// define entities
out.Define("a", out.P{{18, 8}})
// load results
out.LoadResults(nil)
nf_a := out.GetRes("nf", "a", -1)
pl_a := out.GetRes("pl", "a", -1)
pc_a := make([]float64, len(pl_a))
for i, _ := range pl_a {
pc_a[i] = -pl_a[i]
}
out.Splot("LRM")
_, d, _ := io.ReadTable("lrm.dat")
plt.Plot(d["pc"], d["sl"], "'c-',lw=2")
out.Plot(pc_a, "sl", "a", plt.Fmt{M: "o"}, -1)
out.Csplot.Xlbl = "$p_c$"
out.Splot("porosity")
out.Plot("t", nf_a, "a", plt.Fmt{M: "+"}, -1)
out.Csplot.Ylbl = "$n_f$"
// show
out.Draw("", "", true, nil)
}
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)
}
}
func main() {
// input data
simfn := "elast.sim"
matname := "lrm1"
pcmax := 30.0
npts := 101
// parse flags
flag.Parse()
if len(flag.Args()) > 0 {
simfn = flag.Arg(0)
}
if len(flag.Args()) > 1 {
matname = flag.Arg(1)
}
if len(flag.Args()) > 2 {
pcmax = io.Atof(flag.Arg(2))
}
if len(flag.Args()) > 3 {
npts = io.Atoi(flag.Arg(3))
}
// check extension
if io.FnExt(simfn) == "" {
simfn += ".sim"
}
// print input data
io.Pf("\nInput data\n")
io.Pf("==========\n")
io.Pf(" simfn = %30s // simulation filename\n", simfn)
io.Pf(" matname = %30s // material name\n", matname)
io.Pf(" pcmax = %30v // max pc\n", pcmax)
io.Pf(" npts = %30v // number of points\n", npts)
io.Pf("\n")
// load simulation
sim := inp.ReadSim("", simfn, "lrm_", false)
if sim == nil {
io.PfRed("cannot load simulation\n")
return
}
// get material data
mat := sim.Mdb.Get(matname)
if mat == nil {
io.PfRed("cannot get material\n")
return
}
io.Pforan("mat = %v\n", mat)
// get and initialise model
mdl := mreten.GetModel(simfn, matname, mat.Model, false)
if mdl == nil {
io.PfRed("cannot allocate model\n")
return
}
mdl.Init(mat.Prms)
// plot drying path
d_Pc := utl.LinSpace(0, pcmax, npts)
d_Sl := make([]float64, npts)
d_Sl[0] = 1
var err error
for i := 1; i < npts; i++ {
d_Sl[i], err = mreten.Update(mdl, d_Pc[i-1], d_Sl[i-1], d_Pc[i]-d_Pc[i-1])
if err != nil {
io.PfRed("drying: cannot updated model\n%v\n", err)
return
}
}
plt.Plot(d_Pc, d_Sl, io.Sf("'b-', label='%s (dry)', clip_on=0", matname))
// plot wetting path
w_Pc := utl.LinSpace(pcmax, 0, npts)
w_Sl := make([]float64, npts)
w_Sl[0] = d_Sl[npts-1]
for i := 1; i < npts; i++ {
w_Sl[i], err = mreten.Update(mdl, w_Pc[i-1], w_Sl[i-1], w_Pc[i]-w_Pc[i-1])
if err != nil {
io.PfRed("wetting: cannot updated model\n%v\n", err)
return
}
}
plt.Plot(w_Pc, w_Sl, io.Sf("'c-', label='%s (wet)', clip_on=0", matname))
// save results
type Results struct{ Pc, Sl []float64 }
res := Results{append(d_Pc, w_Pc...), append(d_Sl, w_Sl...)}
var buf bytes.Buffer
enc := json.NewEncoder(&buf)
err = enc.Encode(&res)
if err != nil {
io.PfRed("cannot encode results\n")
return
}
fn := path.Join(sim.Data.DirOut, matname+".dat")
io.WriteFile(fn, &buf)
io.Pf("file <[1;34m%s[0m> written\n", fn)
// show figure
plt.AxisYrange(0, 1)
plt.Cross()
plt.Gll("$p_c$", "$s_{\\ell}$", "")
plt.Show()
}
func main() {
// catch errors
defer func() {
if err := recover(); err != nil {
if mpi.Rank() == 0 {
chk.Verbose = true
for i := 8; i > 3; i-- {
chk.CallerInfo(i)
}
io.PfRed("ERROR: %v\n", err)
}
}
mpi.Stop(false)
}()
mpi.Start(false)
// message
if mpi.Rank() == 0 {
io.PfWhite("\nGofem v3 -- Go Finite Element Method\n\n")
io.Pf("Copyright 2015 Dorival Pedroso and Raul Durand. All rights reserved.\n")
io.Pf("Use of this source code is governed by a BSD-style\n")
io.Pf("license that can be found in the LICENSE file.\n\n")
}
// simulation filenamepath
flag.Parse()
var fnamepath string
if len(flag.Args()) > 0 {
fnamepath = flag.Arg(0)
} else {
chk.Panic("Please, provide a filename. Ex.: cylinder.sim")
}
// check extension
if io.FnExt(fnamepath) == "" {
fnamepath += ".sim"
}
// other options
erasefiles := true
verbose := true
if len(flag.Args()) > 1 {
erasefiles = io.Atob(flag.Arg(1))
}
if len(flag.Args()) > 2 {
verbose = io.Atob(flag.Arg(2))
}
// profiling?
defer utl.DoProf(false)()
// start global variables and log
if !fem.Start(fnamepath, erasefiles, verbose) {
chk.Panic("Start failed\n")
return
}
// make sure to flush log
defer fem.End()
// run simulation
if !fem.Run() {
io.PfRed("ERROR: cannot run simulation\n")
}
}
func main() {
// finalise analysis process and catch errors
defer out.End()
// input data
simfn := "data/twoqua4.sim"
exnwl := false
stgidx := 0
// parse flags
flag.Parse()
if len(flag.Args()) > 0 {
simfn = flag.Arg(0)
}
if len(flag.Args()) > 1 {
exnwl = io.Atob(flag.Arg(1))
}
if len(flag.Args()) > 2 {
stgidx = io.Atoi(flag.Arg(2))
}
// check extension
if io.FnExt(simfn) == "" {
simfn += ".sim"
}
// print input data
io.Pf("\nInput data\n")
io.Pf("==========\n")
io.Pf(" simfn = %30s // simulation filename\n", simfn)
io.Pf(" exnwl = %30v // extrapolate nwl\n", exnwl)
io.Pf(" stgidx = %30v // stage index\n", stgidx)
io.Pf("\n")
// start analysis process
out.Start(simfn, stgidx, 0)
// global variables
ndim = out.Dom.Msh.Ndim
verts = out.Dom.Msh.Verts
cells = out.Dom.Msh.Cells
nodes = out.Dom.Nodes
elems = out.Dom.Elems
dirout = fem.Global.Sim.Data.DirOut
fnkey = fem.Global.Sim.Data.FnameKey
steady = fem.Global.Sim.Data.Steady
// flags
has_u := out.Dom.YandC["ux"]
has_pl := out.Dom.YandC["pl"]
has_pg := out.Dom.YandC["pg"]
has_sig := out.Ipkeys["sx"]
has_nwl := out.Ipkeys["nwlx"]
has_p := has_pl || has_pg
lbb := has_u && has_p
if fem.Global.Sim.Data.NoLBB {
lbb = false
}
// buffers
pvd := make(map[string]*bytes.Buffer)
geo := make(map[string]*bytes.Buffer)
vtu := make(map[string]*bytes.Buffer)
if _, ok := out.Dom.YandC["ux"]; ok {
pvd["u"] = new(bytes.Buffer)
geo["u"] = new(bytes.Buffer)
vtu["u"] = new(bytes.Buffer)
}
if _, ok := out.Dom.YandC["fl"]; ok {
pvd["fl"] = new(bytes.Buffer)
geo["fl"] = new(bytes.Buffer)
vtu["fl"] = new(bytes.Buffer)
}
if _, ok := out.Dom.YandC["pl"]; ok {
pvd["pl"] = new(bytes.Buffer)
geo["pl"] = new(bytes.Buffer)
vtu["pl"] = new(bytes.Buffer)
}
if _, ok := out.Dom.YandC["pg"]; ok {
pvd["pg"] = new(bytes.Buffer)
geo["pg"] = new(bytes.Buffer)
vtu["pg"] = new(bytes.Buffer)
}
if len(out.Ipkeys) > 0 {
pvd["ips"] = new(bytes.Buffer)
geo["ips"] = new(bytes.Buffer)
vtu["ips"] = new(bytes.Buffer)
}
if exnwl {
pvd["ex_nwl"] = new(bytes.Buffer)
geo["ex_nwl"] = new(bytes.Buffer)
vtu["ex_nwl"] = new(bytes.Buffer)
}
// extrapolated values keys
extrap_keys := []string{"nwlx", "nwly"}
if ndim == 3 {
extrap_keys = []string{"nwlx", "nwly", "nwlz"}
}
// headers
for _, b := range pvd {
pvd_header(b)
}
// process results
for tidx, t := range out.Sum.OutTimes {
// input results into domain
if !out.Dom.In(out.Sum, tidx, true) {
chk.Panic("cannot load results into domain; please check log file")
}
// message
io.PfWhite("time = %g\r", t)
// generate topology
if tidx == 0 {
for label, b := range geo {
topology(b, label == "ips", lbb)
}
// allocate integration points values
ipvals = make([]map[string]float64, len(out.Ipoints))
for i, _ := range out.Ipoints {
ipvals[i] = make(map[string]float64)
}
}
// get integration points values @ time t
for i, p := range out.Ipoints {
vals := p.Calc(out.Dom.Sol)
for key, val := range vals {
ipvals[i][key] = val
}
}
// compute extrapolated values
if exnwl {
out.ComputeExtrapolatedValues(extrap_keys)
}
// for each data buffer
for label, b := range vtu {
// reset buffer
b.Reset()
// points data
if label == "ips" {
pdata_open(b)
if has_sig {
pdata_write(b, "sig", skeys, true)
}
if has_nwl {
pdata_write(b, "nwl", nwlkeys, true)
}
for key, _ := range out.Ipkeys {
if !is_sig[key] && !is_nwl[key] {
pdata_write(b, key, []string{key}, true)
}
}
pdata_close(b)
} else {
pdata_open(b)
pdata_write(b, label, label2keys[label], false)
pdata_close(b)
}
// cells data
cdata_write(b, label == "ips")
// write vtu file
vtu_write(geo[label], b, tidx, label)
}
// pvd
for label, b := range pvd {
pvd_line(b, tidx, t, label)
}
}
// write pvd files
for label, b := range pvd {
pvd_write(b, label)
}
}
// PlotNurbsBasis plots basis functions la and lb
func PlotNurbsBasis(dirout, fn string, b *Nurbs, la, lb int) {
npts := 41
ndiv := 11
if b.gnd == 1 {
ndiv = 101
}
plt.Reset()
if io.FnExt(fn) == ".eps" {
plt.SetForEps(1.5, 500)
} else {
plt.SetForPng(1.5, 600, 150)
}
plt.Subplot(3, 2, 1)
if b.gnd == 2 {
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
}
t0 := time.Now()
b.PlotBasis(la, "clip_on=0", ndiv, 0) // 0 => CalcBasis
io.Pfcyan("time elapsed (calcbasis) = %v\n", time.Now().Sub(t0))
if b.gnd == 2 {
plt.Equal()
}
plt.Subplot(3, 2, 2)
if b.gnd == 2 {
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
}
b.PlotBasis(lb, "clip_on=0", ndiv, 0) // 0 => CalcBasis
if b.gnd == 2 {
plt.Equal()
}
plt.Subplot(3, 2, 3)
if b.gnd == 2 {
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
}
b.PlotBasis(la, "clip_on=0", ndiv, 1) // 1 => CalcBasisAndDerivs
if b.gnd == 2 {
plt.Equal()
}
plt.Subplot(3, 2, 4)
if b.gnd == 2 {
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
}
b.PlotBasis(lb, "clip_on=0", ndiv, 1) // 1 => CalcBasisAndDerivs
if b.gnd == 2 {
plt.Equal()
}
plt.Subplot(3, 2, 5)
if b.gnd == 2 {
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
}
t0 = time.Now()
b.PlotBasis(la, "clip_on=0", ndiv, 2) // 2 => RecursiveBasis
io.Pfcyan("time elapsed (recursive) = %v\n", time.Now().Sub(t0))
if b.gnd == 2 {
plt.Equal()
}
plt.Subplot(3, 2, 6)
if b.gnd == 2 {
b.DrawCtrl2d(false, "", "")
b.DrawElems2d(npts, false, "", "")
}
b.PlotBasis(lb, "clip_on=0", ndiv, 2) // 2 => RecursiveBasis
if b.gnd == 2 {
plt.Equal()
}
plt.SaveD(dirout, fn)
}