NeumannBc::NeumannBc(
NeumannBcConfig const& bc,
unsigned const integration_order,
NumLib::LocalToGlobalIndexMap const& local_to_global_index_map,
int const variable_id,
int const component_id)
: _function(*bc.getFunction()),
_integration_order(integration_order)
{
assert(component_id < static_cast<int>(local_to_global_index_map.getNumberOfComponents()));
// deep copy because the neumann bc config destroys the elements.
std::transform(bc.elementsBegin(), bc.elementsEnd(),
std::back_inserter(_elements),
std::mem_fn(&MeshLib::Element::clone));
std::vector<MeshLib::Node*> nodes = MeshLib::getUniqueNodes(_elements);
auto const& mesh_subsets =
local_to_global_index_map.getMeshSubsets(variable_id, component_id);
// TODO extend the node intersection to all parts of mesh_subsets, i.e.
// to each of the MeshSubset in the mesh_subsets.
_mesh_subset_all_nodes =
mesh_subsets.getMeshSubset(0).getIntersectionByNodes(nodes);
std::unique_ptr<MeshLib::MeshSubsets> all_mesh_subsets{
new MeshLib::MeshSubsets{_mesh_subset_all_nodes}};
// Create local DOF table from intersected mesh subsets for the given
// variable and component ids.
_local_to_global_index_map.reset(
local_to_global_index_map.deriveBoundaryConstrainedMap(
variable_id, component_id, std::move(all_mesh_subsets),
_elements));
}
GlobalSparsityPattern computeSparsityPatternPETSc(
NumLib::LocalToGlobalIndexMap const& dof_table,
MeshLib::Mesh const& mesh)
{
assert(dynamic_cast<MeshLib::NodePartitionedMesh const*>(&mesh));
auto const& npmesh =
*static_cast<MeshLib::NodePartitionedMesh const*>(&mesh);
auto const max_nonzeroes = dof_table.getNumberOfComponents()
* npmesh.getMaximumNConnectedNodesToNode();
// The sparsity pattern is misused here in the sense that it will only
// contain a single value.
return GlobalSparsityPattern(1, max_nonzeroes);
}
LocalLinearLeastSquaresExtrapolator::LocalLinearLeastSquaresExtrapolator(
NumLib::LocalToGlobalIndexMap const& dof_table)
: _dof_table_single_component(dof_table)
{
/* Note in case the following assertion fails:
* If you copied the extrapolation code, for your processes from
* somewhere, note that the code from the groundwater flow process might
* not suit your needs: It is a special case and is therefore most
* likely too simplistic. You better adapt the extrapolation code from
* some more advanced process, like the TES process.
*/
if (dof_table.getNumberOfComponents() != 1)
OGS_FATAL(
"The d.o.f. table passed must be for one variable that has "
"only one component!");
}
void ProcessVariable::createBoundaryConditionsForDeactivatedSubDomains(
const NumLib::LocalToGlobalIndexMap& dof_table, const int variable_id,
std::vector<std::unique_ptr<ParameterBase>> const& parameters,
std::vector<std::unique_ptr<BoundaryCondition>>& bcs)
{
auto& parameter = findParameter<double>(
DeactivatedSubdomain::name_of_paramater_of_zero, parameters, 1);
for (auto const& deactivated_subdomain : _deactivated_subdomains)
{
auto const& deactivated_subdomain_meshes =
deactivated_subdomain->deactivated_subdomain_meshes;
for (auto const& deactivated_subdomain_mesh :
deactivated_subdomain_meshes)
{
for (int component_id = 0;
component_id < dof_table.getNumberOfComponents();
component_id++)
{
// Copy the time interval.
std::unique_ptr<BaseLib::TimeInterval> time_interval =
std::make_unique<BaseLib::TimeInterval>(
*deactivated_subdomain->time_interval);
auto bc = std::make_unique<
DirichletBoundaryConditionWithinTimeInterval>(
std::move(time_interval), parameter,
*(deactivated_subdomain_mesh->mesh),
deactivated_subdomain_mesh->inactive_nodes, dof_table,
variable_id, component_id);
#ifdef USE_PETSC
// TODO: make it work under PETSc too.
if (bc == nullptr)
{
continue;
}
#endif // USE_PETSC
bcs.push_back(std::move(bc));
}
}
}
}
// TODO Copied from VectorMatrixAssembler. Could be provided by the DOF table.
inline NumLib::LocalToGlobalIndexMap::RowColumnIndices
getRowColumnIndices_(std::size_t const id,
NumLib::LocalToGlobalIndexMap const& dof_table,
std::vector<GlobalIndexType>& indices)
{
assert(dof_table.size() > id);
indices.clear();
// Local matrices and vectors will always be ordered by component,
// no matter what the order of the global matrix is.
for (unsigned c = 0; c < dof_table.getNumberOfComponents(); ++c)
{
auto const& idcs = dof_table(id, c).rows;
indices.reserve(indices.size() + idcs.size());
indices.insert(indices.end(), idcs.begin(), idcs.end());
}
return NumLib::LocalToGlobalIndexMap::RowColumnIndices(indices,
indices);
}