CYCLUS
Loading...
Searching...
No Matches
xml_flat_loader.cc
Go to the documentation of this file.
1#include "xml_flat_loader.h"
2
3#include "agent.h"
4#include "context.h"
5#include "discovery.h"
6#include "env.h"
7#include "error.h"
8#include "infile_tree.h"
9#include "logger.h"
10#include "recorder.h"
11#include "timer.h"
12
13namespace cyclus {
14
15std::string BuildFlatMasterSchema(std::string schema_path, std::vector<AgentSpec> specs) {
16 Timer ti;
17 Recorder rec;
18 Context ctx(&ti, &rec);
19
20 std::stringstream schema("");
21 LoadStringstreamFromFile(schema, schema_path);
22 std::string master = schema.str();
23
24 std::string subschemas;
25 for (int i = 0; i < specs.size(); ++i) {
26 Agent* m = DynamicModule::Make(&ctx, specs[i]);
27 subschemas += "<element name=\"" + specs[i].alias() + "\">\n";
28 subschemas += m->schema() + "\n";
29 subschemas += "</element>\n";
30 ctx.DelAgent(m);
31 }
32
33 // replace refs in master rng template file
34 std::string search_str = std::string("@MODEL_SCHEMAS@");
35 size_t pos = master.find(search_str);
36 if (pos != std::string::npos) {
37 master.replace(pos, search_str.size(), subschemas);
38 }
39
40 return master;
41}
42
43std::string BuildFlatMasterSchema(std::string schema_path, std::string infile) {
44
45 std::vector<AgentSpec> specs = ParseSpecs(infile);
46
47 return BuildFlatMasterSchema(schema_path, specs);
48
49}
50
51std::string BuildFlatMasterSchema(std::string schema_path) {
52
53 std::vector<AgentSpec> specs = ParseSpecs(cyclus::DiscoverSpecsInCyclusPath());
54
55 return BuildFlatMasterSchema(schema_path, specs);
56
57}
58
62
64 InfileTree xqe(*parser_);
65
66 // create prototypes
67 int num_protos = xqe.NMatches("/*/prototype");
68 for (int i = 0; i < num_protos; i++) {
69 InfileTree* qe = xqe.SubTree("/*/prototype", i);
70 std::string prototype = qe->GetString("name");
71 std::string alias = qe->SubTree("config")->GetElementName(0);
72 AgentSpec spec = specs_[alias];
73
74 Agent* agent = DynamicModule::Make(ctx_, spec);
75
76 // call manually without agent impl injected to keep all Agent state in a
77 // single, consolidated db table
78 agent->Agent::InfileToDb(qe, DbInit(agent, true));
79
80 agent->InfileToDb(qe, DbInit(agent));
81 rec_->Flush();
82
83 std::vector<Cond> conds;
84 conds.push_back(Cond("SimId", "==", rec_->sim_id()));
85 conds.push_back(Cond("AgentId", "==", agent->id()));
86 conds.push_back(Cond("SimTime", "==", static_cast<int>(0)));
87 CondInjector ci(b_, conds);
88 PrefixInjector pi(&ci, "AgentState");
89
90 // call manually without agent impl injected
91 agent->Agent::InitFrom(&pi);
92
93 pi = PrefixInjector(&ci, "AgentState" + spec.Sanitize());
94 agent->InitFrom(&pi);
95 ctx_->AddPrototype(prototype, agent);
96 }
97
98 // retrieve agent hierarchy and initial inventories
99 int num_agents = xqe.NMatches("/*/agent");
100 std::map<std::string, std::string> protos; // map<name, prototype>
101 std::map<std::string, std::string> parents; // map<agent, parent>
102 std::set<std::string> agents; // set<agent_name>
103 std::map<std::string, InfileTree*> invs; // map<agent, qe>;
104 for (int i = 0; i < num_agents; i++) {
105 InfileTree* qe = xqe.SubTree("/*/agent", i);
106 std::string name = qe->GetString("name");
107 std::string proto = qe->GetString("prototype");
108 std::string parent = OptionalQuery<std::string>(qe, "parent", "");
109 protos[name] = proto;
110 parents[name] = parent;
111 invs[name] = qe;
112 agents.insert(name);
113 }
114
115 // build agents starting at roots (no parent) down.
116 std::map<std::string, Agent*> built; // map<agent_name, agent_ptr>
117 std::set<std::string>::iterator it = agents.begin();
118 while (agents.size() > 0) {
119 std::string name = *it;
120 std::string proto = protos[name];
121 std::string parent = parents[name];
122 if (parent == "") {
123 built[name] = BuildAgent(proto, NULL);
124 ++it;
125 agents.erase(name);
126 } else if (built.count(parent) > 0) {
127 built[name] = BuildAgent(proto, built[parent]);
128 ++it;
129 agents.erase(name);
130 } else {
131 ++it;
132 }
133 if (it == agents.end()) {
134 it = agents.begin();
135 }
136 }
137}
138
139} // namespace cyclus
std::string Sanitize()
The abstract base class used by all types of agents that live and interact in a simulation.
Definition agent.h:49
virtual void InitFrom(QueryableBackend *b)
Intializes an agent's internal state from the database.
Definition agent.cc:45
virtual std::string schema()
Returns an agent's xml rng schema for initializing from input files.
Definition agent.h:333
virtual void InfileToDb(InfileTree *qe, DbInit di)
Translates info for the agent from an input file to the database by reading parameters from the passe...
Definition agent.cc:36
virtual const int id() const
The agent instance's unique ID within a simulation.
Definition agent.h:352
Wrapper class for QueryableBackends that injects a set of Cond's into every query before being execut...
Represents a condition used to filter rows returned by a query.
A simulation context provides access to necessary simulation-global functions and state.
Definition context.h:145
void DelAgent(Agent *m)
Destructs and cleans up m (and it's children recursively).
Definition context.cc:115
DbInit provides an interface for agents to record data to the output db that automatically injects th...
Definition db_init.h:14
static Agent * Make(Context *ctx, AgentSpec spec)
Returns a newly constructed agent for the given module spec.
A class for extracting information from a given XML parser.
Definition infile_tree.h:22
virtual int NMatches(std::string query)
investigates the current status and returns the number of elements matching a query
virtual std::string GetElementName(int index=0)
investigates the current status and returns a string representing the name of a given index
InfileTree * SubTree(std::string query, int index=0)
populates a child infile based on a query and index
virtual std::string GetString(std::string query, int index=0)
investigates the current status and returns a string representing the content of a query at a given i...
Wrapper class for QueryableBackends that injects prefix in front of the title/table for every query b...
Collects and manages output data generation for the cyclus core and agents during a simulation.
Definition recorder.h:45
Controls simulation timestepping and inter-timestep phases.
Definition timer.h:22
boost::shared_ptr< XMLParser > parser_
the parser
QueryableBackend * b_
std::string schema_path_
filepath to the schema
std::map< std::string, AgentSpec > specs_
Agent * BuildAgent(std::string proto, Agent *parent)
Creates and builds an agent, notifying its parent.
std::string file_
the input file name
void LoadInitialAgents()
Creates all initial agent instances from the input file.
virtual std::string master_schema()
Code providing rudimentary logging capability for the Cyclus core.
taken directly from OsiSolverInterface.cpp on 2/17/14 from https://projects.coin-or....
Definition agent.cc:14
std::string BuildFlatMasterSchema(std::string schema_path, std::vector< AgentSpec > specs)
Builds and returns a master cyclus input xml schema defining a flat prototype and instance structure ...
std::set< std::string > DiscoverSpecsInCyclusPath()
Discover archetype specifications that live recursively in CYCLUS_PATH directories.
Definition discovery.cc:130
void LoadStringstreamFromFile(std::stringstream &stream, std::string file, std::string format)
Reads the given file path as XML into the passed stream.
std::vector< AgentSpec > ParseSpecs(std::set< std::string > agent_set)
Returns a list of the full module+agent spec for all agents in the given set of agent names.
T OptionalQuery(InfileTree *tree, std::string query, T default_val)
a query method for optional parameters