func main() {
// options
verbose := false
show := true
// finalise analysis process and catch errors upon exit
defer out.End()
// start analysis process
out.Start("spo754.sim", 0, 0)
// all nodes
out.Define("all nodes", out.AllNodes())
out.Define("A", out.At{0, 5})
// load results
out.LoadResults(nil)
// check
skipK := true
tolK := 1e-17
tolu := 1e-11
tols := 1e-04
var tst testing.T
fem.TestingCompareResultsU(&tst, "data/spo754.sim", "spo754.cmp", tolK, tolu, tols, skipK, verbose)
// plot
out.Splot("Plot")
out.Plot("uy", "t", "A", plt.Fmt{C: "r", M: "o"}, -1)
out.Draw("", "", show, nil)
}
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)
}
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 read_summary(simfn string) (*utl.DblSlist, string) {
if simfn == "" {
return nil, ""
}
if io.FnExt(simfn) == "" {
simfn += ".sim"
}
defer out.End()
out.Start(simfn, 0, 0)
return &out.Sum.Resids, io.FnKey(simfn)
}
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--'")
}
})
}
}
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() {
// finalise analysis process and catch errors
defer out.End()
var sol ana.PressCylin
sol.Init(fun.Prms{
&fun.Prm{N: "a", V: 100},
&fun.Prm{N: "b", V: 200},
&fun.Prm{N: "E", V: 210},
&fun.Prm{N: "ν", V: 0.3},
&fun.Prm{N: "σy", V: 0.24},
&fun.Prm{N: "P", V: 0.2},
})
// start analysis process
datadir := "$GOPATH/src/github.com/cpmech/gofem/examples/spo751_pressurised_cylinder/"
out.Start(datadir+"spo751.sim", 0, 0)
// define entities
out.Define("A", out.N{0})
out.Define("B", out.N{20})
out.Define("bottom", out.Along{{100, 0}, {101, 0}})
// load results
out.LoadResults(nil)
out.Splot("Pressure at inner and outer face")
out.Plot("ux", "t", "A", plt.Fmt{C: "b", M: ".", L: "inner"}, -1)
out.Plot("ux", "t", "B", plt.Fmt{C: "r", M: ".", L: "outer"}, -1)
//out.Splot("radial stress")
//X, _, _ := out.GetXYZ("ux", "bottom")
//SR := make([]float64, len(X))
//ST := make([]float64, len(X))
//c := sol.Getc()
//sol.Sig(c, X, SR, ST)
//out.Plt(X, ST, "bottom", plt.FmtS{"b.-"}, -1)
// show
out.Draw("", "", true, nil)
}
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)
}
}