std::vector<VariableRecord> FunctionRecord_Impl::variableRecords() const {
VariableRecordVector result;
ProjectDatabase database = projectDatabase();
QSqlQuery query(*(database.qSqlDatabase()));
query.prepare(toQString("SELECT * FROM " + VariableRecord::databaseTableName() +
" WHERE functionRecordId=:functionRecordId ORDER BY variableVectorIndex"));
query.bindValue(":functionRecordId",id());
assertExec(query);
OptionalInt previousIndex;
bool resort(false);
while (query.next()) {
result.push_back(VariableRecord::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;
}
std::vector<FunctionRecord> OptimizationProblemRecord_Impl::objectiveRecords() const {
FunctionRecordVector result;
ProjectDatabase database = projectDatabase();
QSqlQuery query(*(database.qSqlDatabase()));
query.prepare(toQString("SELECT * FROM " + FunctionRecord::databaseTableName() +
" WHERE problemRecordId=:problemRecordId AND functionType=:functionType " +
"ORDER BY functionVectorIndex"));
query.bindValue(":problemRecordId", id());
query.bindValue(":functionType",FunctionType::Objective);
assertExec(query);
OptionalInt previousIndex;
bool resort(false);
while (query.next()) {
result.push_back(FunctionRecord::factoryFromQuery(query, database).get());
int index = result.back().functionVectorIndex();
if (previousIndex) {
if (index <= previousIndex.get()) {
resort = true; // if functions are moved around, order in database itself can
// get out of date (as compared to database + dirty records).
}
}
previousIndex = index;
}
if (resort) {
FunctionRecordFunctionVectorIndexLess comparator;
std::sort(result.begin(),result.end(),comparator);
}
return result;
}
std::vector<WorkflowRecord> ProblemRecord_Impl::workflowRecords() const {
WorkflowRecordVector result;
ProjectDatabase database = projectDatabase();
QSqlQuery query(*(database.qSqlDatabase()));
query.prepare(toQString("SELECT * FROM " + WorkflowRecord::databaseTableName() +
" WHERE problemRecordId=:problemRecordId ORDER BY workflowIndex"));
query.bindValue(":problemRecordId",id());
assertExec(query);
OptionalInt previousIndex;
bool resort(false);
while (query.next()) {
result.push_back(WorkflowRecord::factoryFromQuery(query, database).get());
int index = result.back().workflowIndex();
if (previousIndex) {
if (index < previousIndex.get()) {
resort = true;
}
}
previousIndex = index;
}
if (resort) {
WorkflowRecordWorkflowIndexLess comparator;
std::sort(result.begin(),result.end(),comparator);
}
return result;
}
bool MeasureRecordMeasureVectorIndexLess::operator()(
const MeasureRecord& left,
const MeasureRecord& right) const
{
OptionalInt leftIndex = left.measureVectorIndex();
OptionalInt rightIndex = right.measureVectorIndex();
if (leftIndex && rightIndex) {
return (leftIndex.get() < rightIndex.get());
}
return false;
}
std::vector<MeasureRecord> MeasureGroupRecord_Impl::measureRecords(bool selectedMeasuresOnly) const
{
std::vector<MeasureRecord> result;
ProjectDatabase database = this->projectDatabase();
QSqlQuery query(*(database.qSqlDatabase()));
if (selectedMeasuresOnly){
query.prepare(toQString("SELECT * FROM " + MeasureRecord::databaseTableName() +
" WHERE variableRecordId=:id AND isSelected=:isSelected ORDER BY measureVectorIndex"));
query.bindValue(":id", this->id());
query.bindValue(":isSelected", true);
}else{
query.prepare(toQString("SELECT * FROM " + MeasureRecord::databaseTableName() +
" WHERE variableRecordId=:id ORDER BY measureVectorIndex"));
query.bindValue(":id", this->id());
}
assertExec(query);
OptionalInt previousIndex;
bool resort(false);
while (query.next()){
boost::optional<MeasureRecord> measure = MeasureRecord::factoryFromQuery(query, database);
OS_ASSERT(measure);
result.push_back(*measure);
OptionalInt index = result.back().measureVectorIndex();
if (previousIndex && index) {
if (index.get() <= previousIndex.get()) {
resort = true;
}
}
if (index) {
previousIndex = index;
}
}
if (resort) {
MeasureRecordMeasureVectorIndexLess comparator;
std::sort(result.begin(),result.end(),comparator);
}
return result;
}
boost::optional<IdfObject> ForwardTranslator::translateTableMultiVariableLookup( TableMultiVariableLookup& modelObject )
{
OptionalString s;
OptionalDouble d;
OptionalModelObject temp;
OptionalInt n;
// Create a new IddObjectType::Table_MultiVariableLookup
IdfObject idfObject(IddObjectType::Table_MultiVariableLookup);
m_idfObjects.push_back(idfObject);
// Name
s = modelObject.name();
if(s)
{
idfObject.setName(*s);
}
// InterpolationMethod
if( (s = modelObject.interpolationMethod()) )
{
idfObject.setString(Table_MultiVariableLookupFields::InterpolationMethod,s.get());
}
// NumberofInterpolationPoints
if( (n = modelObject.numberofInterpolationPoints()) )
{
idfObject.setInt(Table_MultiVariableLookupFields::NumberofInterpolationPoints,n.get());
}
// CurveType
if( (s = modelObject.curveType()) )
{
idfObject.setString(Table_MultiVariableLookupFields::CurveType,s.get());
}
// TableDataFormat
if( (s = modelObject.tableDataFormat()) )
{
idfObject.setString(Table_MultiVariableLookupFields::TableDataFormat,s.get());
}
// ExternalFileName
// Not supported
// X1SortOrder
idfObject.setString(Table_MultiVariableLookupFields::X1SortOrder,"Ascending");
// X2SortOrder
idfObject.setString(Table_MultiVariableLookupFields::X2SortOrder,"Ascending");
// NormalizationReference
if( (d = modelObject.normalizationReference()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::NormalizationReference,d.get());
}
// MinimumValueofX1
if( (d = modelObject.minimumValueofX1()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MinimumValueofX1,d.get());
}
// MaximumValueofX1
if( (d = modelObject.maximumValueofX1()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MaximumValueofX1,d.get());
}
// MinimumValueofX2
if( (d = modelObject.minimumValueofX2()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MinimumValueofX2,d.get());
}
// MaximumValueofX2
if( (d = modelObject.maximumValueofX2()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MaximumValueofX2,d.get());
}
// MinimumValueofX3
if( (d = modelObject.minimumValueofX3()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MinimumValueofX3,d.get());
}
// MaximumValueofX3
if( (d = modelObject.maximumValueofX3()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MaximumValueofX3,d.get());
}
// MinimumValueofX4
if( (d = modelObject.minimumValueofX4()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MinimumValueofX4,d.get());
}
// MaximumValueofX4
if( (d = modelObject.maximumValueofX4()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MaximumValueofX4,d.get());
}
// MinimumValueofX5
if( (d = modelObject.minimumValueofX5()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MinimumValueofX5,d.get());
}
// MaximumValueofX5
if( (d = modelObject.maximumValueofX5()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MaximumValueofX5,d.get());
}
// MinimumTableOutput
if( (d = modelObject.minimumTableOutput()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MinimumTableOutput,d.get());
}
// MaximumTableOutput
if( (d = modelObject.maximumTableOutput()) )
{
idfObject.setDouble(Table_MultiVariableLookupFields::MaximumTableOutput,d.get());
}
// InputUnitTypeforX1
if( (s = modelObject.inputUnitTypeforX1()) )
{
idfObject.setString(Table_MultiVariableLookupFields::InputUnitTypeforX1,s.get());
}
// InputUnitTypeforX2
if( (s = modelObject.inputUnitTypeforX2()) )
{
idfObject.setString(Table_MultiVariableLookupFields::InputUnitTypeforX2,s.get());
}
// InputUnitTypeforX3
if( (s = modelObject.inputUnitTypeforX3()) )
{
idfObject.setString(Table_MultiVariableLookupFields::InputUnitTypeforX3,s.get());
}
// InputUnitTypeforX4
if( (s = modelObject.inputUnitTypeforX4()) )
{
idfObject.setString(Table_MultiVariableLookupFields::InputUnitTypeforX4,s.get());
}
// InputUnitTypeforX5
if( (s = modelObject.inputUnitTypeforX5()) )
{
idfObject.setString(Table_MultiVariableLookupFields::InputUnitTypeforX5,s.get());
}
// OutputUnitType
if( (s = modelObject.outputUnitType()) )
{
idfObject.setString(Table_MultiVariableLookupFields::OutputUnitType,s.get());
}
// NumberofIndependentVariables
if( (n = modelObject.numberofIndependentVariables()) )
{
idfObject.setInt(Table_MultiVariableLookupFields::NumberofIndependentVariables,n.get());
}
unsigned t_numNonextensibleFields = idfObject.numNonextensibleFields();
unsigned t_currentFieldIndex = t_numNonextensibleFields;
unsigned t_numberofIndependentVariables = modelObject.numberofIndependentVariables();
// Set the number of xValues for each independent variable
for(unsigned i = 0; i != t_numberofIndependentVariables; ++i)
{
unsigned xValueCount = modelObject.getImpl<model::detail::TableMultiVariableLookup_Impl>()->xValues(i).size();
idfObject.setUnsigned(t_currentFieldIndex,xValueCount);
++t_currentFieldIndex;
}
// Set the xValues for each independent variable
for(unsigned i = 0; i != t_numberofIndependentVariables; ++i)
{
std::vector<double> xValues = modelObject.getImpl<model::detail::TableMultiVariableLookup_Impl>()->xValues(i);
for(auto it = xValues.begin();
it != xValues.end();
++it)
{
idfObject.setDouble(t_currentFieldIndex,*it);
++t_currentFieldIndex;
}
}
// Set the table data
if(t_numberofIndependentVariables == 1u)
{
// If there is just one variable then we just make a list of the y values.
std::vector<double> xValues = modelObject.getImpl<model::detail::TableMultiVariableLookup_Impl>()->xValues(0);
for(auto it = xValues.begin();
it != xValues.end();
++it)
{
std::vector<double> coord(1);
coord[0] = *it;
boost::optional<double> yValue = modelObject.getImpl<model::detail::TableMultiVariableLookup_Impl>()->yValue(coord);
if(yValue)
{
idfObject.setDouble(t_currentFieldIndex,yValue.get());
}
else
{
idfObject.setString(t_currentFieldIndex,"");
}
++t_currentFieldIndex;
}
}
else if(t_numberofIndependentVariables == 2u)
{
// If there are two variables we make a list of the y values corresponding to x1 and x2,
// iterating over x2 in the outer layer
std::vector<double> x1Values = modelObject.getImpl<model::detail::TableMultiVariableLookup_Impl>()->xValues(0);
std::vector<double> x2Values = modelObject.getImpl<model::detail::TableMultiVariableLookup_Impl>()->xValues(1);
for(auto it2 = x2Values.begin();
it2 != x2Values.end();
++it2)
{
for(auto it1 = x1Values.begin();
it1 != x1Values.end();
++it1)
{
std::vector<double> coord(2);
coord[0] = *it1;
coord[1] = *it2;
boost::optional<double> yValue = modelObject.yValue(coord);
if(yValue)
{
idfObject.setDouble(t_currentFieldIndex,yValue.get());
}
else
{
idfObject.setString(t_currentFieldIndex,"");
}
++t_currentFieldIndex;
}
}
}
else
{
std::vector<std::pair<std::vector<double>,double> > points = modelObject.points();
// Slice the first and second x values off the coordinates
std::vector<std::vector<double> > slices;
for(std::vector<std::pair<std::vector<double>,double> >::const_iterator it = points.begin();
it != points.end();
++it)
{
OS_ASSERT(it->first.size() == t_numberofIndependentVariables);
std::vector<double> slice(it->first.begin() + 2,it->first.begin() + t_numberofIndependentVariables);
slices.push_back(slice);
}
// Remove duplicate slices
std::sort(slices.begin(),slices.end());
slices.erase(std::unique(slices.begin(),slices.end()),slices.end());
// Iterate over each slice that is left, creating a 2D table for each one
for(std::vector<std::vector<double> >::const_iterator it = slices.begin();
it != slices.end();
++it)
{
for(auto it2 = it->begin();
it2 != it->end();
++it2)
{
idfObject.setDouble(t_currentFieldIndex,*it2);
++t_currentFieldIndex;
}
std::vector<double> x1Values = modelObject.getImpl<model::detail::TableMultiVariableLookup_Impl>()->xValues(0);
std::vector<double> x2Values = modelObject.getImpl<model::detail::TableMultiVariableLookup_Impl>()->xValues(1);
for(auto x2It = x2Values.begin();
x2It != x2Values.end();
++x2It)
{
for(auto x1It = x1Values.begin();
x1It != x1Values.end();
++x1It)
{
std::vector<double> coord(2);
coord[0] = *x1It;
coord[1] = *x2It;
coord.insert(coord.end(),it->begin(),it->end());
boost::optional<double> yValue = modelObject.yValue(coord);
if(yValue)
{
idfObject.setDouble(t_currentFieldIndex,yValue.get());
}
else
{
idfObject.setString(t_currentFieldIndex,"");
}
++t_currentFieldIndex;
}
}
}
}
return idfObject;
}
int DesignOfExperiments_Impl::createNextIteration(Analysis& analysis) {
int result(0);
// to make sure problem type check has already occurred. this is stated usage in header.
OS_ASSERT(analysis.algorithm().get() == getPublicObject<DesignOfExperiments>());
// nothing else is supported yet
DesignOfExperimentsOptions options = designOfExperimentsOptions();
OS_ASSERT(options.designType() == DesignOfExperimentsType::FullFactorial);
if (isComplete()) {
LOG(Info,"Algorithm is already marked as complete. Returning without creating new points.");
return result;
}
if (options.maxIter() && options.maxIter().get() < 1) {
LOG(Info,"Maximum iterations set to less than one. No DataPoints will be added to Analysis '"
<< analysis.name() << "', and the Algorithm will be marked complete.");
markComplete();
return result;
}
OptionalInt mxSim = options.maxSims();
DataPointVector dataPoints = analysis.getDataPoints("DOE");
int totPoints = dataPoints.size();
if (mxSim && (totPoints >= *mxSim)) {
LOG(Info,"Analysis '" << analysis.name() << "' already contains " << totPoints
<< " DataPoints added by the DesignOfExperiments algorithm, which meets or exceeds the "
<< "maximum number specified in this algorithm's options object, " << *mxSim << ". "
<< "No data points will be added and the Algorithm will be marked complete.");
markComplete();
return result;
}
m_iter = 1;
// determine all combinations
std::vector< std::vector<QVariant> > variableValues;
for (const Variable& variable : analysis.problem().variables()) {
// variable must be DiscreteVariable, otherwise !isCompatibleProblemType(analysis.problem())
DiscreteVariable discreteVariable = variable.cast<DiscreteVariable>();
IntVector dvValues = discreteVariable.validValues(true);
std::vector< std::vector<QVariant> > currentValues = variableValues;
for (IntVector::const_iterator it = dvValues.begin(), itEnd = dvValues.end();
it != itEnd; ++it)
{
std::vector< std::vector<QVariant> > nextSet = currentValues;
if (currentValues.empty()) {
variableValues.push_back(std::vector<QVariant>(1u,QVariant(*it)));
}
else {
for (std::vector<QVariant>& point : nextSet) {
point.push_back(QVariant(*it));
}
if (it == dvValues.begin()) {
variableValues = nextSet;
}
else {
variableValues.insert(variableValues.end(),nextSet.begin(),nextSet.end());
}
}
}
}
// create data points and add to analysis
for (const std::vector<QVariant>& value : variableValues) {
DataPoint dataPoint = analysis.problem().createDataPoint(value).get();
dataPoint.addTag("DOE");
bool added = analysis.addDataPoint(dataPoint);
if (added) {
++result;
++totPoints;
if (mxSim && (totPoints == mxSim.get())) {
break;
}
}
}
if (result == 0) {
LOG(Trace,"No new points were added, so marking this DesignOfExperiments complete.");
markComplete();
}
return result;
}
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());
}