// Start initialises 'global' and starts logging
func Start(simfilepath string, erasefiles, verbose bool) (startisok bool) {
// multiprocessing data
Global.Rank = 0
Global.Nproc = 1
Global.Root = true
Global.Distr = false
if mpi.IsOn() {
Global.Rank = mpi.Rank()
Global.Nproc = mpi.Size()
Global.Root = Global.Rank == 0
Global.Distr = Global.Nproc > 1
}
Global.Verbose = verbose
if !Global.Root {
Global.Verbose = false
}
Global.WspcStop = make([]int, Global.Nproc)
Global.WspcInum = make([]int, Global.Nproc)
// simulation and convenience variables
dir := filepath.Dir(simfilepath)
fn := filepath.Base(simfilepath)
Global.Sim = inp.ReadSim(dir, fn, Global.LogPrefix, erasefiles)
LogErrCond(Global.Sim == nil, "ReadSim failed\n")
if Stop() {
return
}
Global.Ndim = Global.Sim.Ndim
Global.Dirout = Global.Sim.Data.DirOut
Global.Fnkey = Global.Sim.Data.FnameKey
Global.Enc = Global.Sim.Data.Encoder
Global.Stat = Global.Sim.Data.Stat
Global.LogBcs = Global.Sim.Data.LogBcs
Global.Debug = Global.Sim.Data.Debug
// fix show residual flag
if !Global.Root {
Global.Sim.Data.ShowR = false
}
// auxiliar structures
Global.DynCoefs = new(DynCoefs)
if !Global.DynCoefs.Init(&Global.Sim.Solver) {
return
}
Global.HydroSt = new(HydroStatic)
Global.HydroSt.Init()
// success
return true
}
func main() {
// input data
simfile := "simfile.sim"
zmin := 0.0
zmax := 3.0
npts := 11
// parse flags
flag.Parse()
if len(flag.Args()) > 0 {
simfile = flag.Arg(0)
}
if len(flag.Args()) > 1 {
zmin = io.Atof(flag.Arg(1))
}
if len(flag.Args()) > 2 {
zmax = io.Atob(flag.Arg(2))
}
if len(flag.Args()) > 3 {
npts = io.Atoi(flag.Arg(3))
}
// print input data
io.Pf("\nInput data\n")
io.Pf("==========\n")
io.Pf(" simfile = %30s // simulation filename\n", simfile)
io.Pf(" zmin = %30s // min elevation\n", zmin)
io.Pf(" zmax = %30v // max elevation\n", zmax)
io.Pf(" npts = %30v // number of points\n", npts)
io.Pf("\n")
// sim file
sim := inp.ReadSim("", simfile, false)
if sim == nil {
io.PfRed("cannot read sim file\n")
return
}
// layer
var lay fem.GeoLayer
lay.Zmin = zmin
lay.Zmax = zmax
lay.Cl = sim.WaterRho0 / sim.WaterBulk
//if !lay.ReadPorousParameters(sim.Regions[0],
// TODO
}
func main() {
// catch errors
defer func() {
if err := recover(); err != nil {
io.PfRed("ERROR: %v\n", err)
}
}()
// input data
simfile, _ := io.ArgToFilename(0, "simfile.sim", true)
zmin := io.ArgToFloat(1, 0.0)
zmax := io.ArgToFloat(2, 3.0)
npts := io.ArgToInt(3, 11)
io.Pf("\n%s\n", io.ArgsTable(
"simulation filename", "simfile", simfile,
"min elevation", "zmin", zmin,
"max elevation", "zmax", zmax,
"number of points", "npts", npts,
))
// sim file
sim := inp.ReadSim("", simfile, false)
if sim == nil {
io.PfRed("cannot read sim file\n")
return
}
// layer
var lay fem.GeoLayer
lay.Zmin = zmin
lay.Zmax = zmax
lay.Cl = sim.WaterRho0 / sim.WaterBulk
//if !lay.ReadPorousParameters(sim.Regions[0],
// TODO
}
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 {
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()
}