コード例 #1
0
int
Piro::PerformDakotaAnalysis(
    Thyra::ModelEvaluatorDefaultBase<double>& piroModel,
    Teuchos::ParameterList& dakotaParams,
    RCP< Thyra::VectorBase<double> >& p)
{
#ifdef HAVE_PIRO_TRIKOTA
  dakotaParams.validateParameters(*Piro::getValidPiroAnalysisDakotaParameters(),0);
  using std::string;

  string dakotaIn  = dakotaParams.get("Input File","dakota.in");
  string dakotaOut = dakotaParams.get("Output File","dakota.out");
  string dakotaErr = dakotaParams.get("Error File","dakota.err");
  string dakotaRes = dakotaParams.get("Restart File","dakota_restart.out");
  string dakotaRestartIn;
  if (dakotaParams.isParameter("Restart File To Read"))
    dakotaRestartIn = dakotaParams.get<string>("Restart File To Read");

  int dakotaRestartEvals= dakotaParams.get("Restart Evals To Read", 0);

  int p_index = dakotaParams.get("Parameter Vector Index", 0);
  int g_index = dakotaParams.get("Response Vector Index", 0);

  TriKota::Driver dakota(dakotaIn, dakotaOut, dakotaErr, dakotaRes,
                         dakotaRestartIn, dakotaRestartEvals);

  RCP<TriKota::ThyraDirectApplicInterface> trikota_interface =
    rcp(new TriKota::ThyraDirectApplicInterface
         (dakota.getProblemDescDB(), rcp(&piroModel,false), p_index, g_index),
	false);

  dakota.run(trikota_interface.get());

  Dakota::RealVector finalValues;
  if (dakota.rankZero())
    finalValues = dakota.getFinalSolution().all_continuous_variables();

  // Copy Dakota parameters into Thyra
  p = Thyra::createMember(piroModel.get_p_space(p_index));
  {
      Thyra::DetachedVectorView<double> global_p(p);
      for (int i = 0; i < finalValues.length(); ++i)
        global_p[i] = finalValues[i];
  }

  return 0;
#else
 RCP<Teuchos::FancyOStream> out = Teuchos::VerboseObjectBase::getDefaultOStream();
 *out << "ERROR: Trilinos/Piro was not configured to include Dakota analysis."
      << "\nYou must enable TriKota." << endl;
 return 0;  // should not fail tests
#endif
}
コード例 #2
0
int
Piro::Thyra::PerformDakotaAnalysis(
    ::Thyra::ModelEvaluatorDefaultBase<double>& piroModel,
    Teuchos::ParameterList& dakotaParams,
    RCP< ::Thyra::VectorBase<double> >& p)
{
#ifdef Piro_ENABLE_TriKota
  string dakotaIn = dakotaParams.get("Input File","dakota.in");
  string dakotaOut= dakotaParams.get("Output File","dakota.out");
  string dakotaErr= dakotaParams.get("Error File","dakota.err");
  string dakotaRes= dakotaParams.get("Restart File","dakota_restart.out");

  TriKota::Driver dakota(dakotaIn.c_str(), dakotaOut.c_str(),
                         dakotaErr.c_str(), dakotaRes.c_str());

  RCP<TriKota::ThyraDirectApplicInterface> trikota_interface =
    rcp(new TriKota::ThyraDirectApplicInterface
         (dakota.getProblemDescDB(), rcp(&piroModel,false)), false);

  dakota.run(trikota_interface.get());

  Dakota::RealVector finalValues =
    dakota.getFinalSolution().all_continuous_variables();

  // Copy Dakota parameters into Thyra
  p = ::Thyra::createMember(piroModel.get_p_space(0));
  {
      ::Thyra::DetachedVectorView<double> global_p(p);
      for (int i = 0; i < finalValues.length(); ++i) 
        global_p[i] = finalValues[i];
  }

  return 0;
#else
 RCP<Teuchos::FancyOStream> out = Teuchos::VerboseObjectBase::getDefaultOStream();
 *out << "ERROR: Trilinos/Piro was not configured to include Dakota analysis."
      << "\nYou must enable TriKota." << endl;
 return 0;  // should not fail tests
#endif
}
void 
TriKota::MPDirectApplicInterface::
wait_local_evaluations(Dakota::PRPQueue& prp_queue)
{
  using Teuchos::RCP;
  using Teuchos::rcp;
  using Stokhos::ProductEpetraVector;
  using Stokhos::ProductEpetraMultiVector;

  if (model != Teuchos::null) {
    unsigned int queue_size = prp_queue.size();
    unsigned int num_blocks = queue_size / block_size;
    unsigned int remainder = queue_size % block_size;

    *out << "TriKota:: Performing multi-point evaluation of " << queue_size
	 << " responses using a block size of " << block_size
	 << std::endl;
    
    Dakota::PRPQueueIter block_iter = prp_queue.begin();
    unsigned int block = 0;
    while (block_iter != prp_queue.end()) {

      // Load up block p
      Dakota::PRPQueueIter iter = block_iter;
      bool valFlag = true;
      bool gradFlag = true;
      bool hessFlag = true;
      unsigned int blk_sz = block_size;
      if (block == num_blocks && remainder > 0)
	blk_sz = remainder;
      for (unsigned int idx=0; idx<blk_sz; idx++) {
	const Dakota::Variables& vars = iter->variables();
	const Dakota::RealVector& xC  = vars.continuous_variables();
	unsigned int numVars = xC.length();
	for (unsigned int i=0; i<numVars; i++) 
	  (*model_p)[idx][i]=xC[i];

	const Dakota::ActiveSet& set  = iter->active_set();
	short asv = set.request_vector()[0];
	valFlag  = valFlag  && (asv & 1);
	gradFlag = gradFlag && (asv & 2);
	hessFlag = hessFlag && (asv & 4);

	Dakota::Response resp = iter->response();
	Dakota::RealVector fnVals = resp.function_values_view();
	unsigned int numFns = fnVals.length();
	
	// test for consistency of problem definition between ModelEval and 
	// Dakota
	TEUCHOS_TEST_FOR_EXCEPTION(numVars > numParameters, std::logic_error,
				   "TriKota_Dakota Adapter Error: ");
	TEUCHOS_TEST_FOR_EXCEPTION(hessFlag, std::logic_error,
				   "TriKota_Dakota Adapter Error: ");
	TEUCHOS_TEST_FOR_EXCEPTION(numFns > numResponses, std::logic_error,
				   "TriKota_Dakota Adapter Error: ");
	TEUCHOS_TEST_FOR_EXCEPTION(gradFlag && !supportsSensitivities, 
				   std::logic_error,
				   "TriKota_Dakota Adapter Error: ");
	
	++iter;
      }

      // Put in copies of last point for remainder
      if (block == num_blocks && remainder > 0) {
	--iter;
	for (unsigned int idx=remainder; idx<block_size; idx++) {
	  const Dakota::Variables& vars = iter->variables();
	  const Dakota::RealVector& xC  = vars.continuous_variables();
	  unsigned int numVars = xC.length();
	  for (unsigned int i=0; i<numVars; i++) 
	    (*model_p)[idx][i]=xC[i];
	}
      }

      // Evaluate model
      EEME::InArgs inArgs = model->createInArgs();
      EEME::OutArgs outArgs = model->createOutArgs();
      inArgs.set_p_mp(p_index, model_p);
      if (valFlag)
	outArgs.set_g_mp(g_index, model_g);
      if (gradFlag) 
	outArgs.set_DgDp_mp(g_index, p_index,
			    EEME::MPDerivative(model_dgdp, orientation));
      *out << "TriKota:: evaluating block " << block;
      if (gradFlag)
	*out << " with gradients." << std::endl;
      else
	*out << " without gradients." << std::endl;
      model->evalModel(inArgs, outArgs);

      // Copy responses from block g
      iter = block_iter;
      for (unsigned int idx=0; idx<blk_sz; idx++) {
	const Dakota::Variables& vars = iter->variables();
	const Dakota::RealVector& xC  = vars.continuous_variables();
	unsigned int numVars = xC.length();
	Dakota::Response         resp = iter->response(); // shared rep
	Dakota::RealVector fnVals     = resp.function_values_view();
	Dakota::RealMatrix fnGrads    = resp.function_gradients_view();
	unsigned int numFns = fnVals.length();
	
	if (valFlag)
	  for (unsigned int j=0; j<numFns; j++) 
	    fnVals[j]= (*model_g)[idx][j];
	if (gradFlag)  {
	  if (orientation == EEME::DERIV_MV_BY_COL) {
	    for (unsigned int i=0; i<numVars; i++)
	      for (unsigned int j=0; j<numFns; j++)
		fnGrads[j][i]= (*model_dgdp)[idx][i][j];
	  } 
	  else {
	    for (unsigned int i=0; i<numFns; i++)
	      for (unsigned int j=0; j<numVars; j++)
		fnGrads[i][j]= (*model_dgdp)[idx][i][j];
	  }
	}

	// indicate completion of job to ApplicationInterface schedulers
	int fn_eval_id = iter->eval_id();
	completionSet.insert(fn_eval_id);

	++iter;
	++block_iter;
      }
      ++block;
    }
    TEUCHOS_TEST_FOR_EXCEPT((remainder == 0 && block != num_blocks) || 
			    (remainder  > 0 && block != num_blocks+1))
  }