func main() {
log.SetFlags(0)
flag.Parse()
if *help || flag.NArg() != 1 {
fmt.Println("Usage: inventory [cyclus-db]")
fmt.Println("Creates a fast queryable inventory table for a cyclus sqlite output file.\n")
flag.PrintDefaults()
return
}
fname := flag.Arg(0)
db, err := sql.Open("sqlite3", fname)
fatalif(err)
defer db.Close()
fatalif(post.Prepare(db))
defer post.Finish(db)
simids, err := post.GetSimIds(db)
fatalif(err)
for _, simid := range simids {
ctx := post.NewContext(db, simid)
if *verbose {
ctx.Log = log.New(os.Stdout, "", 0)
}
err := ctx.WalkAll()
if err != nil {
fmt.Println(err)
}
}
}
func main() {
log.SetFlags(0)
flag.Parse()
if *help || flag.NArg() < 1 {
fmt.Println("Usage: metric -db <cyclus-db> [opts] <command> [args...]")
fmt.Println("Calculates metrics for cyclus simulation data in a sqlite database.")
flag.PrintDefaults()
fmt.Println("\nCommands:")
for i := range cmds.Names {
fmt.Printf(" %v: %v\n", cmds.Names[i], cmds.Helps[i])
}
return
} else if *dbname == "" {
log.Fatal("must specify database with db flag")
}
if *custom != "" {
data, err := ioutil.ReadFile(*custom)
fatalif(err)
fatalif(json.Unmarshal(data, &customSql))
}
var err error
db, err = sql.Open("sqlite3", *dbname)
fatalif(err)
defer db.Close()
if *simidstr == "" {
ids, err := query.SimIds(db)
fatalif(err)
simid = ids[0]
} else {
simid, err = hex.DecodeString(*simidstr)
fatalif(err)
}
// post process if necessary
fatalif(post.Prepare(db))
simids, err := post.GetSimIds(db)
fatalif(err)
for _, simid := range simids {
ctx := post.NewContext(db, simid)
err := ctx.WalkAll()
if !post.IsAlreadyPostErr(err) {
fatalif(err)
}
}
fatalif(post.Finish(db))
// run command
cmds.Execute(flag.Args())
}
func RunSim(scen *Scenario) (dbfile string, simid []byte, err error) {
if scen.Handle == "" {
scen.Handle = "none"
}
// generate cyclus input file and run cyclus
ui := uuid.NewRandom()
err = os.MkdirAll(tmpDir, 0755)
if err != nil {
return "", nil, err
}
cycin := filepath.Join(tmpDir, ui.String()+".cyclus.xml")
cycout := filepath.Join(tmpDir, ui.String()+".sqlite")
err = GenCyclusInfile(scen, cycin)
if err != nil {
return "", nil, err
}
cmd := exec.Command(scen.CyclusBin, cycin, "-o", cycout)
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
return "", nil, err
}
// post process cyclus output db
db, err := sql.Open("sqlite3", cycout)
if err != nil {
return "", nil, err
}
defer db.Close()
if err := post.Prepare(db); err != nil {
return "", nil, err
}
defer post.Finish(db)
simids, err := post.GetSimIds(db)
if err != nil {
return "", nil, err
}
ctx := post.NewContext(db, simids[0])
if err := ctx.WalkAll(); err != nil {
return "", nil, err
}
return cycout, simids[0], nil
}
func uploadInner(w http.ResponseWriter, r *http.Request, kill chan bool) {
// parse database from multi part form data
if err := r.ParseMultipartForm(MAX_MEMORY); err != nil {
log.Println(err)
http.Error(w, err.Error(), http.StatusForbidden)
return
}
gotDb := false
uid := r.URL.Path[len("/upload/"):]
fname := uid + ".sqlite"
for _, fileHeaders := range r.MultipartForm.File {
for _, fileHeader := range fileHeaders {
file, _ := fileHeader.Open()
data, _ := ioutil.ReadAll(file)
err := ioutil.WriteFile(fname, data, 0644)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
defer func() { os.Remove(fname) }()
gotDb = true
break
}
break
}
if !gotDb {
http.Error(w, "No file provided", http.StatusBadRequest)
log.Print("received request with no file")
return
}
select {
case <-kill:
return
default:
}
// post process the database
db, err := sql.Open("sqlite3", fname)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
defer db.Close()
err = post.Prepare(db)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
defer post.Finish(db)
simids, err := post.GetSimIds(db)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
ctx := post.NewContext(db, simids[0])
if err := ctx.WalkAll(); err != nil {
log.Println(err)
}
// get simid
ids, err := query.SimIds(db)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
simid := ids[0]
rs := &Results{}
select {
case <-kill:
return
default:
}
// create flow graph
combineProto := false
arcs, err := query.FlowGraph(db, simid, 0, -1, combineProto)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
dotname := fname + ".dot"
dotf, err := os.Create(dotname)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
defer func() { os.Remove(dotname) }()
fmt.Fprintln(dotf, "digraph ResourceFlows {")
fmt.Fprintln(dotf, " overlap = false;")
fmt.Fprintln(dotf, " nodesep=1.0;")
fmt.Fprintln(dotf, " edge [fontsize=9];")
for _, arc := range arcs {
fmt.Fprintf(dotf, " \"%v\" -> \"%v\" [label=\"%v\\n(%.3g kg)\"];\n", arc.Src, arc.Dst, arc.Commod, arc.Quantity)
}
fmt.Fprintln(dotf, "}")
dotf.Close()
var buf bytes.Buffer
cmd := exec.Command("dot", "-Tsvg", dotname)
cmd.Stdout = &buf
err = cmd.Run()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
rs.Flowgraph = buf.String()
select {
case <-kill:
return
default:
}
// create agents table
rs.Agents, err = query.AllAgents(db, simid, "")
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
// create Material transactions table
sql := `
SELECT TransactionId,Time,SenderId,ReceiverId,tr.ResourceId,Commodity,NucId,MassFrac*Quantity
FROM Transactions AS tr
INNER JOIN Resources AS res ON tr.ResourceId = res.ResourceId
INNER JOIN Compositions AS cmp ON res.QualId = cmp.QualId
WHERE tr.SimId = ? AND cmp.SimId = res.SimId AND res.SimId = tr.SimId
AND res.Type = 'Material';
`
rows, err := db.Query(sql, simid)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
for rows.Next() {
t := &Trans{}
if err := rows.Scan(&t.Id, &t.Time, &t.Sender, &t.Receiver, &t.ResourceId, &t.Commod, &t.Nuc, &t.Qty); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
rs.TransMats = append(rs.TransMats, t)
}
if err := rows.Err(); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
// create Material transactions table
sql = `
SELECT TransactionId,Time,SenderId,ReceiverId,tr.ResourceId,Commodity,Quality,Quantity
FROM Transactions AS tr
INNER JOIN Resources AS res ON tr.ResourceId = res.ResourceId
INNER JOIN Products AS pd ON res.QualId = pd.QualId
WHERE tr.SimId = ? AND pd.SimId = res.SimId AND res.SimId = tr.SimId
AND res.Type = 'Product';
`
rows, err = db.Query(sql, simid)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
for rows.Next() {
t := &ProdTrans{}
if err := rows.Scan(&t.Id, &t.Time, &t.Sender, &t.Receiver, &t.ResourceId, &t.Commod, &t.Quality, &t.Qty); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
rs.TransProds = append(rs.TransProds, t)
}
if err := rows.Err(); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
select {
case <-kill:
return
default:
}
// render all results and save page
rs.Uid = uid
resultTmpl.Execute(w, rs)
f, err := os.Create(uid + ".html")
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Print(err)
return
}
defer f.Close()
resultTmpl.Execute(f, rs)
close(kill)
}
func main() {
flag.Parse()
log.SetFlags(log.Lshortfile)
// load problem scen file
scen := &Scenario{}
err := scen.Load(*scenfile)
fatalif(err)
// build dakota input file from template and return
if *dakotaGen {
if *dakotaif == "" {
*dakotaif = filepath.Base(scen.DakotaTmpl) + ".gen"
}
t := template.Must(template.ParseFiles(scen.DakotaTmpl))
f, err := os.Create(*dakotaif)
fatalif(err)
defer f.Close()
err = t.Execute(f, scen)
fatalif(err)
return
}
if *sweep != "" {
db, err := sql.Open("sqlite3", *sweep)
fatalif(err)
defer db.Close()
db.Exec(`
CREATE TABLE IF NOT EXISTS Sweep (
f1_t1 INTEGER,
f1_t2 INTEGER,
f1_t3 INTEGER,
f1_t4 INTEGER,
f1_t5 INTEGER,
f2_t1 INTEGER,
f2_t2 INTEGER,
f2_t3 INTEGER,
f2_t4 INTEGER,
f2_t5 INTEGER,
f3_t1 INTEGER,
f3_t2 INTEGER,
f3_t3 INTEGER,
f3_t4 INTEGER,
f3_t5 INTEGER,
f4_t1 INTEGER,
f4_t2 INTEGER,
f4_t3 INTEGER,
f4_t4 INTEGER,
f4_t5 INTEGER,
Objective REAL
);
`)
smt, err := db.Prepare("INSERT INTO Sweep VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);")
fatalif(err)
tx, err := db.Begin()
stmt := tx.Stmt(smt)
fatalif(err)
for i, p := range buildSweep() {
if (i+1)%20 == 0 {
fatalif(tx.Commit())
tx, err = db.Begin()
stmt = tx.Stmt(smt)
fatalif(err)
}
scen.InitParams(p)
cycdb, simid, err := RunSim(scen)
fatalif(err)
val, err := CalcObjective(cycdb, simid, scen)
fatalif(err)
vals := []interface{}{}
for _, v := range p {
vals = append(vals, v)
}
vals = append(vals, val)
_, err = stmt.Exec(vals...)
fatalif(err)
}
fatalif(tx.Commit())
return
}
if *metric != "" {
// post process cyclus output db
db, err := sql.Open("sqlite3", *metric)
fatalif(err)
defer db.Close()
fatalif(post.Prepare(db))
defer post.Finish(db)
simids, err := post.GetSimIds(db)
fatalif(err)
ctx := post.NewContext(db, simids[0])
if err := ctx.WalkAll(); err != nil {
fmt.Println(err)
}
// calculate and write out objective val
val, err := CalcObjective(*metric, simids[0], scen)
fatalif(err)
fmt.Println(val)
return
}
// Parse dakota params into scenario object
paramsFile := flag.Arg(0)
err = ParseParams(scen, paramsFile)
fatalif(err)
cycout, simid, err := RunSim(scen)
fatalif(err)
// calculate and write out objective val
resultFile := flag.Arg(1)
val, err := CalcObjective(cycout, simid, scen)
fatalif(err)
err = ioutil.WriteFile(resultFile, []byte(fmt.Sprint(val)), 0755)
fatalif(err)
}
