//-----------------------------------------------------------------------------
void Function::init_vector()
{
Timer timer("Init dof vector");
// Get dof map
dolfin_assert(_function_space);
dolfin_assert(_function_space->dofmap());
const GenericDofMap& dofmap = *(_function_space->dofmap());
// Check that function space is not a subspace (view)
if (dofmap.is_view())
{
dolfin_error("Function.cpp",
"initialize vector of degrees of freedom for function",
"Cannot be created from subspace. Consider collapsing the "
"function space");
}
// Get index map
std::shared_ptr<const IndexMap> index_map = dofmap.index_map();
dolfin_assert(index_map);
DefaultFactory factory;
// Create layout for initialising tensor
std::shared_ptr<TensorLayout> tensor_layout;
tensor_layout = factory.create_layout(1);
dolfin_assert(tensor_layout);
dolfin_assert(!tensor_layout->sparsity_pattern());
dolfin_assert(_function_space->mesh());
tensor_layout->init(_function_space->mesh()->mpi_comm(), {index_map},
TensorLayout::Ghosts::GHOSTED);
// Create vector of dofs
if (!_vector)
_vector = factory.create_vector();
dolfin_assert(_vector);
if (!_vector->empty())
{
dolfin_error("Function.cpp",
"initialize vector of degrees of freedom for function",
"Cannot re-initialize a non-empty vector. Consider creating a new function");
}
_vector->init(*tensor_layout);
_vector->zero();
}
//-----------------------------------------------------------------------------
void Function::init_vector()
{
Timer timer("Init dof vector");
// Check that function space is not a subspace (view)
dolfin_assert(_function_space);
if (_function_space->dofmap()->is_view())
{
dolfin_error("Function.cpp",
"initialize vector of degrees of freedom for function",
"Cannot be created from subspace. Consider collapsing the function space");
}
// Get global size
const std::size_t N = _function_space->dofmap()->global_dimension();
// Get local range
const std::pair<std::size_t, std::size_t> range
= _function_space->dofmap()->ownership_range();
const std::size_t local_size = range.second - range.first;
// Determine ghost vertices if dof map is distributed
std::vector<la_index> ghost_indices;
if (N > local_size)
compute_ghost_indices(range, ghost_indices);
// Create vector of dofs
if (!_vector)
{
DefaultFactory factory;
_vector = factory.create_vector();
}
dolfin_assert(_vector);
// Initialize vector of dofs
dolfin_assert(_function_space->mesh());
if (_vector->empty())
_vector->init(_function_space->mesh()->mpi_comm(), range, ghost_indices);
else
{
dolfin_error("Function.cpp",
"initialize vector of degrees of freedom for function",
"Cannot re-initialize a non-empty vector. Consider creating a new function");
}
_vector->zero();
}
//-----------------------------------------------------------------------------
void KrylovSolver::init(std::string method, std::string preconditioner)
{
// Get default linear algebra factory
DefaultFactory factory;
// Get list of available methods and preconditioners
const std::map<std::string, std::string>
methods = factory.krylov_solver_methods();
const std::map<std::string, std::string>
preconditioners = factory.krylov_solver_preconditioners();
// Check that method is available
if (!LinearSolver::in_list(method, methods))
{
dolfin_error("KrylovSolver.cpp",
"solve linear system using Krylov iteration",
"Unknown Krylov method \"%s\". "
"Use list_krylov_solver_methods() to list available Krylov methods",
method.c_str());
}
// Check that preconditioner is available
if (!LinearSolver::in_list(preconditioner, preconditioners))
{
dolfin_error("KrylovSolver.cpp",
"solve linear system using Krylov iteration",
"Unknown preconditioner \"%s\". "
"Use list_krylov_solver_preconditioners() to list available preconditioners()",
preconditioner.c_str());
}
// Set default parameters
parameters = dolfin::parameters("krylov_solver");
// Initialize solver
solver = factory.create_krylov_solver(method, preconditioner);
solver->parameters.update(parameters);
}
