void doDirectedRefinements(SGPP::base::AdpativityConfiguration& adaptConfig,
                           SGPP::base::Grid& grid, SGPP::base::GridGenerator& gridGen) {

  double dummySurplusValue = 1.0;

  SGPP::base::DataVector alphaRefine(grid.getSize());

  for (size_t i = 0; i < alphaRefine.getSize(); i++) {
    alphaRefine[i] = dummySurplusValue;
    dummySurplusValue += 1.0;
  }

  for (size_t i = 0; i < adaptConfig.numRefinements_; i++) {
    SGPP::base::SurplusRefinementFunctor* myRefineFunc = new
    SGPP::base::SurplusRefinementFunctor(&alphaRefine,
                                         adaptConfig.noPoints_, adaptConfig.threshold_);
    gridGen.refine(myRefineFunc);
    size_t oldSize = alphaRefine.getSize();
    alphaRefine.resize(grid.getSize());

    for (size_t j = oldSize; j < alphaRefine.getSize(); j++) {
      alphaRefine[i] = dummySurplusValue;

    }

    //increment only once for added grid points
    dummySurplusValue += 1.0;

    delete myRefineFunc;
  }
}
void doRandomRefinements(SGPP::base::AdpativityConfiguration& adaptConfig,
                         SGPP::base::Grid& grid, SGPP::base::GridGenerator& gridGen) {

  std::random_device rd;
  std::mt19937 mt(rd());
  std::uniform_real_distribution<double> dist(1, 100);

  SGPP::base::DataVector alphaRefine(grid.getSize());

  for (size_t i = 0; i < alphaRefine.getSize(); i++) {
    alphaRefine[i] = dist(mt);
  }

  for (size_t i = 0; i < adaptConfig.numRefinements_; i++) {
    SGPP::base::SurplusRefinementFunctor* myRefineFunc = new
    SGPP::base::SurplusRefinementFunctor(&alphaRefine,
                                         adaptConfig.noPoints_, adaptConfig.threshold_);
    gridGen.refine(myRefineFunc);
    size_t oldSize = alphaRefine.getSize();
    alphaRefine.resize(grid.getSize());

    for (size_t j = oldSize; j < alphaRefine.getSize(); j++) {
      alphaRefine[j] = dist(mt);
    }

    delete myRefineFunc;
  }
}
void PDESolver::coarsenInitialGridSurplus(SGPP::base::DataVector& alpha, float_t dThreshold) {
  if (bGridConstructed) {
    SGPP::base::GridGenerator* myGenerator = myGrid->createGridGenerator();
    size_t numCoarsen = myGenerator->getNumberOfRemovablePoints();
    size_t originalGridSize = myGrid->getStorage()->size();
    SGPP::base::SurplusCoarseningFunctor* myCoarsenFunctor =
        new SGPP::base::SurplusCoarseningFunctor(&alpha, numCoarsen, dThreshold);

    myGenerator->coarsenNFirstOnly(myCoarsenFunctor, &alpha, originalGridSize);

    delete myCoarsenFunctor;
    delete myGenerator;
  } else {
    throw new SGPP::base::application_exception(
        "PDESolver::coarsenInitialGridSurplus : The grid wasn't initialized before!");
  }
}
Exemple #4
0
int main(int argc, char** argv) {
  /*    SGPP::base::OCLOperationConfiguration parameters;
   parameters.readFromFile("StreamingOCL.cfg");
   std::cout << "internal precision: " << parameters.get("INTERNAL_PRECISION")
   << std::endl;*/

  //  std::string fileName = "friedman2_90000.arff";
  //    std::string fileName = "debugging.arff";
  std::string fileName = "friedman_4d.arff";
  //  std::string fileName = "friedman_10d.arff";
  //  std::string fileName = "DR5_train.arff";
  //  std::string fileName = "debugging_small.arff";

  uint32_t level = 5;

  SGPP::base::AdpativityConfiguration adaptConfig;
  adaptConfig.maxLevelType_ = false;
  adaptConfig.noPoints_ = 80;
  adaptConfig.numRefinements_ = 0;
  adaptConfig.percent_ = 200.0;
  adaptConfig.threshold_ = 0.0;

  SGPP::base::OCLOperationConfiguration parameters("singleDevice.cfg");

  SGPP::datadriven::OperationMultipleEvalConfiguration configuration(
      SGPP::datadriven::OperationMultipleEvalType::STREAMING,
      SGPP::datadriven::OperationMultipleEvalSubType::OCLMASKMP, parameters);

  SGPP::datadriven::ARFFTools arffTools;
  SGPP::datadriven::Dataset dataset = arffTools.readARFF(fileName);

  SGPP::base::DataMatrix& trainingData = dataset.getData();

  size_t dim = dataset.getDimension();
  //    SGPP::base::Grid* grid = SGPP::base::Grid::createLinearGrid(dim);

  bool modLinear = true;
  SGPP::base::Grid* grid = nullptr;
  if (modLinear) {
    grid = SGPP::base::Grid::createModLinearGrid(dim);
  } else {
    grid = SGPP::base::Grid::createLinearGrid(dim);
  }

  SGPP::base::GridStorage* gridStorage = grid->getStorage();
  std::cout << "dimensionality:        " << gridStorage->dim() << std::endl;

  SGPP::base::GridGenerator* gridGen = grid->createGridGenerator();
  gridGen->regular(level);
  std::cout << "number of grid points: " << gridStorage->size() << std::endl;
  std::cout << "number of data points: " << dataset.getNumberInstances() << std::endl;

  SGPP::base::DataVector alpha(gridStorage->size());

  for (size_t i = 0; i < alpha.getSize(); i++) {
    //    alpha[i] = dist(mt);
    alpha[i] = static_cast<double>(i) + 1.0;
  }

  std::cout << "creating operation with unrefined grid" << std::endl;
  SGPP::base::OperationMultipleEval* eval =
      SGPP::op_factory::createOperationMultipleEval(*grid, trainingData, configuration);

  doAllRefinements(adaptConfig, *grid, *gridGen, alpha);

  std::cout << "number of grid points after refinement: " << gridStorage->size() << std::endl;
  std::cout << "grid set up" << std::endl;

  SGPP::base::DataVector dataSizeVectorResult(dataset.getNumberInstances());
  dataSizeVectorResult.setAll(0);

  std::cout << "preparing operation for refined grid" << std::endl;
  eval->prepare();

  std::cout << "calculating result" << std::endl;

  for (size_t i = 0; i < 1; i++) {
    std::cout << "repeated mult: " << i << std::endl;
    eval->mult(alpha, dataSizeVectorResult);
  }

  std::cout << "duration: " << eval->getDuration() << std::endl;

  //    SGPP::base::DataVector alpha2(gridStorage->size());
  //    alpha2.setAll(0.0);
  //
  //    eval->multTranspose(dataSizeVectorResult, alpha2);

  std::cout << "calculating comparison values..." << std::endl;

  SGPP::base::OperationMultipleEval* evalCompare =
      SGPP::op_factory::createOperationMultipleEval(*grid, trainingData);

  SGPP::base::DataVector dataSizeVectorResultCompare(dataset.getNumberInstances());
  dataSizeVectorResultCompare.setAll(0.0);

  evalCompare->mult(alpha, dataSizeVectorResultCompare);

  double mse = 0.0;

  for (size_t i = 0; i < dataSizeVectorResultCompare.getSize(); i++) {
    mse += (dataSizeVectorResult[i] - dataSizeVectorResultCompare[i]) *
           (dataSizeVectorResult[i] - dataSizeVectorResultCompare[i]);
  }

  mse = mse / static_cast<double>(dataSizeVectorResultCompare.getSize());
  std::cout << "mse: " << mse << std::endl;
}
	SCSimulation_normal(
		std::string& _nastin_dat, 
		std::string& _solidz_dat, 
		std::string& _run_exec, 
		std::string& _output_data, 
		std::string& _gather_data_exec_sc, 
		std::string& _get_output_sc,
		std::string& _postproc_stat_exec_sc,
		std::string& _output_file_sc, 
		std::string& _coeff_sc,
		std::string& _postproc_stat_sc,
		std::string& _insert_nastin_exec, 
		std::string& _insert_solidz_exec,
		std::string& _gather_alya_output,  
		const unsigned int& _ncoeff, 
		const unsigned int& _prob_dim,
		const unsigned int& _sg_level,
		const double& _rho_f_p1, 
		const double& _rho_f_p2, 
		const double& _nu_f_p1, 
		const double& _nu_f_p2, 
		const double& _rho_s_p1, 
		const double& _rho_s_p2)
	{
		i_ncoeff = _ncoeff;
		i_dim = _prob_dim;
		i_sg_level = _sg_level;

		nastin_dat = _nastin_dat;
		solidz_dat = _solidz_dat;
		run_exec = _run_exec;
		output_data = _output_data;
		gather_data_exec_sc = _gather_data_exec_sc;
		get_output_sc = _get_output_sc;
		postproc_stat_exec_sc = _postproc_stat_exec_sc;
		output_file_sc = _output_file_sc;
		coeff_sc = _coeff_sc;
		postproc_stat_sc = _postproc_stat_sc;
		insert_nastin_exec = _insert_nastin_exec;
		insert_solidz_exec = _insert_solidz_exec;
		gather_alya_output = _gather_alya_output;

		rho_f_p1 = _rho_f_p1;
		rho_f_p2 = _rho_f_p2;
		nu_f_p1 = _nu_f_p1;
		nu_f_p2 = _nu_f_p2;
		rho_s_p1 = _rho_s_p1;
		rho_s_p2 = _rho_s_p2;

		multi_ncoeff = compute_no_coeff();

		for(int i = 0 ; i < i_dim ; ++i)
		{
			l_limits.push_back(-3.0);
			r_limits.push_back(3.0);
		}

		grid = SGPP::base::Grid::createLinearGrid(_prob_dim);
		grid_storage = grid->getStorage(); 
		grid_gen = grid->createGridGenerator();
		grid_gen->regular(_sg_level);

		quad = SGPP::op_factory::createOperationQuadrature(*grid);

		grid_storage_size = grid_storage->size();
	}