// Start starts handling of results given a simulation input file
func Start(simfnpath string, stageIdx, regionIdx int) {
// start FE global structure
fem.Global.LogPrefix = "out_"
erasefiles := false
verbose := false
if !fem.Start(simfnpath, erasefiles, verbose) {
chk.Panic("cannot start analysis process with simfnpath=%q\n", simfnpath)
}
// read summary
Sum = fem.ReadSum(fem.Global.Dirout, fem.Global.Fnkey)
if Sum == nil {
chk.Panic("cannot read summary file for simulation=%q\n", simfnpath)
}
// allocate domain
distr := false
Dom = fem.NewDomain(fem.Global.Sim.Regions[regionIdx], distr)
if !Dom.SetStage(stageIdx, fem.Global.Sim.Stages[stageIdx], distr) {
chk.Panic("cannot allocate domain\n")
}
// clear previous data
Ipoints = make([]*fem.OutIpData, 0)
Cid2ips = make([][]int, len(Dom.Msh.Cells))
Ipkey2ips = make(map[string][]int)
Ipkeys = make(map[string]bool)
Planes = make(map[string]*PlaneData)
Results = make(map[string]Points)
TimeInds = make([]int, 0)
Times = make([]float64, 0)
Splots = make([]*SplotDat, 0)
// bins
m := Dom.Msh
δ := TolC * 2
xi := []float64{m.Xmin - δ, m.Ymin - δ}
xf := []float64{m.Xmax + δ, m.Ymax + δ}
if m.Ndim == 3 {
xi = append(xi, m.Zmin-δ)
xf = append(xf, m.Zmax+δ)
}
err := NodBins.Init(xi, xf, Ndiv)
if err != nil {
chk.Panic("cannot initialise bins for nodes: %v", err)
}
err = IpsBins.Init(xi, xf, Ndiv)
if err != nil {
chk.Panic("cannot initialise bins for integration points: %v", err)
}
// add nodes to bins
for _, nod := range Dom.Nodes {
err := NodBins.Append(nod.Vert.C, nod.Vert.Id)
if err != nil {
return
}
}
// to find limits
ndim := Dom.Msh.Ndim
IpsMin = make([]float64, ndim)
IpsMax = make([]float64, ndim)
first := true
// add integration points to slice of ips and to bins
for cid, ele := range Dom.Cid2elem {
if ele == nil {
continue
}
dat := ele.OutIpsData()
nip := len(dat)
ids := make([]int, nip)
for i, d := range dat {
// add to bins
ipid := len(Ipoints)
ids[i] = ipid
Ipoints = append(Ipoints, d)
err = IpsBins.Append(d.X, ipid)
if err != nil {
chk.Panic("cannot append to bins of integration points: %v", err)
}
// set auxiliary map
vals := d.Calc(Dom.Sol)
for key, _ := range vals {
utl.StrIntsMapAppend(&Ipkey2ips, key, ipid)
Ipkeys[key] = true
}
// limits
if first {
for j := 0; j < ndim; j++ {
IpsMin[j] = d.X[j]
IpsMax[j] = d.X[j]
}
first = false
} else {
for j := 0; j < ndim; j++ {
IpsMin[j] = min(IpsMin[j], d.X[j])
IpsMax[j] = max(IpsMax[j], d.X[j])
}
}
}
Cid2ips[cid] = ids
}
}
// Start starts handling of results given a simulation input file
func Start(simfnpath string, stageIdx, regionIdx int) {
// fem structure
Analysis = fem.NewFEM(simfnpath, "", false, false, true, false, false, 0)
Dom = Analysis.Domains[regionIdx]
Sum = Analysis.Summary
// set stage
err := Analysis.SetStage(stageIdx)
if err != nil {
chk.Panic("cannot set stage:\n%v", err)
}
// initialise solution vectors
err = Analysis.ZeroStage(stageIdx, true)
if err != nil {
chk.Panic("cannot initialise solution vectors:\n%v", err)
}
// clear previous data
Ipoints = make([]*fem.OutIpData, 0)
Cid2ips = make([][]int, len(Dom.Msh.Cells))
Ipkey2ips = make(map[string][]int)
Ipkeys = make(map[string]bool)
Planes = make(map[string]*PlaneData)
Results = make(map[string]Points)
TimeInds = make([]int, 0)
Times = make([]float64, 0)
Splots = make([]*SplotDat, 0)
// bins
m := Dom.Msh
δ := TolC * 2
xi := []float64{m.Xmin - δ, m.Ymin - δ}
xf := []float64{m.Xmax + δ, m.Ymax + δ}
if m.Ndim == 3 {
xi = append(xi, m.Zmin-δ)
xf = append(xf, m.Zmax+δ)
}
err = NodBins.Init(xi, xf, Ndiv)
if err != nil {
chk.Panic("cannot initialise bins for nodes: %v", err)
}
err = IpsBins.Init(xi, xf, Ndiv)
if err != nil {
chk.Panic("cannot initialise bins for integration points: %v", err)
}
// add nodes to bins
for _, nod := range Dom.Nodes {
err := NodBins.Append(nod.Vert.C, nod.Vert.Id)
if err != nil {
return
}
}
// to find limits
ndim := Dom.Msh.Ndim
IpsMin = make([]float64, ndim)
IpsMax = make([]float64, ndim)
first := true
// add integration points to slice of ips and to bins
for cid, ele := range Dom.Cid2elem {
if ele == nil {
continue
}
dat := ele.OutIpsData()
nip := len(dat)
ids := make([]int, nip)
for i, d := range dat {
// add to bins
ipid := len(Ipoints)
ids[i] = ipid
Ipoints = append(Ipoints, d)
err = IpsBins.Append(d.X, ipid)
if err != nil {
chk.Panic("cannot append to bins of integration points: %v", err)
}
// set auxiliary map
vals := d.Calc(Dom.Sol)
for key, _ := range vals {
utl.StrIntsMapAppend(&Ipkey2ips, key, ipid)
Ipkeys[key] = true
}
// limits
if first {
for j := 0; j < ndim; j++ {
IpsMin[j] = d.X[j]
IpsMax[j] = d.X[j]
}
first = false
} else {
for j := 0; j < ndim; j++ {
IpsMin[j] = utl.Min(IpsMin[j], d.X[j])
IpsMax[j] = utl.Max(IpsMax[j], d.X[j])
}
}
}
Cid2ips[cid] = ids
}
}
