C++ Analysis::name方法代码示例

  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;
  }

// Test not yet to scale re: total data points.
TEST_F(ProjectFixture,Profile_UpdateAnalysis) {
  Analysis analysis = getAnalysisToRun(100,500);

  // save to database
  ProjectDatabase db = getCleanDatabase(toPath("./UpdateAnalysis"));
  ASSERT_TRUE(db.startTransaction());
  AnalysisRecord record(analysis,db);
  db.save();
  ASSERT_TRUE(db.commitTransaction());

  // add output data to 1 data point
  DataPointVector dataPoints = analysis.dataPoints();
  boost::mt19937 mt;
  typedef boost::uniform_real<> uniform_dist_type;
  typedef boost::variate_generator<boost::mt19937&, uniform_dist_type> uniform_gen_type;
  uniform_gen_type responseGenerator(mt,uniform_dist_type(50.0,500.0));
  for (int i = 0; i < 1; ++i) {
    std::stringstream ss;
    ss << "dataPoint" << i + 1;
    DoubleVector responseValues;
    for (int j = 0, n = analysis.problem().responses().size(); j < n; ++j) {
      responseValues.push_back(responseGenerator());
    }
    openstudio::path runDir = toPath(ss.str());
    dataPoints[i] = DataPoint(dataPoints[i].uuid(),
                              createUUID(),
                              dataPoints[i].name(),
                              dataPoints[i].displayName(),
                              dataPoints[i].description(),
                              analysis.problem(),
                              true,
                              false,
                              true,
                              DataPointRunType::Local,
                              dataPoints[i].variableValues(),
                              responseValues,
                              runDir,
                              FileReference(runDir / toPath("ModelToIdf/in.osm")),
                              FileReference(runDir / toPath("ModelToIdf/out.idf")),
                              FileReference(runDir / toPath("EnergyPlus/eplusout.sql")),
                              FileReferenceVector(1u,FileReference(runDir / toPath("Ruby/report.xml"))),
                              boost::optional<runmanager::Job>(),
                              std::vector<openstudio::path>(),
                              TagVector(),
                              AttributeVector());
    dataPoints[i].setName(dataPoints[i].name()); // set dirty
  }
  analysis = Analysis(analysis.uuid(),
                      analysis.versionUUID(),
                      analysis.name(),
                      analysis.displayName(),
                      analysis.description(),
                      analysis.problem(),
                      analysis.algorithm(),
                      analysis.seed(),
                      analysis.weatherFile(),
                      dataPoints,
                      false,
                      false);
  analysis.setName(analysis.name()); // set dirty

  // time the process of updating the database
  ptime start = microsec_clock::local_time();
  db.unloadUnusedCleanRecords();
  ASSERT_TRUE(db.startTransaction());
  record = AnalysisRecord(analysis,db);
  db.save();
  ASSERT_TRUE(db.commitTransaction());
  time_duration updateTime = microsec_clock::local_time() - start;

  std::cout << "Time: " << to_simple_string(updateTime) << std::endl;
}

//! Recarrega a lista de analises disponiveis e os arquivos associados a cada uma delas
void TerraMEPlayerDialog::reloadInterface()
{
	// Limpar interface e objetos que guardam em memoria os resultados das analises TerraME
	_terraMEAnalysisListWidget->clear();
	_datetimeListWidget->clear();
	_terraMEImageAnalysisWidget->setImageAnalysis("");
	_terraMEResult.clear();
	_currentAnalysis.clear();
	_currentAnalysisResult.clear();
	_currentAnalysisImageIndex = 0;
	_imageCountLabel->setText("");
	_changeResultTimer.stop();

	// Obter lista de analises TerraME que estao na base de dados e atualizar a interface
	AnalysisList* analysisList = _manager->analysisList();
	for(int i = 0; analysisList && i < analysisList->count(); ++i)
	{
		Analysis* ana = analysisList->at(i);
		if(ana->getAnalysisType() == WS_ANALYSISTYPE_TERRAME)
		{
			QListWidgetItem* item = new QListWidgetItem(ana->name());
			item->setData(Qt::UserRole, ana->id());

			_terraMEAnalysisListWidget->addItem(item);
		}	
	}

	// Carregar os logs das analises TerraME
	std::vector<wsAnalysisLog> terraMEAnalysisLogs;
	_manager->getAllTerraMEAnalysisLogs(terraMEAnalysisLogs);

	// Montar objeto que vai guardar, para cada analise TerraME, um conjunto de timestamps que 
	// representa os momentos em que cada analise foi executada. E para cada timestamp estara associado
	// um conjunto de imagens geradas.
	for(int i = 0; i < terraMEAnalysisLogs.size(); ++i)
	{
		wsAnalysisLog log = terraMEAnalysisLogs[i];

		// Acessar diretorio de imagens desta analise
		QDir dir(log.terraMEImagePath.c_str());
		if(dir.exists())
		{
			// Obter lista de imagens, ordenadas pela hora da modificacao do arquivo.
			QFileInfoList imageFileNameList = dir.entryInfoList(_imageFileFilter, QDir::Files, QDir::Name);

			// Se foram encontradas imagens, guardar referencia para elas
			if(!imageFileNameList.isEmpty())
			{
				QDateTime dateTime(QDate(log.dateStartYear, log.dateStartMonth, log.dateStartDay),
								   QTime(log.timeStartHour, log.timeStartMinutes, log.timeStartSeconds));

				TerraMEAnalysisResult analysisResult(dateTime, imageFileNameList);
				_terraMEResult[log.analysisId].push_back(analysisResult);
			}
		}
	}
	
	// Ordenar resultados pela data/hora da execucao da analise
	QMapIterator<int, QList<TerraMEAnalysisResult> > it(_terraMEResult);
	while(it.hasNext())
	{
		it.next();
		qSort(_terraMEResult[it.key()].begin(), _terraMEResult[it.key()].end());
	}

	// Se alguma analise TerraME foi encontrada, selecionar a primeira
	if(_terraMEAnalysisListWidget->count() > 0)
	{
		_terraMEAnalysisListWidget->setCurrentRow(0);
	}
}