Skip to content

Commit

Permalink
reorder init
Browse files Browse the repository at this point in the history 
del calculate class
  • Loading branch information
@Franguuuu
Franguuuu committed Sep 9, 2024
1 parent 32f67a7 commit a80ce96
Show file tree
Hide file tree
Showing 6 changed files with 68 additions and 171 deletions.
56 changes: 28 additions & 28 deletions src/shared/geometries/level_set.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,13 +29,13 @@ MultilevelLevelSet::MultilevelLevelSet(
finish_data_packages.exec();
probe_signed_distance_set_.push_back(
probe_signed_distance_vector_keeper_
.template createPtr<MeshCalculateDynamics<Real, ProbeSignedDistance>>(*mesh_data_set_[0]));
.template createPtr<ProbeSignedDistance>(*mesh_data_set_[0]));
probe_normal_direction_set_.push_back(
probe_normal_direction_vector_keeper_
.template createPtr<MeshCalculateDynamics<Vecd, ProbeNormalDirection>>(*mesh_data_set_[0]));
.template createPtr<ProbeNormalDirection>(*mesh_data_set_[0]));
probe_level_set_gradient_set_.push_back(
probe_level_set_gradient_vector_keeper_
.template createPtr<MeshCalculateDynamics<Vecd, ProbeLevelSetGradient>>(*mesh_data_set_[0]));
.template createPtr<ProbeLevelSetGradient>(*mesh_data_set_[0]));

for (size_t level = 1; level != total_levels_; ++level)
{
Expand All @@ -58,13 +58,13 @@ MultilevelLevelSet::MultilevelLevelSet(

probe_signed_distance_set_.push_back(
probe_signed_distance_vector_keeper_
.template createPtr<MeshCalculateDynamics<Real, ProbeSignedDistance>>(*mesh_data_set_[level]));
.template createPtr<ProbeSignedDistance>(*mesh_data_set_[level]));
probe_normal_direction_set_.push_back(
probe_normal_direction_vector_keeper_
.template createPtr<MeshCalculateDynamics<Vecd, ProbeNormalDirection>>(*mesh_data_set_[level]));
.template createPtr<ProbeNormalDirection>(*mesh_data_set_[level]));
probe_level_set_gradient_set_.push_back(
probe_level_set_gradient_vector_keeper_
.template createPtr<MeshCalculateDynamics<Vecd, ProbeLevelSetGradient>>(*mesh_data_set_[level]));
.template createPtr<ProbeLevelSetGradient>(*mesh_data_set_[level]));
}

clean_interface = new CleanInterface{*mesh_data_set_.back(), kernel_, global_h_ratio_vec_.back()};
Expand Down Expand Up @@ -96,13 +96,13 @@ MultilevelLevelSet::MultilevelLevelSet(

probe_signed_distance_set_.push_back(
probe_signed_distance_vector_keeper_
.template createPtr<MeshCalculateDynamics<Real, ProbeSignedDistance>>(*mesh_data_set_[0]));
.template createPtr<ProbeSignedDistance>(*mesh_data_set_[0]));
probe_normal_direction_set_.push_back(
probe_normal_direction_vector_keeper_
.template createPtr<MeshCalculateDynamics<Vecd, ProbeNormalDirection>>(*mesh_data_set_[0]));
.template createPtr<ProbeNormalDirection>(*mesh_data_set_[0]));
probe_level_set_gradient_set_.push_back(
probe_level_set_gradient_vector_keeper_
.template createPtr<MeshCalculateDynamics<Vecd, ProbeLevelSetGradient>>(*mesh_data_set_[0]));
.template createPtr<ProbeLevelSetGradient>(*mesh_data_set_[0]));

