TEST_F(AnalysisDriverFixture,SimpleProject_Create) {
openstudio::path projectDir = toPath("AnalysisDriverFixtureData");
if (!boost::filesystem::exists(projectDir)) {
boost::filesystem::create_directory(projectDir);
}
projectDir = projectDir / toPath("NewProject");
boost::filesystem::remove_all(projectDir);
OptionalSimpleProject project = SimpleProject::create(projectDir);
ASSERT_TRUE(project);
EXPECT_TRUE(boost::filesystem::exists(projectDir));
EXPECT_TRUE(boost::filesystem::is_directory(projectDir));
EXPECT_TRUE(boost::filesystem::exists(projectDir / toPath("project.osp")));
EXPECT_TRUE(boost::filesystem::exists(projectDir / toPath("run.db")));
EXPECT_TRUE(boost::filesystem::exists(projectDir / toPath("project.log")));
Analysis analysis = project->analysis();
EXPECT_EQ(0,analysis.problem().numVariables());
EXPECT_FALSE(analysis.algorithm());
EXPECT_EQ(0u,analysis.dataPoints().size());
AnalysisRecord analysisRecord = project->analysisRecord();
EXPECT_EQ(0u,analysisRecord.problemRecord().inputVariableRecords().size());
EXPECT_EQ(0u,analysisRecord.dataPointRecords().size());
}
// Test not yet to scale re: total data points.
TEST_F(ProjectFixture,Profile_DeserializeAnalysis) {
// ETH@20121108 - When this test is running reasonably well, replace the beginning of
// UpdateAnalysis with this.
ProjectDatabase db = getPopulatedDatabase(100,500,false,toPath("./UpdateAnalysis"));
AnalysisRecordVector records = AnalysisRecord::getAnalysisRecords(db);
ASSERT_EQ(1u,records.size());
AnalysisRecord record = records[0];
// time the process of deserializing an analysis
ptime start = microsec_clock::local_time();
Analysis analysis = record.analysis();
time_duration deserializeTime = microsec_clock::local_time() - start;
std::cout << "Time: " << to_simple_string(deserializeTime) << std::endl;
}
DesignOfExperimentsRecord::DesignOfExperimentsRecord(
const analysis::DesignOfExperiments& designOfExperiments, AnalysisRecord& analysisRecord)
: OpenStudioAlgorithmRecord(boost::shared_ptr<detail::DesignOfExperimentsRecord_Impl>(
new detail::DesignOfExperimentsRecord_Impl(designOfExperiments, analysisRecord)),
analysisRecord.projectDatabase(),
designOfExperiments)
{
OS_ASSERT(getImpl<detail::DesignOfExperimentsRecord_Impl>());
}
DDACEAlgorithmRecord::DDACEAlgorithmRecord(const analysis::DDACEAlgorithm& ddaceAlgorithm,
AnalysisRecord& analysisRecord)
: DakotaAlgorithmRecord(std::shared_ptr<detail::DDACEAlgorithmRecord_Impl>(
new detail::DDACEAlgorithmRecord_Impl(ddaceAlgorithm, analysisRecord)),
analysisRecord.projectDatabase(),
ddaceAlgorithm)
{
OS_ASSERT(getImpl<detail::DDACEAlgorithmRecord_Impl>());
constructRelatedRecords(ddaceAlgorithm);
}
ParameterStudyAlgorithmRecord::ParameterStudyAlgorithmRecord(
const analysis::ParameterStudyAlgorithm& parameterStudyAlgorithm,
AnalysisRecord& analysisRecord)
: DakotaAlgorithmRecord(std::shared_ptr<detail::ParameterStudyAlgorithmRecord_Impl>(
new detail::ParameterStudyAlgorithmRecord_Impl(parameterStudyAlgorithm, analysisRecord)),
analysisRecord.projectDatabase(),
parameterStudyAlgorithm)
{
OS_ASSERT(getImpl<detail::ParameterStudyAlgorithmRecord_Impl>());
constructRelatedRecords(parameterStudyAlgorithm);
}
PSUADEDaceAlgorithmRecord::PSUADEDaceAlgorithmRecord(
const analysis::PSUADEDaceAlgorithm& psuadedaceAlgorithm,
AnalysisRecord& analysisRecord)
: DakotaAlgorithmRecord(boost::shared_ptr<detail::PSUADEDaceAlgorithmRecord_Impl>(
new detail::PSUADEDaceAlgorithmRecord_Impl(psuadedaceAlgorithm, analysisRecord)),
analysisRecord.projectDatabase(),
psuadedaceAlgorithm)
{
BOOST_ASSERT(getImpl<detail::PSUADEDaceAlgorithmRecord_Impl>());
constructRelatedRecords(psuadedaceAlgorithm);
}
TEST_F(AnalysisDriverFixture, DesignOfExperiments_MeshAnalysis) {
openstudio::path rubyLibDirPath = openstudio::toPath(rubyLibDir());
// GET SIMPLE PROJECT
SimpleProject project = getCleanSimpleProject("DesignOfExperiments_MeshAnalysis");
Analysis analysis = project.analysis();
// SET PROBLEM
Problem problem = retrieveProblem("MixedOsmIdf",false,false);
analysis.setProblem(problem);
// SET SEED
Model model = model::exampleModel();
openstudio::path p = toPath("./example.osm");
model.save(p,true);
FileReference seedModel(p);
analysis.setSeed(seedModel);
// SET ALGORITHM
DesignOfExperimentsOptions algOptions(DesignOfExperimentsType::FullFactorial);
DesignOfExperiments algorithm(algOptions);
analysis.setAlgorithm(algorithm);
// RUN ANALYSIS
AnalysisDriver driver = project.analysisDriver();
AnalysisRunOptions runOptions = standardRunOptions(project.projectDir());
driver.run(analysis,runOptions);
EXPECT_TRUE(driver.waitForFinished());
// CHECK RESULTS
AnalysisRecord analysisRecord = project.analysisRecord();
EXPECT_EQ(4,analysisRecord.problemRecord().combinatorialSize(true).get());
EXPECT_EQ(4u, analysisRecord.dataPointRecords().size());
BOOST_FOREACH(const DataPointRecord& dataPointRecord, analysisRecord.dataPointRecords()) {
EXPECT_TRUE(dataPointRecord.isComplete());
EXPECT_FALSE(dataPointRecord.failed());
}
// get data points by perturbations and vice versa
std::vector<DataPointRecord> testDataPoints;
std::vector<QVariant> testVariableValues;
// all data points are successful
testDataPoints = analysisRecord.successfulDataPointRecords();
EXPECT_EQ(4u,testDataPoints.size());
// empty variableValues returns all data points
testDataPoints = analysisRecord.getDataPointRecords(testVariableValues);
EXPECT_EQ(4u, testDataPoints.size());
// find the baseline
testVariableValues.clear();
testVariableValues.push_back(0);
testVariableValues.push_back(QVariant(QVariant::Int)); // only one perturbation, null works too
testVariableValues.push_back(0);
ASSERT_TRUE(testVariableValues[1].isNull());
testDataPoints = analysisRecord.getDataPointRecords(testVariableValues);
ASSERT_EQ(1u, testDataPoints.size());
// find model with improved wall and roof
testVariableValues.clear();
testVariableValues.push_back(1);
testVariableValues.push_back(0);
testVariableValues.push_back(1);
testDataPoints = analysisRecord.getDataPointRecords(testVariableValues);
ASSERT_EQ(1u, testDataPoints.size());
DataPoint testDataPoint = testDataPoints[0].dataPoint();
std::vector<OptionalDiscretePerturbation> perturbations =
analysis.problem().getDiscretePerturbations(testVariableValues);
ASSERT_EQ(3u,perturbations.size());
ASSERT_TRUE(perturbations[0] && perturbations[1] && perturbations[2]);
EXPECT_TRUE(perturbations[0]->uuid() == problem.variables()[0].cast<DiscreteVariable>().perturbations(false)[1].uuid());
EXPECT_TRUE(perturbations[1]->uuid() == problem.variables()[1].cast<DiscreteVariable>().perturbations(false)[0].uuid());
EXPECT_TRUE(perturbations[2]->uuid() == problem.variables()[2].cast<DiscreteVariable>().perturbations(false)[1].uuid());
EXPECT_TRUE(perturbations[0]->optionalCast<RubyPerturbation>());
EXPECT_TRUE(perturbations[1]->optionalCast<RubyPerturbation>());
EXPECT_TRUE(perturbations[2]->optionalCast<RubyPerturbation>());
// find models with improved wall
testVariableValues.clear();
testVariableValues.push_back(1);
testDataPoints = analysisRecord.getDataPointRecords(testVariableValues);
ASSERT_EQ(2u, testDataPoints.size());
// infeasible
testVariableValues.clear();
testVariableValues.push_back(0);
testVariableValues.push_back(0);
testVariableValues.push_back(0);
testVariableValues.push_back(0);
testDataPoints = analysisRecord.getDataPointRecords(testVariableValues);
ASSERT_EQ(0u, testDataPoints.size());
}
TEST_F(AnalysisDriverFixture, DDACE_LatinHypercube_Continuous) {
{
// GET SIMPLE PROJECT
SimpleProject project = getCleanSimpleProject("DDACE_LatinHypercube_Continuous");
Analysis analysis = project.analysis();
// SET PROBLEM
Problem problem = retrieveProblem("Continuous",true,false);
analysis.setProblem(problem);
// DEFINE SEED
Model model = model::exampleModel();
openstudio::path p = toPath("./example.osm");
model.save(p,true);
FileReference seedModel(p);
analysis.setSeed(seedModel);
// CREATE ANALYSIS
DDACEAlgorithmOptions algOptions(DDACEAlgorithmType::lhs);
DDACEAlgorithm algorithm(algOptions);
analysis.setAlgorithm(algorithm);
// RUN ANALYSIS
AnalysisDriver driver = project.analysisDriver();
AnalysisRunOptions runOptions = standardRunOptions(project.projectDir());
CurrentAnalysis currentAnalysis = driver.run(analysis,runOptions);
EXPECT_TRUE(driver.waitForFinished());
boost::optional<runmanager::JobErrors> jobErrors = currentAnalysis.dakotaJobErrors();
ASSERT_TRUE(jobErrors);
EXPECT_FALSE(jobErrors->errors().empty()); // require specification of number of samples
EXPECT_TRUE(driver.currentAnalyses().empty());
Table summary = currentAnalysis.analysis().summaryTable();
EXPECT_EQ(1u,summary.nRows()); // no points
project.clearAllResults();
algOptions.setSamples(4);
EXPECT_EQ(4,analysis.algorithm()->cast<DDACEAlgorithm>().ddaceAlgorithmOptions().samples());
currentAnalysis = driver.run(analysis,runOptions);
EXPECT_TRUE(driver.waitForFinished());
jobErrors = currentAnalysis.dakotaJobErrors();
ASSERT_TRUE(jobErrors);
EXPECT_TRUE(jobErrors->errors().empty());
EXPECT_TRUE(driver.currentAnalyses().empty());
summary = currentAnalysis.analysis().summaryTable();
EXPECT_EQ(5u,summary.nRows());
summary.save(project.projectDir() / toPath("summary.csv"));
BOOST_FOREACH(const DataPoint& dataPoint,analysis.dataPoints()) {
EXPECT_TRUE(dataPoint.isComplete());
EXPECT_FALSE(dataPoint.failed());
// EXPECT_FALSE(dataPoint.responseValues().empty());
}
ASSERT_TRUE(analysis.algorithm());
EXPECT_TRUE(analysis.algorithm()->isComplete());
EXPECT_FALSE(analysis.algorithm()->failed());
{
AnalysisRecord analysisRecord = project.analysisRecord();
Analysis analysisCopy = analysisRecord.analysis();
ASSERT_TRUE(analysisCopy.algorithm());
EXPECT_TRUE(analysisCopy.algorithm()->isComplete());
EXPECT_FALSE(analysisCopy.algorithm()->failed());
}
}
LOG(Info,"Restart from existing project.");
// Get existing project
SimpleProject project = getSimpleProject("DDACE_LatinHypercube_Continuous");
EXPECT_FALSE(project.analysisIsLoaded()); // make sure starting fresh
Analysis analysis = project.analysis();
EXPECT_FALSE(analysis.isDirty());
// Add custom data point
std::vector<QVariant> values;
values.push_back(0.0);
values.push_back(0.8);
values.push_back(int(0));
OptionalDataPoint dataPoint = analysis.problem().createDataPoint(values);
ASSERT_TRUE(dataPoint);
analysis.addDataPoint(*dataPoint);
EXPECT_EQ(1u,analysis.dataPointsToQueue().size());
ASSERT_TRUE(analysis.algorithm());
EXPECT_TRUE(analysis.algorithm()->isComplete());
EXPECT_FALSE(analysis.algorithm()->failed());
EXPECT_TRUE(analysis.isDirty());
EXPECT_FALSE(analysis.resultsAreInvalid());
EXPECT_FALSE(analysis.dataPointsAreInvalid());
// get last modified time of a file in a completed data point to make sure nothing is re-run
DataPointVector completePoints = analysis.completeDataPoints();
ASSERT_FALSE(completePoints.empty());
OptionalFileReference inputFileRef = completePoints[0].osmInputData();
ASSERT_TRUE(inputFileRef);
QFileInfo inputFileInfo(toQString(inputFileRef->path()));
QDateTime inputFileModifiedTestTime = inputFileInfo.lastModified();
EXPECT_EQ(1u,analysis.dataPointsToQueue().size());
AnalysisDriver driver = project.analysisDriver();
CurrentAnalysis currentAnalysis = driver.run(
analysis,
standardRunOptions(project.projectDir()));
EXPECT_TRUE(driver.waitForFinished());
boost::optional<runmanager::JobErrors> jobErrors = currentAnalysis.dakotaJobErrors();
EXPECT_FALSE(jobErrors); // should not try to re-run DakotaAlgorithm
EXPECT_TRUE(driver.currentAnalyses().empty());
EXPECT_TRUE(analysis.dataPointsToQueue().empty());
Table summary = currentAnalysis.analysis().summaryTable();
EXPECT_EQ(6u,summary.nRows());
summary.save(project.projectDir() / toPath("summary_post_restart.csv"));
// RunManager should not re-run any data points
EXPECT_EQ(inputFileModifiedTestTime,inputFileInfo.lastModified());
}
TEST_F(ProjectFixture, DataPointTagRecords) {
// create Analysis with one DataPoint with one Tag ("test tag")
analysis::Problem problem("problem",analysis::VariableVector(),runmanager::Workflow());
FileReference seed(toPath("in.osm"));
analysis::Analysis analysis("analysis",problem,seed);
analysis::DataPoint dataPoint = problem.createDataPoint(std::vector<QVariant>()).get();
dataPoint.addTag("test tag");
analysis.addDataPoint(dataPoint);
// make sure tag records follow data points around.
// trying to replicate issue where data point tag records get repointed to
// file reference record with id 0.
{
// save analysis to a new database
ProjectDatabase database = getCleanDatabase("DataPointTagRecords");
AnalysisRecord analysisRecord(analysis,database);
database.save();
ASSERT_EQ(1u,analysisRecord.dataPointRecords().size());
DataPointRecord dataPointRecord = analysisRecord.dataPointRecords()[0];
ASSERT_EQ(1u,dataPointRecord.tagRecords().size());
TagRecord tagRecord = dataPointRecord.tagRecords()[0];
EXPECT_EQ("test tag",tagRecord.name());
analysis::DataPoint dataPoint = dataPointRecord.dataPoint();
ASSERT_EQ(1u,dataPoint.tags().size());
EXPECT_EQ("test tag",dataPoint.tags()[0].name());
analysis::Analysis analysis = analysisRecord.analysis();
ASSERT_EQ(1u,analysis.dataPoints().size());
dataPoint = analysis.dataPoints()[0];
ASSERT_EQ(1u,dataPoint.tags().size());
EXPECT_EQ("test tag",dataPoint.tags()[0].name());
}
NameFinder<TagRecord> testRecordFinder("test tag");
NameFinder<TagRecord> anotherTestRecordFinder("another test");
NameFinder<Tag> testTagFinder("test tag");
NameFinder<Tag> anotherTestTagFinder("another test");
{
ProjectDatabase database = getExistingDatabase("DataPointTagRecords");
ASSERT_EQ(1u,AnalysisRecord::getAnalysisRecords(database).size());
AnalysisRecord analysisRecord = AnalysisRecord::getAnalysisRecords(database)[0];
ASSERT_EQ(1u,analysisRecord.dataPointRecords().size());
DataPointRecord dataPointRecord = analysisRecord.dataPointRecords()[0];
ASSERT_EQ(1u,dataPointRecord.tagRecords().size());
TagRecord tagRecord = dataPointRecord.tagRecords()[0];
EXPECT_EQ("test tag",tagRecord.name());
analysis::DataPoint dataPoint = dataPointRecord.dataPoint();
ASSERT_EQ(1u,dataPoint.tags().size());
EXPECT_EQ("test tag",dataPoint.tags()[0].name());
analysis::Analysis analysis = analysisRecord.analysis();
ASSERT_EQ(1u,analysis.dataPoints().size());
dataPoint = analysis.dataPoints()[0];
ASSERT_EQ(1u,dataPoint.tags().size());
EXPECT_EQ("test tag",dataPoint.tags()[0].name());
// adding a second tag and resaving the analysis
dataPoint.addTag("another test");
analysisRecord = AnalysisRecord(analysis,database);
bool test = database.save();
EXPECT_TRUE(test);
ASSERT_EQ(1u,analysisRecord.dataPointRecords().size());
dataPointRecord = analysisRecord.dataPointRecords()[0];
TagRecordVector tagRecords = dataPointRecord.tagRecords();
EXPECT_EQ(2u,tagRecords.size());
EXPECT_FALSE(std::find_if(tagRecords.begin(),tagRecords.end(),testRecordFinder) == tagRecords.end());
EXPECT_FALSE(std::find_if(tagRecords.begin(),tagRecords.end(),anotherTestRecordFinder) == tagRecords.end());
dataPoint = dataPointRecord.dataPoint();
TagVector tags = dataPoint.tags();
EXPECT_EQ(2u,tags.size());
EXPECT_FALSE(std::find_if(tags.begin(),tags.end(),testTagFinder) == tags.end());
EXPECT_FALSE(std::find_if(tags.begin(),tags.end(),anotherTestTagFinder) == tags.end());
analysis = analysisRecord.analysis();
ASSERT_EQ(1u,analysis.dataPoints().size());
dataPoint = analysis.dataPoints()[0];
tags = dataPoint.tags();
EXPECT_EQ(2u,tags.size());
EXPECT_FALSE(std::find_if(tags.begin(),tags.end(),testTagFinder) == tags.end());
EXPECT_FALSE(std::find_if(tags.begin(),tags.end(),anotherTestTagFinder) == tags.end());
tagRecords = TagRecord::getTagRecords(database);
EXPECT_EQ(2u,tagRecords.size());
EXPECT_FALSE(std::find_if(tagRecords.begin(),tagRecords.end(),testRecordFinder) == tagRecords.end());
EXPECT_FALSE(std::find_if(tagRecords.begin(),tagRecords.end(),anotherTestRecordFinder) == tagRecords.end());
}
{
ProjectDatabase database = getExistingDatabase("DataPointTagRecords");
ASSERT_EQ(1u,AnalysisRecord::getAnalysisRecords(database).size());
AnalysisRecord analysisRecord = AnalysisRecord::getAnalysisRecords(database)[0];
ASSERT_EQ(1u,analysisRecord.dataPointRecords().size());
DataPointRecord dataPointRecord = analysisRecord.dataPointRecords()[0];
TagRecordVector tagRecords = dataPointRecord.tagRecords();
EXPECT_EQ(2u,tagRecords.size());
EXPECT_FALSE(std::find_if(tagRecords.begin(),tagRecords.end(),testRecordFinder) == tagRecords.end());
EXPECT_FALSE(std::find_if(tagRecords.begin(),tagRecords.end(),anotherTestRecordFinder) == tagRecords.end());
dataPoint = dataPointRecord.dataPoint();
TagVector tags = dataPoint.tags();
EXPECT_FALSE(std::find_if(tags.begin(),tags.end(),testTagFinder) == tags.end());
EXPECT_FALSE(std::find_if(tags.begin(),tags.end(),anotherTestTagFinder) == tags.end());
analysis = analysisRecord.analysis();
ASSERT_EQ(1u,analysis.dataPoints().size());
dataPoint = analysis.dataPoints()[0];
tags = dataPoint.tags();
EXPECT_FALSE(std::find_if(tags.begin(),tags.end(),testTagFinder) == tags.end());
EXPECT_FALSE(std::find_if(tags.begin(),tags.end(),anotherTestTagFinder) == tags.end());
}
}
