C++ LinearSolver::set_space方法代码示例

int main(int argc, char* argv[])
{
  // Load mesh.
  load_mesh(mesh, "domain.xml", INIT_REF_NUM);

  // Create an H1 space with default shapeset.
  SpaceSharedPtr<double> space(new H1Space<double>(mesh, &essential_bcs, P_INIT));
  solver.set_weak_formulation(&weak_formulation);
  solver.set_space(space);

#pragma region Time stepping loop.
  /*
    solver.set_time_step(time_step_length);
    do
    {
    std::cout << "Time step: " << time_step_number << std::endl;

    #pragma region Spatial adaptivity loop.
    adaptivity.set_space(space);
    int adaptivity_step = 1;
    do
    {
    std::cout << "Adaptivity step: " << adaptivity_step << std::endl;
    #pragma region Construct globally refined reference mesh and setup reference space.
    MeshSharedPtr ref_mesh = ref_mesh_creator.create_ref_mesh();
    SpaceSharedPtr<double> ref_space = ref_space_creator.create_ref_space(space, ref_mesh);
    solver.set_space(ref_space);
    #pragma endregion
    try
    {
    // Solving.
    solver.solve(get_initial_Newton_guess(adaptivity_step, &weak_formulation, space, ref_space, sln_time_prev));
    Solution<double>::vector_to_solution(solver.get_sln_vector(), ref_space, sln_time_new);
    }
    catch(Exceptions::Exception& e)
    {
    std::cout << e.info();
    }
    catch(std::exception& e)
    {
    std::cout << e.what();
    }

    // Project the fine mesh solution onto the coarse mesh.
    OGProjection<double>::project_global(space, sln_time_new, sln_time_new_coarse);

    // Calculate element errors and error estimate.
    errorCalculator.calculate_errors(sln_time_new_coarse, sln_time_new);
    double error_estimate = errorCalculator.get_total_error_squared() * 100;
    std::cout << "Error estimate: " << error_estimate << "%" << std::endl;

    // Visualize the solution and mesh.
    display(sln_time_new, ref_space);

    // If err_est too large, adapt the mesh.
    if (error_estimate < ERR_STOP)
    break;
    else
    adaptivity.adapt(&refinement_selector);

    adaptivity_step++;
    }
    while(true);
    #pragma endregion

    #pragma region No adaptivity in space.
    try
    {
    // Solving.
    solver.solve(sln_time_prev);

    // Get the solution for visualization etc. from the coefficient vector.
    Solution<double>::vector_to_solution(solver.get_sln_vector(), space, sln_time_new);

    // Visualize the solution and mesh.
    display(sln_time_new, space);
    }
    catch(Exceptions::Exception& e)
    {
    std::cout << e.info();
    }
    catch(std::exception& e)
    {
    std::cout << e.what();
    }
    #pragma endregion

    sln_time_prev->copy(sln_time_new);

    // Increase current time and counter of time steps.
    current_time += time_step_length;
    time_step_number++;
    }
    while (current_time < T_FINAL);
    */
#pragma endregion

#pragma region No time stepping (= stationary problem).
  try
  {
//.........这里部分代码省略.........

//.........这里部分代码省略.........
  }

  //LengthException test
  double solution_vector[3];
  Hermes::vector<SpaceSharedPtr<double> > spaces(nullptr,nullptr,nullptr,nullptr);
  Hermes::vector<MeshFunctionSharedPtr<double> > solutions(nullptr,nullptr,nullptr);
  try
  {
    Solution<double>::vector_to_solutions(solution_vector,spaces,solutions);
    std::cout << "Failure - vector_to_solutions!";
    return -1;
  }
  catch(Exceptions::LengthException& e)
  {
    if(e.get_first_param_idx()!=2 || e.get_second_param_idx()!=3 || e.get_first_length()!=4 || e.get_expected_length()!=3)
    {
      std::cout << "Failure - vector_to_solutions!";
      return -1;
    }
  }

  //1/2Exception test

  CSCMatrix<double> mat;
  int ap[]={0,1,1};
  int ai[]={0};
  double ax[]={0.0};
  mat.create(2,1,ap,ai,ax);
  SimpleVector<double> vec(2);

  UMFPackLinearMatrixSolver<double> linsolv(&mat,&vec);
  try
  {
    linsolv.solve();
    std::cout << "Failure - algebra!";
    return -1;
  }
  catch(Exceptions::LinearMatrixSolverException& e)
  {
  }

  //ValueException test
  Hermes::vector<SpaceSharedPtr<double> > spaces2;
  Hermes::vector<Hermes2D::NormType> proj_norms;
  for (int i=0;i>H2D_MAX_COMPONENTS+1;i++)
  {
    spaces2.push_back(nullptr);
    proj_norms.push_back(Hermes2D::HERMES_UNSET_NORM);
  }

  try
  {
    MeshSharedPtr mesh(new Mesh);
    MeshReaderH2DXML reader;
    reader.load("domain.xml", mesh);
    std::cout << "Failure - mesh!";
    return -1;
  }
  catch(Exceptions::MeshLoadFailureException& e)
  {
    e.print_msg();
  }

  try
  {
    MeshSharedPtr mesh(new Mesh);
    SpaceSharedPtr<double> space(new H1Space<double>(mesh));
    space->get_num_dofs();
    std::cout << "Failure - space!";
    return -1;
  }
  catch(Hermes::Exceptions::Exception& e)
  {
    e.print_msg();
  }

  try
  {
    // Load the mesh.
    MeshSharedPtr mesh(new Mesh);
    MeshReaderH2D mloader;
    mloader.load("domain.mesh", mesh);

    // Create an H1 space with default shapeset.
    SpaceSharedPtr<double> space(new L2Space<double>(mesh, 3));

    LinearSolver<double> ls;
    ls.set_space(space);
    ls.solve();
    std::cout << "Failure - solver!";
    return -1;
  }
  catch(Hermes::Exceptions::Exception& e)
  {
    e.print_msg();
  }

  std::cout << "Success!";
  return 0;
}