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)
// default input parameters
// read input parameters
fnamepath, _ := io.ArgToFilename(0, "", ".sim", true)
verbose := io.ArgToBool(1, true)
erasePrev := io.ArgToBool(2, true)
saveSummary := io.ArgToBool(3, true)
allowParallel := io.ArgToBool(4, true)
alias := io.ArgToString(5, "")
// message
if mpi.Rank() == 0 && verbose {
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")
io.Pf("\n%v\n", io.ArgsTable(
"filename path", "fnamepath", fnamepath,
"show messages", "verbose", verbose,
"erase previous results", "erasePrev", erasePrev,
"save summary", "saveSummary", saveSummary,
"allow parallel run", "allowParallel", allowParallel,
"word to add to results", "alias", alias,
))
}
// profiling?
defer utl.DoProf(false)()
// analysis data
readSummary := false
analysis := fem.NewFEM(fnamepath, alias, erasePrev, saveSummary, readSummary, allowParallel, verbose, 0)
// run simulation
err := analysis.Run()
if err != nil {
chk.Panic("Run failed:\n%v", err)
}
}
func main() {
// catch errors
defer func() {
if err := recover(); err != nil {
io.PfRed("ERROR: %v\n", err)
}
}()
// input data
matOld := io.ArgToString(0, "matOld.mat")
matNew := io.ArgToString(1, "matNew.mat")
convSymb := io.ArgToBool(2, true)
io.Pf("\n%s\n", io.ArgsTable(
"old material filename", "matOld", matOld,
"new material filenamen", "matNew", matNew,
"do convert symbols", "convSymb", convSymb,
))
// convert old => new
inp.MatfileOld2New("", matNew, matOld, convSymb)
io.Pf("conversion successful\n")
io.Pfblue2("file <matNew.mat> created\n")
}
func main() {
// catch errors
defer func() {
if err := recover(); err != nil {
io.PfRed("ERROR: %v\n", err)
}
}()
// input data
simfn, _ := io.ArgToFilename(0, "elast", ".sim", true)
matname := io.ArgToString(1, "lrm1")
pcmax := io.ArgToFloat(2, 30.0)
npts := io.ArgToInt(3, 101)
// print input table
io.Pf("\n%s\n", io.ArgsTable(
"simulation filename", "simfn", simfn,
"material name", "matname", matname,
"max pc", "pcmax", pcmax,
"number of points", "npts", npts,
))
// load simulation
sim := inp.ReadSim(simfn, "lrm", false, 0)
if sim == nil {
io.PfRed("cannot load simulation\n")
return
}
// get material data
mat := sim.MatParams.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 {
io.PfRed("ERROR: %v\n", err)
}
}()
// input data
simfnA, fnkA := io.ArgToFilename(0, "o2elastCO", ".sim", true)
skip := io.ArgToInt(1, 0)
simfnB, fnkB := io.ArgToFilename(2, "", ".sim", false)
labelA := io.ArgToString(3, "")
labelB := io.ArgToString(4, "")
// print input data
io.Pf("\n%s\n", io.ArgsTable(
"simulation filename", "simfnA", simfnA,
"number of initial increments to skip", "skip", skip,
"simulation filename for comparison", "simfnB", simfnB,
"label for histogram", "labelA", labelA,
"label for histogram", "labelB", labelB,
))
// read residuals
residA, fnkA := read_summary(simfnA)
residB, fnkB := read_summary(simfnB)
// residuals: it => residuals
io.Pf("\nResiduals A\n")
io.Pf("============\n")
residA.Print("%10.2e")
if simfnB != "" {
io.Pf("\nResiduals B\n")
io.Pf("============\n")
residB.Print("%10.2e")
}
io.Pf("\n")
// plot convergence curves
plot_conv_curve(fnkA, skip, residA)
if simfnB != "" {
plot_conv_curve(fnkB, skip, residB)
}
// plot histogram
io.Pf("\n")
X := [][]float64{count_iters(residA)}
labels := []string{fnkA}
if labelA != "" {
labels[0] = labelA
}
if simfnB != "" {
X = append(X, count_iters(residB))
labels = append(labels, fnkB)
if labelB != "" {
labels[1] = labelB
}
}
plt.Reset()
plt.SetForEps(0.75, 300)
plt.Hist(X, labels, "")
plt.Gll("number of iterations", "counts", "")
plt.SaveD("/tmp", "gofem_residplot_"+fnkA+"_"+fnkB+"_hist.eps")
}