void GenericCell<dim, spacedim>::project_flux_BC_to_face(
const Function<dim, func_out_type> &func,
const poly_space_basis<BasisType, dim - 1> &the_basis,
const std::vector<double> &weights,
mtl::vec::dense_vector<func_out_type> &vec)
{
if (std::is_same<JacobiPolys<dim - 1>, BasisType>::value)
{
std::vector<dealii::Point<dim> > integration_points_loc =
this->face_quad_fe_vals->get_quadrature_points();
std::vector<dealii::Point<dim> > normals_at_integration =
this->face_quad_fe_vals->get_normal_vectors();
assert(the_basis.n_quads == integration_points_loc.size());
assert(integration_points_loc.size() == weights.size());
vec.change_dim(the_basis.n_polys);
vec = 0;
for (unsigned i1 = 0; i1 < weights.size(); ++i1)
{
const eigen3mat &Nj0 = the_basis.get_func_vals_at_iquad(i1);
mtl::vec::dense_vector<double> Nj(the_basis.n_polys,
(double *)Nj0.data());
const func_out_type &value =
func.value(integration_points_loc[i1], normals_at_integration[i1]);
vec += weights[i1] * value * Nj;
}
}
else if (std::is_same<LagrangePolys<dim - 1>, BasisType>::value)
{
std::vector<dealii::Point<dim> > support_points_loc =
this->face_supp_fe_vals->get_quadrature_points();
std::vector<dealii::Point<dim> > normals_at_supports =
this->face_supp_fe_vals->get_normal_vectors();
assert(support_points_loc.size() == the_basis.n_polys);
vec.change_dim(the_basis.n_polys);
vec = 0;
unsigned counter = 0;
for (auto &&support_point : support_points_loc)
{
vec[counter] = func.value(support_point, normals_at_supports[counter]);
counter++;
}
}
}
void GenericCell<dim, spacedim>::project_func_to_face(
const TimeFunction<dim, func_out_type> &func,
const poly_space_basis<BasisType, dim - 1> &the_basis,
const std::vector<double> &weights,
mtl::vec::dense_vector<func_out_type> &vec,
const unsigned &i_face,
const double &time)
{
if (std::is_same<JacobiPolys<dim - 1>, BasisType>::value)
{
std::vector<dealii::Point<dim> > integration_points_loc =
this->face_quad_fe_vals->get_quadrature_points();
std::vector<dealii::Point<dim - 1> > face_quad_points =
this->face_quad_bundle->get_points();
assert(the_basis.n_quads == integration_points_loc.size());
assert(integration_points_loc.size() == weights.size());
vec.change_dim(the_basis.n_polys);
vec = 0;
for (unsigned i1 = 0; i1 < weights.size(); ++i1)
{
const std::vector<double> &face_basis_at_iquad =
this->the_face_basis->value(face_quad_points[i1],
this->half_range_flag[i_face]);
mtl::vec::dense_vector<double> Nj(the_basis.n_polys,
(double *)face_basis_at_iquad.data());
const func_out_type &value = func.value(
integration_points_loc[i1], integration_points_loc[i1], time);
vec += weights[i1] * value * Nj;
}
}
else if (std::is_same<LagrangePolys<dim - 1>, BasisType>::value)
{
std::vector<dealii::Point<dim> > support_points_loc =
this->face_supp_fe_vals->get_quadrature_points();
assert(support_points_loc.size() == the_basis.n_polys);
vec.change_dim(the_basis.n_polys);
unsigned counter = 0;
for (auto &&support_point : support_points_loc)
vec[counter++] = func.value(support_point, support_point, time);
}
}
int GModel::readP3D(const std::string &name)
{
FILE *fp = Fopen(name.c_str(), "r");
if(!fp) {
Msg::Error("Unable to open file '%s'", name.c_str());
return 0;
}
int numBlocks = 0;
if(fscanf(fp, "%d", &numBlocks) != 1 || numBlocks <= 0) {
fclose(fp);
return 0;
}
std::vector<int> Ni(numBlocks), Nj(numBlocks), Nk(numBlocks);
for(int n = 0; n < numBlocks; n++)
if(fscanf(fp, "%d %d %d", &Ni[n], &Nj[n], &Nk[n]) != 3) {
fclose(fp);
return 0;
}
for(int n = 0; n < numBlocks; n++) {
if(Nk[n] == 1) {
GFace *gf = new discreteFace(this, getMaxElementaryNumber(2) + 1);
add(gf);
gf->transfinite_vertices.resize(Ni[n]);
for(int i = 0; i < Ni[n]; i++) gf->transfinite_vertices[i].resize(Nj[n]);
for(int coord = 0; coord < 3; coord++) {
for(int j = 0; j < Nj[n]; j++) {
for(int i = 0; i < Ni[n]; i++) {
double d;
if(fscanf(fp, "%lf", &d) != 1) {
fclose(fp);
return 0;
}
if(coord == 0) {
MVertex *v = new MVertex(d, 0., 0., gf);
gf->transfinite_vertices[i][j] = v;
gf->mesh_vertices.push_back(v);
}
else if(coord == 1) {
gf->transfinite_vertices[i][j]->y() = d;
}
else if(coord == 2) {
gf->transfinite_vertices[i][j]->z() = d;
}
}
}
}
for(std::size_t i = 0; i < gf->transfinite_vertices.size() - 1; i++)
for(std::size_t j = 0; j < gf->transfinite_vertices[0].size() - 1; j++)
gf->quadrangles.push_back(new MQuadrangle(
gf->transfinite_vertices[i][j], gf->transfinite_vertices[i + 1][j],
gf->transfinite_vertices[i + 1][j + 1],
gf->transfinite_vertices[i][j + 1]));
}
else {
GRegion *gr = new discreteRegion(this, getMaxElementaryNumber(3) + 1);
add(gr);
gr->transfinite_vertices.resize(Ni[n]);
for(int i = 0; i < Ni[n]; i++) {
gr->transfinite_vertices[i].resize(Nj[n]);
for(int j = 0; j < Nj[n]; j++) {
gr->transfinite_vertices[i][j].resize(Nk[n]);
}
}
for(int coord = 0; coord < 3; coord++) {
for(int k = 0; k < Nk[n]; k++) {
for(int j = 0; j < Nj[n]; j++) {
for(int i = 0; i < Ni[n]; i++) {
double d;
if(fscanf(fp, "%lf", &d) != 1) {
fclose(fp);
return 0;
}
if(coord == 0) {
MVertex *v = new MVertex(d, 0., 0., gr);
gr->transfinite_vertices[i][j][k] = v;
gr->mesh_vertices.push_back(v);
}
else if(coord == 1) {
gr->transfinite_vertices[i][j][k]->y() = d;
}
else if(coord == 2) {
gr->transfinite_vertices[i][j][k]->z() = d;
}
}
}
}
}
for(std::size_t i = 0; i < gr->transfinite_vertices.size() - 1; i++)
for(std::size_t j = 0; j < gr->transfinite_vertices[0].size() - 1; j++)
for(std::size_t k = 0; k < gr->transfinite_vertices[0][0].size() - 1;
k++)
gr->hexahedra.push_back(
new MHexahedron(gr->transfinite_vertices[i][j][k],
gr->transfinite_vertices[i + 1][j][k],
gr->transfinite_vertices[i + 1][j + 1][k],
gr->transfinite_vertices[i][j + 1][k],
gr->transfinite_vertices[i][j][k + 1],
gr->transfinite_vertices[i + 1][j][k + 1],
gr->transfinite_vertices[i + 1][j + 1][k + 1],
gr->transfinite_vertices[i][j + 1][k + 1]));
}
}
fclose(fp);
return 1;
}
