// Constructor for writing
VTKIO::VTKIO (const MeshBase& mesh, MeshData* mesh_data) :
MeshOutput<MeshBase>(mesh),
_mesh_data(mesh_data),
_compress(false),
_local_node_map()
{
_vtk_grid = NULL;
libmesh_experimental();
}
// Constructor for reading
VTKIO::VTKIO (MeshBase & mesh, MeshData * mesh_data) :
MeshInput<MeshBase> (mesh),
MeshOutput<MeshBase>(mesh),
_mesh_data(mesh_data),
_compress(false),
_local_node_map()
{
_vtk_grid = libmesh_nullptr;
libmesh_experimental();
}
void RadialBasisInterpolation<KDDim,RBF>::interpolate_field_data (const std::vector<std::string> &field_names,
const std::vector<Point> &tgt_pts,
std::vector<Number> &tgt_vals) const
{
START_LOG ("interpolate_field_data()", "RadialBasisInterpolation<>");
libmesh_experimental();
const unsigned int
n_vars = this->n_field_variables(),
n_src_pts = this->_src_pts.size(),
n_tgt_pts = tgt_pts.size();
libmesh_assert_equal_to (_weights.size(), this->_src_vals.size());
libmesh_assert_equal_to (field_names.size(), this->n_field_variables());
// If we already have field variables, we assume we are appending.
// that means the names and ordering better be identical!
if (this->_names.size() != field_names.size())
{
libMesh::err << "ERROR: when adding field data to an existing list the\n"
<< "varaible list must be the same!\n";
libmesh_error();
}
for (unsigned int v=0; v<this->_names.size(); v++)
if (_names[v] != field_names[v])
{
libMesh::err << "ERROR: when adding field data to an existing list the\n"
<< "varaible list must be the same!\n";
libmesh_error();
}
RBF rbf(_r_bbox);
tgt_vals.resize (n_tgt_pts*n_vars); /**/ std::fill (tgt_vals.begin(), tgt_vals.end(), Number(0.));
for (unsigned int tgt=0; tgt<n_tgt_pts; tgt++)
{
const Point &p (tgt_pts[tgt]);
for (unsigned int i=0; i<n_src_pts; i++)
{
const Point &x_i(_src_pts[i]);
const Real
r_i = (p - x_i).size(),
phi_i = rbf(r_i);
for (unsigned int var=0; var<n_vars; var++)
tgt_vals[tgt*n_vars + var] += _weights[i*n_vars + var]*phi_i;
}
}
STOP_LOG ("interpolate_field_data()", "RadialBasisInterpolation<>");
}
RBParametrized::RBParametrized()
:
verbose_mode(false),
parameters_initialized(false)
{
libmesh_experimental();
parameters.clear();
parameters_min.clear();
parameters_max.clear();
}
// Constructor for writing
VTKIO::VTKIO (const MeshBase & mesh, MeshData * mesh_data) :
MeshOutput<MeshBase>(mesh, /*is_parallel_format=*/true)
#ifdef LIBMESH_HAVE_VTK
,_vtk_grid(libmesh_nullptr)
,_mesh_data(mesh_data)
,_compress(false)
#endif
{
// Ignore unused parameters when !LIBMESH_HAVE_VTK
libmesh_ignore(mesh_data);
libmesh_experimental();
}
//------------------------------------------------------------------
// PointLocator methods
PointLocatorList::PointLocatorList (const MeshBase& mesh,
const PointLocatorBase* master) :
PointLocatorBase (mesh,master),
_list (NULL)
{
// This code will only work if your mesh is the Voroni mesh of it's
// own elements' centroids. If your mesh is that regular you might
// as well hand-code an O(1) algorithm for locating points within
// it. - RHS
libmesh_experimental();
this->init();
}
void
MeshfreeSolutionTransfer::transfer(const Variable & from_var,
const Variable & to_var)
{
libmesh_experimental();
System * from_sys = from_var.system();
System * to_sys = to_var.system();
EquationSystems & from_es = from_sys->get_equation_systems();
MeshBase & from_mesh = from_es.get_mesh();
InverseDistanceInterpolation<LIBMESH_DIM> idi
(from_mesh.comm(), 4, 2);
std::vector<Point> & src_pts (idi.get_source_points());
std::vector<Number> & src_vals (idi.get_source_vals());
std::vector<std::string> field_vars;
field_vars.push_back(from_var.name());
idi.set_field_variables(field_vars);
// We now will loop over every node in the source mesh
// and add it to a source point list, along with the solution
{
MeshBase::const_node_iterator nd = from_mesh.local_nodes_begin();
MeshBase::const_node_iterator end = from_mesh.local_nodes_end();
for (; nd!=end; ++nd)
{
const Node * node = *nd;
src_pts.push_back(*node);
src_vals.push_back((*from_sys->solution)(node->dof_number(from_sys->number(),from_var.number(),0)));
}
}
// We have only set local values - prepare for use by gathering remote gata
idi.prepare_for_use();
// Create a MeshlessInterpolationFunction that uses our
// InverseDistanceInterpolation object. Since each
// MeshlessInterpolationFunction shares the same
// InverseDistanceInterpolation object in a threaded environment we
// must also provide a locking mechanism.
Threads::spin_mutex mutex;
MeshlessInterpolationFunction mif(idi, mutex);
// project the solution
to_sys->project_solution(&mif);
}
DGFEMContext::DGFEMContext (const System &sys)
: FEMContext(sys),
_neighbor(NULL),
_neighbor_dof_indices_var(sys.n_vars()),
_dg_terms_active(false)
{
libmesh_experimental();
unsigned int nv = sys.n_vars();
libmesh_assert (nv);
_neighbor_subresiduals.reserve(nv);
_elem_elem_subjacobians.resize(nv);
_elem_neighbor_subjacobians.resize(nv);
_neighbor_elem_subjacobians.resize(nv);
_neighbor_neighbor_subjacobians.resize(nv);
for (unsigned int i=0; i != nv; ++i)
{
_neighbor_subresiduals.push_back(new DenseSubVector<Number>(_neighbor_residual));
_elem_elem_subjacobians[i].reserve(nv);
_elem_neighbor_subjacobians[i].reserve(nv);
_neighbor_elem_subjacobians[i].reserve(nv);
_neighbor_neighbor_subjacobians[i].reserve(nv);
for (unsigned int j=0; j != nv; ++j)
{
_elem_elem_subjacobians[i].push_back
(new DenseSubMatrix<Number>(_elem_elem_jacobian));
_elem_neighbor_subjacobians[i].push_back
(new DenseSubMatrix<Number>(_elem_neighbor_jacobian));
_neighbor_elem_subjacobians[i].push_back
(new DenseSubMatrix<Number>(_neighbor_elem_jacobian));
_neighbor_neighbor_subjacobians[i].push_back
(new DenseSubMatrix<Number>(_neighbor_neighbor_jacobian));
}
}
_neighbor_side_fe_var.resize(nv);
for (unsigned int i=0; i != nv; ++i)
{
FEType fe_type = sys.variable_type(i);
if ( _neighbor_side_fe[fe_type] == NULL )
{
_neighbor_side_fe[fe_type] = FEAbstract::build(dim, fe_type).release();
}
_neighbor_side_fe_var[i] = _neighbor_side_fe[fe_type];
}
}
void
DTKSolutionTransfer::transfer(const Variable & from_var, const Variable & to_var)
{
libmesh_experimental();
EquationSystems * from_es = &from_var.system()->get_equation_systems();
EquationSystems * to_es = &to_var.system()->get_equation_systems();
// Possibly make an Adapter for from_es
if(adapters.find(from_es) == adapters.end())
adapters[from_es] = new DTKAdapter(comm_default, *from_es);
// Possibly make an Adapter for to_es
if(adapters.find(to_es) == adapters.end())
adapters[to_es] = new DTKAdapter(comm_default, *to_es);
DTKAdapter * from_adapter = adapters[from_es];
DTKAdapter * to_adapter = adapters[to_es];
std::pair<EquationSystems *, EquationSystems *> from_to(from_es, to_es);
// If we haven't created a map for this pair of EquationSystems yet, do it now
if(dtk_maps.find(from_to) == dtk_maps.end())
{
libmesh_assert(from_es->get_mesh().mesh_dimension() == to_es->get_mesh().mesh_dimension());
shared_domain_map_type * map = new shared_domain_map_type(comm_default, from_es->get_mesh().mesh_dimension(), true);
dtk_maps[from_to] = map;
// The tolerance here is for the "contains_point()" implementation in DTK. Set a larger value for a looser tolerance...
map->setup(from_adapter->get_mesh_manager(), to_adapter->get_target_coords(), 30*Teuchos::ScalarTraits<double>::eps());
}
DTKAdapter::RCP_Evaluator from_evaluator = from_adapter->get_variable_evaluator(from_var.name());
Teuchos::RCP<DataTransferKit::FieldManager<DTKAdapter::FieldContainerType> > to_values = to_adapter->get_values_to_fill(to_var.name());
dtk_maps[from_to]->apply(from_evaluator, to_values);
if(dtk_maps[from_to]->getMissedTargetPoints().size())
libMesh::out<<"Warning: Some points were missed in the transfer of "<<from_var.name()<<" to "<<to_var.name()<<"!"<<std::endl;
to_adapter->update_variable_values(to_var.name());
}
void MeshfreeInterpolation::add_field_data (const std::vector<std::string> &field_names,
const std::vector<Point> &pts,
const std::vector<Number> &vals)
{
libmesh_experimental();
libmesh_assert_equal_to (field_names.size()*pts.size(), vals.size());
// If we already have field variables, we assume we are appending.
// that means the names and ordering better be identical!
if (!_names.empty())
{
if (_names.size() != field_names.size())
{
libMesh::err << "ERROR: when adding field data to an existing list the\n"
<< "varaible list must be the same!\n";
libmesh_error();
}
for (unsigned int v=0; v<_names.size(); v++)
if (_names[v] != field_names[v])
{
libMesh::err << "ERROR: when adding field data to an existing list the\n"
<< "varaible list must be the same!\n";
libmesh_error();
}
}
// otherwise copy the names
else
_names = field_names;
// append the data
_src_pts.insert (_src_pts.end(),
pts.begin(),
pts.end());
_src_vals.insert (_src_vals.end(),
vals.begin(),
vals.end());
libmesh_assert_equal_to (_src_vals.size(),
_src_pts.size()*this->n_field_variables());
}
PostscriptIO::PostscriptIO (const MeshBase& mesh_in)
: MeshOutput<MeshBase> (mesh_in),
shade_value(0.0),
line_width(0.5),
//_M(3,3),
_offset(0., 0.),
_scale(1.0),
_current_point(0., 0.)
{
// This code is still undergoing some development.
libmesh_experimental();
// Entries of transformation matrix from physical to Bezier coords.
// _M(0,0) = -1./6.; _M(0,1) = 1./6.; _M(0,2) = 1.;
// _M(1,0) = -1./6.; _M(1,1) = 0.5 ; _M(1,2) = 1./6.;
// _M(2,0) = 0. ; _M(2,1) = 1. ; _M(2,2) = 0.;
// Make sure there is enough room to store Bezier coefficients.
_bezier_coeffs.resize(3);
}
std::pair<unsigned int, Real>
EigenSparseLinearSolver<T>::adjoint_solve (SparseMatrix<T> &matrix_in,
NumericVector<T> &solution_in,
NumericVector<T> &rhs_in,
const double tol,
const unsigned int m_its)
{
START_LOG("adjoint_solve()", "EigenSparseLinearSolver");
libmesh_experimental();
EigenSparseMatrix<T> mat_trans(this->comm());
matrix_in.get_transpose(mat_trans);
std::pair<unsigned int, Real> retval = this->solve (mat_trans,
solution_in,
rhs_in,
tol,
m_its);
STOP_LOG("adjoint_solve()", "EigenSparseLinearSolver");
return retval;
}
void InverseDistanceInterpolation<KDDim>::interpolate_field_data (const std::vector<std::string> &field_names,
const std::vector<Point> &tgt_pts,
std::vector<Number> &tgt_vals) const
{
libmesh_experimental();
// forcibly initialize, if needed
#ifdef LIBMESH_HAVE_NANOFLANN
if (_kd_tree.get() == NULL)
const_cast<InverseDistanceInterpolation<KDDim>*>(this)->construct_kd_tree();
#endif
START_LOG ("interpolate_field_data()", "InverseDistanceInterpolation<>");
libmesh_assert_equal_to (field_names.size(), this->n_field_variables());
// If we already have field variables, we assume we are appending.
// that means the names and ordering better be identical!
if (_names.size() != field_names.size())
{
libMesh::err << "ERROR: when adding field data to an existing list the\n"
<< "varaible list must be the same!\n";
libmesh_error();
}
for (unsigned int v=0; v<_names.size(); v++)
if (_names[v] != field_names[v])
{
libMesh::err << "ERROR: when adding field data to an existing list the\n"
<< "varaible list must be the same!\n";
libmesh_error();
}
tgt_vals.resize (tgt_pts.size()*this->n_field_variables());
#ifdef LIBMESH_HAVE_NANOFLANN
{
std::vector<Number>::iterator out_it = tgt_vals.begin();
const size_t num_results = std::min((size_t) _n_interp_pts, _src_pts.size());
std::vector<size_t> ret_index(num_results);
std::vector<Real> ret_dist_sqr(num_results);
for (std::vector<Point>::const_iterator tgt_it=tgt_pts.begin();
tgt_it != tgt_pts.end(); ++tgt_it)
{
const Point &tgt(*tgt_it);
const Real query_pt[] = { tgt(0), tgt(1), tgt(2) };
_kd_tree->knnSearch(&query_pt[0], num_results, &ret_index[0], &ret_dist_sqr[0]);
this->interpolate (tgt, ret_index, ret_dist_sqr, out_it);
// libMesh::out << "knnSearch(): num_results=" << num_results << "\n";
// for (size_t i=0;i<num_results;i++)
// libMesh::out << "idx[" << i << "]="
// << std::setw(6) << ret_index[i]
// << "\t dist["<< i << "]=" << ret_dist_sqr[i]
// << "\t val[" << std::setw(6) << ret_index[i] << "]=" << _src_vals[ret_index[i]]
// << std::endl;
// libMesh::out << "\n";
// libMesh::out << "ival=" << _vals[0] << '\n';
}
}
#else
libMesh::err << "ERROR: This functionality requires the library to be configured\n"
<< "with nanoflann KD-Tree approximate nearest neighbor support!\n"
<< std::endl;
libmesh_error();
#endif
STOP_LOG ("interpolate_field_data()", "InverseDistanceInterpolation<>");
}
