std::vector<InputVariableRecord> ProblemRecord_Impl::inputVariableRecords() const {
InputVariableRecordVector result;
ProjectDatabase database = projectDatabase();
QSqlQuery query(*(database.qSqlDatabase()));
query.prepare(toQString("SELECT * FROM " + VariableRecord::databaseTableName() +
" WHERE problemRecordId=:problemRecordId AND variableRecordType=:variableRecordType " +
"ORDER BY variableVectorIndex"));
query.bindValue(":problemRecordId",id());
query.bindValue(":variableRecordType",VariableRecordType::InputVariableRecord);
assertExec(query);
OptionalInt previousIndex;
bool resort(false);
while (query.next()) {
result.push_back(InputVariableRecord::factoryFromQuery(query, database).get());
int index = result.back().variableVectorIndex();
if (previousIndex) {
if (index <= previousIndex.get()) {
resort = true; // if variables are changed around, order in database itself can
// get out of date (as compared to database + dirty records).
}
}
previousIndex = index;
}
if (resort) {
VariableRecordVariableVectorIndexLess comparator;
std::sort(result.begin(),result.end(),comparator);
}
return result;
}
TEST_F(ProjectFixture, RubyMeasureRecord_RubyScript) {
// Measures
MeasureVector measures;
// Null Measure
measures.push_back(NullMeasure());
openstudio::path rubyLibDirPath = openstudio::toPath(rubyLibDir());
openstudio::path perturbScript = rubyLibDirPath/openstudio::toPath("openstudio/runmanager/rubyscripts/PerturbObject.rb");
RubyMeasure rubyMeasure(perturbScript,
FileReferenceType::OSM,
FileReferenceType::OSM);
rubyMeasure.addArgument("inputPath", "in.osm");
rubyMeasure.addArgument("outputPath", "out.osm");
rubyMeasure.addArgument("objectType", "OS:Material");
rubyMeasure.addArgument("nameRegex", "I02 50mm insulation board");
rubyMeasure.addArgument("field", "3");
rubyMeasure.addArgument("value", "0.10");
// RubyMeasure
measures.push_back(rubyMeasure);
// Variables
VariableVector variables;
variables.push_back(MeasureGroup("Wall Construction",measures));
// Workflow
openstudio::runmanager::Workflow workflow;
// Problem
Problem problem("Variable",variables,workflow);
// Save to database
{
ProjectDatabase database = getCleanDatabase("RubyMeasureRecord_RubyScript");
bool didStartTransaction = database.startTransaction();
EXPECT_TRUE(didStartTransaction);
// Problem Record
ProblemRecord problemRecord = ProblemRecord::factoryFromProblem(problem,database);
database.save();
if (didStartTransaction) {
EXPECT_TRUE(database.commitTransaction());
}
// Variable Records
InputVariableRecordVector measureGroupRecords = problemRecord.inputVariableRecords();
EXPECT_EQ(1u,measureGroupRecords.size());
// Discrete Variable Record
MeasureGroupRecord measureGroupRecord = measureGroupRecords.at(0).cast<MeasureGroupRecord>();
EXPECT_EQ(2u,measureGroupRecord.measureRecordIds(true).size());
EXPECT_EQ(2u,measureGroupRecord.measureRecords(true).size());
RubyMeasureRecord rubyMeasureRecord(rubyMeasure,measureGroupRecord,0);
EXPECT_EQ("MeasureRecords",rubyMeasureRecord.databaseTableName());
ObjectRecordVector objectRecordVector = rubyMeasureRecord.children();
EXPECT_EQ(6u,objectRecordVector.size()); // arguments
objectRecordVector = rubyMeasureRecord.resources();
EXPECT_EQ(1u,objectRecordVector.size()); // script
FileReferenceRecord scriptRecord = rubyMeasureRecord.fileReferenceRecord();
EXPECT_EQ("FileReferenceRecords",scriptRecord.databaseTableName());
Measure measure = rubyMeasureRecord.measure();
EXPECT_EQ(true,measure.isSelected());
ASSERT_TRUE(measure.optionalCast<RubyMeasure>());
RubyMeasure rubyMeasureCopy = measure.cast<RubyMeasure>();
EXPECT_FALSE(rubyMeasureCopy.usesBCLMeasure());
EXPECT_FALSE(rubyMeasureCopy.isUserScript());
EXPECT_EQ(6u,rubyMeasureCopy.arguments().size());
MeasureGroupRecord measureGroupRecordFromRuby = rubyMeasureRecord.measureGroupRecord().get();
EXPECT_EQ(measureGroupRecord.databaseTableName(),measureGroupRecordFromRuby.databaseTableName());
EXPECT_EQ(measureGroupRecord.id(),measureGroupRecordFromRuby.id());
}
// Reopen database
{
ProjectDatabase database = getExistingDatabase("RubyMeasureRecord_RubyScript");
ProblemRecordVector problemRecords = ProblemRecord::getProblemRecords(database);
ASSERT_FALSE(problemRecords.empty());
EXPECT_EQ(1u,problemRecords.size());
ProblemRecord problemRecord = problemRecords[0];
// COPY-PASTED FROM ABOVE
// Variable Records
InputVariableRecordVector measureGroupRecords = problemRecord.inputVariableRecords();
EXPECT_EQ(1u,measureGroupRecords.size());
// Discrete Variable Record
MeasureGroupRecord measureGroupRecord = measureGroupRecords.at(0).cast<MeasureGroupRecord>();
EXPECT_EQ(2u,measureGroupRecord.measureRecordIds(true).size());
EXPECT_EQ(2u,measureGroupRecord.measureRecords(true).size());
RubyMeasureRecord rubyMeasureRecord(rubyMeasure,measureGroupRecord,0);
EXPECT_EQ("MeasureRecords",rubyMeasureRecord.databaseTableName());
ObjectRecordVector objectRecordVector = rubyMeasureRecord.children();
EXPECT_EQ(6u,objectRecordVector.size()); // arguments
objectRecordVector = rubyMeasureRecord.resources();
EXPECT_EQ(1u,objectRecordVector.size()); // script
FileReferenceRecord scriptRecord = rubyMeasureRecord.fileReferenceRecord();
EXPECT_EQ("FileReferenceRecords",scriptRecord.databaseTableName());
Measure measure = rubyMeasureRecord.measure();
EXPECT_EQ(true,measure.isSelected());
ASSERT_TRUE(measure.optionalCast<RubyMeasure>());
RubyMeasure rubyMeasureCopy = measure.cast<RubyMeasure>();
EXPECT_FALSE(rubyMeasureCopy.usesBCLMeasure());
EXPECT_FALSE(rubyMeasureCopy.isUserScript());
EXPECT_EQ(6u,rubyMeasureCopy.arguments().size());
MeasureGroupRecord measureGroupRecordFromRuby = rubyMeasureRecord.measureGroupRecord().get();
EXPECT_EQ(measureGroupRecord.databaseTableName(),measureGroupRecordFromRuby.databaseTableName());
EXPECT_EQ(measureGroupRecord.id(),measureGroupRecordFromRuby.id());
}
}
TEST_F(ProjectFixture, ProblemRecord)
{
//Logger::instance().logLevel(Debug);
openstudio::path rubyLibDirPath = openstudio::toPath(rubyLibDir());
openstudio::path perturbScript = rubyLibDirPath/openstudio::toPath("openstudio/runmanager/rubyscripts/PerturbObject.rb");
// Workflow
Workflow workflow;
// Variables
VariableVector variables;
// Measures
MeasureVector perturbations1;
MeasureVector perturbations2;
// Discrete Variable Records
InputVariableRecordVector measureGroupRecords;
{
// Problem
Problem problem("0 Variables",variables,workflow);
// Project Database
ProjectDatabase database = getCleanDatabase("ProblemRecord");
// Problem Record
ProblemRecord problemRecord = ProblemRecord::factoryFromProblem(problem,database);
InputVariableRecordVector measureGroupRecords = problemRecord.inputVariableRecords();
EXPECT_EQ(0u,measureGroupRecords.size());
}
{
perturbations1.push_back(NullMeasure());
variables.push_back(analysis::MeasureGroup("",perturbations1));
// Problem
Problem problem("perturbations1",variables,workflow);
// Project Database
ProjectDatabase database = getCleanDatabase("ProblemRecord");
// Problem Record
ProblemRecord problemRecord = ProblemRecord::factoryFromProblem(problem,database);
measureGroupRecords = problemRecord.inputVariableRecords();
EXPECT_EQ(1u,measureGroupRecords.size());
// Discrete Variable Record
MeasureGroupRecord measureGroupRecord = measureGroupRecords.at(0).cast<MeasureGroupRecord>();
EXPECT_EQ(1u,measureGroupRecord.measureRecordIds(true).size());
EXPECT_EQ(1u,measureGroupRecord.measureRecords(true).size());
}
{
variables.push_back(MeasureGroup("Wall Construction",perturbations1));
// Problem
Problem problem("perturbations1",variables,workflow);
// Project Database
ProjectDatabase database = getCleanDatabase("ProblemRecord");
// Problem Record
ProblemRecord problemRecord = ProblemRecord::factoryFromProblem(problem,database);
measureGroupRecords = problemRecord.inputVariableRecords();
EXPECT_EQ(2u,measureGroupRecords.size());
// Discrete Variable Record
MeasureGroupRecord variable1 = measureGroupRecords.at(0).cast<MeasureGroupRecord>();
EXPECT_EQ(static_cast<unsigned>(1), variable1.measureRecords(true).size());
EXPECT_EQ(static_cast<unsigned>(1), variable1.measureRecords(false).size());
EXPECT_EQ(static_cast<unsigned>(2), problemRecord.inputVariableRecords().size());
}
{
perturbations2.push_back(NullMeasure());
variables.push_back(MeasureGroup("Roof Construction",perturbations2));
// Problem
Problem problem("perturbations2",variables,workflow);
// Project Database
ProjectDatabase database = getCleanDatabase("ProblemRecord");
// Problem Record
ProblemRecord problemRecord = ProblemRecord::factoryFromProblem(problem,database);
measureGroupRecords = problemRecord.inputVariableRecords();
EXPECT_EQ(3u,measureGroupRecords.size());
// Discrete Variable Record
MeasureGroupRecord variable1 = measureGroupRecords.at(0).cast<MeasureGroupRecord>();
MeasureGroupRecord variable2 = measureGroupRecords.at(0).cast<MeasureGroupRecord>();
MeasureGroupRecord variable3 = measureGroupRecords.at(0).cast<MeasureGroupRecord>();
EXPECT_EQ(static_cast<size_t>(1), variable1.measureRecords(true).size());
EXPECT_EQ(static_cast<size_t>(1), variable1.measureRecords(false).size());
EXPECT_EQ(static_cast<size_t>(3), problemRecord.inputVariableRecords().size());
UUID uuid1;
UUID versionUUID1;
NullMeasure nullMeasure1(uuid1,versionUUID1,"","","",true);
NullMeasureRecord nullMeasureRecord1(nullMeasure1,variable1,0);
EXPECT_EQ(static_cast<unsigned>(2), variable1.measureRecords(true).size());
EXPECT_EQ(static_cast<unsigned>(2), variable1.measureRecords(false).size());
EXPECT_EQ(static_cast<unsigned>(2), variable2.measureRecords(true).size());
EXPECT_EQ(static_cast<unsigned>(2), variable2.measureRecords(false).size());
UUID uuid2;
UUID versionUUID2;
NullMeasure nullMeasure2(uuid2,versionUUID2,"","","",true);
NullMeasureRecord nullMeasureRecord2(nullMeasure2,variable1,0);
EXPECT_EQ(static_cast<unsigned>(2), variable1.measureRecords(true).size());
EXPECT_EQ(static_cast<unsigned>(2), variable1.measureRecords(false).size());
EXPECT_EQ(static_cast<unsigned>(2), variable2.measureRecords(true).size());
EXPECT_EQ(static_cast<unsigned>(2), variable2.measureRecords(false).size());
MeasureVector perturbations;
MeasureGroup measureGroup("Wall Construction",perturbations);
MeasureGroupRecord measureGroupRecord(measureGroup, problemRecord,0);
openstudio::path rubyPath = resourcesPath() / openstudio::toPath("project/rubyscripts/*.rb");
openstudio::path perturbScript = rubyPath/openstudio::toPath("openstudio/runmanager/rubyscripts/PerturbObject.rb");
RubyMeasure rubyMeasure(perturbScript,FileReferenceType::OSM,FileReferenceType::OSM);
RubyMeasureRecord rubyMeasureRecord1(rubyMeasure,measureGroupRecord,0);
EXPECT_EQ(static_cast<unsigned>(1), measureGroupRecord.numMeasures(true));
EXPECT_EQ(static_cast<unsigned>(1), measureGroupRecord.measureRecordIds(true).size());
EXPECT_EQ(static_cast<unsigned>(1), measureGroupRecord.measureRecords(true).size());
RubyMeasureRecord rubyMeasureRecord(rubyMeasure,measureGroupRecord,0);
EXPECT_EQ(static_cast<unsigned>(1), measureGroupRecord.numMeasures(true));
EXPECT_EQ(static_cast<unsigned>(1), measureGroupRecord.measureRecordIds(true).size());
EXPECT_EQ(rubyMeasureRecord.id(), measureGroupRecord.measureRecordIds(true)[0]);
EXPECT_EQ(static_cast<unsigned>(1), measureGroupRecord.measureRecords(true).size());
EXPECT_EQ(rubyMeasureRecord.handle(), measureGroupRecord.measureRecords(true)[0].handle());
}
}
TEST_F(ProjectFixture,AnalysisRecord_AddAndRemoveDataPoints) {
// create an analysis with data points, no results
Analysis analysis("My Analysis",
Problem("My Problem",VariableVector(),runmanager::Workflow()),
FileReferenceType::OSM);
Problem problem = analysis.problem();
DiscretePerturbationVector perturbations;
int pi = 1;
std::stringstream ss;
for (int i = 0; i < 3; ++i) {
perturbations.push_back(NullPerturbation());
for (int j = 0; j < 4; ++j) {
ss << "measure" << pi << ".rb";
perturbations.push_back(RubyPerturbation(toPath(ss.str()),
FileReferenceType::OSM,
FileReferenceType::OSM,true));
ss.str("");
++pi;
}
ss << "Variable " << i+1;
problem.push(DiscreteVariable(ss.str(),perturbations));
perturbations.clear();
ss.str("");
}
EXPECT_EQ(3u,analysis.problem().variables().size());
ASSERT_FALSE(problem.variables().empty());
EXPECT_EQ(5u,problem.variables()[0].cast<DiscreteVariable>().numPerturbations(true));
problem.pushResponse(
LinearFunction("Energy Use",
VariableVector(1u,OutputAttributeVariable("Energy Use","Total.Energy.Use"))));
EXPECT_EQ(1u,problem.responses().size());
std::vector<QVariant> values(3u,0);
OptionalDataPoint dataPoint = problem.createDataPoint(values);
ASSERT_TRUE(dataPoint);
bool test = analysis.addDataPoint(*dataPoint);
EXPECT_TRUE(test);
values[1] = 3;
dataPoint = problem.createDataPoint(values);
ASSERT_TRUE(dataPoint);
test = analysis.addDataPoint(*dataPoint);
EXPECT_TRUE(test);
values[0] = 1;
values[1] = 2;
values[2] = 4;
dataPoint = problem.createDataPoint(values);
ASSERT_TRUE(dataPoint);
test = analysis.addDataPoint(*dataPoint);
EXPECT_TRUE(test);
EXPECT_TRUE(analysis.isDirty());
EXPECT_TRUE(problem.isDirty());
BOOST_FOREACH(const Variable& variable, problem.variables()) {
EXPECT_TRUE(variable.isDirty());
ASSERT_TRUE(variable.optionalCast<DiscreteVariable>());
BOOST_FOREACH(const DiscretePerturbation& perturbation,variable.cast<DiscreteVariable>().perturbations(false)) {
EXPECT_TRUE(perturbation.isDirty());
}
}
BOOST_FOREACH(const Function& response, problem.responses()) {
EXPECT_TRUE(response.isDirty());
}
BOOST_FOREACH(const DataPoint& dataPoint, analysis.dataPoints()) {
EXPECT_TRUE(dataPoint.isDirty());
}
// save to database, make sure everything is there, make sure clean signal filters down
ProjectDatabase database = getCleanDatabase("AnalysisRecord_AddAndRemoveDataPoints");
{
bool transactionStarted = database.startTransaction();
EXPECT_TRUE(transactionStarted);
AnalysisRecord analysisRecord(analysis,database);
database.save();
test = database.commitTransaction();
EXPECT_TRUE(test);
EXPECT_EQ(analysis.uuid(),analysisRecord.handle());
EXPECT_EQ(analysis.versionUUID(),analysisRecord.uuidLast());
ASSERT_NO_THROW(analysisRecord.problemRecord());
ProblemRecord problemRecord = analysisRecord.problemRecord();
InputVariableRecordVector variableRecords = problemRecord.inputVariableRecords();
EXPECT_EQ(3u,variableRecords.size());
ASSERT_FALSE(variableRecords.empty());
ASSERT_TRUE(variableRecords[0].optionalCast<DiscreteVariableRecord>());
DiscretePerturbationRecordVector perturbationRecords = variableRecords[0].cast<DiscreteVariableRecord>().discretePerturbationRecords(false);
EXPECT_EQ(5u,perturbationRecords.size());
ASSERT_TRUE(perturbationRecords.size() > 1);
EXPECT_TRUE(perturbationRecords[0].optionalCast<NullPerturbationRecord>());
EXPECT_TRUE(perturbationRecords[1].optionalCast<RubyPerturbationRecord>());
EXPECT_EQ(3u,analysisRecord.dataPointRecords().size());
EXPECT_TRUE(analysisRecord.completeDataPointRecords().empty());
}
analysis.clearDirtyFlag();
EXPECT_FALSE(analysis.isDirty());
EXPECT_FALSE(problem.isDirty());
BOOST_FOREACH(const Variable& variable, problem.variables()) {
EXPECT_FALSE(variable.isDirty());
ASSERT_TRUE(variable.optionalCast<DiscreteVariable>());
BOOST_FOREACH(const DiscretePerturbation& perturbation,variable.cast<DiscreteVariable>().perturbations(false)) {
EXPECT_FALSE(perturbation.isDirty());
}
}
BOOST_FOREACH(const Function& response, problem.responses()) {
EXPECT_FALSE(response.isDirty());
}
BOOST_FOREACH(const DataPoint& dataPoint, analysis.dataPoints()) {
EXPECT_FALSE(dataPoint.isDirty());
}
// make some more data points and make sure dirty flag bubbles up
values[0] = 3;
values[1] = 2;
values[2] = 2;
dataPoint = problem.createDataPoint(values);
ASSERT_TRUE(dataPoint);
test = analysis.addDataPoint(*dataPoint);
EXPECT_TRUE(test);
values[0] = 0;
values[1] = 4;
values[2] = 0;
dataPoint = problem.createDataPoint(values);
ASSERT_TRUE(dataPoint);
test = analysis.addDataPoint(*dataPoint);
EXPECT_TRUE(test);
EXPECT_EQ(5u,analysis.dataPoints().size());
EXPECT_TRUE(analysis.isDirty());
EXPECT_FALSE(problem.isDirty());
BOOST_FOREACH(const Variable& variable, problem.variables()) {
EXPECT_FALSE(variable.isDirty());
ASSERT_TRUE(variable.optionalCast<DiscreteVariable>());
BOOST_FOREACH(const DiscretePerturbation& perturbation,variable.cast<DiscreteVariable>().perturbations(false)) {
EXPECT_FALSE(perturbation.isDirty());
}
}
BOOST_FOREACH(const Function& response, problem.responses()) {
EXPECT_FALSE(response.isDirty());
}
int i = 0;
BOOST_FOREACH(const DataPoint& dataPoint, analysis.dataPoints()) {
if (i < 3) {
EXPECT_FALSE(dataPoint.isDirty());
}
else {
EXPECT_TRUE(dataPoint.isDirty());
}
++i;
}
// save to database, make sure changes made it in
{
bool transactionStarted = database.startTransaction();
EXPECT_TRUE(transactionStarted);
database.unloadUnusedCleanRecords(); // ETH@20130201 - Having to call this is awkward.
// Where is the best place?
AnalysisRecord analysisRecord(analysis,database);
database.save();
test = database.commitTransaction();
EXPECT_TRUE(test);
EXPECT_EQ(analysis.uuid(),analysisRecord.handle());
EXPECT_EQ(analysis.versionUUID(),analysisRecord.uuidLast());
ASSERT_NO_THROW(analysisRecord.problemRecord());
ProblemRecord problemRecord = analysisRecord.problemRecord();
EXPECT_EQ(problemRecord.handle(),analysisRecord.problemRecord().handle());
EXPECT_EQ(problemRecord.uuidLast(),analysisRecord.problemRecord().uuidLast());
InputVariableRecordVector variableRecords = problemRecord.inputVariableRecords();
EXPECT_EQ(3u,variableRecords.size());
ASSERT_FALSE(variableRecords.empty());
ASSERT_TRUE(variableRecords[0].optionalCast<DiscreteVariableRecord>());
DiscretePerturbationRecordVector perturbationRecords = variableRecords[0].cast<DiscreteVariableRecord>().discretePerturbationRecords(false);
EXPECT_EQ(5u,perturbationRecords.size());
ASSERT_TRUE(perturbationRecords.size() > 1);
EXPECT_TRUE(perturbationRecords[0].optionalCast<NullPerturbationRecord>());
EXPECT_TRUE(perturbationRecords[1].optionalCast<RubyPerturbationRecord>());
EXPECT_EQ(5u,analysisRecord.dataPointRecords().size());
EXPECT_TRUE(analysisRecord.completeDataPointRecords().empty());
}
analysis.clearDirtyFlag();
EXPECT_FALSE(analysis.isDirty());
EXPECT_FALSE(problem.isDirty());
BOOST_FOREACH(const Variable& variable, problem.variables()) {
EXPECT_FALSE(variable.isDirty());
ASSERT_TRUE(variable.optionalCast<DiscreteVariable>());
BOOST_FOREACH(const DiscretePerturbation& perturbation,variable.cast<DiscreteVariable>().perturbations(false)) {
EXPECT_FALSE(perturbation.isDirty());
}
}
BOOST_FOREACH(const Function& response, problem.responses()) {
EXPECT_FALSE(response.isDirty());
}
BOOST_FOREACH(const DataPoint& dataPoint, analysis.dataPoints()) {
EXPECT_FALSE(dataPoint.isDirty());
}
// remove a data point and save database. make sure point actually disappears
DataPoint toRemove = analysis.dataPoints()[3];
test = analysis.removeDataPoint(toRemove);
EXPECT_TRUE(test);
EXPECT_TRUE(analysis.isDirty());
{
bool transactionStarted = database.startTransaction();
EXPECT_TRUE(transactionStarted);
database.unloadUnusedCleanRecords(); // ETH@20130201 - Having to call this is awkward.
// Where is the best place?
AnalysisRecord analysisRecord(analysis,database);
database.save();
test = database.commitTransaction();
EXPECT_TRUE(test);
EXPECT_EQ(analysis.uuid(),analysisRecord.handle());
EXPECT_EQ(analysis.versionUUID(),analysisRecord.uuidLast());
ASSERT_NO_THROW(analysisRecord.problemRecord());
ProblemRecord problemRecord = analysisRecord.problemRecord();
EXPECT_EQ(problemRecord.handle(),analysisRecord.problemRecord().handle());
EXPECT_EQ(problemRecord.uuidLast(),analysisRecord.problemRecord().uuidLast());
InputVariableRecordVector variableRecords = problemRecord.inputVariableRecords();
EXPECT_EQ(3u,variableRecords.size());
ASSERT_FALSE(variableRecords.empty());
ASSERT_TRUE(variableRecords[0].optionalCast<DiscreteVariableRecord>());
DiscretePerturbationRecordVector perturbationRecords = variableRecords[0].cast<DiscreteVariableRecord>().discretePerturbationRecords(false);
EXPECT_EQ(5u,perturbationRecords.size());
ASSERT_TRUE(perturbationRecords.size() > 1);
EXPECT_TRUE(perturbationRecords[0].optionalCast<NullPerturbationRecord>());
EXPECT_TRUE(perturbationRecords[1].optionalCast<RubyPerturbationRecord>());
EXPECT_EQ(4u,analysisRecord.dataPointRecords().size());
OptionalDataPointRecord searchResult = database.getObjectRecordByHandle<DataPointRecord>(toRemove.uuid());
EXPECT_FALSE(searchResult);
EXPECT_EQ(4u,DataPointRecord::getDataPointRecords(database).size());
}
EXPECT_EQ(4u,analysis.dataPoints().size());
test = analysis.clearDirtyFlag();
EXPECT_TRUE(test);
}
analysis::Problem ProblemRecord_Impl::problem() const {
InputVariableRecordVector inputVariableRecords = this->inputVariableRecords();
WorkflowRecordVector workflowRecords = this->workflowRecords();
analysis::WorkflowStepVector workflow;
// mesh InputVariables and WorkItems together to form overall workflow
int ivrIndex(0); // index into input variable records
int wrIndex(0); // index into workflow records
int wIndex(0); // index into workflow
int ivrN = inputVariableRecords.size();
int wrN = workflowRecords.size();
OptionalInt ivrWIndex; // saved index into workflow for next input variable
OptionalInt wrWIndex; // saved index into workflow for next workflow record
if (!inputVariableRecords.empty()) {
ivrWIndex = inputVariableRecords[ivrIndex].variableVectorIndex();
}
if (!workflowRecords.empty()) {
wrWIndex = workflowRecords[wrIndex].workflowIndex();
}
for (int i = 0, n = ivrN + wrN; i < n; ++i) {
if (!wrWIndex || (ivrWIndex && (*ivrWIndex < *wrWIndex))) {
// InputVariable is next
BOOST_ASSERT(*ivrWIndex == wIndex); // saved and expected index into workflow match
BOOST_ASSERT(ivrIndex < ivrN); // there is an input variable record to deserialize
workflow.push_back(WorkflowStep(inputVariableRecords[ivrIndex].inputVariable()));
++ivrIndex; // go to next input variable record
++wIndex; // and next index into workflow
BOOST_ASSERT(wIndex == int(workflow.size())); // next index into workflow should match current size
if (ivrIndex < ivrN) {
ivrWIndex = inputVariableRecords[ivrIndex].variableVectorIndex();
}
else {
ivrWIndex.reset(); // no more input variables to deserialize
}
}
else {
// Workflow is next
BOOST_ASSERT(wrWIndex);
int temp = *wrWIndex; // for debugging
BOOST_ASSERT(temp == wIndex); // saved index into workflow should match expected value
BOOST_ASSERT(wrIndex < wrN); // there is a workflow record to deserialize
std::vector<runmanager::WorkItem> workItems = workflowRecords[wrIndex].workflow().toWorkItems();
workflow.insert(workflow.end(),workItems.begin(),workItems.end());
++wrIndex; // go to next workflow record
wIndex += workItems.size(); // update next expected workflow index
BOOST_ASSERT(wIndex == int(workflow.size())); // next index into workflow should match current size
if (wrIndex < wrN) {
wrWIndex = workflowRecords[wrIndex].workflowIndex();
}
else {
wrWIndex.reset(); // no more workflow records to deserialize
}
}
}
analysis::FunctionVector responses;
FunctionRecordVector responseRecords = this->responseRecords();
BOOST_FOREACH(const FunctionRecord responseRecord,responseRecords) {
responses.push_back(responseRecord.function());
}
