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() {
// input data
fn, fnk := io.ArgToFilename(0, "nurbs01", ".msh", true)
ctrl := io.ArgToBool(1, true)
ids := io.ArgToBool(2, true)
useminmax := io.ArgToBool(3, false)
axisequal := io.ArgToBool(4, true)
xmin := io.ArgToFloat(5, 0)
xmax := io.ArgToFloat(6, 0)
ymin := io.ArgToFloat(7, 0)
ymax := io.ArgToFloat(8, 0)
eps := io.ArgToBool(9, false)
npts := io.ArgToInt(10, 41)
// print input table
io.Pf("\n%s\n", io.ArgsTable("INPUT ARGUMENTS",
"mesh filename", "fn", fn,
"show control points", "ctrl", ctrl,
"show ids", "ids", ids,
"use xmin,xmax,ymin,ymax", "useminmax", useminmax,
"enforce axis.equal", "axisequal", axisequal,
"min(x)", "xmin", xmin,
"max(x)", "xmax", xmax,
"min(y)", "ymin", ymin,
"max(y)", "ymax", ymax,
"generate eps instead of png", "eps", eps,
"number of divisions", "npts", npts,
))
// load nurbss
B := gm.ReadMsh(fnk)
// plot
if eps {
plt.SetForEps(0.75, 500)
} else {
plt.SetForPng(0.75, 500, 150)
}
for _, b := range B {
if ctrl {
b.DrawCtrl2d(ids, "", "")
}
b.DrawElems2d(npts, ids, "", "")
}
if axisequal {
plt.Equal()
}
if useminmax {
plt.AxisRange(xmin, xmax, ymin, ymax)
}
ext := ".png"
if eps {
ext = ".eps"
}
plt.Save(fnk + ext)
}
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, "data/twoqua4", ".sim", true)
exnwl := io.ArgToBool(1, false)
stgidx := io.ArgToInt(2, 0)
io.Pf("\n%s\n", io.ArgsTable(
"simulation filename", "simfn", simfn,
"extrapolate nwl", "exnwl", exnwl,
"stage index", "stgidx", stgidx,
))
// 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 = out.Dom.Sim.DirOut
fnkey = out.Dom.Sim.Key
steady = out.Dom.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 out.Dom.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)
}
for ykey, _ := range out.Dom.Dof2Tnum {
if ykey == "ux" || ykey == "uy" || ykey == "uz" {
continue
}
pvd[ykey] = new(bytes.Buffer)
geo[ykey] = new(bytes.Buffer)
vtu[ykey] = new(bytes.Buffer)
label2keys[ykey] = []string{ykey}
}
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
err := out.Dom.Read(out.Sum, tidx, 0, true)
if err != nil {
chk.Panic("cannot load results into domain\n%v", err)
}
// 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)
}
}