clean_interface = new CleanInterface{*mesh_data_set_.back(), kernel_, global_h_ratio_vec_.back()};
correct_topology = new CorrectTopology{*mesh_data_set_.back(), kernel_, global_h_ratio_vec_.back()};
Expand Down Expand Up @@ -132,24 +132,24 @@ void MultilevelLevelSet::correctTopology(Real small_shift_factor)
//=============================================================================================//
Real MultilevelLevelSet::probeSignedDistance(const Vecd &position)
{
return probe_signed_distance_set_[getProbeLevel(position)]->exec(position);
return probe_signed_distance_set_[getProbeLevel(position)]->update(position);
}
//=============================================================================================//
Vecd MultilevelLevelSet::probeNormalDirection(const Vecd &position)
{
return probe_normal_direction_set_[getProbeLevel(position)]->exec(position);
return probe_normal_direction_set_[getProbeLevel(position)]->update(position);
}
//=============================================================================================//
Vecd MultilevelLevelSet::probeLevelSetGradient(const Vecd &position)
{
return probe_level_set_gradient_set_[getProbeLevel(position)]->exec(position);
return probe_level_set_gradient_set_[getProbeLevel(position)]->update(position);
}
//=============================================================================================//
size_t MultilevelLevelSet::getProbeLevel(const Vecd &position)
{
for (size_t level = total_levels_; level != 0; --level){
MeshCalculateDynamics<bool, IsWithinCorePackage> is_within_core_package{*mesh_data_set_[level - 1]};
if(is_within_core_package.exec(position))
IsWithinCorePackage is_within_core_package{*mesh_data_set_[level - 1]};
if(is_within_core_package.update(position))
return level - 1; // jump out of the loop!
}
return 0;
Expand All @@ -158,33 +158,33 @@ size_t MultilevelLevelSet::getProbeLevel(const Vecd &position)
Real MultilevelLevelSet::probeKernelIntegral(const Vecd &position, Real h_ratio)
{
if(mesh_data_set_.size() == 1){
MeshCalculateDynamics<Real, ProbeKernelIntegral> refine_probe{*mesh_data_set_[0]};
return refine_probe.exec(position);
ProbeKernelIntegral refine_probe{*mesh_data_set_[0]};
return refine_probe.update(position);
}
size_t coarse_level = getCoarseLevel(h_ratio);
Real alpha = (global_h_ratio_vec_[coarse_level + 1] - h_ratio) /
(global_h_ratio_vec_[coarse_level + 1] - global_h_ratio_vec_[coarse_level]);
MeshCalculateDynamics<Real, ProbeKernelIntegral> coarse_probe{*mesh_data_set_[coarse_level]};
MeshCalculateDynamics<Real, ProbeKernelIntegral> fine_probe{*mesh_data_set_[coarse_level + 1]};
Real coarse_level_value = coarse_probe.exec(position);
Real fine_level_value = fine_probe.exec(position);
ProbeKernelIntegral coarse_probe{*mesh_data_set_[coarse_level]};
ProbeKernelIntegral fine_probe{*mesh_data_set_[coarse_level + 1]};
Real coarse_level_value = coarse_probe.update(position);
Real fine_level_value = fine_probe.update(position);

return alpha * coarse_level_value + (1.0 - alpha) * fine_level_value;
}
//=================================================================================================//
Vecd MultilevelLevelSet::probeKernelGradientIntegral(const Vecd &position, Real h_ratio)
{
if(mesh_data_set_.size() == 1){
MeshCalculateDynamics<Vecd, ProbeKernelGradientIntegral> refine_probe{*mesh_data_set_[0]};
return refine_probe.exec(position);
ProbeKernelGradientIntegral refine_probe{*mesh_data_set_[0]};
return refine_probe.update(position);
}
size_t coarse_level = getCoarseLevel(h_ratio);
Real alpha = (global_h_ratio_vec_[coarse_level + 1] - h_ratio) /
(global_h_ratio_vec_[coarse_level + 1] - global_h_ratio_vec_[coarse_level]);
MeshCalculateDynamics<Vecd, ProbeKernelGradientIntegral> coarse_probe{*mesh_data_set_[coarse_level]};
MeshCalculateDynamics<Vecd, ProbeKernelGradientIntegral> fine_probe{*mesh_data_set_[coarse_level + 1]};
Vecd coarse_level_value = coarse_probe.exec(position);
Vecd fine_level_value = fine_probe.exec(position);
ProbeKernelGradientIntegral coarse_probe{*mesh_data_set_[coarse_level]};
ProbeKernelGradientIntegral fine_probe{*mesh_data_set_[coarse_level + 1]};
Vecd coarse_level_value = coarse_probe.update(position);
Vecd fine_level_value = fine_probe.update(position);

return alpha * coarse_level_value + (1.0 - alpha) * fine_level_value;
}
Expand All @@ -194,8 +194,8 @@ bool MultilevelLevelSet::probeIsWithinMeshBound(const Vecd &position)
bool is_bounded = true;
for (size_t l = 0; l != total_levels_; ++l)
{
MeshCalculateDynamics<bool, ProbeIsWithinMeshBound> probe_is_within_mesh_bound{*mesh_data_set_[l]};
if (!probe_is_within_mesh_bound.exec(position))
ProbeIsWithinMeshBound probe_is_within_mesh_bound{*mesh_data_set_[l]};
if (!probe_is_within_mesh_bound.update(position))
{
is_bounded = false;
break;
Expand Down
16 changes: 8 additions & 8 deletions src/shared/geometries/level_set.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -65,8 +65,8 @@ class MultilevelLevelSet : public BaseMeshField
{
for (size_t l = 0; l != total_levels_; ++l)
{
MeshCalculateDynamics<void, WriteMeshFieldToPlt> write_mesh_field_to_plt(*mesh_data_set_[l]);
write_mesh_field_to_plt.exec(output_file);
WriteMeshFieldToPlt write_mesh_field_to_plt(*mesh_data_set_[l]);
write_mesh_field_to_plt.update(output_file);
}
}

Expand All @@ -79,13 +79,13 @@ class MultilevelLevelSet : public BaseMeshField
size_t total_levels_; /**< level 0 is the coarsest */
StdVec<Real> global_h_ratio_vec_;
StdVec<MeshWithGridDataPackagesType *> mesh_data_set_;
StdVec<MeshCalculateDynamics<Real, ProbeSignedDistance> *> probe_signed_distance_set_;
StdVec<MeshCalculateDynamics<Vecd, ProbeNormalDirection> *> probe_normal_direction_set_;
StdVec<MeshCalculateDynamics<Vecd, ProbeLevelSetGradient> *> probe_level_set_gradient_set_;
StdVec<ProbeSignedDistance *> probe_signed_distance_set_;
StdVec<ProbeNormalDirection *> probe_normal_direction_set_;
StdVec<ProbeLevelSetGradient *> probe_level_set_gradient_set_;
UniquePtrsKeeper<MeshWithGridDataPackagesType> mesh_data_ptr_vector_keeper_;
UniquePtrsKeeper<MeshCalculateDynamics<Real, ProbeSignedDistance>> probe_signed_distance_vector_keeper_;
UniquePtrsKeeper<MeshCalculateDynamics<Vecd, ProbeNormalDirection>> probe_normal_direction_vector_keeper_;
UniquePtrsKeeper<MeshCalculateDynamics<Vecd, ProbeLevelSetGradient>> probe_level_set_gradient_vector_keeper_;
UniquePtrsKeeper<ProbeSignedDistance> probe_signed_distance_vector_keeper_;
UniquePtrsKeeper<ProbeNormalDirection> probe_normal_direction_vector_keeper_;
UniquePtrsKeeper<ProbeLevelSetGradient> probe_level_set_gradient_vector_keeper_;

CleanInterface *clean_interface;
CorrectTopology *correct_topology;
Expand Down
69 changes: 0 additions & 69 deletions src/shared/meshes/all_mesh_dynamics.cpp
View file

This file was deleted.

12 changes: 6 additions & 6 deletions src/shared/meshes/all_mesh_dynamics.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -57,8 +57,8 @@ class FinishDataPackages : public BaseMeshDynamics
mesh_data_.resizeMeshVariableData();

Real far_field_distance = grid_spacing_ * (Real)buffer_width_;
initialize_data_for_singular_package.exec(0, -far_field_distance);
initialize_data_for_singular_package.exec(1, far_field_distance);
initialize_data_for_singular_package.update(0, -far_field_distance);
initialize_data_for_singular_package.update(1, far_field_distance);

initialize_basic_data_for_a_package.exec();
update_level_set_gradient.exec();
Expand All @@ -72,7 +72,7 @@ class FinishDataPackages : public BaseMeshDynamics
Real grid_spacing_;
size_t buffer_width_;

MeshSingleDynamics<InitializeDataForSingularPackage> initialize_data_for_singular_package{mesh_data_};
InitializeDataForSingularPackage initialize_data_for_singular_package{mesh_data_};
MeshAllDynamics<TagACellIsInnerPackage> tag_a_cell_is_inner_package{mesh_data_};
MeshInnerDynamics<InitializeIndexMesh> initialize_index_mesh{mesh_data_};
MeshInnerDynamics<InitializeCellNeighborhood> initialize_cell_neighborhood{mesh_data_};
Expand All @@ -90,21 +90,21 @@ class ProbeNormalDirection : public BaseMeshLocalDynamics

Vecd update(const Vecd &position)
{
Vecd probed_value = probe_level_set_gradient.exec(position);
Vecd probed_value = probe_level_set_gradient.update(position);

Real threshold = 1.0e-2 * data_spacing_;
while (probed_value.norm() < threshold)
{
Vecd jittered = position; // jittering
for (int l = 0; l != position.size(); ++l)
jittered[l] += rand_uniform(-0.5, 0.5) * 0.5 * data_spacing_;
probed_value = probe_level_set_gradient.exec(jittered);
probed_value = probe_level_set_gradient.update(jittered);
}
return probed_value.normalized();
}

private:
MeshCalculateDynamics<Vecd, ProbeLevelSetGradient> probe_level_set_gradient{mesh_data_};
ProbeLevelSetGradient probe_level_set_gradient{mesh_data_};
};

class CleanInterface : public BaseMeshDynamics
Expand Down
65 changes: 23 additions & 42 deletions src/shared/meshes/mesh_dynamics.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -52,12 +52,16 @@ class BaseMeshDynamics
public:
BaseMeshDynamics(MeshWithGridDataPackages<4> &mesh_data)
: mesh_data_(mesh_data),
all_cells_(mesh_data.AllCells()){};
all_cells_(mesh_data.AllCells()),
num_grid_pkgs_(mesh_data.num_grid_pkgs_),
meta_data_cell_(mesh_data.meta_data_cell_){};
virtual ~BaseMeshDynamics(){};

protected:
MeshWithGridDataPackages<4> &mesh_data_;
Arrayi all_cells_;
size_t &num_grid_pkgs_;
std::pair<Arrayi, int>* &meta_data_cell_;

template <typename FunctionOnData>
void grid_parallel_for(const FunctionOnData &function)
Expand All @@ -68,6 +72,21 @@ class BaseMeshDynamics
function(cell_index);
});
}

/** Iterator on a collection of mesh data packages. parallel computing. */
template <typename FunctionOnData>
void package_parallel_for(const FunctionOnData &function)
{
parallel_for(IndexRange(2, num_grid_pkgs_),
[&](const IndexRange &r)
{
for (size_t i = r.begin(); i != r.end(); ++i)
{
function(i);
}
},
ap);
}
};

/**
Expand Down Expand Up @@ -111,7 +130,7 @@ class MeshInnerDynamics : public LocalDynamicsType, public BaseMeshDynamics

void exec()
{
mesh_data_.package_parallel_for(
package_parallel_for(
[&](size_t package_index)
{
this->update(package_index);
Expand All @@ -136,10 +155,10 @@ class MeshCoreDynamics : public LocalDynamicsType, public BaseMeshDynamics

void exec()
{
mesh_data_.package_parallel_for(
package_parallel_for(
[&](size_t package_index)
{
std::pair<Arrayi, int> &metadata = mesh_data_.meta_data_cell_[package_index];
std::pair<Arrayi, int> &metadata = meta_data_cell_[package_index];
if (metadata.second == 1)
{
this->update(package_index);
Expand All @@ -148,43 +167,5 @@ class MeshCoreDynamics : public LocalDynamicsType, public BaseMeshDynamics
);
};
};

/**
* @class MeshSingleDynamics
* @brief Mesh dynamics for only core cells on the mesh
*/
template <class LocalDynamicsType>
class MeshSingleDynamics : public LocalDynamicsType, public BaseMeshDynamics
{
public:
template <class DynamicsIdentifier, typename... Args>
MeshSingleDynamics(DynamicsIdentifier &identifier, Args &&...args)
: LocalDynamicsType(identifier, std::forward<Args>(args)...),
BaseMeshDynamics(identifier){};
virtual ~MeshSingleDynamics(){};

template <typename... Args>
void exec(Args &&...args)
{
this->update(std::forward<Args>(args)...);
};
};

template <typename ReturnType, class LocalDynamicsType>
class MeshCalculateDynamics : public LocalDynamicsType, public BaseMeshDynamics
{
public:
template <class DynamicsIdentifier, typename... Args>
MeshCalculateDynamics(DynamicsIdentifier &identifier, Args &&...args)
: LocalDynamicsType(identifier, std::forward<Args>(args)...),
BaseMeshDynamics(identifier){};
virtual ~MeshCalculateDynamics(){};

template <typename... Args>
ReturnType exec(Args &&...args)
{
return this->update(std::forward<Args>(args)...);
};
};
} // namespace SPH
#endif // MESH_DYNAMICS_H
Loading

0 comments on commit a80ce96

Please sign in to comment.