diff --git a/src/particle/src/algorithm/4C_particle_algorithm_constraints.cpp b/src/particle/src/algorithm/4C_particle_algorithm_constraints.cpp index c382958b7a..7a12ccc4a5 100644 --- a/src/particle/src/algorithm/4C_particle_algorithm_constraints.cpp +++ b/src/particle/src/algorithm/4C_particle_algorithm_constraints.cpp @@ -45,11 +45,11 @@ void Particle::ConstraintsProjectionBase::apply( if (n_particle_stored <= 0) continue; // get pointer to particle velocity and acceleration - double* vel = container->get_ptr_to_state_writable(Particle::State::Velocity, 0); - double* acc = container->get_ptr_to_state_writable(Particle::State::Acceleration, 0); - double* modvel = container->try_get_ptr_to_state_writable(Particle::State::ModifiedVelocity, 0); + double* vel = container->get_ptr_to_state_writable(Particle::State::Velocity); + double* acc = container->get_ptr_to_state_writable(Particle::State::Acceleration); + double* modvel = container->try_get_ptr_to_state_writable(Particle::State::ModifiedVelocity); double* modacc = - container->try_get_ptr_to_state_writable(Particle::State::ModifiedAcceleration, 0); + container->try_get_ptr_to_state_writable(Particle::State::ModifiedAcceleration); // get particle state dimension const int pos_state_dim = container->get_state_dim(Particle::State::Position); @@ -105,10 +105,10 @@ void Particle::ConstraintsProjectionBase::check_particles( if (n_particle_stored <= 0) continue; // get pointer to particle position - const double* pos = container->get_ptr_to_state(Particle::State::Position, 0); + const double* pos = container->get_ptr_to_state(Particle::State::Position); // get pointer to particle radius - const double* rad = container->get_ptr_to_state(Particle::State::Radius, 0); + const double* rad = container->get_ptr_to_state(Particle::State::Radius); // get particle state dimension const int pos_state_dim = container->get_state_dim(Particle::State::Position); @@ -145,8 +145,8 @@ int Particle::ConstraintsProjection2D::calc_primary_axis_local( if (n_particle_stored < 3) continue; // get pointer to particle position and radius - const double* pos = container->get_ptr_to_state(Particle::State::Position, 0); - const double* rad = container->get_ptr_to_state(Particle::State::Radius, 0); + const double* pos = container->get_ptr_to_state(Particle::State::Position); + const double* rad = container->get_ptr_to_state(Particle::State::Radius); // get particle state dimension const int pos_state_dim = container->get_state_dim(Particle::State::Position); @@ -271,7 +271,7 @@ int Particle::ConstraintsProjection1D::calc_primary_axis_local( if (n_particle_stored < 2) continue; // get pointer to particle position - const double* pos = container->get_ptr_to_state(Particle::State::Position, 0); + const double* pos = container->get_ptr_to_state(Particle::State::Position); // get particle state dimension const int pos_state_dim = container->get_state_dim(Particle::State::Position); diff --git a/src/particle/src/algorithm/4C_particle_algorithm_dirichlet_bc.cpp b/src/particle/src/algorithm/4C_particle_algorithm_dirichlet_bc.cpp index 23753a3b50..b5156d2e7d 100644 --- a/src/particle/src/algorithm/4C_particle_algorithm_dirichlet_bc.cpp +++ b/src/particle/src/algorithm/4C_particle_algorithm_dirichlet_bc.cpp @@ -209,10 +209,10 @@ void Particle::DirichletBoundaryConditionHandler::evaluate_dirichlet_boundary_co "dimension of function defining dirichlet boundary condition not correct!"); // get pointer to particle states - const double* refpos = container->get_ptr_to_state(Particle::State::ReferencePosition, 0); - double* pos = container->get_ptr_to_state_writable(Particle::State::Position, 0); - double* vel = container->get_ptr_to_state_writable(Particle::State::Velocity, 0); - double* acc = container->get_ptr_to_state_writable(Particle::State::Acceleration, 0); + const double* refpos = container->get_ptr_to_state(Particle::State::ReferencePosition); + double* pos = container->get_ptr_to_state_writable(Particle::State::Position); + double* vel = container->get_ptr_to_state_writable(Particle::State::Velocity); + double* acc = container->get_ptr_to_state_writable(Particle::State::Acceleration); // iterate over owned particles of current type and apply dbc values to particle states for (int i = 0; i < particlestored; ++i) @@ -239,11 +239,11 @@ void Particle::DirichletBoundaryConditionHandler::evaluate_dirichlet_boundary_co // get pointer to particle states const double* dirichlet_function_id = - container->get_ptr_to_state(Particle::State::DirichletFunctionId, 0); - const double* refpos = container->get_ptr_to_state(Particle::State::ReferencePosition, 0); - double* pos = container->get_ptr_to_state_writable(Particle::State::Position, 0); - double* vel = container->get_ptr_to_state_writable(Particle::State::Velocity, 0); - double* acc = container->get_ptr_to_state_writable(Particle::State::Acceleration, 0); + container->get_ptr_to_state(Particle::State::DirichletFunctionId); + const double* refpos = container->get_ptr_to_state(Particle::State::ReferencePosition); + double* pos = container->get_ptr_to_state_writable(Particle::State::Position); + double* vel = container->get_ptr_to_state_writable(Particle::State::Velocity); + double* acc = container->get_ptr_to_state_writable(Particle::State::Acceleration); // iterate over owned particles of current type for (int i = 0; i < particlestored; ++i) @@ -285,8 +285,7 @@ void Particle::DirichletBoundaryConditionHandler::build_funct_cache(MPI_Comm com const int n = container->particles_stored(); if (n <= 0) continue; - const double* funct_id_ptr = - container->get_ptr_to_state(Particle::State::DirichletFunctionId, 0); + const double* funct_id_ptr = container->get_ptr_to_state(Particle::State::DirichletFunctionId); for (int i = 0; i < n; ++i) { const int funct_id = static_cast(funct_id_ptr[i]); diff --git a/src/particle/src/algorithm/4C_particle_algorithm_initial_field.cpp b/src/particle/src/algorithm/4C_particle_algorithm_initial_field.cpp index cf6c2cfabc..a4444a7f8a 100644 --- a/src/particle/src/algorithm/4C_particle_algorithm_initial_field.cpp +++ b/src/particle/src/algorithm/4C_particle_algorithm_initial_field.cpp @@ -92,8 +92,8 @@ void Particle::InitialFieldHandler::set_initial_fields() Global::Problem::instance()->function_by_id(functid); // get pointer to particle states - const double* pos = container->get_ptr_to_state(Particle::State::Position, 0); - double* state = container->get_ptr_to_state_writable(particleState, 0); + const double* pos = container->get_ptr_to_state(Particle::State::Position); + double* state = container->get_ptr_to_state_writable(particleState); // get particle state dimensions int posstatedim = container->get_state_dim(Particle::State::Position); diff --git a/src/particle/src/algorithm/4C_particle_algorithm_result_test.cpp b/src/particle/src/algorithm/4C_particle_algorithm_result_test.cpp index 2cda298e8f..27f9f44b8b 100644 --- a/src/particle/src/algorithm/4C_particle_algorithm_result_test.cpp +++ b/src/particle/src/algorithm/4C_particle_algorithm_result_test.cpp @@ -195,13 +195,10 @@ void Particle::ParticleResultTest::test_special( "state '{}' not found in container!", Particle::enum_to_state_name(particleState)); // get pointer to particle state - const double* state = container->get_ptr_to_state(particleState, 0); - - // get particle state dimension - int statedim = container->get_state_dim(particleState); + const double* state = container->get_ptr_to_state(particleState, index); // get actual result - actresult = state[statedim * index + dim]; + actresult = state[dim]; // compare values const int err = compare_values(actresult, "SPECIAL", result_container); diff --git a/src/particle/src/algorithm/4C_particle_algorithm_temperature_bc.cpp b/src/particle/src/algorithm/4C_particle_algorithm_temperature_bc.cpp index 6edb717693..6ab99251e5 100644 --- a/src/particle/src/algorithm/4C_particle_algorithm_temperature_bc.cpp +++ b/src/particle/src/algorithm/4C_particle_algorithm_temperature_bc.cpp @@ -105,8 +105,8 @@ void Particle::TemperatureBoundaryConditionHandler::evaluate_temperature_boundar Global::Problem::instance()->function_by_id(functid); // get pointer to particle states - const double* refpos = container->get_ptr_to_state(Particle::State::ReferencePosition, 0); - double* temp = container->get_ptr_to_state_writable(Particle::State::Temperature, 0); + const double* refpos = container->get_ptr_to_state(Particle::State::ReferencePosition); + double* temp = container->get_ptr_to_state_writable(Particle::State::Temperature); // get particle state dimension int statedim = container->get_state_dim(Particle::State::Position); diff --git a/src/particle/src/algorithm/4C_particle_algorithm_timint.cpp b/src/particle/src/algorithm/4C_particle_algorithm_timint.cpp index aacfcb4fa6..7514d0cd3c 100644 --- a/src/particle/src/algorithm/4C_particle_algorithm_timint.cpp +++ b/src/particle/src/algorithm/4C_particle_algorithm_timint.cpp @@ -206,7 +206,7 @@ void Particle::TimInt::add_initial_random_noise_to_position() if (particlestored <= 0) continue; // get pointer to particle state - double* pos = container->get_ptr_to_state_writable(Particle::State::Position, 0); + double* pos = container->get_ptr_to_state_writable(Particle::State::Position); // get particle state dimension int statedim = container->get_state_dim(Particle::State::Position); diff --git a/src/particle/src/engine/4C_particle_engine.cpp b/src/particle/src/engine/4C_particle_engine.cpp index d2398d860e..b5a77e609f 100644 --- a/src/particle/src/engine/4C_particle_engine.cpp +++ b/src/particle/src/engine/4C_particle_engine.cpp @@ -2012,8 +2012,8 @@ void Particle::ParticleEngine::store_positions_after_particle_transfer() if (particlestored == 0) continue; // get pointer to particle states - const double* pos = container->get_ptr_to_state(State::Position, 0); - double* lasttransferpos = container->get_ptr_to_state_writable(State::LastTransferPosition, 0); + const double* pos = container->get_ptr_to_state(State::Position); + double* lasttransferpos = container->get_ptr_to_state_writable(State::LastTransferPosition); // get particle state dimension int statedim = container->get_state_dim(State::Position); @@ -2046,7 +2046,7 @@ void Particle::ParticleEngine::relate_owned_particles_to_bins() if (particlestored <= 0) continue; // get pointer to position of particle after last transfer - const double* lasttransferpos = container->get_ptr_to_state(State::LastTransferPosition, 0); + const double* lasttransferpos = container->get_ptr_to_state(State::LastTransferPosition); // get particle state dimension int statedim = container->get_state_dim(State::Position); diff --git a/src/particle/src/engine/4C_particle_engine_container.cpp b/src/particle/src/engine/4C_particle_engine_container.cpp index 1d37b72a19..df2f2ca5e4 100644 --- a/src/particle/src/engine/4C_particle_engine_container.cpp +++ b/src/particle/src/engine/4C_particle_engine_container.cpp @@ -264,7 +264,7 @@ double Particle::ParticleContainer::get_min_value_of_state(Particle::State state if (particlestored_ <= 0) return 0.0; - const double* state_ptr = get_ptr_to_state(state, 0); + const double* state_ptr = get_ptr_to_state(state); double min = state_ptr[0]; for (int i = 1; i < (particlestored_ * statedim_[static_cast(state)]); ++i) @@ -280,7 +280,7 @@ double Particle::ParticleContainer::get_max_value_of_state(Particle::State state if (particlestored_ <= 0) return 0.0; - const double* state_ptr = get_ptr_to_state(state, 0); + const double* state_ptr = get_ptr_to_state(state); double max = state_ptr[0]; for (int i = 1; i < (particlestored_ * statedim_[static_cast(state)]); ++i) diff --git a/src/particle/src/engine/4C_particle_engine_container.hpp b/src/particle/src/engine/4C_particle_engine_container.hpp index f2d9421163..c80439b7df 100644 --- a/src/particle/src/engine/4C_particle_engine_container.hpp +++ b/src/particle/src/engine/4C_particle_engine_container.hpp @@ -183,6 +183,32 @@ namespace Particle */ const double* get_ptr_to_state(Particle::State state, int index) const; + /*! + * \brief get read-only pointer to state of all particles + * + * This is the default method to be used to get a pointer with read-only access to the state of + * all particles. Returns a nullptr if the container is empty. + * + * \note Throws an error in the debug version in case the requested state is not stored in the + * particle container. + * + * \note The returned pointer may not be used to access memory without checking for a nullptr. + * + * + * \param[in] state particle state + * + * \return pointer with read-only access to particle state or nullptr + */ + inline const double* get_ptr_to_state(Particle::State state) const + { + FOUR_C_ASSERT(storedstates_.contains(state), "particle state '{}' not stored in container!", + enum_to_state_name(state)); + + if (particlestored_ == 0) return nullptr; + + return get_ptr_to_state(state, 0); + }; + /*! * \brief conditionally get read-only pointer to state of a particle at index * @@ -209,6 +235,28 @@ namespace Particle return nullptr; }; + /*! + * \brief conditionally get read-only pointer to state of all particles + * + * This method to get a pointer with read-only access to the state of all particles + * is used in cases when a state may not be stored in the particle container. + * Conditionally, a pointer is returned in case the state is stored in the particle container, + * otherwise, a nullptr is returned. Returns a nullptr if the container is empty. + * + * \note The returned pointer may not be used to access memory without checking for a nullptr. + * + * + * \param[in] state particle state + * + * \return pointer with read-only access to particle state or nullptr + */ + inline const double* try_get_ptr_to_state(Particle::State state) const + { + if (particlestored_ == 0) return nullptr; + + return try_get_ptr_to_state(state, 0); + }; + /*! * \brief get writable pointer to state of a particle at index * @@ -226,6 +274,32 @@ namespace Particle */ double* get_ptr_to_state_writable(Particle::State state, int index); + /*! + * \brief get writable pointer to state of all particles + * + * This is the default method to be used to get a pointer with writable access to the state of + * all particles. Returns a nullptr if the container is empty. + * + * \note Throws an error in the debug version in case the requested state is not stored in the + * particle container. + * + * \note The returned pointer may not be used to access memory without checking for a nullptr. + * + * + * \param[in] state particle state + * + * \return pointer with writable access to particle state or nullptr + */ + double* get_ptr_to_state_writable(Particle::State state) + { + FOUR_C_ASSERT(storedstates_.contains(state), "particle state '{}' not stored in container!", + enum_to_state_name(state)); + + if (particlestored_ == 0) return nullptr; + + return get_ptr_to_state_writable(state, 0); + }; + /*! * \brief conditionally get writable pointer to state of a particle at index * @@ -252,6 +326,28 @@ namespace Particle return nullptr; }; + /*! + * \brief conditionally get writable pointer to state of all particles + * + * This method to get a pointer with writable access to the state of all particles + * is used in cases when a state may not be stored in the particle container. + * Conditionally, a pointer is returned in case the state is stored in the particle container, + * otherwise, a nullptr is returned. Returns a nullptr if the container is empty. + * + * \note The returned pointer may not be used to access memory without checking for a nullptr. + * + * + * \param[in] state particle state + * + * \return pointer with writable access to particle state or nullptr + */ + inline double* try_get_ptr_to_state_writable(Particle::State state) + { + if (particlestored_ == 0) return nullptr; + + return try_get_ptr_to_state_writable(state, 0); + }; + /*! * \brief get pointer to global id of a particle at index * @@ -285,9 +381,7 @@ namespace Particle FOUR_C_ASSERT(storedstates_.contains(state), "particle state '{}' not stored in container!", enum_to_state_name(state)); - if (particlestored_ <= 0) return; - - double* state_ptr = get_ptr_to_state_writable(state, 0); + double* state_ptr = get_ptr_to_state_writable(state); for (int i = 0; i < (particlestored_ * statedim_[static_cast(state)]); ++i) state_ptr[i] *= fac; @@ -319,10 +413,8 @@ namespace Particle FOUR_C_ASSERT(statedim_[static_cast(stateA)] == statedim_[static_cast(stateB)], "dimensions of states do not match!"); - if (particlestored_ <= 0) return; - - const double* state_b_ptr = get_ptr_to_state(stateB, 0); - double* state_a_ptr = get_ptr_to_state_writable(stateA, 0); + const double* state_b_ptr = get_ptr_to_state(stateB); + double* state_a_ptr = get_ptr_to_state_writable(stateA); for (int i = 0; i < (particlestored_ * statedim_[static_cast(stateA)]); ++i) state_a_ptr[i] = facA * state_a_ptr[i] + facB * state_b_ptr[i]; @@ -343,9 +435,7 @@ namespace Particle FOUR_C_ASSERT(statedim_[static_cast(state)] == static_cast(val.size()), "dimensions of states do not match!"); - if (particlestored_ <= 0) return; - - double* state_ptr = get_ptr_to_state_writable(state, 0); + double* state_ptr = get_ptr_to_state_writable(state); for (int i = 0; i < particlestored_; ++i) for (int dim = 0; dim < statedim_[static_cast(state)]; ++dim) @@ -363,9 +453,7 @@ namespace Particle FOUR_C_ASSERT(storedstates_.contains(state), "particle state '{}' not stored in container!", enum_to_state_name(state)); - if (particlestored_ <= 0) return; - - double* state_ptr = get_ptr_to_state_writable(state, 0); + double* state_ptr = get_ptr_to_state_writable(state); for (int i = 0; i < (particlestored_ * statedim_[static_cast(state)]); ++i) state_ptr[i] = 0.0; diff --git a/src/particle/src/engine/4C_particle_engine_container_bundle.cpp b/src/particle/src/engine/4C_particle_engine_container_bundle.cpp index c8a0e5c836..5a45c25cdb 100644 --- a/src/particle/src/engine/4C_particle_engine_container_bundle.cpp +++ b/src/particle/src/engine/4C_particle_engine_container_bundle.cpp @@ -20,7 +20,7 @@ Particle::ParticleContainerBundle::ParticleContainerBundle() } void Particle::ParticleContainerBundle::setup( - const std::map>& particlestatestotypes) + const std::map>& particlestatestotypes) { std::shared_ptr container; @@ -34,7 +34,7 @@ void Particle::ParticleContainerBundle::setup( for (const auto& typeIt : particlestatestotypes) { // get particle type - Particle::Type type = typeIt.first; + ParticleType type = typeIt.first; // insert particle type into set of stored containers storedtypes_.insert(type); @@ -43,7 +43,7 @@ void Particle::ParticleContainerBundle::setup( (containers_[static_cast(type)]).resize(2); // set of particle state enums of current particle type (equal for owned and ghosted particles) - const std::set& stateset = typeIt.second; + const std::set& stateset = typeIt.second; // initial size of particle container int initialsize = 1; @@ -63,6 +63,75 @@ void Particle::ParticleContainerBundle::setup( } } +Particle::ConstParticleContainerBundleStatePtrs& +Particle::ParticleContainerBundle::try_get_ptrs_to_state(ParticleState state, + std::optional> types_option, + std::optional status_optional) const +{ + const int state_idx = static_cast(state); + const std::set types = types_option.value_or(storedtypes_); + bool is_owned = true, is_ghosted = true; + if (status_optional.has_value()) + { + if (status_optional.value() == Status::Owned) is_ghosted = false; + if (status_optional.value() == Status::Ghosted) is_owned = false; + } + + // clear old pointers + std::memset(&conststates_[state_idx], 0, sizeof(ConstParticleContainerBundleStatePtrs)); + + // and fill with new pointers + for (auto type : types) + { + const int type_idx = static_cast(type); + + if (is_owned) + conststates_[state_idx][type_idx][static_cast(Status::Owned)] = + containers_[type_idx][static_cast(Status::Owned)].get()->try_get_ptr_to_state(state); + if (is_ghosted) + conststates_[state_idx][type_idx][static_cast(Status::Ghosted)] = + containers_[type_idx][static_cast(Status::Ghosted)].get()->try_get_ptr_to_state( + state); + } + return conststates_[state_idx]; +} + +Particle::ParticleContainerBundleStatePtrs& +Particle::ParticleContainerBundle::try_get_ptrs_to_state_writable(ParticleState state, + std::optional> types_option, + std::optional status_optional) +{ + const int state_idx = static_cast(state); + const std::set types = types_option.value_or(storedtypes_); + bool is_owned = true, is_ghosted = true; + if (status_optional.has_value()) + { + if (status_optional.value() == Status::Owned) is_ghosted = false; + if (status_optional.value() == Status::Ghosted) is_owned = false; + } + + // clear old pointers + std::memset(&states_[state_idx], 0, sizeof(ParticleContainerBundleStatePtrs)); + + // and fill with new pointers + for (auto type : types) + { + const int type_idx = static_cast(type); + + if (is_owned) + states_[state_idx][type_idx][static_cast(Status::Owned)] = + containers_[type_idx][static_cast(Status::Owned)] + .get() + ->try_get_ptr_to_state_writable(state); + if (is_ghosted) + states_[state_idx][type_idx][static_cast(Status::Ghosted)] = + containers_[type_idx][static_cast(Status::Ghosted)] + .get() + ->try_get_ptr_to_state_writable(state); + } + return states_[state_idx]; +} + void Particle::ParticleContainerBundle::get_packed_particle_objects_of_all_containers( std::vector& particlebuffer) const { diff --git a/src/particle/src/engine/4C_particle_engine_container_bundle.hpp b/src/particle/src/engine/4C_particle_engine_container_bundle.hpp index 86b7e13607..292f00b510 100644 --- a/src/particle/src/engine/4C_particle_engine_container_bundle.hpp +++ b/src/particle/src/engine/4C_particle_engine_container_bundle.hpp @@ -80,6 +80,90 @@ namespace Particle return (containers_[static_cast(type)])[static_cast(status)].get(); }; + /*! + * \brief conditionally get read-only pointer to state of a particle at index + * + * This array is indexed by particle type and status. If a particular combination of type, + * status, and state is not found in the bundle, then the pointer is a nullptr. + * + * \note The returned pointers may not be used to access memory without checking for a nullptr. + * + * + * \param[in] state particle state + * \param[in] types_option particle types, optional + * \param[in] status_option particle status, optional + * + * \return reference to array with pointers with read-only access to particle state + */ + ConstParticleContainerBundleStatePtrs& try_get_ptrs_to_state(Particle::State state, + std::optional> types_option = std::nullopt, + std::optional status_optional = std::nullopt) const; + + /*! + * \brief conditionally get read-only pointer to state of a particle at index + * + * This array is indexed by particle type and status. If a particular combination of type, + * status, and state is not found in the bundle, then the pointer is a nullptr. + * + * \note The returned pointers may not be used to access memory without checking for a nullptr. + * + * + * \param[in] state particle state + * \param[in] status particle status + * + * \return reference to array with pointers with read-only access to particle state + */ + inline ConstParticleContainerBundleStatePtrs& try_get_ptrs_to_state( + Particle::State state, ParticleStatus status) const + { + return try_get_ptrs_to_state(state, std::nullopt, status); + }; + + /*! + * \brief conditionally get writable pointer to state of a particle at index + * + * This array is indexed by particle type and status. If a particular combination of type, + * status, and state is not found in the bundle, then the pointer is a nullptr. + * + * \note The returned pointers may not be used to access memory without checking for a nullptr. + * + * \note The returned pointer may not be used to access memory without checking for a nullptr. + * + * + * \param[in] state particle state + * \param[in] types_option particle types, optional + * \param[in] status_option particle status, optional + * + * \return reference to array with pointers with writable access to particle states + */ + ParticleContainerBundleStatePtrs& try_get_ptrs_to_state_writable(Particle::State state, + std::optional> types_option = std::nullopt, + std::optional status_optional = std::nullopt); + + /*! + * \brief conditionally get writable pointer to state of a particle at index + * + * This array is indexed by particle type and status. If a particular combination of type, + * status, and state is not found in the bundle, then the pointer is a nullptr. + * + * \note The returned pointers may not be used to access memory without checking for a nullptr. + * + * \note The returned pointer may not be used to access memory without checking for a nullptr. + * + * + * \param[in] state particle state + * \param[in] status particle status + * + * \return reference to array with pointers with writable access to particle states + */ + inline ParticleContainerBundleStatePtrs& try_get_ptrs_to_state_writable( + Particle::State state, ParticleStatus status) + { + return try_get_ptrs_to_state_writable(state, std::nullopt, status); + }; + + //! @} + //! \name manipulate particle states of owned particles of specific type //! @{ @@ -280,6 +364,61 @@ namespace Particle //! collection of particle containers indexed by particle type enum and particle status enum TypeStatusContainers containers_; + + //! arrays to hold pointers to particle states, indexed by type and status + mutable std::array(ParticleState::OpenBoundaryId) + 1> + conststates_; + mutable std::array(ParticleState::OpenBoundaryId) + 1> + states_; + }; + + /** + * \brief index into particle container bundle pointers + */ + inline const double* bundle_state_ptrs_index(ConstParticleContainerBundleStatePtrs& ptrs, + ParticleType type, ParticleStatus status, const int index, const int statedim = 1) + { + FOUR_C_ASSERT(ptrs[static_cast(type)][static_cast(status)] != nullptr, + "Dereferencing null state pointer"); + + return &ptrs[static_cast(type)][static_cast(status)][statedim * index]; + }; + + /** + * \brief index into particle container bundle pointers + */ + inline const double* bundle_state_ptrs_index(ConstParticleContainerBundleStatePtrs& ptrs, + const double* fallback, ParticleType type, ParticleStatus status, const int index, + const int statedim = 1) + { + return ptrs[static_cast(type)][static_cast(status)] + ? &ptrs[static_cast(type)][static_cast(status)][statedim * index] + : fallback; + }; + + /** + * \brief index into particle container bundle pointers + */ + inline double* bundle_state_ptrs_index(ParticleContainerBundleStatePtrs& ptrs, ParticleType type, + ParticleStatus status, const int index, const int statedim = 1) + { + FOUR_C_ASSERT(ptrs[static_cast(type)][static_cast(status)] != nullptr, + "Dereferencing null state pointer"); + + return &ptrs[static_cast(type)][static_cast(status)][statedim * index]; + }; + + /** + * \brief index into particle container bundle pointers + */ + inline double* bundle_state_ptrs_index(ParticleContainerBundleStatePtrs& ptrs, double* fallback, + ParticleType type, ParticleStatus status, const int index, const int statedim = 1) + { + return ptrs[static_cast(type)][static_cast(status)] + ? &ptrs[static_cast(type)][static_cast(status)][statedim * index] + : fallback; }; } // namespace Particle diff --git a/src/particle/src/engine/4C_particle_engine_runtime_vtp_writer.cpp b/src/particle/src/engine/4C_particle_engine_runtime_vtp_writer.cpp index 1df023df1f..dee1dcb3ef 100644 --- a/src/particle/src/engine/4C_particle_engine_runtime_vtp_writer.cpp +++ b/src/particle/src/engine/4C_particle_engine_runtime_vtp_writer.cpp @@ -121,8 +121,7 @@ void Particle::ParticleRuntimeVtpWriter::set_particle_positions_and_states() std::string statename = enum_to_state_name(state); // get pointer to particle state - const double* state_ptr = - (particlestored > 0) ? container->get_ptr_to_state(state, 0) : nullptr; + const double* state_ptr = container->get_ptr_to_state(state); if (state == State::Position) { diff --git a/src/particle/src/engine/4C_particle_engine_typedefs.hpp b/src/particle/src/engine/4C_particle_engine_typedefs.hpp index 881fa97c8b..fbac2f9a12 100644 --- a/src/particle/src/engine/4C_particle_engine_typedefs.hpp +++ b/src/particle/src/engine/4C_particle_engine_typedefs.hpp @@ -64,6 +64,17 @@ namespace Particle //! shared pointer to particle container bundle using ParticleContainerBundleShrdPtr = std::shared_ptr; + //! array of state pointers from a particle container bundle + using ConstParticleContainerBundleStatePtrs = + const double * + [static_cast( + ParticleType::Uninitialized)][static_cast(ParticleStatus::Uninitialized)]; + + //! array of state pointers from a particle container bundle + using ParticleContainerBundleStatePtrs = + double * [static_cast( + ParticleType::Uninitialized)][static_cast(ParticleStatus::Uninitialized)]; + /*! * \brief local index tuple of a particle * diff --git a/src/particle/src/interaction/4C_particle_interaction_base.cpp b/src/particle/src/interaction/4C_particle_interaction_base.cpp index e5893e6ef2..0baa358d9d 100644 --- a/src/particle/src/interaction/4C_particle_interaction_base.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_base.cpp @@ -130,10 +130,10 @@ double Particle::ParticleInteractionBase::max_particle_radius() const { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get maximum stored value of state - double currmaxrad = container->get_max_value_of_state(Particle::State::Radius); + double currmaxrad = container->get_max_value_of_state(ParticleState::Radius); // compare to current maximum maxrad = std::max(maxrad, currmaxrad); diff --git a/src/particle/src/interaction/4C_particle_interaction_base.hpp b/src/particle/src/interaction/4C_particle_interaction_base.hpp index 4077c8a7ba..ee305d05ac 100644 --- a/src/particle/src/interaction/4C_particle_interaction_base.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_base.hpp @@ -69,7 +69,7 @@ namespace Particle //! insert interaction dependent states of all particle types virtual void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) = 0; + std::map>& particlestatestotypes) = 0; //! set initial states virtual void set_initial_states() = 0; diff --git a/src/particle/src/interaction/4C_particle_interaction_dem.cpp b/src/particle/src/interaction/4C_particle_interaction_dem.cpp index b5939419e1..280ca59bcc 100644 --- a/src/particle/src/interaction/4C_particle_interaction_dem.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_dem.cpp @@ -95,7 +95,7 @@ void Particle::ParticleInteractionDEM::read_restart( } void Particle::ParticleInteractionDEM::insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) + std::map>& particlestatestotypes) { // iterate over particle types for (auto& typeIt : particlestatestotypes) @@ -104,7 +104,7 @@ void Particle::ParticleInteractionDEM::insert_particle_states_of_particle_types( std::set& particlestates = typeIt.second; // insert states of regular phase particles - particlestates.insert({Particle::State::Force, Particle::State::Mass, Particle::State::Radius}); + particlestates.insert({ParticleState::Force, ParticleState::Mass, ParticleState::Radius}); } // states for contact evaluation scheme @@ -238,7 +238,7 @@ void Particle::ParticleInteractionDEM::set_initial_radius() { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container->particles_stored(); @@ -277,7 +277,7 @@ void Particle::ParticleInteractionDEM::set_initial_radius() { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container->particles_stored(); @@ -286,10 +286,10 @@ void Particle::ParticleInteractionDEM::set_initial_radius() if (particlestored <= 0) continue; // safety checks - FOUR_C_ASSERT_ALWAYS(container->get_min_value_of_state(Particle::State::Radius) > 0, + FOUR_C_ASSERT_ALWAYS(container->get_min_value_of_state(ParticleState::Radius) > 0, "the minimum particle radius is smaller than zero. Fix the particle input."); - FOUR_C_ASSERT_ALWAYS(container->get_max_value_of_state(Particle::State::Radius) <= r_max, + FOUR_C_ASSERT_ALWAYS(container->get_max_value_of_state(ParticleState::Radius) <= r_max, "the maximum particle radius is larger than the maximum allowed particle radius!"); } @@ -321,7 +321,7 @@ void Particle::ParticleInteractionDEM::set_initial_radius() { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container->particles_stored(); @@ -334,7 +334,7 @@ void Particle::ParticleInteractionDEM::set_initial_radius() particlematerial_->get_ptr_to_particle_mat_parameter(type_i); // get pointer to particle state - double* radius = container->get_ptr_to_state_writable(Particle::State::Radius, 0); + double* radius = container->get_ptr_to_state_writable(ParticleState::Radius); // determine mu of random particle radius distribution const double mu = (radiusdistributiontype == Particle::NormalRadiusDistribution) @@ -379,7 +379,7 @@ void Particle::ParticleInteractionDEM::set_initial_mass() { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container->particles_stored(); @@ -392,8 +392,8 @@ void Particle::ParticleInteractionDEM::set_initial_mass() particlematerial_->get_ptr_to_particle_mat_parameter(type_i); // get pointer to particle states - const double* radius = container->get_ptr_to_state(Particle::State::Radius, 0); - double* mass = container->get_ptr_to_state_writable(Particle::State::Mass, 0); + const double* radius = container->get_ptr_to_state(ParticleState::Radius); + double* mass = container->get_ptr_to_state_writable(ParticleState::Mass); // compute mass via particle volume and initial density const double fac = material->initDensity_ * 4.0 / 3.0 * std::numbers::pi; @@ -417,12 +417,12 @@ void Particle::ParticleInteractionDEM::set_initial_inertia() if (particlestored <= 0) continue; // no inertia state for current particle type - if (not container->have_stored_state(Particle::State::Inertia)) continue; + if (not container->have_stored_state(ParticleState::Inertia)) continue; // get pointer to particle states - const double* radius = container->get_ptr_to_state(Particle::State::Radius, 0); - const double* mass = container->get_ptr_to_state(Particle::State::Mass, 0); - double* inertia = container->get_ptr_to_state_writable(Particle::State::Inertia, 0); + const double* radius = container->get_ptr_to_state(ParticleState::Radius); + const double* mass = container->get_ptr_to_state(ParticleState::Mass); + double* inertia = container->get_ptr_to_state_writable(ParticleState::Inertia); // compute mass via particle volume and initial density for (int i = 0; i < particlestored; ++i) @@ -437,14 +437,14 @@ void Particle::ParticleInteractionDEM::clear_force_and_moment_states() const { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // clear force of all particles - container->clear_state(Particle::State::Force); + container->clear_state(ParticleState::Force); // clear moment of all particles - if (container->have_stored_state(Particle::State::Moment)) - container->clear_state(Particle::State::Moment); + if (container->have_stored_state(ParticleState::Moment)) + container->clear_state(ParticleState::Moment); } } @@ -469,13 +469,12 @@ void Particle::ParticleInteractionDEM::compute_acceleration() const const int statedim = container->get_state_dim(Particle::State::Acceleration); // get pointer to particle states - const double* radius = container->get_ptr_to_state(Particle::State::Radius, 0); - const double* mass = container->get_ptr_to_state(Particle::State::Mass, 0); - const double* force = container->get_ptr_to_state(Particle::State::Force, 0); - const double* moment = container->try_get_ptr_to_state(Particle::State::Moment, 0); - double* acc = container->get_ptr_to_state_writable(Particle::State::Acceleration, 0); - double* angacc = - container->try_get_ptr_to_state_writable(Particle::State::AngularAcceleration, 0); + const double* radius = container->get_ptr_to_state(ParticleState::Radius); + const double* mass = container->get_ptr_to_state(ParticleState::Mass); + const double* force = container->get_ptr_to_state(ParticleState::Force); + const double* moment = container->try_get_ptr_to_state(ParticleState::Moment); + double* acc = container->get_ptr_to_state_writable(ParticleState::Acceleration); + double* angacc = container->try_get_ptr_to_state_writable(ParticleState::AngularAcceleration); // compute acceleration for (int i = 0; i < particlestored; ++i) @@ -538,7 +537,7 @@ void Particle::ParticleInteractionDEM::evaluate_particle_kinetic_energy(double& { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container->particles_stored(); @@ -547,13 +546,13 @@ void Particle::ParticleInteractionDEM::evaluate_particle_kinetic_energy(double& if (particlestored <= 0) continue; // get particle state dimension - const int statedim = container->get_state_dim(Particle::State::Position); + const int statedim = container->get_state_dim(ParticleState::Position); // get pointer to particle states - const double* radius = container->get_ptr_to_state(Particle::State::Radius, 0); - const double* mass = container->get_ptr_to_state(Particle::State::Mass, 0); - const double* vel = container->get_ptr_to_state(Particle::State::Velocity, 0); - const double* angvel = container->try_get_ptr_to_state(Particle::State::AngularVelocity, 0); + const double* radius = container->get_ptr_to_state(ParticleState::Radius); + const double* mass = container->get_ptr_to_state(ParticleState::Mass); + const double* vel = container->get_ptr_to_state(ParticleState::Velocity); + const double* angvel = container->try_get_ptr_to_state(ParticleState::AngularVelocity); // add translational kinetic energy contribution for (int i = 0; i < particlestored; ++i) @@ -582,7 +581,7 @@ void Particle::ParticleInteractionDEM::evaluate_particle_gravitational_potential { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container->particles_stored(); @@ -591,11 +590,11 @@ void Particle::ParticleInteractionDEM::evaluate_particle_gravitational_potential if (particlestored <= 0) continue; // get particle state dimension - const int statedim = container->get_state_dim(Particle::State::Position); + const int statedim = container->get_state_dim(ParticleState::Position); // get pointer to particle states - const double* pos = container->get_ptr_to_state(Particle::State::Position, 0); - const double* mass = container->get_ptr_to_state(Particle::State::Mass, 0); + const double* pos = container->get_ptr_to_state(ParticleState::Position); + const double* mass = container->get_ptr_to_state(ParticleState::Mass); // add gravitational potential energy contribution for (int i = 0; i < particlestored; ++i) diff --git a/src/particle/src/interaction/4C_particle_interaction_dem.hpp b/src/particle/src/interaction/4C_particle_interaction_dem.hpp index ef5da6dfad..4fd90fcff6 100644 --- a/src/particle/src/interaction/4C_particle_interaction_dem.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_dem.hpp @@ -66,7 +66,7 @@ namespace Particle //! insert interaction dependent states of all particle types void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) override; + std::map>& particlestatestotypes) override; //! set initial states void set_initial_states() override; diff --git a/src/particle/src/interaction/4C_particle_interaction_dem_adhesion.cpp b/src/particle/src/interaction/4C_particle_interaction_dem_adhesion.cpp index 14c7aae224..ca85386568 100644 --- a/src/particle/src/interaction/4C_particle_interaction_dem_adhesion.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_dem_adhesion.cpp @@ -143,17 +143,26 @@ void Particle::DEMAdhesion::evaluate_particle_adhesion() DEMHistoryPairAdhesionData& adhesionhistorydata = historypairs_->get_ref_to_particle_adhesion_history_data(); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ParticleContainerBundleStatePtrs& force = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Force); + // iterate over particle pairs for (const auto& particlepair : neighborpairs_->get_ref_to_particle_pair_adhesion_data()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; @@ -168,16 +177,19 @@ void Particle::DEMAdhesion::evaluate_particle_adhesion() const int* globalid_i = container_i->get_ptr_to_global_id(particle_i); const int* globalid_j = container_j->get_ptr_to_global_id(particle_j); - // get pointer to particle states - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - double* force_i = container_i->get_ptr_to_state_writable(Particle::State::Force, particle_i); + // get pointers to particle states + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + double* force_i = + Particle::bundle_state_ptrs_index(force, type_i, status_i, particle_i, statedim); - const double* vel_j = container_j->get_ptr_to_state(Particle::State::Velocity, particle_j); - const double* rad_j = container_j->get_ptr_to_state(Particle::State::Radius, particle_j); + const double* vel_j = + Particle::bundle_state_ptrs_index(vel, type_j, status_j, particle_j, statedim); + const double* rad_j = Particle::bundle_state_ptrs_index(rad, type_j, status_j, particle_j); double* force_j = nullptr; - if (status_j == Particle::Status::Owned) - force_j = container_j->get_ptr_to_state_writable(Particle::State::Force, particle_j); + if (status_j == ParticleStatus::Owned) + force_j = Particle::bundle_state_ptrs_index(force, type_j, status_j, particle_j, statedim); // relative velocity in contact point c between particle i and j (neglecting angular velocity) double vel_rel[3]; @@ -210,7 +222,7 @@ void Particle::DEMAdhesion::evaluate_particle_adhesion() vel_rel_normal, particlepair.m_eff_, adhesionhistory_ij.adhesion_force_); // copy history from interaction pair ij to ji - if (status_j == Particle::Status::Owned) + if (status_j == ParticleStatus::Owned) { // get reference to touched adhesion history TouchedDEMHistoryPairAdhesion& touchedadhesionhistory_ji = @@ -272,12 +284,25 @@ void Particle::DEMAdhesion::evaluate_particle_wall_adhesion() surfaceenergy.reserve(numparticlewallpairs); } + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(Particle::State::Position); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ParticleContainerBundleStatePtrs& force = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Force); + // iterate over particle-wall pairs for (const auto& particlewallpair : particlewallpairdata) { // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlewallpair.tuple_i_; @@ -289,11 +314,14 @@ void Particle::DEMAdhesion::evaluate_particle_wall_adhesion() const int* globalid_i = container_i->get_ptr_to_global_id(particle_i); // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - double* force_i = container_i->get_ptr_to_state_writable(Particle::State::Force, particle_i); + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + double* force_i = + Particle::bundle_state_ptrs_index(force, type_i, status_i, particle_i, statedim); // get pointer to column wall element Core::Elements::Element* ele = particlewallpair.ele_; diff --git a/src/particle/src/interaction/4C_particle_interaction_dem_contact.cpp b/src/particle/src/interaction/4C_particle_interaction_dem_contact.cpp index cfc34ae860..8cd3fd2410 100644 --- a/src/particle/src/interaction/4C_particle_interaction_dem_contact.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_dem_contact.cpp @@ -122,18 +122,18 @@ void Particle::DEMContact::set_current_step_size(const double currentstepsize) } void Particle::DEMContact::insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const + std::map>& particlestatestotypes) const { // iterate over particle types for (auto& typeIt : particlestatestotypes) { // set of particle states for current particle type - std::set& particlestates = typeIt.second; + std::set& particlestates = typeIt.second; // states for tangential and rolling contact evaluation scheme if (contacttangential_ or contactrolling_) - particlestates.insert({Particle::State::Moment, Particle::State::AngularVelocity, - Particle::State::AngularAcceleration}); + particlestates.insert({ParticleState::Moment, ParticleState::AngularVelocity, + ParticleState::AngularAcceleration}); } } @@ -153,7 +153,7 @@ void Particle::DEMContact::check_critical_time_step() const { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container->particles_stored(); @@ -162,7 +162,7 @@ void Particle::DEMContact::check_critical_time_step() const if (particlestored <= 0) continue; // get minimum stored value of state - double currminmass = container->get_min_value_of_state(Particle::State::Mass); + double currminmass = container->get_min_value_of_state(ParticleState::Mass); // update value of minimum mass minmass = std::min(minmass, currminmass); @@ -361,17 +361,30 @@ void Particle::DEMContact::evaluate_particle_contact() // rolling contact friction coefficient const double mu_rolling = contactrolling_ ? params_dem_.get("FRICT_COEFF_ROLL") : 0.0; + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ParticleContainerBundleStatePtrs& force = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Force); + ConstParticleContainerBundleStatePtrs& angvel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::AngularVelocity); + ParticleContainerBundleStatePtrs& moment = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Moment); + // iterate over particle pairs for (const auto& particlepair : neighborpairs_->get_ref_to_particle_pair_data()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; @@ -386,32 +399,36 @@ void Particle::DEMContact::evaluate_particle_contact() const int* globalid_i = container_i->get_ptr_to_global_id(particle_i); const int* globalid_j = container_j->get_ptr_to_global_id(particle_j); - // get pointer to particle states - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - double* force_i = container_i->get_ptr_to_state_writable(Particle::State::Force, particle_i); + // get pointers to particle states + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + double* force_i = + Particle::bundle_state_ptrs_index(force, type_i, status_i, particle_i, statedim); const double* angvel_i = nullptr; double* moment_i = nullptr; if (contacttangential_ or contactrolling_) { - angvel_i = container_i->get_ptr_to_state(Particle::State::AngularVelocity, particle_i); - moment_i = container_i->get_ptr_to_state_writable(Particle::State::Moment, particle_i); + angvel_i = Particle::bundle_state_ptrs_index(angvel, type_i, status_i, particle_i, statedim); + moment_i = Particle::bundle_state_ptrs_index(moment, type_i, status_i, particle_i, statedim); } - const double* vel_j = container_j->get_ptr_to_state(Particle::State::Velocity, particle_j); - const double* rad_j = container_j->get_ptr_to_state(Particle::State::Radius, particle_j); + const double* vel_j = + Particle::bundle_state_ptrs_index(vel, type_j, status_j, particle_j, statedim); + const double* rad_j = Particle::bundle_state_ptrs_index(rad, type_j, status_j, particle_j); double* force_j = nullptr; - if (status_j == Particle::Status::Owned) - force_j = container_j->get_ptr_to_state_writable(Particle::State::Force, particle_j); + if (status_j == ParticleStatus::Owned) + force_j = Particle::bundle_state_ptrs_index(force, type_j, status_j, particle_j, statedim); const double* angvel_j = nullptr; double* moment_j = nullptr; if (contacttangential_ or contactrolling_) { - angvel_j = container_j->get_ptr_to_state(Particle::State::AngularVelocity, particle_j); - if (status_j == Particle::Status::Owned) - moment_j = container_j->get_ptr_to_state_writable(Particle::State::Moment, particle_j); + angvel_j = Particle::bundle_state_ptrs_index(angvel, type_j, status_j, particle_j, statedim); + if (status_j == ParticleStatus::Owned) + moment_j = + Particle::bundle_state_ptrs_index(moment, type_j, status_j, particle_j, statedim); } // compute vectors from particle i and j to contact point c @@ -477,7 +494,7 @@ void Particle::DEMContact::evaluate_particle_contact() mu_tangential, normalcontactforce, tangentialcontactforce); // copy history from interaction pair ij to ji - if (status_j == Particle::Status::Owned) + if (status_j == ParticleStatus::Owned) { // get reference to touched tangential history TouchedDEMHistoryPairTangential& touchedtangentialhistory_ji = @@ -533,7 +550,7 @@ void Particle::DEMContact::evaluate_particle_contact() normalcontactforce, rollingcontactmoment); // copy history from interaction pair ij to ji - if (status_j == Particle::Status::Owned) + if (status_j == ParticleStatus::Owned) { // get reference to touched rolling history TouchedDEMHistoryPairRolling& touchedrollinghistory_ji = @@ -596,12 +613,30 @@ void Particle::DEMContact::evaluate_particle_wall_contact() normaldirection.reserve(3 * numparticlewallpairs); } + // get pointers to particle states + static int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ParticleContainerBundleStatePtrs& force = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Force); + + ConstParticleContainerBundleStatePtrs& angvel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::AngularVelocity); + ParticleContainerBundleStatePtrs& moment = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Moment); + // iterate over particle-wall pairs for (const auto& particlewallpair : particlewallpairdata) { // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlewallpair.tuple_i_; @@ -613,18 +648,21 @@ void Particle::DEMContact::evaluate_particle_wall_contact() const int* globalid_i = container_i->get_ptr_to_global_id(particle_i); // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - double* force_i = container_i->get_ptr_to_state_writable(Particle::State::Force, particle_i); + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + double* force_i = + Particle::bundle_state_ptrs_index(force, type_i, status_i, particle_i, statedim); const double* angvel_i = nullptr; double* moment_i = nullptr; if (contacttangential_ or contactrolling_) { - angvel_i = container_i->get_ptr_to_state(Particle::State::AngularVelocity, particle_i); - moment_i = container_i->get_ptr_to_state_writable(Particle::State::Moment, particle_i); + angvel_i = Particle::bundle_state_ptrs_index(angvel, type_i, status_i, particle_i, statedim); + moment_i = Particle::bundle_state_ptrs_index(moment, type_i, status_i, particle_i, statedim); } // get pointer to column wall element @@ -853,13 +891,13 @@ void Particle::DEMContact::evaluate_particle_elastic_potential_energy( for (const auto& particlepair : neighborpairs_->get_ref_to_particle_pair_data()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; @@ -880,7 +918,7 @@ void Particle::DEMContact::evaluate_particle_elastic_potential_energy( // add normal potential energy contribution elasticpotentialenergy += 0.5 * normalpotentialenergy; - if (status_j == Particle::Status::Owned) elasticpotentialenergy += 0.5 * normalpotentialenergy; + if (status_j == ParticleStatus::Owned) elasticpotentialenergy += 0.5 * normalpotentialenergy; // calculation of tangential potential energy if (contacttangential_) @@ -899,7 +937,7 @@ void Particle::DEMContact::evaluate_particle_elastic_potential_energy( // add tangential potential energy contribution elasticpotentialenergy += 0.5 * tangentialpotentialenergy; - if (status_j == Particle::Status::Owned) + if (status_j == ParticleStatus::Owned) elasticpotentialenergy += 0.5 * tangentialpotentialenergy; } @@ -919,8 +957,7 @@ void Particle::DEMContact::evaluate_particle_elastic_potential_energy( // add rolling potential energy contribution elasticpotentialenergy += 0.5 * rollingpotentialenergy; - if (status_j == Particle::Status::Owned) - elasticpotentialenergy += 0.5 * rollingpotentialenergy; + if (status_j == ParticleStatus::Owned) elasticpotentialenergy += 0.5 * rollingpotentialenergy; } } } @@ -943,8 +980,8 @@ void Particle::DEMContact::evaluate_particle_wall_elastic_potential_energy( for (const auto& particlewallpair : neighborpairs_->get_ref_to_particle_wall_pair_data()) { // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlewallpair.tuple_i_; diff --git a/src/particle/src/interaction/4C_particle_interaction_dem_contact.hpp b/src/particle/src/interaction/4C_particle_interaction_dem_contact.hpp index de4067b75b..e547e0dd2a 100644 --- a/src/particle/src/interaction/4C_particle_interaction_dem_contact.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_dem_contact.hpp @@ -70,7 +70,7 @@ namespace Particle //! insert contact evaluation dependent states void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const; + std::map>& particlestatestotypes) const; //! get normal contact stiffness double get_normal_contact_stiffness() const; diff --git a/src/particle/src/interaction/4C_particle_interaction_dem_neighbor_pairs.cpp b/src/particle/src/interaction/4C_particle_interaction_dem_neighbor_pairs.cpp index 887f20f1cb..00d352ee2c 100644 --- a/src/particle/src/interaction/4C_particle_interaction_dem_neighbor_pairs.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_dem_neighbor_pairs.cpp @@ -67,36 +67,40 @@ void Particle::DEMNeighborPairs::evaluate_particle_pairs() // clear particle pair data particlepairdata_.clear(); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + // iterate over potential particle neighbors for (const auto& potentialneighbors : particleengineinterface_->get_potential_particle_neighbors()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = potentialneighbors.first; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = potentialneighbors.second; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - - // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); + // get pointers to particle states + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); - const double* pos_j = container_j->get_ptr_to_state(Particle::State::Position, particle_j); - const double* rad_j = container_j->get_ptr_to_state(Particle::State::Radius, particle_j); - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); + const double* pos_j = + Particle::bundle_state_ptrs_index(pos, type_j, status_j, particle_j, statedim); + const double* rad_j = Particle::bundle_state_ptrs_index(rad, type_j, status_j, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); // vector from particle i to j double r_ji[3]; @@ -154,12 +158,19 @@ void Particle::DEMNeighborPairs::evaluate_particle_wall_pairs() // index of particle-wall pairs int particlewallpairindex = 0; + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Position); + // iterate over potential wall neighbors for (const auto& potentialneighbors : particlewallinterface_->get_potential_wall_neighbors()) { // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = potentialneighbors.first; @@ -171,11 +182,11 @@ void Particle::DEMNeighborPairs::evaluate_particle_wall_pairs() const int* globalid_i = container_i->get_ptr_to_global_id(particle_i); // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); // get position of particle i const Core::LinAlg::Matrix<3, 1> pos_i( - container_i->get_ptr_to_state(Particle::State::Position, particle_i)); + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim)); // get pointer to column wall element Core::Elements::Element* ele = potentialneighbors.second; @@ -262,17 +273,13 @@ void Particle::DEMNeighborPairs::evaluate_particle_wall_pairs() particlewallpairdata_[indexofparticlewallpairs[0].second].tuple_i_; // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = tuple_i; - // get corresponding particle container - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + // get pointer to particle state + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); // define tolerance dependent on the particle radius const double adaptedtol = 1.0e-7 * rad_i[0]; @@ -356,36 +363,40 @@ void Particle::DEMNeighborPairs::evaluate_particle_pairs_adhesion(const double& // clear adhesion particle pair data particlepairadhesiondata_.clear(); + // get pointers to particle states + static int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + // iterate over potential particle neighbors for (const auto& potentialneighbors : particleengineinterface_->get_potential_particle_neighbors()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = potentialneighbors.first; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = potentialneighbors.second; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - - // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); + // get pointers to particle states + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); - const double* pos_j = container_j->get_ptr_to_state(Particle::State::Position, particle_j); - const double* rad_j = container_j->get_ptr_to_state(Particle::State::Radius, particle_j); - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); + const double* pos_j = + Particle::bundle_state_ptrs_index(pos, type_j, status_j, particle_j, statedim); + const double* rad_j = Particle::bundle_state_ptrs_index(rad, type_j, status_j, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); // vector from particle i to j double r_ji[3]; @@ -444,12 +455,19 @@ void Particle::DEMNeighborPairs::evaluate_particle_wall_pairs_adhesion( // index of particle-wall pairs int particlewallpairindex = 0; + // get pointers to particle states + static int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Position); + // iterate over potential wall neighbors for (const auto& potentialneighbors : particlewallinterface_->get_potential_wall_neighbors()) { // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = potentialneighbors.first; @@ -461,11 +479,11 @@ void Particle::DEMNeighborPairs::evaluate_particle_wall_pairs_adhesion( const int* globalid_i = container_i->get_ptr_to_global_id(particle_i); // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); // get position of particle i const Core::LinAlg::Matrix<3, 1> pos_i( - container_i->get_ptr_to_state(Particle::State::Position, particle_i)); + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim)); // get pointer to column wall element Core::Elements::Element* ele = potentialneighbors.second; @@ -570,17 +588,13 @@ void Particle::DEMNeighborPairs::evaluate_particle_wall_pairs_adhesion( particlewallpairadhesiondata_[indexofparticlewallpairs[0].second].tuple_i_; // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = tuple_i; - // get corresponding particle container - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); // define tolerance dependent on the particle radius const double adaptedtol = 1.0e-7 * rad_i[0]; diff --git a/src/particle/src/interaction/4C_particle_interaction_material_handler.cpp b/src/particle/src/interaction/4C_particle_interaction_material_handler.cpp index 8a71536a62..58da40ba64 100644 --- a/src/particle/src/interaction/4C_particle_interaction_material_handler.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_material_handler.cpp @@ -22,7 +22,7 @@ Particle::MaterialHandler::MaterialHandler(const Teuchos::ParameterList& params) void Particle::MaterialHandler::initialize_parameters() { // init map relating particle types to material ids - std::map typetomatidmap; + std::map typetomatidmap; // read parameters relating particle types to values ParticleUtils::read_params_types_related_to_values( @@ -38,7 +38,7 @@ void Particle::MaterialHandler::initialize_parameters() for (auto& typeIt : typetomatidmap) { // get type of particle - Particle::Type type_i = typeIt.first; + ParticleType type_i = typeIt.first; // add to set of particle types of stored particle material parameters storedtypes_.insert(type_i); diff --git a/src/particle/src/interaction/4C_particle_interaction_material_handler.hpp b/src/particle/src/interaction/4C_particle_interaction_material_handler.hpp index 8353a006f8..7ab032de71 100644 --- a/src/particle/src/interaction/4C_particle_interaction_material_handler.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_material_handler.hpp @@ -36,13 +36,13 @@ namespace Particle //! return pointer to particle material parameter inline const Mat::PAR::ParticleMaterialBase* get_ptr_to_particle_mat_parameter( - Particle::Type type_i) const + ParticleType type_i) const { return phasetypetoparticlematpar_[static_cast(type_i)]; } //! get particle types of stored particle material parameters - inline std::set get_particle_types() const { return storedtypes_; }; + inline std::set get_particle_types() const { return storedtypes_; }; private: void initialize_parameters(); @@ -54,7 +54,7 @@ namespace Particle std::vector phasetypetoparticlematpar_; //! set of particle types of stored particle material parameters - std::set storedtypes_; + std::set storedtypes_; }; } // namespace Particle diff --git a/src/particle/src/interaction/4C_particle_interaction_pd_neighbor_pairs.cpp b/src/particle/src/interaction/4C_particle_interaction_pd_neighbor_pairs.cpp index 558ea13ac3..304b8b4a40 100644 --- a/src/particle/src/interaction/4C_particle_interaction_pd_neighbor_pairs.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_pd_neighbor_pairs.cpp @@ -171,8 +171,8 @@ void Particle::PDNeighborPairs::evaluate_particle_pairs() // all close and non-bonded particle pairs are considered as potential colliding partners // undergoing short range force interaction - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - const double* pos_j = container_j->get_ptr_to_state(Particle::State::Position, particle_j); + const double* pos_i = container_i->get_ptr_to_state(ParticleState::Position, particle_i); + const double* pos_j = container_j->get_ptr_to_state(ParticleState::Position, particle_j); // vector from particle i to j double r_ji[3]; @@ -184,8 +184,8 @@ void Particle::PDNeighborPairs::evaluate_particle_pairs() const double absdist = ParticleUtils::vec_norm_two(r_ji); #ifdef FOUR_C_ENABLE_ASSERTIONS - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* rad_j = container_j->get_ptr_to_state(Particle::State::Radius, particle_j); + const double* rad_i = container_i->get_ptr_to_state(ParticleState::Radius, particle_i); + const double* rad_j = container_j->get_ptr_to_state(ParticleState::Radius, particle_j); if (absdist < (1.0e-10 * rad_i[0]) or absdist < (1.0e-10 * rad_j[0])) FOUR_C_THROW("absolute distance {} between particles close to zero!", absdist); @@ -309,11 +309,11 @@ void Particle::PDNeighborPairs::evaluate_particle_wall_pairs() const int* globalid_i = container_i->get_ptr_to_global_id(particle_i); // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + const double* rad_i = container_i->get_ptr_to_state(ParticleState::Radius, particle_i); // get position of particle i const Core::LinAlg::Matrix<3, 1> pos_i( - container_i->get_ptr_to_state(Particle::State::Position, particle_i)); + container_i->get_ptr_to_state(ParticleState::Position, particle_i)); // get pointer to column wall element Core::Elements::Element* ele = potentialneighbors.second; @@ -410,7 +410,7 @@ void Particle::PDNeighborPairs::evaluate_particle_wall_pairs() particlecontainerbundle_->get_specific_container(type_i, status_i); // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + const double* rad_i = container_i->get_ptr_to_state(ParticleState::Radius, particle_i); // define tolerance dependent on the particle radius const double adaptedtol = 1.0e-7 * rad_i[0]; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph.cpp b/src/particle/src/interaction/4C_particle_interaction_sph.cpp index 6258bd209b..a5aa429312 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph.cpp @@ -168,8 +168,8 @@ void Particle::ParticleInteractionSPH::setup( void Particle::ParticleInteractionSPH::check_open_boundaries() const { // types of particles to check - const std::unordered_map types_to_check{ - {{Particle::Type::DirichletPhase, "Dirichlet"}, {Particle::Type::NeumannPhase, "Neumann"}}}; + const std::unordered_map types_to_check{ + {{ParticleType::DirichletPhase, "Dirichlet"}, {ParticleType::NeumannPhase, "Neumann"}}}; // get all available boundary ids std::vector available_boundary_ids(openboundaries_.size()); @@ -186,7 +186,7 @@ void Particle::ParticleInteractionSPH::check_open_boundaries() const // get container of owned particles of open boundary phase Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_id, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_id, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container_i->particles_stored(); @@ -198,7 +198,7 @@ void Particle::ParticleInteractionSPH::check_open_boundaries() const for (int particle_i = 0; particle_i < particlestored; ++particle_i) { const auto particle_boundary_id = static_cast( - *container_i->get_ptr_to_state(Particle::State::OpenBoundaryId, particle_i)); + *container_i->get_ptr_to_state(ParticleState::OpenBoundaryId, particle_i)); if (std::find(available_boundary_ids.begin(), available_boundary_ids.end(), particle_boundary_id) == available_boundary_ids.end()) @@ -236,35 +236,35 @@ void Particle::ParticleInteractionSPH::read_restart( } void Particle::ParticleInteractionSPH::insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) + std::map>& particlestatestotypes) { // iterate over particle types for (auto& typeIt : particlestatestotypes) { // get type of particles - Particle::Type type = typeIt.first; + ParticleType type = typeIt.first; // set of particle states for current particle type - std::set& particlestates = typeIt.second; + std::set& particlestates = typeIt.second; - if (type == Particle::Type::BoundaryPhase or type == Particle::Type::RigidPhase or - type == Particle::Type::PDPhase) + if (type == ParticleType::BoundaryPhase or type == ParticleType::RigidPhase or + type == ParticleType::PDPhase) { // insert states of boundary and rigid particles - particlestates.insert({Particle::State::Mass, Particle::State::Radius, - Particle::State::BoundaryPressure, Particle::State::BoundaryVelocity}); + particlestates.insert({ParticleState::Mass, ParticleState::Radius, + ParticleState::BoundaryPressure, ParticleState::BoundaryVelocity}); } - else if (type == Particle::Type::DirichletPhase or type == Particle::Type::NeumannPhase) + else if (type == ParticleType::DirichletPhase or type == ParticleType::NeumannPhase) { // insert states of open boundary particles - particlestates.insert({Particle::State::Mass, Particle::State::Radius, - Particle::State::Density, Particle::State::Pressure, Particle::State::OpenBoundaryId}); + particlestates.insert({ParticleState::Mass, ParticleState::Radius, ParticleState::Density, + ParticleState::Pressure, ParticleState::OpenBoundaryId}); } else { // insert states of regular phase particles - particlestates.insert({Particle::State::Mass, Particle::State::Radius, - Particle::State::Density, Particle::State::Pressure}); + particlestates.insert({ParticleState::Mass, ParticleState::Radius, ParticleState::Density, + ParticleState::Pressure}); } } @@ -304,7 +304,7 @@ void Particle::ParticleInteractionSPH::set_initial_states() { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container->particles_stored(); @@ -329,15 +329,15 @@ void Particle::ParticleInteractionSPH::set_initial_states() initradius[0] = material->initRadius_; // set initial density for respective particles of current type - if (container->have_stored_state(Particle::State::Density)) - container->set_state(initdensity, Particle::State::Density); + if (container->have_stored_state(ParticleState::Density)) + container->set_state(initdensity, ParticleState::Density); // set initial mass and radius for all particles of current type - container->set_state(initmass, Particle::State::Mass); - container->set_state(initradius, Particle::State::Radius); + container->set_state(initmass, ParticleState::Mass); + container->set_state(initradius, ParticleState::Radius); // evaluate initial inertia for respective particles of current type - if (container->have_stored_state(Particle::State::Inertia)) + if (container->have_stored_state(ParticleState::Inertia)) { // (initial) inertia of current phase std::vector initinertia(1); @@ -365,7 +365,7 @@ void Particle::ParticleInteractionSPH::set_initial_states() } // set initial inertia for respective particles of current type - container->set_state(initinertia, Particle::State::Inertia); + container->set_state(initinertia, ParticleState::Inertia); } // initial states for temperature evaluation @@ -381,15 +381,14 @@ void Particle::ParticleInteractionSPH::set_initial_states() inittemperature[0] = material->initTemperature_; // set initial temperature for all particles of current type - container->set_state(inittemperature, Particle::State::Temperature); + container->set_state(inittemperature, ParticleState::Temperature); } // set initial state for peridynamics - if (peridynamics_ && type_i == Particle::Type::PDPhase) + if (peridynamics_ && type_i == ParticleType::PDPhase) { // set particle reference position - container->update_state( - 0.0, Particle::State::ReferencePosition, 1.0, Particle::State::Position); + container->update_state(0.0, ParticleState::ReferencePosition, 1.0, ParticleState::Position); // get material for current particle type const Mat::PAR::ParticleMaterialPD* material = @@ -399,12 +398,12 @@ void Particle::ParticleInteractionSPH::set_initial_states() // set Young's modulus for all peridynamic phase particles std::vector young(1); young[0] = material->young_; - container->set_state(young, Particle::State::Young); + container->set_state(young, ParticleState::Young); // set critical stretch for all peridynamic phase particles std::vector stretch(1); stretch[0] = material->critical_stretch_; - container->set_state(stretch, Particle::State::CriticalStretch); + container->set_state(stretch, ParticleState::CriticalStretch); // initialize peridynamic bond list once at the beginning of the simulation peridynamics_->init_peridynamic_bondlist(); diff --git a/src/particle/src/interaction/4C_particle_interaction_sph.hpp b/src/particle/src/interaction/4C_particle_interaction_sph.hpp index 73a8b61014..2424af1cff 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph.hpp @@ -76,7 +76,7 @@ namespace Particle //! insert interaction dependent states of all particle types void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) override; + std::map>& particlestatestotypes) override; //! set initial states void set_initial_states() override; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_boundary_particle.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_boundary_particle.cpp index 0b6d1d54bb..d0cadb5fe8 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_boundary_particle.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_boundary_particle.cpp @@ -19,10 +19,9 @@ FOUR_C_NAMESPACE_OPEN Particle::SPHBoundaryParticleBase::SPHBoundaryParticleBase(const Teuchos::ParameterList& params) : params_sph_(params), - fluidtypes_({Particle::Type::Phase1, Particle::Type::Phase2, Particle::Type::DirichletPhase, - Particle::Type::NeumannPhase}), - boundarytypes_( - {Particle::Type::BoundaryPhase, Particle::Type::RigidPhase, Particle::Type::PDPhase}) + fluidtypes_({ParticleType::Phase1, ParticleType::Phase2, ParticleType::DirichletPhase, + ParticleType::NeumannPhase}), + boundarytypes_({ParticleType::BoundaryPhase, ParticleType::RigidPhase, ParticleType::PDPhase}) { // empty constructor } @@ -73,8 +72,8 @@ void Particle::SPHBoundaryParticleAdami::setup( // setup modified states of ghosted boundary particles to refresh { - std::vector states{ - Particle::State::BoundaryPressure, Particle::State::BoundaryVelocity}; + std::vector states{ + ParticleState::BoundaryPressure, ParticleState::BoundaryVelocity}; for (const auto& type_i : boundarytypes_) boundarystatestorefresh_.push_back(std::make_pair(type_i, states)); @@ -99,7 +98,7 @@ void Particle::SPHBoundaryParticleAdami::init_boundary_particle_states(std::vect { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container_i->particles_stored(); @@ -117,6 +116,17 @@ void Particle::SPHBoundaryParticleAdami::init_boundary_particle_states(std::vect neighborpairs_->get_relevant_particle_pair_indices_for_disjoint_combination( boundarytypes_, fluidtypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& acc = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Acceleration); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& press = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Pressure); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -124,27 +134,25 @@ void Particle::SPHBoundaryParticleAdami::init_boundary_particle_states(std::vect neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; // evaluate contribution of neighboring fluid particle j if (boundarytypes_.contains(type_i)) { - // get container of owned particles - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get pointer to particle states - const double* vel_j = container_j->get_ptr_to_state(Particle::State::Velocity, particle_j); - const double* dens_j = container_j->get_ptr_to_state(Particle::State::Density, particle_j); - const double* press_j = container_j->get_ptr_to_state(Particle::State::Pressure, particle_j); + const double* vel_j = + Particle::bundle_state_ptrs_index(vel, type_j, status_j, particle_j, statedim); + const double* dens_j = Particle::bundle_state_ptrs_index(dens, type_j, status_j, particle_j); + const double* press_j = + Particle::bundle_state_ptrs_index(press, type_j, status_j, particle_j); // sum contribution of neighboring particle j sumj_wij_[static_cast(type_i)][particle_i] += particlepair.Wij_; @@ -160,16 +168,14 @@ void Particle::SPHBoundaryParticleAdami::init_boundary_particle_states(std::vect } // evaluate contribution of neighboring fluid particle i - if (boundarytypes_.contains(type_j) and status_j == Particle::Status::Owned) + if (boundarytypes_.contains(type_j) and status_j == ParticleStatus::Owned) { - // get container of owned particles - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - // get pointer to particle states - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - const double* press_i = container_i->get_ptr_to_state(Particle::State::Pressure, particle_i); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + const double* press_i = + Particle::bundle_state_ptrs_index(press, type_i, status_i, particle_i); // sum contribution of neighboring particle i sumj_wij_[static_cast(type_j)][particle_j] += particlepair.Wji_; @@ -189,12 +195,18 @@ void Particle::SPHBoundaryParticleAdami::init_boundary_particle_states(std::vect for (const auto& type_i : boundarytypes_) { // get container of owned particles + ParticleStatus status_i = ParticleStatus::Owned; Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, status_i); // clear modified boundary particle states - container_i->clear_state(Particle::State::BoundaryPressure); - container_i->clear_state(Particle::State::BoundaryVelocity); + container_i->clear_state(ParticleState::BoundaryPressure); + container_i->clear_state(ParticleState::BoundaryVelocity); + + // get pointers to particle states + double* boundarypress = + container_i->get_ptr_to_state_writable(Particle::State::BoundaryPressure); + double* boundaryvel = container_i->get_ptr_to_state_writable(Particle::State::BoundaryVelocity); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) @@ -202,14 +214,13 @@ void Particle::SPHBoundaryParticleAdami::init_boundary_particle_states(std::vect // set modified boundary particle states if (sumj_wij_[static_cast(type_i)][particle_i] > 0.0) { - // get pointer to particle states - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); + // get pointers to particle states + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); const double* acc_i = - container_i->get_ptr_to_state(Particle::State::Acceleration, particle_i); - double* boundarypress_i = - container_i->get_ptr_to_state_writable(Particle::State::BoundaryPressure, particle_i); - double* boundaryvel_i = - container_i->get_ptr_to_state_writable(Particle::State::BoundaryVelocity, particle_i); + Particle::bundle_state_ptrs_index(acc, type_i, status_i, particle_i, statedim); + double* boundarypress_i = &boundarypress[particle_i]; + double* boundaryvel_i = &boundaryvel[particle_i * statedim]; // get relative acceleration of boundary particle double relacc[3]; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_boundary_particle.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_boundary_particle.hpp index 421e88df67..fbd46b150b 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_boundary_particle.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_boundary_particle.hpp @@ -66,10 +66,10 @@ namespace Particle std::shared_ptr neighborpairs_; //! set of fluid particle types - std::set fluidtypes_; + std::set fluidtypes_; //! set of boundary particle types - std::set boundarytypes_; + std::set boundarytypes_; }; class SPHBoundaryParticleAdami : public SPHBoundaryParticleBase diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_density.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_density.cpp index 140c46efdb..3dbc282fdb 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_density.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_density.cpp @@ -34,7 +34,7 @@ FOUR_C_NAMESPACE_OPEN | definitions | *---------------------------------------------------------------------------*/ Particle::SPHDensityBase::SPHDensityBase(const Teuchos::ParameterList& params) - : params_sph_(params), fluidtypes_({Particle::Type::Phase1, Particle::Type::Phase2}), dt_(0.0) + : params_sph_(params), fluidtypes_({ParticleType::Phase1, ParticleType::Phase2}), dt_(0.0) { // empty constructor } @@ -80,7 +80,7 @@ void Particle::SPHDensityBase::setup( // setup density of ghosted particles to refresh { - std::vector states{Particle::State::Density}; + std::vector states{ParticleState::Density}; for (const auto& type_i : fluidtypes_) densitytorefresh_.push_back(std::make_pair(type_i, states)); @@ -114,10 +114,10 @@ void Particle::SPHDensityBase::clear_density_sum_state() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // clear density sum state - container_i->clear_state(Particle::State::DensitySum); + container_i->clear_state(ParticleState::DensitySum); } } @@ -130,16 +130,20 @@ void Particle::SPHDensityBase::sum_weighted_mass_self_contribution() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); + + // get pointer to particle states + const double* rad = container_i->get_ptr_to_state(ParticleState::Radius); + const double* mass = container_i->get_ptr_to_state(ParticleState::Mass); + double* denssum = container_i->get_ptr_to_state_writable(ParticleState::DensitySum); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - double* denssum_i = - container_i->get_ptr_to_state_writable(Particle::State::DensitySum, particle_i); + const double* rad_i = &rad[particle_i]; + const double* mass_i = &mass[particle_i]; + double* denssum_i = &denssum[particle_i]; // evaluate kernel const double Wii = kernel_->w0(rad_i[0]); @@ -154,37 +158,35 @@ void Particle::SPHDensityBase::sum_weighted_mass_particle_contribution() const { TEUCHOS_FUNC_TIME_MONITOR("Particle::SPHDensityBase::sum_weighted_mass_particle_contribution"); + // get pointers to particle states + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ParticleContainerBundleStatePtrs& denssum = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::DensitySum); + // iterate over particle pairs for (auto& particlepair : neighborpairs_->get_ref_to_particle_pair_data()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - - // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); + // get pointers to particle states + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); double* denssum_i = - container_i->try_get_ptr_to_state_writable(Particle::State::DensitySum, particle_i); + Particle::bundle_state_ptrs_index(denssum, nullptr, type_i, status_i, particle_i); - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); double* denssum_j = nullptr; - if (status_j == Particle::Status::Owned) - denssum_j = - container_j->try_get_ptr_to_state_writable(Particle::State::DensitySum, particle_j); + if (status_j == ParticleStatus::Owned) + denssum_j = Particle::bundle_state_ptrs_index(denssum, nullptr, type_j, status_j, particle_j); // sum contribution of neighboring particle j if (denssum_i) denssum_i[0] += particlepair.Wij_ * mass_i[0]; @@ -203,6 +205,14 @@ void Particle::SPHDensityBase::sum_weighted_mass_particle_wall_contribution() co std::vector relindices; neighborpairs_->get_relevant_particle_wall_pair_indices(fluidtypes_, relindices); + // get pointers to particle states + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ParticleContainerBundleStatePtrs& denssum = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::DensitySum); + // iterate over relevant particle-wall pairs for (const int particlewallpairindex : relindices) { @@ -210,20 +220,15 @@ void Particle::SPHDensityBase::sum_weighted_mass_particle_wall_contribution() co neighborpairs_->get_ref_to_particle_wall_pair_data()[particlewallpairindex]; // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlewallpair.tuple_i_; - // get corresponding particle container - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - double* denssum_i = - container_i->get_ptr_to_state_writable(Particle::State::DensitySum, particle_i); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + double* denssum_i = Particle::bundle_state_ptrs_index(denssum, type_i, status_i, particle_i); // compute vector from wall contact point j to particle i double r_ij[3]; @@ -283,10 +288,10 @@ void Particle::SPHDensityBase::clear_colorfield_state() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // clear colorfield state - container_i->clear_state(Particle::State::Colorfield); + container_i->clear_state(ParticleState::Colorfield); } } @@ -299,17 +304,22 @@ void Particle::SPHDensityBase::sum_colorfield_self_contribution() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); + + // get pointers to particle states + const double* rad = container_i->get_ptr_to_state(ParticleState::Radius); + const double* mass = container_i->get_ptr_to_state(ParticleState::Mass); + const double* dens = container_i->get_ptr_to_state(ParticleState::Density); + double* colorfield = container_i->get_ptr_to_state_writable(ParticleState::Colorfield); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - double* colorfield_i = - container_i->get_ptr_to_state_writable(Particle::State::Colorfield, particle_i); + const double* rad_i = &rad[particle_i]; + const double* mass_i = &mass[particle_i]; + const double* dens_i = &dens[particle_i]; + double* colorfield_i = &colorfield[particle_i]; // evaluate kernel const double Wii = kernel_->w0(rad_i[0]); @@ -324,27 +334,28 @@ void Particle::SPHDensityBase::sum_colorfield_particle_contribution() const { TEUCHOS_FUNC_TIME_MONITOR("Particle::SPHDensityBase::sum_colorfield_particle_contribution"); + // get pointers to particle states + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ParticleContainerBundleStatePtrs& colorfield = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Colorfield); + // iterate over particle pairs for (auto& particlepair : neighborpairs_->get_ref_to_particle_pair_data()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get material for particle types const Mat::PAR::ParticleMaterialBase* material_i = particlematerial_->get_ptr_to_particle_mat_parameter(type_i); @@ -352,26 +363,20 @@ void Particle::SPHDensityBase::sum_colorfield_particle_contribution() const const Mat::PAR::ParticleMaterialBase* material_j = particlematerial_->get_ptr_to_particle_mat_parameter(type_j); - // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - - const double* dens_i = container_i->have_stored_state(Particle::State::Density) - ? container_i->get_ptr_to_state(Particle::State::Density, particle_i) - : &(material_j->initDensity_); - + // get pointers to particle states + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index( + dens, &(material_j->initDensity_), type_i, status_i, particle_i); double* colorfield_i = - container_i->try_get_ptr_to_state_writable(Particle::State::Colorfield, particle_i); - - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - - const double* dens_j = container_j->have_stored_state(Particle::State::Density) - ? container_j->get_ptr_to_state(Particle::State::Density, particle_j) - : &(material_i->initDensity_); + Particle::bundle_state_ptrs_index(colorfield, nullptr, type_i, status_i, particle_i); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index( + dens, &(material_i->initDensity_), type_j, status_j, particle_j); double* colorfield_j = nullptr; - if (status_j == Particle::Status::Owned) + if (status_j == ParticleStatus::Owned) colorfield_j = - container_j->try_get_ptr_to_state_writable(Particle::State::Colorfield, particle_j); + Particle::bundle_state_ptrs_index(colorfield, nullptr, type_j, status_j, particle_j); // sum contribution of neighboring particle j if (colorfield_i) colorfield_i[0] += (particlepair.Wij_ / dens_j[0]) * mass_j[0]; @@ -389,6 +394,14 @@ void Particle::SPHDensityBase::sum_colorfield_particle_wall_contribution() const std::vector relindices; neighborpairs_->get_relevant_particle_wall_pair_indices(fluidtypes_, relindices); + // get pointers to particle states + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ParticleContainerBundleStatePtrs& colorfield = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Colorfield); + // iterate over relevant particle-wall pairs for (const int particlewallpairindex : relindices) { @@ -396,26 +409,22 @@ void Particle::SPHDensityBase::sum_colorfield_particle_wall_contribution() const neighborpairs_->get_ref_to_particle_wall_pair_data()[particlewallpairindex]; // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlewallpair.tuple_i_; - // get corresponding particle container - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - // get material for particle types const Mat::PAR::ParticleMaterialBase* material_i = particlematerial_->get_ptr_to_particle_mat_parameter(type_i); // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); double* colorfield_i = - container_i->get_ptr_to_state_writable(Particle::State::Colorfield, particle_i); + Particle::bundle_state_ptrs_index(colorfield, type_i, status_i, particle_i); // get pointer to virtual particle states - const double* mass_k = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); + const double* mass_k = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); const double* dens_k = &(material_i->initDensity_); // (current) volume of virtual particle k @@ -476,10 +485,10 @@ void Particle::SPHDensityBase::clear_density_dot_state() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // clear density dot state - container_i->clear_state(Particle::State::DensityDot); + container_i->clear_state(ParticleState::DensityDot); } } @@ -487,27 +496,34 @@ void Particle::SPHDensityBase::continuity_equation_particle_contribution() const { TEUCHOS_FUNC_TIME_MONITOR("Particle::SPHDensityBase::continuity_equation_particle_contribution"); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& mod_vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::ModifiedVelocity); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ParticleContainerBundleStatePtrs& densdot = + particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::DensityDot, ParticleStatus::Owned); + // iterate over particle pairs for (auto& particlepair : neighborpairs_->get_ref_to_particle_pair_data()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get material for particle types const Mat::PAR::ParticleMaterialBase* material_i = particlematerial_->get_ptr_to_particle_mat_parameter(type_i); @@ -516,35 +532,24 @@ void Particle::SPHDensityBase::continuity_equation_particle_contribution() const particlematerial_->get_ptr_to_particle_mat_parameter(type_j); // get pointer to particle states - const double* vel_i = - container_i->have_stored_state(Particle::State::ModifiedVelocity) - ? container_i->get_ptr_to_state(Particle::State::ModifiedVelocity, particle_i) - : container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); - - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - - const double* dens_i = container_i->have_stored_state(Particle::State::Density) - ? container_i->get_ptr_to_state(Particle::State::Density, particle_i) - : &(material_j->initDensity_); - + const double* vel_i = Particle::bundle_state_ptrs_index(mod_vel, + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim), type_i, + status_i, particle_i, statedim); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index( + dens, &(material_i->initDensity_), type_i, status_i, particle_i); double* densdot_i = - container_i->try_get_ptr_to_state_writable(Particle::State::DensityDot, particle_i); - - const double* vel_j = - container_j->have_stored_state(Particle::State::ModifiedVelocity) - ? container_j->get_ptr_to_state(Particle::State::ModifiedVelocity, particle_j) - : container_j->get_ptr_to_state(Particle::State::Velocity, particle_j); - - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - - const double* dens_j = container_j->have_stored_state(Particle::State::Density) - ? container_j->get_ptr_to_state(Particle::State::Density, particle_j) - : &(material_i->initDensity_); - + Particle::bundle_state_ptrs_index(densdot, nullptr, type_i, status_i, particle_i); + + const double* vel_j = Particle::bundle_state_ptrs_index(mod_vel, + Particle::bundle_state_ptrs_index(vel, type_j, status_j, particle_j, statedim), type_j, + status_j, particle_j, statedim); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index( + dens, &(material_j->initDensity_), type_j, status_j, particle_j); double* densdot_j = nullptr; - if (status_j == Particle::Status::Owned) - densdot_j = - container_j->try_get_ptr_to_state_writable(Particle::State::DensityDot, particle_j); + if (status_j == ParticleStatus::Owned) + densdot_j = Particle::bundle_state_ptrs_index(densdot, nullptr, type_j, status_j, particle_j); // relative velocity (use modified velocities in case of transport velocity formulation) double vel_ij[3]; @@ -576,6 +581,21 @@ void Particle::SPHDensityBase::continuity_equation_particle_wall_contribution() std::vector relindices; neighborpairs_->get_relevant_particle_wall_pair_indices(fluidtypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& mod_vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::ModifiedVelocity); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ParticleContainerBundleStatePtrs& densdot = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::DensityDot); + // iterate over relevant particle-wall pairs for (const int particlewallpairindex : relindices) { @@ -583,29 +603,22 @@ void Particle::SPHDensityBase::continuity_equation_particle_wall_contribution() neighborpairs_->get_ref_to_particle_wall_pair_data()[particlewallpairindex]; // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlewallpair.tuple_i_; - // get corresponding particle container - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - // get material for particle types const Mat::PAR::ParticleMaterialBase* material_i = particlematerial_->get_ptr_to_particle_mat_parameter(type_i); - // get pointer to particle states - const double* vel_i = - container_i->have_stored_state(Particle::State::ModifiedVelocity) - ? container_i->get_ptr_to_state(Particle::State::ModifiedVelocity, particle_i) - : container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); - - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - double* densdot_i = - container_i->get_ptr_to_state_writable(Particle::State::DensityDot, particle_i); + // get pointers to particle states + const double* vel_i = Particle::bundle_state_ptrs_index(mod_vel, + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim), type_i, + status_i, particle_i, statedim); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + double* densdot_i = Particle::bundle_state_ptrs_index(densdot, type_i, status_i, particle_i); // get pointer to column wall element Core::Elements::Element* ele = particlewallpair.ele_; @@ -646,7 +659,7 @@ void Particle::SPHDensityBase::continuity_equation_particle_wall_contribution() } // get pointer to virtual particle states - const double* mass_k = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); + const double* mass_k = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); const double* dens_k = &(material_i->initDensity_); const double* vel_k = vel_j.data(); @@ -703,10 +716,10 @@ void Particle::SPHDensityBase::set_density_sum() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // update density of all particles - container_i->update_state(0.0, Particle::State::Density, 1.0, Particle::State::DensitySum); + container_i->update_state(0.0, ParticleState::Density, 1.0, ParticleState::DensitySum); } } @@ -717,10 +730,10 @@ void Particle::SPHDensityBase::add_time_step_scaled_density_dot() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // update density of all particles - container_i->update_state(1.0, Particle::State::Density, dt_, Particle::State::DensityDot); + container_i->update_state(1.0, ParticleState::Density, dt_, ParticleState::DensityDot); } } @@ -731,22 +744,22 @@ Particle::SPHDensitySummation::SPHDensitySummation(const Teuchos::ParameterList& } void Particle::SPHDensitySummation::insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const + std::map>& particlestatestotypes) const { // iterate over particle types for (auto& typeIt : particlestatestotypes) { // get type of particles - Particle::Type type_i = typeIt.first; + ParticleType type_i = typeIt.first; // set of particle states for current particle type - std::set& particlestates = typeIt.second; + std::set& particlestates = typeIt.second; // current particle type is not a fluid particle type if (not fluidtypes_.contains(type_i)) continue; // states for density evaluation scheme - particlestates.insert(Particle::State::DensitySum); + particlestates.insert(ParticleState::DensitySum); } } @@ -771,22 +784,22 @@ Particle::SPHDensityIntegration::SPHDensityIntegration(const Teuchos::ParameterL } void Particle::SPHDensityIntegration::insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const + std::map>& particlestatestotypes) const { // iterate over particle types for (auto& typeIt : particlestatestotypes) { // get type of particles - Particle::Type type_i = typeIt.first; + ParticleType type_i = typeIt.first; // set of particle states for current particle type - std::set& particlestates = typeIt.second; + std::set& particlestates = typeIt.second; // current particle type is not a fluid particle type if (not fluidtypes_.contains(type_i)) continue; // states for density evaluation scheme - particlestates.insert(Particle::State::DensityDot); + particlestates.insert(ParticleState::DensityDot); } } @@ -827,23 +840,23 @@ void Particle::SPHDensityPredictCorrect::setup( } void Particle::SPHDensityPredictCorrect::insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const + std::map>& particlestatestotypes) const { // iterate over particle types for (auto& typeIt : particlestatestotypes) { // get type of particles - Particle::Type type_i = typeIt.first; + ParticleType type_i = typeIt.first; // set of particle states for current particle type - std::set& particlestates = typeIt.second; + std::set& particlestates = typeIt.second; // current particle type is not a fluid particle type if (not fluidtypes_.contains(type_i)) continue; // states for density evaluation scheme particlestates.insert( - {Particle::State::DensityDot, Particle::State::DensitySum, Particle::State::Colorfield}); + {ParticleState::DensityDot, ParticleState::DensitySum, ParticleState::Colorfield}); } } @@ -915,7 +928,7 @@ void Particle::SPHDensityPredictCorrect::correct_density() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container_i->particles_stored(); @@ -923,10 +936,10 @@ void Particle::SPHDensityPredictCorrect::correct_density() const // no owned particles of current particle type if (particlestored <= 0) continue; - // get pointer to particle state - const double* denssum = container_i->get_ptr_to_state(Particle::State::DensitySum, 0); - const double* colorfield = container_i->get_ptr_to_state(Particle::State::Colorfield, 0); - double* dens = container_i->get_ptr_to_state_writable(Particle::State::Density, 0); + // get pointers to particle states + const double* denssum = container_i->get_ptr_to_state(ParticleState::DensitySum); + const double* colorfield = container_i->get_ptr_to_state(ParticleState::Colorfield); + double* dens = container_i->get_ptr_to_state_writable(ParticleState::Density); // get material for current particle type const Mat::PAR::ParticleMaterialBase* material = diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_density.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_density.hpp index 9a9ac85856..0b9f3776c2 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_density.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_density.hpp @@ -65,7 +65,7 @@ namespace Particle //! insert density evaluation dependent states virtual void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const = 0; + std::map>& particlestatestotypes) const = 0; //! compute density field virtual void compute_density() const = 0; @@ -150,7 +150,7 @@ namespace Particle Particle::StatesOfTypesToRefresh densitytorefresh_; //! set of fluid particle types - std::set fluidtypes_; + std::set fluidtypes_; //! time step size double dt_; @@ -164,7 +164,7 @@ namespace Particle //! insert density evaluation dependent states void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const override; + std::map>& particlestatestotypes) const override; //! compute density field void compute_density() const override; @@ -178,7 +178,7 @@ namespace Particle //! insert density evaluation dependent states void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const override; + std::map>& particlestatestotypes) const override; //! compute density field void compute_density() const override; @@ -210,7 +210,7 @@ namespace Particle //! insert density evaluation dependent states void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const override; + std::map>& particlestatestotypes) const override; //! compute density field void compute_density() const override; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_equationofstate_bundle.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_equationofstate_bundle.cpp index 16fea08f91..5422bc5f53 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_equationofstate_bundle.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_equationofstate_bundle.cpp @@ -41,8 +41,8 @@ void Particle::SPHEquationOfStateBundle::init(Particle::MaterialHandler& particl for (const auto& type_i : particlematerial.get_particle_types()) { // no equation of state for boundary or rigid particles - if (type_i == Particle::Type::BoundaryPhase or type_i == Particle::Type::RigidPhase or - type_i == Particle::Type::PDPhase) + if (type_i == ParticleType::BoundaryPhase or type_i == ParticleType::RigidPhase or + type_i == ParticleType::PDPhase) continue; // add to set of particle types of stored equation of state handlers diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_equationofstate_bundle.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_equationofstate_bundle.hpp index 85a0c027cc..9ddda74bcb 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_equationofstate_bundle.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_equationofstate_bundle.hpp @@ -44,7 +44,7 @@ namespace Particle //! return pointer to specific equation of state inline const Particle::SPHEquationOfStateBase* get_ptr_to_specific_equation_of_state( - Particle::Type type_i) const + ParticleType type_i) const { return phasetypetoequationofstate_[static_cast(type_i)].get(); }; @@ -57,7 +57,7 @@ namespace Particle std::vector> phasetypetoequationofstate_; //! set of particle types of stored equation of state handlers - std::set storedtypes_; + std::set storedtypes_; }; } // namespace Particle diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_heatloss_evaporation.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_heatloss_evaporation.cpp index abe7ddbbd4..106abd5960 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_heatloss_evaporation.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_heatloss_evaporation.cpp @@ -20,7 +20,7 @@ FOUR_C_NAMESPACE_OPEN Particle::SPHHeatLossEvaporation::SPHHeatLossEvaporation(const Teuchos::ParameterList& params) : params_sph_(params), - evaporatingphase_(Particle::Type::Phase1), + evaporatingphase_(ParticleType::Phase1), recoilboilingtemp_(params_sph_.get("VAPOR_RECOIL_BOILINGTEMPERATURE")), recoil_pfac_(params_sph_.get("VAPOR_RECOIL_PFAC")), recoil_tfac_(params_sph_.get("VAPOR_RECOIL_TFAC")), @@ -68,22 +68,27 @@ void Particle::SPHHeatLossEvaporation::evaluate_evaporation_induced_heat_loss() // get container of owned particles of evaporating phase Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(evaporatingphase_, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(evaporatingphase_, ParticleStatus::Owned); const Mat::PAR::ParticleMaterialThermo* thermomaterial_i = thermomaterial_[static_cast(evaporatingphase_)]; + // get pointers to states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + const double* dens = container_i->get_ptr_to_state(ParticleState::Density); + const double* temp = container_i->get_ptr_to_state(ParticleState::Temperature); + const double* cfg = container_i->get_ptr_to_state(ParticleState::ColorfieldGradient); + const double* ifn = container_i->get_ptr_to_state(ParticleState::InterfaceNormal); + double* tempdot = container_i->get_ptr_to_state_writable(ParticleState::TemperatureDot); + // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - const double* temp_i = container_i->get_ptr_to_state(Particle::State::Temperature, particle_i); - const double* cfg_i = - container_i->get_ptr_to_state(Particle::State::ColorfieldGradient, particle_i); - const double* ifn_i = - container_i->get_ptr_to_state(Particle::State::InterfaceNormal, particle_i); - double* tempdot_i = - container_i->get_ptr_to_state_writable(Particle::State::TemperatureDot, particle_i); + const double* dens_i = &dens[particle_i]; + const double* temp_i = &temp[particle_i]; + const double* cfg_i = &cfg[particle_i * statedim]; + const double* ifn_i = &ifn[particle_i * statedim]; + double* tempdot_i = &tempdot[particle_i]; // evaluation only for non-zero interface normal if (not(ParticleUtils::vec_norm_two(ifn_i) > 0.0)) continue; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_heatloss_evaporation.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_heatloss_evaporation.hpp index 51ea9a160a..3d320d2ab1 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_heatloss_evaporation.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_heatloss_evaporation.hpp @@ -73,7 +73,7 @@ namespace Particle std::vector thermomaterial_; //! evaporating phase - Particle::Type evaporatingphase_; + ParticleType evaporatingphase_; //! boiling temperature in recoil pressure formula double recoilboilingtemp_; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_heatsource.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_heatsource.cpp index b8c5c06ffa..6914eaf774 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_heatsource.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_heatsource.cpp @@ -61,8 +61,8 @@ void Particle::SPHHeatSourceBase::setup( particlematerial_->get_ptr_to_particle_mat_parameter(type_i)); // set of potential absorbing particle types - std::set potentialabsorbingtypes = {Particle::Type::Phase1, - Particle::Type::Phase2, Particle::Type::RigidPhase, Particle::Type::PDPhase}; + std::set potentialabsorbingtypes = { + ParticleType::Phase1, ParticleType::Phase2, ParticleType::RigidPhase, ParticleType::PDPhase}; // iterate over particle types for (const auto& type_i : particlecontainerbundle_->get_particle_types()) @@ -112,7 +112,7 @@ void Particle::SPHHeatSourceVolume::evaluate_heat_source(const double& evaltime) { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get material for current particle type const Mat::PAR::ParticleMaterialBase* basematerial_i = @@ -121,18 +121,19 @@ void Particle::SPHHeatSourceVolume::evaluate_heat_source(const double& evaltime) const Mat::PAR::ParticleMaterialThermo* thermomaterial_i = thermomaterial_[static_cast(type_i)]; + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + const double* dens = container_i->try_get_ptr_to_state(ParticleState::Density); + const double* pos = container_i->get_ptr_to_state(ParticleState::Position); + double* tempdot = container_i->get_ptr_to_state_writable(ParticleState::TemperatureDot); + // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { - // get pointer to particle states - const double* dens_i = - (container_i->have_stored_state(Particle::State::Density)) - ? container_i->get_ptr_to_state(Particle::State::Density, particle_i) - : &(basematerial_i->initDensity_); - - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - double* tempdot_i = - container_i->get_ptr_to_state_writable(Particle::State::TemperatureDot, particle_i); + // get pointers to particle states + const double* dens_i = dens ? &dens[particle_i] : &(basematerial_i->initDensity_); + const double* pos_i = &pos[particle_i * statedim]; + double* tempdot_i = &tempdot[particle_i]; // evaluate function defining heat source funct = function.evaluate_time_derivative(std::span(pos_i, 3), evaltime, 0, 0); @@ -188,7 +189,7 @@ void Particle::SPHHeatSourceSurface::evaluate_heat_source(const double& evaltime { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container_i->particles_stored(); @@ -202,6 +203,12 @@ void Particle::SPHHeatSourceSurface::evaluate_heat_source(const double& evaltime neighborpairs_->get_relevant_particle_pair_indices_for_disjoint_combination( absorbingtypes_, nonabsorbingtypes_, relindices); + // get pointers to particle states + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -209,23 +216,16 @@ void Particle::SPHHeatSourceSurface::evaluate_heat_source(const double& evaltime neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get material for particle types const Mat::PAR::ParticleMaterialBase* material_i = particlematerial_->get_ptr_to_particle_mat_parameter(type_i); @@ -234,17 +234,13 @@ void Particle::SPHHeatSourceSurface::evaluate_heat_source(const double& evaltime particlematerial_->get_ptr_to_particle_mat_parameter(type_j); // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - - const double* dens_i = container_i->have_stored_state(Particle::State::Density) - ? container_i->get_ptr_to_state(Particle::State::Density, particle_i) - : &(material_i->initDensity_); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index( + dens, &(material_i->initDensity_), type_i, status_i, particle_i); - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - - const double* dens_j = container_j->have_stored_state(Particle::State::Density) - ? container_j->get_ptr_to_state(Particle::State::Density, particle_j) - : &(material_j->initDensity_); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index( + dens, &(material_j->initDensity_), type_j, status_j, particle_j); // (current) volume of particle i and j const double V_i = mass_i[0] / dens_i[0]; @@ -262,7 +258,7 @@ void Particle::SPHHeatSourceSurface::evaluate_heat_source(const double& evaltime } // evaluate contribution of neighboring particle i - if (absorbingtypes_.contains(type_j) and status_j == Particle::Status::Owned) + if (absorbingtypes_.contains(type_j) and status_j == ParticleStatus::Owned) { // sum contribution of neighboring particle i ParticleUtils::vec_add_scale(cfg_i[static_cast(type_j)][particle_j].data(), @@ -282,12 +278,21 @@ void Particle::SPHHeatSourceSurface::evaluate_heat_source(const double& evaltime if (function.number_components() != 1) FOUR_C_THROW("dimension of function defining heat source is not one!"); + // get pointer to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& pos = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::Position, absorbingtypes_, ParticleStatus::Owned); + ParticleContainerBundleStatePtrs& tempdot = + particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::TemperatureDot, absorbingtypes_, ParticleStatus::Owned); + // iterate over absorbing particle types for (const auto& type_i : absorbingtypes_) { // get container of owned particles of current particle type + ParticleStatus status_i = ParticleStatus::Owned; Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get material for current particle type const Mat::PAR::ParticleMaterialBase* basematerial_i = @@ -316,14 +321,11 @@ void Particle::SPHHeatSourceSurface::evaluate_heat_source(const double& evaltime if (f_i_proj < 0.0) continue; // get pointer to particle states - const double* dens_i = - (container_i->have_stored_state(Particle::State::Density)) - ? container_i->get_ptr_to_state(Particle::State::Density, particle_i) - : &(basematerial_i->initDensity_); - - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - double* tempdot_i = - container_i->get_ptr_to_state_writable(Particle::State::TemperatureDot, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index( + dens, &(basematerial_i->initDensity_), type_i, status_i, particle_i); + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + double* tempdot_i = Particle::bundle_state_ptrs_index(tempdot, type_i, status_i, particle_i); // evaluate function defining heat source funct = function.evaluate_time_derivative(std::span(pos_i, 3), evaltime, 0, 0); diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_heatsource.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_heatsource.hpp index 8844f33c0b..be12778a46 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_heatsource.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_heatsource.hpp @@ -85,10 +85,10 @@ namespace Particle const int heatsourcefctnumber_; //! set of absorbing particle types - std::set absorbingtypes_; + std::set absorbingtypes_; //! set of non-absorbing particle types - std::set nonabsorbingtypes_; + std::set nonabsorbingtypes_; }; class SPHHeatSourceVolume : public SPHHeatSourceBase diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_momentum.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_momentum.cpp index 0a6385851c..a1a26900ef 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_momentum.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_momentum.cpp @@ -47,13 +47,11 @@ Particle::SPHMomentum::SPHMomentum(const Teuchos::ParameterList& params) params_sph_, "TRANSPORTVELOCITYFORMULATION")), writeparticlewallinteraction_(params_sph_.get("WRITE_PARTICLE_WALL_INTERACTION")), reduced_dimension_scale_factor_(params_sph_.get("REDUCED_DIMENSION_SCALE_FACTOR")), - allfluidtypes_({Particle::Type::Phase1, Particle::Type::Phase2, - Particle::Type::DirichletPhase, Particle::Type::NeumannPhase}), - intfluidtypes_( - {Particle::Type::Phase1, Particle::Type::Phase2, Particle::Type::NeumannPhase}), - purefluidtypes_({Particle::Type::Phase1, Particle::Type::Phase2}), - boundarytypes_( - {Particle::Type::BoundaryPhase, Particle::Type::RigidPhase, Particle::Type::PDPhase}) + allfluidtypes_({ParticleType::Phase1, ParticleType::Phase2, ParticleType::DirichletPhase, + ParticleType::NeumannPhase}), + intfluidtypes_({ParticleType::Phase1, ParticleType::Phase2, ParticleType::NeumannPhase}), + purefluidtypes_({ParticleType::Phase1, ParticleType::Phase2}), + boundarytypes_({ParticleType::BoundaryPhase, ParticleType::RigidPhase, ParticleType::PDPhase}) { init_momentum_formulation_handler(); @@ -141,16 +139,16 @@ void Particle::SPHMomentum::setup( } void Particle::SPHMomentum::insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const + std::map>& particlestatestotypes) const { // iterate over particle types for (auto& typeIt : particlestatestotypes) { // get type of particles - Particle::Type type_i = typeIt.first; + ParticleType type_i = typeIt.first; // set of particle states for current particle type - std::set& particlestates = typeIt.second; + std::set& particlestates = typeIt.second; // current particle type is not a pure fluid particle type if (not purefluidtypes_.contains(type_i)) continue; @@ -158,8 +156,7 @@ void Particle::SPHMomentum::insert_particle_states_of_particle_types( // additional states for transport velocity formulation if (transportvelocityformulation_ != Particle::TransportVelocityFormulation::NoTransportVelocity) - particlestates.insert( - {Particle::State::ModifiedVelocity, Particle::State::ModifiedAcceleration}); + particlestates.insert({ParticleState::ModifiedVelocity, ParticleState::ModifiedAcceleration}); } } @@ -225,6 +222,25 @@ void Particle::SPHMomentum::momentum_equation_particle_contribution() const neighborpairs_->get_relevant_particle_pair_indices_for_equal_combination( allfluidtypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& press = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Pressure); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& mod_vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::ModifiedVelocity); + ParticleContainerBundleStatePtrs& acc = particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::Acceleration, intfluidtypes_); + ParticleContainerBundleStatePtrs& mod_acc = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::ModifiedAcceleration); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -232,61 +248,53 @@ void Particle::SPHMomentum::momentum_equation_particle_contribution() const neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get material for particle types const Mat::PAR::ParticleMaterialSPHFluid* material_i = fluidmaterial_[static_cast(type_i)]; const Mat::PAR::ParticleMaterialSPHFluid* material_j = fluidmaterial_[static_cast(type_j)]; // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - const double* press_i = container_i->get_ptr_to_state(Particle::State::Pressure, particle_i); - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); - + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + const double* press_i = Particle::bundle_state_ptrs_index(press, type_i, status_i, particle_i); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); + const double* mod_vel_i = + Particle::bundle_state_ptrs_index(mod_vel, nullptr, type_i, status_i, particle_i, statedim); double* acc_i = nullptr; if (intfluidtypes_.contains(type_i)) - acc_i = container_i->get_ptr_to_state_writable(Particle::State::Acceleration, particle_i); - - const double* mod_vel_i = - container_i->try_get_ptr_to_state(Particle::State::ModifiedVelocity, particle_i); - double* mod_acc_i = container_i->try_get_ptr_to_state_writable( - Particle::State::ModifiedAcceleration, particle_i); + acc_i = + Particle::bundle_state_ptrs_index(acc, nullptr, type_i, status_i, particle_i, statedim); + double* mod_acc_i = + Particle::bundle_state_ptrs_index(mod_acc, nullptr, type_i, status_i, particle_i, statedim); // get pointer to particle states - const double* rad_j = container_j->get_ptr_to_state(Particle::State::Radius, particle_j); - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - const double* dens_j = container_j->get_ptr_to_state(Particle::State::Density, particle_j); - const double* press_j = container_j->get_ptr_to_state(Particle::State::Pressure, particle_j); - const double* vel_j = container_j->get_ptr_to_state(Particle::State::Velocity, particle_j); - - double* acc_j = nullptr; - if (intfluidtypes_.contains(type_j) and status_j == Particle::Status::Owned) - acc_j = container_j->get_ptr_to_state_writable(Particle::State::Acceleration, particle_j); - + const double* rad_j = Particle::bundle_state_ptrs_index(rad, type_j, status_j, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index(dens, type_j, status_j, particle_j); + const double* press_j = Particle::bundle_state_ptrs_index(press, type_j, status_j, particle_j); + const double* vel_j = + Particle::bundle_state_ptrs_index(vel, type_j, status_j, particle_j, statedim); const double* mod_vel_j = - container_j->try_get_ptr_to_state(Particle::State::ModifiedVelocity, particle_j); - + Particle::bundle_state_ptrs_index(mod_vel, nullptr, type_j, status_j, particle_j, statedim); + double* acc_j = nullptr; + if (intfluidtypes_.contains(type_j) and status_j == ParticleStatus::Owned) + acc_j = + Particle::bundle_state_ptrs_index(acc, nullptr, type_j, status_j, particle_j, statedim); double* mod_acc_j = nullptr; - if (status_j == Particle::Status::Owned) - mod_acc_j = container_j->try_get_ptr_to_state_writable( - Particle::State::ModifiedAcceleration, particle_j); + if (status_j == ParticleStatus::Owned) + mod_acc_j = Particle::bundle_state_ptrs_index( + mod_acc, nullptr, type_j, status_j, particle_j, statedim); // evaluate specific coefficient double speccoeff_ij(0.0); @@ -385,6 +393,33 @@ void Particle::SPHMomentum::momentum_equation_particle_boundary_contribution() c neighborpairs_->get_relevant_particle_pair_indices_for_disjoint_combination( intfluidtypes_, boundarytypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& press = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Pressure); + ConstParticleContainerBundleStatePtrs& bpress = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::BoundaryPressure, boundarytypes_); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& bvel = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::BoundaryVelocity, boundarytypes_); + ConstParticleContainerBundleStatePtrs& mod_vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::ModifiedVelocity); + ParticleContainerBundleStatePtrs& acc = particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::Acceleration, ParticleStatus::Owned); + ParticleContainerBundleStatePtrs& mod_acc = + particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::ModifiedAcceleration, ParticleStatus::Owned); + ParticleContainerBundleStatePtrs& force = + particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::Force, ParticleStatus::Owned); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -392,13 +427,13 @@ void Particle::SPHMomentum::momentum_equation_particle_boundary_contribution() c neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; @@ -421,13 +456,6 @@ void Particle::SPHMomentum::momentum_equation_particle_boundary_contribution() c // first derivative of kernel const double dWdrij = (swapparticles) ? particlepair.dWdrji_ : particlepair.dWdrij_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get material for particle types const Mat::PAR::ParticleMaterialSPHFluid* material_i = fluidmaterial_[static_cast(type_i)]; @@ -436,38 +464,36 @@ void Particle::SPHMomentum::momentum_equation_particle_boundary_contribution() c equationofstatebundle_->get_ptr_to_specific_equation_of_state(type_i); // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - const double* press_i = container_i->get_ptr_to_state(Particle::State::Pressure, particle_i); - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); - - double* acc_i = nullptr; - if (status_i == Particle::Status::Owned) - acc_i = container_i->get_ptr_to_state_writable(Particle::State::Acceleration, particle_i); - + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + const double* press_i = Particle::bundle_state_ptrs_index(press, type_i, status_i, particle_i); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); const double* mod_vel_i = - container_i->try_get_ptr_to_state(Particle::State::ModifiedVelocity, particle_i); - + Particle::bundle_state_ptrs_index(mod_vel, nullptr, type_i, status_i, particle_i, statedim); + double* acc_i = nullptr; + if (status_i == ParticleStatus::Owned) + acc_i = Particle::bundle_state_ptrs_index(acc, type_i, status_i, particle_i, statedim); double* mod_acc_i = nullptr; - if (status_i == Particle::Status::Owned) - mod_acc_i = container_i->try_get_ptr_to_state_writable( - Particle::State::ModifiedAcceleration, particle_i); + if (status_i == ParticleStatus::Owned) + mod_acc_i = Particle::bundle_state_ptrs_index( + mod_acc, nullptr, type_i, status_i, particle_i, statedim); // get pointer to boundary particle states - const double* mass_j = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* press_j = - container_j->get_ptr_to_state(Particle::State::BoundaryPressure, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* press_j = Particle::bundle_state_ptrs_index(bpress, type_j, status_j, particle_j); const double* vel_j = - container_j->get_ptr_to_state(Particle::State::BoundaryVelocity, particle_j); + Particle::bundle_state_ptrs_index(bvel, type_j, status_j, particle_j, statedim); double temp_dens(0.0); temp_dens = equationofstate_i->pressure_to_density(press_j[0], material_i->initDensity_); const double* dens_j = &temp_dens; double* force_j = nullptr; - if (status_j == Particle::Status::Owned) - force_j = container_j->try_get_ptr_to_state_writable(Particle::State::Force, particle_j); + if (status_j == ParticleStatus::Owned) + force_j = + Particle::bundle_state_ptrs_index(force, nullptr, type_j, status_j, particle_j, statedim); // contribution from neighboring boundary particle j double acc_ij[3] = {0.0, 0.0, 0.0}; @@ -604,21 +630,38 @@ void Particle::SPHMomentum::momentum_equation_particle_wall_contribution() const std::vector relindices; neighborpairs_->get_relevant_particle_wall_pair_indices(intfluidtypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& press = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Pressure); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& mod_vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::ModifiedVelocity); + ParticleContainerBundleStatePtrs& acc = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Acceleration); + ParticleContainerBundleStatePtrs& mod_acc = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::ModifiedAcceleration); + // iterate over relevant particle-wall pairs for (const int particlewallpairindex : relindices) { const SPHParticleWallPair& particlewallpair = particlewallpairdata[particlewallpairindex]; // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlewallpair.tuple_i_; - // get corresponding particle container - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - // get material for particle types const Mat::PAR::ParticleMaterialSPHFluid* material_i = fluidmaterial_[static_cast(type_i)]; @@ -627,19 +670,19 @@ void Particle::SPHMomentum::momentum_equation_particle_wall_contribution() const equationofstatebundle_->get_ptr_to_specific_equation_of_state(type_i); // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - const double* press_i = container_i->get_ptr_to_state(Particle::State::Pressure, particle_i); - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); - double* acc_i = - container_i->get_ptr_to_state_writable(Particle::State::Acceleration, particle_i); - + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + const double* press_i = Particle::bundle_state_ptrs_index(press, type_i, status_i, particle_i); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); const double* mod_vel_i = - container_i->try_get_ptr_to_state(Particle::State::ModifiedVelocity, particle_i); - double* mod_acc_i = container_i->try_get_ptr_to_state_writable( - Particle::State::ModifiedAcceleration, particle_i); + Particle::bundle_state_ptrs_index(mod_vel, nullptr, type_i, status_i, particle_i, statedim); + double* acc_i = Particle::bundle_state_ptrs_index(acc, type_i, status_i, particle_i, statedim); + double* mod_acc_i = + Particle::bundle_state_ptrs_index(mod_acc, nullptr, type_i, status_i, particle_i, statedim); // get pointer to column wall element Core::Elements::Element* ele = particlewallpair.ele_; @@ -727,7 +770,8 @@ void Particle::SPHMomentum::momentum_equation_particle_wall_contribution() const ParticleUtils::vec_sub(r_kl_weighted, r_jk); // get pointer to virtual particle states - const double* mass_k = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); + const double* mass_k = + Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); const double temp_press_k = weightedpressure[particlewallpairindex] + ParticleUtils::vec_dot(r_kl_weighted, diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_momentum.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_momentum.hpp index 45d59731d1..f2ef257479 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_momentum.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_momentum.hpp @@ -78,7 +78,7 @@ namespace Particle //! insert momentum evaluation dependent states void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const; + std::map>& particlestatestotypes) const; //! add momentum contribution to acceleration field void add_acceleration_contribution() const; @@ -151,16 +151,16 @@ namespace Particle const double reduced_dimension_scale_factor_; //! set of all fluid particle types - std::set allfluidtypes_; + std::set allfluidtypes_; //! set of integrated fluid particle types - std::set intfluidtypes_; + std::set intfluidtypes_; //! set of pure fluid particle types - std::set purefluidtypes_; + std::set purefluidtypes_; //! set of boundary particle types - std::set boundarytypes_; + std::set boundarytypes_; }; } // namespace Particle diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_neighbor_pairs.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_neighbor_pairs.cpp index fc865366f8..b91da1b19f 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_neighbor_pairs.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_neighbor_pairs.cpp @@ -57,7 +57,7 @@ void Particle::SPHNeighborPairs::setup( } void Particle::SPHNeighborPairs::get_relevant_particle_pair_indices_for_disjoint_combination( - const std::set& types_a, const std::set& types_b, + const std::set& types_a, const std::set& types_b, std::vector& relindices) const { #ifdef FOUR_C_ENABLE_ASSERTIONS @@ -80,7 +80,7 @@ void Particle::SPHNeighborPairs::get_relevant_particle_pair_indices_for_disjoint } void Particle::SPHNeighborPairs::get_relevant_particle_pair_indices_for_equal_combination( - const std::set& types_a, std::vector& relindices) const + const std::set& types_a, std::vector& relindices) const { #ifdef FOUR_C_ENABLE_ASSERTIONS if (relindices.size() != 0) FOUR_C_THROW("vector of relevant particle pair indices not cleared!"); @@ -94,7 +94,7 @@ void Particle::SPHNeighborPairs::get_relevant_particle_pair_indices_for_equal_co } void Particle::SPHNeighborPairs::get_relevant_particle_wall_pair_indices( - const std::set& types_a, std::vector& relindices) const + const std::set& types_a, std::vector& relindices) const { // iterate over particle types to consider for (const auto& type_i : types_a) @@ -126,36 +126,37 @@ void Particle::SPHNeighborPairs::evaluate_particle_pairs() // index of particle pairs int particlepairindex = 0; + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + // iterate over potential particle neighbors for (auto& potentialneighbors : particleengineinterface_->get_potential_particle_neighbors()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = potentialneighbors.first; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = potentialneighbors.second; - if (type_i == Particle::Type::BoundaryPhase and type_j == Particle::Type::BoundaryPhase) - continue; - - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); + if (type_i == ParticleType::BoundaryPhase and type_j == ParticleType::BoundaryPhase) continue; - // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + // get pointers to particle states + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); - const double* pos_j = container_j->get_ptr_to_state(Particle::State::Position, particle_j); - const double* rad_j = container_j->get_ptr_to_state(Particle::State::Radius, particle_j); + const double* pos_j = + Particle::bundle_state_ptrs_index(pos, type_j, status_j, particle_j, statedim); + const double* rad_j = Particle::bundle_state_ptrs_index(rad, type_j, status_j, particle_j); // vector from particle i to j double r_ji[3]; @@ -250,12 +251,19 @@ void Particle::SPHNeighborPairs::evaluate_particle_wall_pairs() // index of particle-wall pairs int particlewallpairindex = 0; + // get pointers to particle states + static int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Position); + // iterate over potential wall neighbors for (const auto& potentialneighbors : particlewallinterface_->get_potential_wall_neighbors()) { // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = potentialneighbors.first; @@ -267,11 +275,11 @@ void Particle::SPHNeighborPairs::evaluate_particle_wall_pairs() const int* globalid_i = container_i->get_ptr_to_global_id(particle_i); // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); // get position of particle i const Core::LinAlg::Matrix<3, 1> pos_i( - container_i->get_ptr_to_state(Particle::State::Position, particle_i)); + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim)); // get pointer to column wall element Core::Elements::Element* ele = potentialneighbors.second; @@ -355,17 +363,15 @@ void Particle::SPHNeighborPairs::evaluate_particle_wall_pairs() particlewallpairdata_[indexofparticlewallpairs[0].second].tuple_i_; // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = tuple_i; - // get corresponding particle container - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + // get pointer to particle state + const int type_i_idx = static_cast(type_i); + const int status_i_idx = static_cast(status_i); + const double* rad_i = &rad[type_i_idx][status_i_idx][particle_i]; // define tolerance dependent on the particle radius const double adaptedtol = 1.0e-7 * rad_i[0]; @@ -443,8 +449,8 @@ void Particle::SPHNeighborPairs::evaluate_particle_wall_pairs() for (auto& particlewallpair : particlewallpairdata_) { // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlewallpair.tuple_i_; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_neighbor_pairs.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_neighbor_pairs.hpp index a294ed3604..f838fb0d46 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_neighbor_pairs.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_neighbor_pairs.hpp @@ -71,16 +71,16 @@ namespace Particle //! get relevant particle pair indices for disjoint combination of particle types void get_relevant_particle_pair_indices_for_disjoint_combination( - const std::set& types_a, const std::set& types_b, + const std::set& types_a, const std::set& types_b, std::vector& relindices) const; //! get relevant particle pair indices for equal combination of particle types void get_relevant_particle_pair_indices_for_equal_combination( - const std::set& types_a, std::vector& relindices) const; + const std::set& types_a, std::vector& relindices) const; //! get relevant particle wall pair indices for specific particle types void get_relevant_particle_wall_pair_indices( - const std::set& types_a, std::vector& relindices) const; + const std::set& types_a, std::vector& relindices) const; //! evaluate neighbor pairs void evaluate_neighbor_pairs(); diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_open_boundary.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_open_boundary.cpp index 3e65a5bfaf..c73686ee58 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_open_boundary.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_open_boundary.cpp @@ -30,8 +30,8 @@ FOUR_C_NAMESPACE_OPEN Particle::SPHOpenBoundaryBase::SPHOpenBoundaryBase(double initialparticlespacing, int boundary_id) : initialparticlespacing_(initialparticlespacing), prescribedstatefunctid_(-1), - fluidphase_(Particle::Type::Phase1), - openboundaryphase_(Particle::Type::DirichletPhase), + fluidphase_(ParticleType::Phase1), + openboundaryphase_(ParticleType::DirichletPhase), boundary_id_(boundary_id) { // empty constructor @@ -94,18 +94,22 @@ void Particle::SPHOpenBoundaryBase::check_open_boundary_phase_change( // get container of owned particles of open boundary phase Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(openboundaryphase_, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(openboundaryphase_, ParticleStatus::Owned); + + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + const double* boundary_id = container_i->get_ptr_to_state(ParticleState::OpenBoundaryId); + double* pos = container_i->get_ptr_to_state_writable(ParticleState::Position); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { // get particle boundary id - const double* boundary_id_i = - container_i->get_ptr_to_state(Particle::State::OpenBoundaryId, particle_i); + const double* boundary_id_i = &boundary_id[particle_i]; if (static_cast(*boundary_id_i) != boundary_id_) continue; // get pointer to particle states - double* pos_i = container_i->get_ptr_to_state_writable(Particle::State::Position, particle_i); + double* pos_i = &pos[particle_i * statedim]; // compute distance of open boundary particle from plane std::vector temp(3); @@ -146,13 +150,16 @@ void Particle::SPHOpenBoundaryBase::check_open_boundary_phase_change( // get container of owned particles of fluid phase Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(fluidphase_, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(fluidphase_, ParticleStatus::Owned); + + // get pointer to particle state + pos = container_j->get_ptr_to_state_writable(ParticleState::Position); // iterate over particles in container for (int particle_j = 0; particle_j < container_j->particles_stored(); ++particle_j) { // get pointer to particle states - double* pos_j = container_j->get_ptr_to_state_writable(Particle::State::Position, particle_j); + double* pos_j = &pos[particle_j * statedim]; // compute distance of fluid particle from plane std::vector temp(3); @@ -225,8 +232,8 @@ Particle::SPHOpenBoundaryDirichlet::SPHOpenBoundaryDirichlet( "dimension (dim = {}) of plane point is not equal to 3!", planepoint_.size()); // init fluid phase and open boundary phase - fluidphase_ = Particle::Type::Phase1; - openboundaryphase_ = Particle::Type::DirichletPhase; + fluidphase_ = ParticleType::Phase1; + openboundaryphase_ = ParticleType::DirichletPhase; } void Particle::SPHOpenBoundaryDirichlet::setup( @@ -242,7 +249,7 @@ void Particle::SPHOpenBoundaryDirichlet::setup( // setup states of ghosted particles to refresh { - std::vector states{Particle::State::Density, Particle::State::Pressure}; + std::vector states{ParticleState::Density, ParticleState::Pressure}; statestorefresh_.push_back(std::make_pair(openboundaryphase_, states)); } @@ -252,7 +259,7 @@ void Particle::SPHOpenBoundaryDirichlet::prescribe_open_boundary_states(const do { // get container of owned particles of open boundary phase Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(openboundaryphase_, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(openboundaryphase_, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container_i->particles_stored(); @@ -269,17 +276,22 @@ void Particle::SPHOpenBoundaryDirichlet::prescribe_open_boundary_states(const do if (function.number_components() != 1) FOUR_C_THROW("dimension of function governing velocity condition is not one!"); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + const double* boundary_id = container_i->get_ptr_to_state(ParticleState::OpenBoundaryId); + const double* pos = container_i->get_ptr_to_state(ParticleState::Position); + double* vel = container_i->get_ptr_to_state_writable(ParticleState::Velocity); + // iterate over particles in container for (int particle_i = 0; particle_i < particlestored; ++particle_i) { // get particle boundary id - const double* boundary_id_i = - container_i->get_ptr_to_state(Particle::State::OpenBoundaryId, particle_i); + const double* boundary_id_i = &boundary_id[particle_i]; if (static_cast(*boundary_id_i) != boundary_id_) continue; // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - double* vel_i = container_i->get_ptr_to_state_writable(Particle::State::Velocity, particle_i); + const double* pos_i = &pos[particle_i * statedim]; + double* vel_i = &vel[particle_i * statedim]; // evaluate function to set velocity ParticleUtils::vec_set_scale( @@ -291,7 +303,7 @@ void Particle::SPHOpenBoundaryDirichlet::interpolate_open_boundary_states() { // get container of owned particles of open boundary phase Particle::ParticleContainer* container_k = - particlecontainerbundle_->get_specific_container(openboundaryphase_, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(openboundaryphase_, ParticleStatus::Owned); // get material for current particle type const Mat::PAR::ParticleMaterialBase* material_k = @@ -312,76 +324,90 @@ void Particle::SPHOpenBoundaryDirichlet::interpolate_open_boundary_states() neighborpairs_->get_relevant_particle_pair_indices_for_disjoint_combination( {openboundaryphase_}, {fluidphase_}, relindices); - // iterate over relevant particle pairs - for (const int particlepairindex : relindices) { - const SPHParticlePair& particlepair = - neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; - - // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; - int particle_i; - std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - - Particle::Type type_j; - Particle::Status status_j; - int particle_j; - std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); + // scoped to prevent memory space access conflicts + // get pointers to particle states + std::set types = {openboundaryphase_, fluidphase_}; + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass, types); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density, types); + ConstParticleContainerBundleStatePtrs& press = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Pressure, types); + + // iterate over relevant particle pairs + for (const int particlepairindex : relindices) + { + const SPHParticlePair& particlepair = + neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; - // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - const double* press_i = container_i->get_ptr_to_state(Particle::State::Pressure, particle_i); + // access values of local index tuples of particle i and j + ParticleType type_i; + ParticleStatus status_i; + int particle_i; + std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - // get pointer to particle states - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - const double* dens_j = container_j->get_ptr_to_state(Particle::State::Density, particle_j); - const double* press_j = container_j->get_ptr_to_state(Particle::State::Pressure, particle_j); + ParticleType type_j; + ParticleStatus status_j; + int particle_j; + std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // evaluate contribution of neighboring particle j - if (type_i == openboundaryphase_) - { - const double fac = mass_j[0] / dens_j[0] * particlepair.Wij_; - sumj_Vj_Wij[particle_i] += fac; - sumj_Vj_Wij_pj[particle_i] += fac * press_j[0]; - } + // get pointer to particle states + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + const double* press_i = + Particle::bundle_state_ptrs_index(press, type_i, status_i, particle_i); - // evaluate contribution of neighboring particle i - if (type_j == openboundaryphase_ and status_j == Particle::Status::Owned) - { - const double fac = mass_i[0] / dens_i[0] * particlepair.Wji_; - sumj_Vj_Wij[particle_j] += fac; - sumj_Vj_Wij_pj[particle_j] += fac * press_i[0]; + // get pointer to particle states + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index(dens, type_j, status_j, particle_j); + const double* press_j = + Particle::bundle_state_ptrs_index(press, type_j, status_j, particle_j); + + // evaluate contribution of neighboring particle j + if (type_i == openboundaryphase_) + { + const double fac = mass_j[0] / dens_j[0] * particlepair.Wij_; + sumj_Vj_Wij[particle_i] += fac; + sumj_Vj_Wij_pj[particle_i] += fac * press_j[0]; + } + + // evaluate contribution of neighboring particle i + if (type_j == openboundaryphase_ and status_j == ParticleStatus::Owned) + { + const double fac = mass_i[0] / dens_i[0] * particlepair.Wji_; + sumj_Vj_Wij[particle_j] += fac; + sumj_Vj_Wij_pj[particle_j] += fac * press_i[0]; + } } } - // iterate over particles in container - for (int particle_k = 0; particle_k < particlestored; ++particle_k) { - // get particle boundary id - const double* boundary_id_k = - container_k->get_ptr_to_state(Particle::State::OpenBoundaryId, particle_k); - if (static_cast(*boundary_id_k) != boundary_id_) continue; + // scoped to prevent memory space access conflicts + // get pointers to particle states + const double* boundary_id = container_k->get_ptr_to_state(ParticleState::OpenBoundaryId); + double* dens = container_k->get_ptr_to_state_writable(ParticleState::Density); + double* press = container_k->get_ptr_to_state_writable(ParticleState::Pressure); - // get pointer to particle states - double* dens_k = container_k->get_ptr_to_state_writable(Particle::State::Density, particle_k); - double* press_k = container_k->get_ptr_to_state_writable(Particle::State::Pressure, particle_k); + // iterate over particles in container + for (int particle_k = 0; particle_k < particlestored; ++particle_k) + { + // get particle boundary id + const double* boundary_id_k = &boundary_id[particle_k]; + if (static_cast(*boundary_id_k) != boundary_id_) continue; - // interpolate pressure - press_k[0] = (sumj_Vj_Wij[particle_k] > 0.0) - ? sumj_Vj_Wij_pj[particle_k] / sumj_Vj_Wij[particle_k] - : 0.0; + // get pointers to particle states + double* dens_k = &dens[particle_k]; + double* press_k = &press[particle_k]; - // compute density - dens_k[0] = equationofstate_k->pressure_to_density(press_k[0], material_k->initDensity_); + // interpolate pressure + press_k[0] = (sumj_Vj_Wij[particle_k] > 0.0) + ? sumj_Vj_Wij_pj[particle_k] / sumj_Vj_Wij[particle_k] + : 0.0; + + // compute density + dens_k[0] = equationofstate_k->pressure_to_density(press_k[0], material_k->initDensity_); + } } // refresh states of ghosted particles @@ -410,8 +436,8 @@ Particle::SPHOpenBoundaryNeumann::SPHOpenBoundaryNeumann( "dimension (dim = {}) of plane point is not equal to 3!", planepoint_.size()); // init fluid phase and open boundary phase - fluidphase_ = Particle::Type::Phase1; - openboundaryphase_ = Particle::Type::NeumannPhase; + fluidphase_ = ParticleType::Phase1; + openboundaryphase_ = ParticleType::NeumannPhase; } void Particle::SPHOpenBoundaryNeumann::setup( @@ -427,7 +453,7 @@ void Particle::SPHOpenBoundaryNeumann::setup( // setup states of ghosted particles to refresh { - std::vector states{Particle::State::Velocity}; + std::vector states{ParticleState::Velocity}; statestorefresh_.push_back(std::make_pair(openboundaryphase_, states)); } @@ -437,7 +463,7 @@ void Particle::SPHOpenBoundaryNeumann::prescribe_open_boundary_states(const doub { // get container of owned particles of open boundary phase Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(openboundaryphase_, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(openboundaryphase_, ParticleStatus::Owned); // get material for current particle type const Mat::PAR::ParticleMaterialBase* material_i = @@ -464,18 +490,22 @@ void Particle::SPHOpenBoundaryNeumann::prescribe_open_boundary_states(const doub if (function.number_components() != 1) FOUR_C_THROW("dimension of function governing pressure condition is not one!"); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + const double* boundary_id = container_i->get_ptr_to_state(ParticleState::OpenBoundaryId); + const double* pos = container_i->get_ptr_to_state(ParticleState::Position); + double* press = container_i->get_ptr_to_state_writable(ParticleState::Pressure); + // iterate over particles in container for (int particle_i = 0; particle_i < particlestored; ++particle_i) { // get particle boundary id - const double* boundary_id_i = - container_i->get_ptr_to_state(Particle::State::OpenBoundaryId, particle_i); + const double* boundary_id_i = &boundary_id[particle_i]; if (static_cast(*boundary_id_i) != boundary_id_) continue; // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - double* press_i = - container_i->get_ptr_to_state_writable(Particle::State::Pressure, particle_i); + const double* pos_i = &pos[particle_i * statedim]; + double* press_i = &press[particle_i]; // evaluate function to set pressure press_i[0] = function.evaluate(std::span(pos_i, 3), evaltime, 0); @@ -484,20 +514,24 @@ void Particle::SPHOpenBoundaryNeumann::prescribe_open_boundary_states(const doub else { // clear pressure state - container_i->clear_state(Particle::State::Pressure); + container_i->clear_state(ParticleState::Pressure); } + // get pointers to particle states + const double* boundary_id = container_i->get_ptr_to_state(ParticleState::OpenBoundaryId); + const double* press = container_i->get_ptr_to_state(ParticleState::Pressure); + double* dens = container_i->get_ptr_to_state_writable(ParticleState::Density); + // iterate over particles in container for (int particle_i = 0; particle_i < particlestored; ++particle_i) { // get particle boundary id - const double* boundary_id_i = - container_i->get_ptr_to_state(Particle::State::OpenBoundaryId, particle_i); + const double* boundary_id_i = &boundary_id[particle_i]; if (static_cast(*boundary_id_i) != boundary_id_) continue; - // get pointer to particle states - const double* press_i = container_i->get_ptr_to_state(Particle::State::Pressure, particle_i); - double* dens_i = container_i->get_ptr_to_state_writable(Particle::State::Density, particle_i); + // get pointers to particle states + const double* press_i = &press[particle_i]; + double* dens_i = &dens[particle_i]; // compute density dens_i[0] = equationofstate_i->pressure_to_density(press_i[0], material_i->initDensity_); diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_open_boundary.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_open_boundary.hpp index 5544a512da..d069351770 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_open_boundary.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_open_boundary.hpp @@ -102,10 +102,10 @@ namespace Particle std::vector planepoint_; //! fluid phase - Particle::Type fluidphase_; + ParticleType fluidphase_; //! open boundary phase - Particle::Type openboundaryphase_; + ParticleType openboundaryphase_; //! boundary id int boundary_id_; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_peridynamic.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_peridynamic.cpp index 36f78fa847..90fd5ca158 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_peridynamic.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_peridynamic.cpp @@ -161,21 +161,21 @@ void Particle::SPHPeridynamic::setup( } void Particle::SPHPeridynamic::insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const + std::map>& particlestatestotypes) const { // iterate over particle types for (auto& typeIt : particlestatestotypes) { - if (typeIt.first == Particle::Type::PDPhase) + if (typeIt.first == ParticleType::PDPhase) { // set of particle states for current particle type - std::set& particlestates = typeIt.second; + std::set& particlestates = typeIt.second; // set temperature state - particlestates.insert({Particle::State::Force, Particle::State::PDBodyId, - Particle::State::ReferencePosition, Particle::State::Young, - Particle::State::CriticalStretch, Particle::State::InitialConnectedBonds, - Particle::State::CurrentConnectedBonds, Particle::State::PDDamageVariable}); + particlestates.insert({ParticleState::Force, ParticleState::PDBodyId, + ParticleState::ReferencePosition, ParticleState::Young, ParticleState::CriticalStretch, + ParticleState::InitialConnectedBonds, ParticleState::CurrentConnectedBonds, + ParticleState::PDDamageVariable}); } } } @@ -185,7 +185,7 @@ void Particle::SPHPeridynamic::init_peridynamic_bondlist() #ifdef FOUR_C_ENABLE_ASSERTIONS // get material for peridynamic phase const Mat::PAR::ParticleMaterialBase* material = - particlematerial_->get_ptr_to_particle_mat_parameter(Particle::Type::PDPhase); + particlematerial_->get_ptr_to_particle_mat_parameter(ParticleType::PDPhase); // (initial) radius of current phase const double initradius = material->initRadius_; @@ -194,23 +194,35 @@ void Particle::SPHPeridynamic::init_peridynamic_bondlist() // important: bin size must be large enough to cover at least peridynamic horizon const Particle::ParticleContainerBundleShrdPtr particlecontainerbundle = particleengineinterface_->get_particle_container_bundle(); + + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle->try_get_ptrs_to_state(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& pdbodyid = + particlecontainerbundle->try_get_ptrs_to_state(ParticleState::PDBodyId); + ParticleContainerBundleStatePtrs& initialconnectedbonds = + particlecontainerbundle->try_get_ptrs_to_state_writable(ParticleState::InitialConnectedBonds); + ParticleContainerBundleStatePtrs& currentconnectedbonds = + particlecontainerbundle->try_get_ptrs_to_state_writable(ParticleState::CurrentConnectedBonds); + // iterate over potential particle neighbors for (const auto& potentialneighbors : particleengineinterface_->get_potential_particle_neighbors()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = potentialneighbors.first; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = potentialneighbors.second; // only peridynamic phase particles can undergo peridynamic interaction - if (type_i != Particle::Type::PDPhase || type_j != Particle::Type::PDPhase) continue; + if (type_i != ParticleType::PDPhase || type_j != ParticleType::PDPhase) continue; // get corresponding particle containers Particle::ParticleContainer* container_i = @@ -218,20 +230,25 @@ void Particle::SPHPeridynamic::init_peridynamic_bondlist() Particle::ParticleContainer* container_j = particlecontainerbundle->get_specific_container(type_j, status_j); - // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - const double* pdbodyid_i = container_i->get_ptr_to_state(Particle::State::PDBodyId, particle_i); + + // get pointers to particle states + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + const double* pdbodyid_i = + Particle::bundle_state_ptrs_index(pdbodyid, type_i, status_i, particle_i); double* initialconnectedbonds_i = - container_i->get_ptr_to_state_writable(Particle::State::InitialConnectedBonds, particle_i); + Particle::bundle_state_ptrs_index(initialconnectedbonds, type_i, status_i, particle_i); double* currentconnectedbonds_i = - container_i->get_ptr_to_state_writable(Particle::State::CurrentConnectedBonds, particle_i); + Particle::bundle_state_ptrs_index(currentconnectedbonds, type_i, status_i, particle_i); - const double* pos_j = container_j->get_ptr_to_state(Particle::State::Position, particle_j); - const double* pdbodyid_j = container_j->get_ptr_to_state(Particle::State::PDBodyId, particle_j); + const double* pos_j = + Particle::bundle_state_ptrs_index(pos, type_j, status_j, particle_j, statedim); + const double* pdbodyid_j = + Particle::bundle_state_ptrs_index(pdbodyid, type_j, status_j, particle_j); double* initialconnectedbonds_j = - container_j->get_ptr_to_state_writable(Particle::State::InitialConnectedBonds, particle_j); + Particle::bundle_state_ptrs_index(initialconnectedbonds, type_j, status_j, particle_j); double* currentconnectedbonds_j = - container_j->get_ptr_to_state_writable(Particle::State::CurrentConnectedBonds, particle_j); + Particle::bundle_state_ptrs_index(currentconnectedbonds, type_j, status_j, particle_j); // vector from particle i to j double r_ji[3]; @@ -296,8 +313,8 @@ void Particle::SPHPeridynamic::add_acceleration_contribution() const // clear force of peridynamic phase particles Particle::ParticleContainer* container = particleengineinterface_->get_particle_container_bundle()->get_specific_container( - Particle::Type::PDPhase, Particle::Status::Owned); - container->clear_state(Particle::State::Force); + ParticleType::PDPhase, ParticleStatus::Owned); + container->clear_state(ParticleState::Force); } void Particle::SPHPeridynamic::compute_interaction_forces() const @@ -305,50 +322,60 @@ void Particle::SPHPeridynamic::compute_interaction_forces() const const Particle::ParticleContainerBundleShrdPtr particlecontainerbundle = particleengineinterface_->get_particle_container_bundle(); + // get pointer to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& ref_pos = + particlecontainerbundle->try_get_ptrs_to_state(ParticleState::ReferencePosition); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle->try_get_ptrs_to_state(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& young = + particlecontainerbundle->try_get_ptrs_to_state(ParticleState::Young); + ConstParticleContainerBundleStatePtrs& critical_stretch = + particlecontainerbundle->try_get_ptrs_to_state(ParticleState::CriticalStretch); + ParticleContainerBundleStatePtrs& force = + particlecontainerbundle->try_get_ptrs_to_state_writable(ParticleState::Force); + ParticleContainerBundleStatePtrs& currentconnectedbonds = + particlecontainerbundle->try_get_ptrs_to_state_writable(ParticleState::CurrentConnectedBonds); + size_t iter = 0; while (iter < bondlist_->size()) { const auto& particlepair = (*bondlist_)[iter]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i, globalid_i; std::tie(type_i, status_i, particle_i, globalid_i) = particlepair.first; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j, globalid_j; std::tie(type_j, status_j, particle_j, globalid_j) = particlepair.second; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle->get_specific_container(type_j, status_j); - - // get pointer to particle states + // get pointers to particle states const double* ref_pos_i = - container_i->get_ptr_to_state(Particle::State::ReferencePosition, particle_i); - - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - const double* young_i = container_i->get_ptr_to_state(Particle::State::Young, particle_i); + Particle::bundle_state_ptrs_index(ref_pos, type_i, status_i, particle_i, statedim); + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + const double* young_i = Particle::bundle_state_ptrs_index(young, type_i, status_i, particle_i); double* force_i = - container_i->try_get_ptr_to_state_writable(Particle::State::Force, particle_i); + Particle::bundle_state_ptrs_index(force, nullptr, type_i, status_i, particle_i, statedim); const double* critical_stretch_i = - container_i->get_ptr_to_state(Particle::State::CriticalStretch, particle_i); + Particle::bundle_state_ptrs_index(critical_stretch, type_i, status_i, particle_i); const double* ref_pos_j = - container_j->get_ptr_to_state(Particle::State::ReferencePosition, particle_j); - const double* pos_j = container_j->get_ptr_to_state(Particle::State::Position, particle_j); - const double* young_j = container_j->get_ptr_to_state(Particle::State::Young, particle_j); + Particle::bundle_state_ptrs_index(ref_pos, type_j, status_j, particle_j, statedim); + const double* pos_j = + Particle::bundle_state_ptrs_index(pos, type_j, status_j, particle_j, statedim); + const double* young_j = Particle::bundle_state_ptrs_index(young, type_j, status_j, particle_j); double* force_j = nullptr; - if (status_j == Particle::Status::Owned) - force_j = container_j->get_ptr_to_state_writable(Particle::State::Force, particle_j); - + if (status_j == ParticleStatus::Owned) + force_j = + Particle::bundle_state_ptrs_index(force, nullptr, type_j, status_j, particle_j, statedim); const double* critical_stretch_j = - container_j->get_ptr_to_state(Particle::State::CriticalStretch, particle_j); + Particle::bundle_state_ptrs_index(critical_stretch, type_j, status_j, particle_j); + // calculate the bond between two particles double xi[3]; ParticleUtils::vec_set(xi, ref_pos_j); @@ -407,10 +434,10 @@ void Particle::SPHPeridynamic::compute_interaction_forces() const } else { - double* currentconnectedbonds_i = container_i->get_ptr_to_state_writable( - Particle::State::CurrentConnectedBonds, particle_i); - double* currentconnectedbonds_j = container_j->get_ptr_to_state_writable( - Particle::State::CurrentConnectedBonds, particle_j); + double* currentconnectedbonds_i = + Particle::bundle_state_ptrs_index(currentconnectedbonds, type_i, status_i, particle_i); + double* currentconnectedbonds_j = + Particle::bundle_state_ptrs_index(currentconnectedbonds, type_j, status_j, particle_j); currentconnectedbonds_i[0] -= 1.0; currentconnectedbonds_j[0] -= 1.0; @@ -424,37 +451,36 @@ void Particle::SPHPeridynamic::compute_interaction_forces() const if (!pd_neighbor_pairs.empty()) Core::IO::cout << "Number of pd_neighbor_pairs in peridynamic evaluation on this proc: " << pd_neighbor_pairs.size() << Core::IO::endl; + + // get pointer to particle states + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle->try_get_ptrs_to_state(ParticleState::Velocity); + for (const auto& particlepair : pd_neighbor_pairs) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle->get_specific_container(type_j, status_j); - // get pointer to particle states - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); double* force_i = - container_i->try_get_ptr_to_state_writable(Particle::State::Force, particle_i); - - // get pointer to particle states - const double* vel_j = container_j->get_ptr_to_state(Particle::State::Velocity, particle_j); + Particle::bundle_state_ptrs_index(force, nullptr, type_i, status_i, particle_i, statedim); + const double* vel_j = + Particle::bundle_state_ptrs_index(vel, type_j, status_j, particle_j, statedim); double* force_j = nullptr; - if (status_j == Particle::Status::Owned) - force_j = container_j->try_get_ptr_to_state_writable(Particle::State::Force, particle_j); + if (status_j == ParticleStatus::Owned) + force_j = + Particle::bundle_state_ptrs_index(force, nullptr, type_j, status_j, particle_j, statedim); // compute normal gap and rate of normal gap const double gap = particlepair.gap_; @@ -476,7 +502,7 @@ void Particle::SPHPeridynamic::compute_acceleration() const // get container of owned particles of current particle type Particle::ParticleContainer* container = particlecontainerbundle_->get_specific_container( - Particle::Type::PDPhase, Particle::Status::Owned); + ParticleType::PDPhase, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container->particles_stored(); @@ -485,16 +511,15 @@ void Particle::SPHPeridynamic::compute_acceleration() const if (particlestored <= 0) return; // get particle state dimension - const int statedim = container->get_state_dim(Particle::State::Acceleration); + const int statedim = container->get_state_dim(ParticleState::Acceleration); // get pointer to particle states - const double* radius = container->get_ptr_to_state(Particle::State::Radius, 0); - const double* mass = container->get_ptr_to_state(Particle::State::Mass, 0); - const double* force = container->get_ptr_to_state(Particle::State::Force, 0); - const double* moment = container->try_get_ptr_to_state(Particle::State::Moment, 0); - double* acc = container->get_ptr_to_state_writable(Particle::State::Acceleration, 0); - double* angacc = - container->try_get_ptr_to_state_writable(Particle::State::AngularAcceleration, 0); + const double* radius = container->get_ptr_to_state(ParticleState::Radius); + const double* mass = container->get_ptr_to_state(ParticleState::Mass); + const double* force = container->get_ptr_to_state(ParticleState::Force); + const double* moment = container->try_get_ptr_to_state(ParticleState::Moment); + double* acc = container->get_ptr_to_state_writable(ParticleState::Acceleration); + double* angacc = container->try_get_ptr_to_state_writable(ParticleState::AngularAcceleration); // compute acceleration for (int i = 0; i < particlestored; ++i) @@ -517,20 +542,22 @@ void Particle::SPHPeridynamic::damage_evaluation() Particle::ParticleContainerBundleShrdPtr particlecontainerbundle = particleengineinterface_->get_particle_container_bundle(); // get container of owned particles of peridynamic phase - Particle::ParticleContainer* container = particlecontainerbundle->get_specific_container( - Particle::Type::PDPhase, Particle::Status::Owned); + Particle::ParticleContainer* container = + particlecontainerbundle->get_specific_container(ParticleType::PDPhase, ParticleStatus::Owned); + + // get pointers to particle states + const double* initialconnectedbonds = + container->get_ptr_to_state(ParticleState::InitialConnectedBonds); + const double* currentconnectedbonds = + container->get_ptr_to_state(ParticleState::CurrentConnectedBonds); + double* pddamagevariable = container->get_ptr_to_state_writable(ParticleState::PDDamageVariable); // loop over particles in container for (int particle_i = 0; particle_i < container->particles_stored(); ++particle_i) { - const double* initialconnectedbonds_i = - container->get_ptr_to_state(Particle::State::InitialConnectedBonds, particle_i); - - const double* currentconnectedbonds_i = - container->get_ptr_to_state(Particle::State::CurrentConnectedBonds, particle_i); - - double* pddamagevariable_i = - container->get_ptr_to_state_writable(Particle::State::PDDamageVariable, particle_i); + const double* initialconnectedbonds_i = &initialconnectedbonds[particle_i]; + const double* currentconnectedbonds_i = ¤tconnectedbonds[particle_i]; + double* pddamagevariable_i = &pddamagevariable[particle_i]; pddamagevariable_i[0] = 1.0 - currentconnectedbonds_i[0] / initialconnectedbonds_i[0]; } diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_peridynamic.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_peridynamic.hpp index d614cd58c2..38b89939a6 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_peridynamic.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_peridynamic.hpp @@ -53,7 +53,7 @@ namespace Particle //! insert peridynamic evaluation dependent states void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const; + std::map>& particlestatestotypes) const; //! setup peridynamic bond list void init_peridynamic_bondlist(); diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_phase_change.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_phase_change.cpp index 8430e1a776..9b6c29c6de 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_phase_change.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_phase_change.cpp @@ -24,9 +24,9 @@ FOUR_C_NAMESPACE_OPEN *---------------------------------------------------------------------------*/ Particle::SPHPhaseChangeBase::SPHPhaseChangeBase(const Teuchos::ParameterList& params) : params_sph_(params), - belowphase_(Particle::Type::Phase1), - abovephase_(Particle::Type::Phase2), - transitionstate_(Particle::State::Density), + belowphase_(ParticleType::Phase1), + abovephase_(ParticleType::Phase2), + transitionstate_(ParticleState::Density), transitionvalue_(0.0), hysteresisgap_(0.0) { @@ -134,18 +134,18 @@ void Particle::SPHPhaseChangeBase::evaluate_phase_change_from_below_to_above_pha std::vector>>& particlestoinsert) const { // set source and target type of particles - Particle::Type type_source = belowphase_; - Particle::Type type_target = abovephase_; + ParticleType type_source = belowphase_; + ParticleType type_target = abovephase_; // check for boundary or rigid particles bool isboundaryrigid_source = - (type_source == Particle::Type::BoundaryPhase or type_source == Particle::Type::RigidPhase); + (type_source == ParticleType::BoundaryPhase or type_source == ParticleType::RigidPhase); bool isboundaryrigid_target = - (type_target == Particle::Type::BoundaryPhase or type_target == Particle::Type::RigidPhase); + (type_target == ParticleType::BoundaryPhase or type_target == ParticleType::RigidPhase); // get container of owned particles of source particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_source, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_source, ParticleStatus::Owned); // get number of particles stored in container int particlestored = container->particles_stored(); @@ -154,7 +154,7 @@ void Particle::SPHPhaseChangeBase::evaluate_phase_change_from_below_to_above_pha if (particlestored <= 0) return; // get pointer to particle state - const double* state = container->get_ptr_to_state(transitionstate_, 0); + const double* state = container->get_ptr_to_state(transitionstate_); // get material for particle types const Mat::PAR::ParticleMaterialBase* material_source = @@ -181,20 +181,20 @@ void Particle::SPHPhaseChangeBase::evaluate_phase_change_from_below_to_above_pha // add density and pressure state for boundary or rigid particles if (isboundaryrigid_source and (not isboundaryrigid_target)) { - particlestates[static_cast(Particle::State::Density)].assign( + particlestates[static_cast(ParticleState::Density)].assign( 1, material_source->initDensity_); const double press = equationofstate_target->density_to_pressure( material_source->initDensity_, material_target->initDensity_); - particlestates[static_cast(Particle::State::Pressure)].assign(1, press); + particlestates[static_cast(ParticleState::Pressure)].assign(1, press); } // clear velocity and acceleration state of boundary or rigid particles if (isboundaryrigid_target and (not isboundaryrigid_source)) { - particlestates[static_cast(Particle::State::Velocity)].assign(3, 0.0); - particlestates[static_cast(Particle::State::Acceleration)].assign(3, 0.0); + particlestates[static_cast(ParticleState::Velocity)].assign(3, 0.0); + particlestates[static_cast(ParticleState::Acceleration)].assign(3, 0.0); } Particle::ParticleObjShrdPtr particleobject = @@ -219,18 +219,18 @@ void Particle::SPHPhaseChangeBase::evaluate_phase_change_from_above_to_below_pha std::vector>>& particlestoinsert) const { // set source and target type of particles - Particle::Type type_source = abovephase_; - Particle::Type type_target = belowphase_; + ParticleType type_source = abovephase_; + ParticleType type_target = belowphase_; // check for boundary or rigid particles bool isboundaryrigid_source = - (type_source == Particle::Type::BoundaryPhase or type_source == Particle::Type::RigidPhase); + (type_source == ParticleType::BoundaryPhase or type_source == ParticleType::RigidPhase); bool isboundaryrigid_target = - (type_target == Particle::Type::BoundaryPhase or type_target == Particle::Type::RigidPhase); + (type_target == ParticleType::BoundaryPhase or type_target == ParticleType::RigidPhase); // get container of owned particles of source particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_source, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_source, ParticleStatus::Owned); // get number of particles stored in container int particlestored = container->particles_stored(); @@ -239,7 +239,7 @@ void Particle::SPHPhaseChangeBase::evaluate_phase_change_from_above_to_below_pha if (particlestored <= 0) return; // get pointer to particle state - const double* state = container->get_ptr_to_state(transitionstate_, 0); + const double* state = container->get_ptr_to_state(transitionstate_); // get material for particle types const Mat::PAR::ParticleMaterialBase* material_source = @@ -266,20 +266,20 @@ void Particle::SPHPhaseChangeBase::evaluate_phase_change_from_above_to_below_pha // add density and pressure state for boundary or rigid particles if (isboundaryrigid_source and (not isboundaryrigid_target)) { - particlestates[static_cast(Particle::State::Density)].assign( + particlestates[static_cast(ParticleState::Density)].assign( 1, material_source->initDensity_); const double press = equationofstate_target->density_to_pressure( material_source->initDensity_, material_target->initDensity_); - particlestates[static_cast(Particle::State::Pressure)].assign(1, press); + particlestates[static_cast(ParticleState::Pressure)].assign(1, press); } // clear velocity and acceleration state of boundary or rigid particles if (isboundaryrigid_target and (not isboundaryrigid_source)) { - particlestates[static_cast(Particle::State::Velocity)].assign(3, 0.0); - particlestates[static_cast(Particle::State::Acceleration)].assign(3, 0.0); + particlestates[static_cast(ParticleState::Velocity)].assign(3, 0.0); + particlestates[static_cast(ParticleState::Acceleration)].assign(3, 0.0); } Particle::ParticleObjShrdPtr particleobject = diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_phase_change.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_phase_change.hpp index 9fd374a0bd..a76634f40e 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_phase_change.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_phase_change.hpp @@ -88,13 +88,13 @@ namespace Particle std::shared_ptr equationofstatebundle_; //! phase below transition value - Particle::Type belowphase_; + ParticleType belowphase_; //! phase above transition value - Particle::Type abovephase_; + ParticleType abovephase_; //! transition state of phase change - Particle::State transitionstate_; + ParticleState transitionstate_; //! transition value of phase change double transitionvalue_; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_pressure.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_pressure.cpp index fe630bbdee..154fa92f88 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_pressure.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_pressure.cpp @@ -18,7 +18,7 @@ FOUR_C_NAMESPACE_OPEN -Particle::SPHPressure::SPHPressure() : fluidtypes_({Particle::Type::Phase1, Particle::Type::Phase2}) +Particle::SPHPressure::SPHPressure() : fluidtypes_({ParticleType::Phase1, ParticleType::Phase2}) { // empty constructor } @@ -48,7 +48,7 @@ void Particle::SPHPressure::setup( // setup pressure of ghosted particles to refresh { - std::vector states{Particle::State::Pressure}; + std::vector states{ParticleState::Pressure}; for (const auto& type_i : fluidtypes_) pressuretorefresh_.push_back(std::make_pair(type_i, states)); @@ -64,7 +64,7 @@ void Particle::SPHPressure::compute_pressure() const { // get container of owned particles of current particle type Particle::ParticleContainer* container = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // get number of particles stored in container const int particlestored = container->particles_stored(); @@ -72,9 +72,9 @@ void Particle::SPHPressure::compute_pressure() const // no owned particles of current particle type if (particlestored <= 0) continue; - // get pointer to particle state - const double* dens = container->get_ptr_to_state(Particle::State::Density, 0); - double* press = container->get_ptr_to_state_writable(Particle::State::Pressure, 0); + // get pointers to particle states + const double* dens = container->get_ptr_to_state(ParticleState::Density); + double* press = container->get_ptr_to_state_writable(ParticleState::Pressure); // get material for current particle type const Mat::PAR::ParticleMaterialBase* material = diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_pressure.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_pressure.hpp index 2692e88c80..9b06b7ca41 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_pressure.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_pressure.hpp @@ -65,7 +65,7 @@ namespace Particle Particle::StatesOfTypesToRefresh pressuretorefresh_; //! set of fluid particle types - std::set fluidtypes_; + std::set fluidtypes_; }; } // namespace Particle diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_rigid_particle_contact.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_rigid_particle_contact.cpp index 7fa16255e1..47488ab07a 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_rigid_particle_contact.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_rigid_particle_contact.cpp @@ -32,7 +32,7 @@ Particle::SPHRigidParticleContactBase::SPHRigidParticleContactBase( const Teuchos::ParameterList& params) : params_sph_(params), writeparticlewallinteraction_(params_sph_.get("WRITE_PARTICLE_WALL_INTERACTION")), - boundarytypes_({Particle::Type::BoundaryPhase, Particle::Type::RigidPhase}) + boundarytypes_({ParticleType::BoundaryPhase, ParticleType::RigidPhase}) { // empty constructor } @@ -68,7 +68,7 @@ void Particle::SPHRigidParticleContactBase::setup( boundarytypes_.erase(type_i); // safety check - if (not boundarytypes_.contains(Particle::Type::RigidPhase)) + if (not boundarytypes_.contains(ParticleType::RigidPhase)) FOUR_C_THROW("no rigid particles defined but a rigid particle contact formulation is set!"); } @@ -128,6 +128,13 @@ void Particle::SPHRigidParticleContactElastic::elastic_contact_particle_contribu neighborpairs_->get_relevant_particle_pair_indices_for_equal_combination( boundarytypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ParticleContainerBundleStatePtrs& force = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Force); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -138,34 +145,29 @@ void Particle::SPHRigidParticleContactElastic::elastic_contact_particle_contribu if (not(particlepair.absdist_ < initialparticlespacing)) continue; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - - // get pointer to particle states - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); + // get pointers to particle states + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); double* force_i = - container_i->try_get_ptr_to_state_writable(Particle::State::Force, particle_i); - - // get pointer to particle states - const double* vel_j = container_j->get_ptr_to_state(Particle::State::Velocity, particle_j); + Particle::bundle_state_ptrs_index(force, nullptr, type_i, status_i, particle_i, statedim); + // get pointers to particle states + const double* vel_j = + Particle::bundle_state_ptrs_index(vel, type_j, status_j, particle_j, statedim); double* force_j = nullptr; - if (status_j == Particle::Status::Owned) - force_j = container_j->try_get_ptr_to_state_writable(Particle::State::Force, particle_j); + if (status_j == ParticleStatus::Owned) + force_j = + Particle::bundle_state_ptrs_index(force, nullptr, type_j, status_j, particle_j, statedim); // compute normal gap and rate of normal gap const double gap = particlepair.absdist_ - initialparticlespacing; @@ -220,7 +222,17 @@ void Particle::SPHRigidParticleContactElastic::elastic_contact_particle_wall_con // get relevant particle wall pair indices for specific particle types std::vector relindices; - neighborpairs_->get_relevant_particle_wall_pair_indices({Particle::Type::RigidPhase}, relindices); + neighborpairs_->get_relevant_particle_wall_pair_indices({ParticleType::RigidPhase}, relindices); + + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + std::set types = {ParticleType::RigidPhase}; + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Position, types); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity, types); + ParticleContainerBundleStatePtrs& force = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Force, types); // iterate over relevant particle-wall pairs for (const int particlewallpairindex : relindices) @@ -231,20 +243,18 @@ void Particle::SPHRigidParticleContactElastic::elastic_contact_particle_wall_con if (not(particlewallpair.absdist_ < 0.5 * initialparticlespacing)) continue; // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlewallpair.tuple_i_; - // get corresponding particle container - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); + // get pointers to particle states + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); double* force_i = - container_i->try_get_ptr_to_state_writable(Particle::State::Force, particle_i); + Particle::bundle_state_ptrs_index(force, nullptr, type_i, status_i, particle_i, statedim); // get pointer to column wall element Core::Elements::Element* ele = particlewallpair.ele_; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_rigid_particle_contact.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_rigid_particle_contact.hpp index 859a543973..2c24f2bfd4 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_rigid_particle_contact.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_rigid_particle_contact.hpp @@ -83,7 +83,7 @@ namespace Particle const bool writeparticlewallinteraction_; //! set of boundary particle types - std::set boundarytypes_; + std::set boundarytypes_; }; class SPHRigidParticleContactElastic : public SPHRigidParticleContactBase diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension.cpp index 0865591561..16a1b0823e 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension.cpp @@ -34,11 +34,11 @@ FOUR_C_NAMESPACE_OPEN *---------------------------------------------------------------------------*/ Particle::SPHSurfaceTension::SPHSurfaceTension(const Teuchos::ParameterList& params) : params_sph_(params), - liquidtype_(Particle::Type::Phase1), - gastype_(Particle::Type::Phase2), + liquidtype_(ParticleType::Phase1), + gastype_(ParticleType::Phase2), fluidtypes_({liquidtype_, gastype_}), boundarytypes_( - {Particle::Type::BoundaryPhase, Particle::Type::RigidPhase, Particle::Type::PDPhase}), + {ParticleType::BoundaryPhase, ParticleType::RigidPhase, ParticleType::PDPhase}), time_(0.0), timerampfct_(params.get("SURFACETENSION_RAMP_FUNCT")), alpha0_(params_sph_.get("SURFACETENSIONCOEFFICIENT")), @@ -140,7 +140,7 @@ void Particle::SPHSurfaceTension::setup( // setup interface normal of ghosted particles to refresh { - std::vector states{Particle::State::InterfaceNormal}; + std::vector states{ParticleState::InterfaceNormal}; // iterate over fluid particle types for (const auto& type_i : fluidtypes_) @@ -154,7 +154,7 @@ void Particle::SPHSurfaceTension::set_current_time(const double currenttime) } void Particle::SPHSurfaceTension::insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const + std::map>& particlestatestotypes) const { bool haveboundarytypes = false; @@ -162,7 +162,7 @@ void Particle::SPHSurfaceTension::insert_particle_states_of_particle_types( for (auto& typeIt : particlestatestotypes) { // get type of particles - Particle::Type type = typeIt.first; + ParticleType type = typeIt.first; if (boundarytypes_.contains(type)) haveboundarytypes = true; } @@ -171,21 +171,20 @@ void Particle::SPHSurfaceTension::insert_particle_states_of_particle_types( for (auto& typeIt : particlestatestotypes) { // get type of particles - Particle::Type type = typeIt.first; + ParticleType type = typeIt.first; // set of particle states for current particle type - std::set& particlestates = typeIt.second; + std::set& particlestates = typeIt.second; // current particle type is not a fluid particle type if (not fluidtypes_.contains(type)) continue; // states for surface tension evaluation scheme - particlestates.insert({Particle::State::ColorfieldGradient, Particle::State::InterfaceNormal, - Particle::State::Curvature}); + particlestates.insert({ParticleState::ColorfieldGradient, ParticleState::InterfaceNormal, + ParticleState::Curvature}); if (haveboundarytypes) - particlestates.insert( - {Particle::State::WallColorfield, Particle::State::WallInterfaceNormal}); + particlestates.insert({ParticleState::WallColorfield, ParticleState::WallInterfaceNormal}); } } @@ -243,16 +242,25 @@ void Particle::SPHSurfaceTension::compute_colorfield_gradient() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // clear colorfield gradient state - container_i->clear_state(Particle::State::ColorfieldGradient); + container_i->clear_state(ParticleState::ColorfieldGradient); } // get relevant particle pair indices std::vector relindices; neighborpairs_->get_relevant_particle_pair_indices_for_equal_combination(fluidtypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ParticleContainerBundleStatePtrs& cfg = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::ColorfieldGradient); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -260,38 +268,29 @@ void Particle::SPHSurfaceTension::compute_colorfield_gradient() const neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; // no evaluation for particles of same type if (type_i == type_j) continue; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - - // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - double* cfg_i = - container_i->get_ptr_to_state_writable(Particle::State::ColorfieldGradient, particle_i); + // get pointers to particle states + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + double* cfg_i = Particle::bundle_state_ptrs_index(cfg, type_i, status_i, particle_i, statedim); - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - const double* dens_j = container_j->get_ptr_to_state(Particle::State::Density, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index(dens, type_j, status_j, particle_j); double* cfg_j = nullptr; - if (status_j == Particle::Status::Owned) - cfg_j = - container_j->get_ptr_to_state_writable(Particle::State::ColorfieldGradient, particle_j); + if (status_j == ParticleStatus::Owned) + cfg_j = Particle::bundle_state_ptrs_index(cfg, type_j, status_j, particle_j, statedim); // (current) volume of particle i and j const double V_i = mass_i[0] / dens_i[0]; @@ -314,16 +313,20 @@ void Particle::SPHSurfaceTension::compute_colorfield_gradient() const for (const auto& type_i : fluidtypes_) { // get container of owned particles of current particle type + const int type_i_idx = static_cast(type_i); + const int status_i_idx = static_cast(ParticleStatus::Owned); Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); + + // get pointer to particle state + auto rad = container_i->get_ptr_to_state(ParticleState::Radius); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { // get pointer to particle state - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - double* cfg_i = - container_i->get_ptr_to_state_writable(Particle::State::ColorfieldGradient, particle_i); + const double* rad_i = &rad[particle_i]; + double* cfg_i = &cfg[type_i_idx][status_i_idx][particle_i * statedim]; // norm of colorfield gradient const double cfg_i_norm = ParticleUtils::vec_norm_two(cfg_i); @@ -341,20 +344,24 @@ void Particle::SPHSurfaceTension::compute_interface_normal() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); + + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + const double* rad = container_i->get_ptr_to_state(ParticleState::Radius); + const double* cfg = container_i->get_ptr_to_state(ParticleState::ColorfieldGradient); + double* ifn = container_i->get_ptr_to_state_writable(ParticleState::InterfaceNormal); // clear interface normal state - container_i->clear_state(Particle::State::InterfaceNormal); + container_i->clear_state(ParticleState::InterfaceNormal); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* cfg_i = - container_i->get_ptr_to_state(Particle::State::ColorfieldGradient, particle_i); - double* ifn_i = - container_i->get_ptr_to_state_writable(Particle::State::InterfaceNormal, particle_i); + const double* rad_i = &rad[particle_i]; + const double* cfg_i = &cfg[particle_i * statedim]; + double* ifn_i = &ifn[particle_i * statedim]; // norm of colorfield gradient const double cfg_i_norm = ParticleUtils::vec_norm_two(cfg_i); @@ -373,13 +380,13 @@ void Particle::SPHSurfaceTension::compute_wall_colorfield_and_wall_interface_nor { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // clear wall colorfield state - container_i->clear_state(Particle::State::WallColorfield); + container_i->clear_state(ParticleState::WallColorfield); // clear wall interface normal state - container_i->clear_state(Particle::State::WallInterfaceNormal); + container_i->clear_state(ParticleState::WallInterfaceNormal); } // get relevant particle pair indices @@ -387,6 +394,19 @@ void Particle::SPHSurfaceTension::compute_wall_colorfield_and_wall_interface_nor neighborpairs_->get_relevant_particle_pair_indices_for_disjoint_combination( boundarytypes_, fluidtypes_, relindices); + // get pointer to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& temp = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Temperature); + ParticleContainerBundleStatePtrs& wallcf = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::WallColorfield); + ParticleContainerBundleStatePtrs& wallifn = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::WallInterfaceNormal); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -394,23 +414,16 @@ void Particle::SPHSurfaceTension::compute_wall_colorfield_and_wall_interface_nor neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // evaluate contribution of neighboring boundary particle j if (fluidtypes_.contains(type_i)) { @@ -419,16 +432,15 @@ void Particle::SPHSurfaceTension::compute_wall_colorfield_and_wall_interface_nor particlematerial_->get_ptr_to_particle_mat_parameter(type_j); // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - double* wallcf_i = - container_i->get_ptr_to_state_writable(Particle::State::WallColorfield, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + double* wallcf_i = Particle::bundle_state_ptrs_index(wallcf, type_i, status_i, particle_i); double* wallifn_i = - container_i->get_ptr_to_state_writable(Particle::State::WallInterfaceNormal, particle_i); + Particle::bundle_state_ptrs_index(wallifn, type_i, status_i, particle_i, statedim); - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); const double* temp_j = - container_j->try_get_ptr_to_state(Particle::State::Temperature, particle_j); + Particle::bundle_state_ptrs_index(temp, nullptr, type_j, status_j, particle_j); // (current) volume of particle i const double V_i = mass_i[0] / dens_i[0]; @@ -439,7 +451,6 @@ void Particle::SPHSurfaceTension::compute_wall_colorfield_and_wall_interface_nor const double fac = (ParticleUtils::pow<2>(V_i) + ParticleUtils::pow<2>(V_j)) * dens_i[0] / (V_i * (dens_i[0] + material_j->initDensity_)); - // evaluate transition factor below reference temperature double tempfac = 1.0; if (trans_d_t_wet_ > 0.0) @@ -453,23 +464,22 @@ void Particle::SPHSurfaceTension::compute_wall_colorfield_and_wall_interface_nor } // evaluate contribution of neighboring boundary particle i - if (fluidtypes_.contains(type_j) and status_j == Particle::Status::Owned) + if (fluidtypes_.contains(type_j) and status_j == ParticleStatus::Owned) { // get material for current particle type const Mat::PAR::ParticleMaterialBase* material_i = particlematerial_->get_ptr_to_particle_mat_parameter(type_i); // get pointer to particle states - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - const double* dens_j = container_j->get_ptr_to_state(Particle::State::Density, particle_j); - double* wallcf_j = - container_j->get_ptr_to_state_writable(Particle::State::WallColorfield, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index(dens, type_j, status_j, particle_j); + double* wallcf_j = Particle::bundle_state_ptrs_index(wallcf, type_j, status_j, particle_j); double* wallifn_j = - container_j->get_ptr_to_state_writable(Particle::State::WallInterfaceNormal, particle_j); + Particle::bundle_state_ptrs_index(wallifn, type_j, status_j, particle_j, statedim); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); const double* temp_i = - container_i->try_get_ptr_to_state(Particle::State::Temperature, particle_i); + Particle::bundle_state_ptrs_index(temp, nullptr, type_i, status_i, particle_i); // (initial) volume of boundary particle i const double V_i = mass_i[0] / material_i->initDensity_; @@ -497,16 +507,20 @@ void Particle::SPHSurfaceTension::compute_wall_colorfield_and_wall_interface_nor for (const auto& type_i : fluidtypes_) { // get container of owned particles of current particle type + const int type_i_idx = static_cast(type_i); + const int status_i_idx = static_cast(ParticleStatus::Owned); Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); + + // get pointer to particle state + const double* rad = container_i->get_ptr_to_state(ParticleState::Radius); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { // get pointer to particle state - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - double* wallifn_i = - container_i->get_ptr_to_state_writable(Particle::State::WallInterfaceNormal, particle_i); + const double* rad_i = &rad[particle_i]; + double* wallifn_i = &wallifn[type_i_idx][status_i_idx][particle_i * statedim]; // norm of wall interface normal const double wallifn_i_norm = ParticleUtils::vec_norm_two(wallifn_i); @@ -534,19 +548,23 @@ void Particle::SPHSurfaceTension::correct_triple_point_normal() const // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); + + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + const double* rad = container_i->get_ptr_to_state(ParticleState::Radius); + const double* wallifn = container_i->get_ptr_to_state(ParticleState::WallInterfaceNormal); + const double* wallcf = container_i->get_ptr_to_state(ParticleState::WallColorfield); + double* ifn = container_i->get_ptr_to_state_writable(ParticleState::InterfaceNormal); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { - // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* wallifn_i = - container_i->get_ptr_to_state(Particle::State::WallInterfaceNormal, particle_i); - const double* wallcf_i = - container_i->get_ptr_to_state(Particle::State::WallColorfield, particle_i); - double* ifn_i = - container_i->get_ptr_to_state_writable(Particle::State::InterfaceNormal, particle_i); + // get pointers to particle states + const double* rad_i = &rad[particle_i]; + const double* wallifn_i = &wallifn[particle_i * statedim]; + const double* wallcf_i = &wallcf[particle_i]; + double* ifn_i = &ifn[particle_i * statedim]; // evaluation only for non-zero wall interface normal if (not(ParticleUtils::vec_norm_two(wallifn_i) > 0.0)) continue; @@ -602,15 +620,29 @@ void Particle::SPHSurfaceTension::compute_curvature() const std::vector> sumj_nij_Vj_eij_dWij(typevectorsize); std::vector> sumj_Vj_Wij(typevectorsize); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& ifn = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::InterfaceNormal); + ConstParticleContainerBundleStatePtrs& temp = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Temperature); + // iterate over fluid particle types for (const auto& type_i : fluidtypes_) { // get container of owned particles of current particle type + ParticleStatus status_i = ParticleStatus::Owned; Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, status_i); // clear curvature state - container_i->clear_state(Particle::State::Curvature); + container_i->clear_state(ParticleState::Curvature); // get number of particles stored in container const int particlestored = container_i->particles_stored(); @@ -622,14 +654,14 @@ void Particle::SPHSurfaceTension::compute_curvature() const // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { - // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); + // get pointers to particle states + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); const double* ifn_i = - container_i->get_ptr_to_state(Particle::State::InterfaceNormal, particle_i); + Particle::bundle_state_ptrs_index(ifn, type_i, status_i, particle_i, statedim); const double* temp_i = - container_i->try_get_ptr_to_state(Particle::State::Temperature, particle_i); + Particle::bundle_state_ptrs_index(temp, nullptr, type_i, status_i, particle_i); // evaluation only for non-zero interface normal if (not(ParticleUtils::vec_norm_two(ifn_i) > 0.0)) continue; @@ -662,37 +694,30 @@ void Particle::SPHSurfaceTension::compute_curvature() const neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - - // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); + // get pointers to particle states + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); const double* ifn_i = - container_i->get_ptr_to_state(Particle::State::InterfaceNormal, particle_i); + Particle::bundle_state_ptrs_index(ifn, type_i, status_i, particle_i, statedim); const double* temp_i = - container_i->try_get_ptr_to_state(Particle::State::Temperature, particle_i); + Particle::bundle_state_ptrs_index(temp, nullptr, type_i, status_i, particle_i); - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - const double* dens_j = container_j->get_ptr_to_state(Particle::State::Density, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index(dens, type_j, status_j, particle_j); const double* ifn_j = - container_j->get_ptr_to_state(Particle::State::InterfaceNormal, particle_j); + Particle::bundle_state_ptrs_index(ifn, type_j, status_j, particle_j, statedim); const double* temp_j = - container_j->try_get_ptr_to_state(Particle::State::Temperature, particle_j); + Particle::bundle_state_ptrs_index(temp, nullptr, type_j, status_j, particle_j); // evaluation only for non-zero interface normals if (not(ParticleUtils::vec_norm_two(ifn_i) > 0.0) or @@ -726,7 +751,7 @@ void Particle::SPHSurfaceTension::compute_curvature() const } // evaluate contribution of neighboring particle i - if (status_j == Particle::Status::Owned) + if (status_j == ParticleStatus::Owned) { // (current) volume of particle i const double V_i = mass_i[0] / dens_i[0]; @@ -748,29 +773,32 @@ void Particle::SPHSurfaceTension::compute_curvature() const for (const auto& type_i : fluidtypes_) { // get container of owned particles of current particle type + const int type_i_idx = static_cast(type_i); + const ParticleStatus status_i = ParticleStatus::Owned; Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, status_i); + + // get pointer to particle states + double* curv = container_i->get_ptr_to_state_writable(ParticleState::Curvature); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { - // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + // get pointers to particle states + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); const double* ifn_i = - container_i->get_ptr_to_state(Particle::State::InterfaceNormal, particle_i); - double* curv_i = - container_i->get_ptr_to_state_writable(Particle::State::Curvature, particle_i); + Particle::bundle_state_ptrs_index(ifn, type_i, status_i, particle_i, statedim); + double* curv_i = &curv[particle_i]; // evaluation only for non-zero interface normal if (not(ParticleUtils::vec_norm_two(ifn_i) > 0.0)) continue; // evaluation only for meaningful contributions - if (not(std::abs(sumj_Vj_Wij[static_cast(type_i)][particle_i]) > (1.0e-10 * rad_i[0]))) - continue; + if (not(std::abs(sumj_Vj_Wij[type_i_idx][particle_i]) > (1.0e-10 * rad_i[0]))) continue; // compute curvature - curv_i[0] = -sumj_nij_Vj_eij_dWij[static_cast(type_i)][particle_i] / - sumj_Vj_Wij[static_cast(type_i)][particle_i]; + curv_i[0] = + -sumj_nij_Vj_eij_dWij[type_i_idx][particle_i] / sumj_Vj_Wij[type_i_idx][particle_i]; } } } @@ -784,27 +812,43 @@ void Particle::SPHSurfaceTension::compute_surface_tension_contribution() const ->function_by_id(timerampfct_) .evaluate(time_); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& dens = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::Density, fluidtypes_, ParticleStatus::Owned); + ConstParticleContainerBundleStatePtrs& curv = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::Curvature, fluidtypes_, ParticleStatus::Owned); + ConstParticleContainerBundleStatePtrs& cfg = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::ColorfieldGradient, fluidtypes_, ParticleStatus::Owned); + ConstParticleContainerBundleStatePtrs& ifn = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::InterfaceNormal, fluidtypes_, ParticleStatus::Owned); + ConstParticleContainerBundleStatePtrs& temp = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::Temperature, fluidtypes_, ParticleStatus::Owned); + ParticleContainerBundleStatePtrs& acc = particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::Acceleration, fluidtypes_, ParticleStatus::Owned); + // iterate over fluid particle types for (const auto& type_i : fluidtypes_) { // get container of owned particles of current particle type + ParticleStatus status_i = ParticleStatus::Owned; Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, status_i); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { - // get pointer to particle states - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - const double* curv_i = container_i->get_ptr_to_state(Particle::State::Curvature, particle_i); + // get pointers to particle states + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + const double* curv_i = Particle::bundle_state_ptrs_index(curv, type_i, status_i, particle_i); const double* cfg_i = - container_i->get_ptr_to_state(Particle::State::ColorfieldGradient, particle_i); + Particle::bundle_state_ptrs_index(cfg, type_i, status_i, particle_i, statedim); const double* ifn_i = - container_i->get_ptr_to_state(Particle::State::InterfaceNormal, particle_i); + Particle::bundle_state_ptrs_index(ifn, type_i, status_i, particle_i, statedim); const double* temp_i = - container_i->try_get_ptr_to_state(Particle::State::Temperature, particle_i); + Particle::bundle_state_ptrs_index(temp, nullptr, type_i, status_i, particle_i); double* acc_i = - container_i->get_ptr_to_state_writable(Particle::State::Acceleration, particle_i); + Particle::bundle_state_ptrs_index(acc, type_i, status_i, particle_i, statedim); // evaluation only for non-zero interface normal if (not(ParticleUtils::vec_norm_two(ifn_i) > 0.0)) continue; @@ -842,28 +886,43 @@ void Particle::SPHSurfaceTension::compute_temp_grad_driven_contribution() const // temperature in transition from linear to constant regime of surface tension coefficient const double transitiontemp = surf_ref_temp_ + (alphamin_ - alpha0_) / alpha_t_; + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& dens = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::Density, fluidtypes_, ParticleStatus::Owned); + ConstParticleContainerBundleStatePtrs& cfg = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::ColorfieldGradient, fluidtypes_, ParticleStatus::Owned); + ConstParticleContainerBundleStatePtrs& ifn = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::InterfaceNormal, fluidtypes_, ParticleStatus::Owned); + ConstParticleContainerBundleStatePtrs& temp = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::Temperature, fluidtypes_, ParticleStatus::Owned); + ConstParticleContainerBundleStatePtrs& tempgrad = particlecontainerbundle_->try_get_ptrs_to_state( + ParticleState::TemperatureGradient, fluidtypes_, ParticleStatus::Owned); + ParticleContainerBundleStatePtrs& acc = particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::Acceleration, fluidtypes_, ParticleStatus::Owned); + // iterate over fluid particle types for (const auto& type_i : fluidtypes_) { // get container of owned particles of current particle type + ParticleStatus status_i = ParticleStatus::Owned; Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, status_i); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { - // get pointer to particle states - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); + // get pointers to particle states + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); const double* cfg_i = - container_i->get_ptr_to_state(Particle::State::ColorfieldGradient, particle_i); + Particle::bundle_state_ptrs_index(cfg, type_i, status_i, particle_i, statedim); const double* ifn_i = - container_i->get_ptr_to_state(Particle::State::InterfaceNormal, particle_i); - const double* temp_i = - container_i->get_ptr_to_state(Particle::State::Temperature, particle_i); + Particle::bundle_state_ptrs_index(ifn, type_i, status_i, particle_i, statedim); + const double* temp_i = Particle::bundle_state_ptrs_index(temp, type_i, status_i, particle_i); const double* tempgrad_i = - container_i->get_ptr_to_state(Particle::State::TemperatureGradient, particle_i); + Particle::bundle_state_ptrs_index(tempgrad, type_i, status_i, particle_i, statedim); double* acc_i = - container_i->get_ptr_to_state_writable(Particle::State::Acceleration, particle_i); + Particle::bundle_state_ptrs_index(acc, type_i, status_i, particle_i, statedim); // evaluation only for non-zero interface normal if (not(ParticleUtils::vec_norm_two(ifn_i) > 0.0)) continue; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension.hpp index 698e7d7c76..c39caed9c5 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension.hpp @@ -68,7 +68,7 @@ namespace Particle //! insert surface tension evaluation dependent states void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const; + std::map>& particlestatestotypes) const; //! compute interface quantities void compute_interface_quantities(); @@ -126,16 +126,16 @@ namespace Particle std::unique_ptr barrierforce_; //! liquid particle type - Particle::Type liquidtype_; + ParticleType liquidtype_; //! gas particle type - Particle::Type gastype_; + ParticleType gastype_; //! set of fluid particle types - std::set fluidtypes_; + std::set fluidtypes_; //! set of boundary particle types - std::set boundarytypes_; + std::set boundarytypes_; //! interface normal of ghosted particles to refresh Particle::StatesOfTypesToRefresh intnormtorefresh_; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_barrier_force.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_barrier_force.cpp index 816ffea0ec..96b4936bdb 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_barrier_force.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_barrier_force.cpp @@ -22,11 +22,11 @@ FOUR_C_NAMESPACE_OPEN *---------------------------------------------------------------------------*/ Particle::SPHBarrierForce::SPHBarrierForce(const Teuchos::ParameterList& params) : params_sph_(params), - liquidtype_(Particle::Type::Phase1), - gastype_(Particle::Type::Phase2), + liquidtype_(ParticleType::Phase1), + gastype_(ParticleType::Phase2), fluidtypes_({liquidtype_, gastype_}), boundarytypes_( - {Particle::Type::BoundaryPhase, Particle::Type::RigidPhase, Particle::Type::PDPhase}), + {ParticleType::BoundaryPhase, ParticleType::RigidPhase, ParticleType::PDPhase}), dist_(params_sph_.get("BARRIER_FORCE_DISTANCE")), cr_(params_sph_.get("BARRIER_FORCE_TEMPSCALE")), trans_ref_temp_(params_sph_.get("TRANS_REF_TEMPERATURE")), @@ -93,6 +93,17 @@ void Particle::SPHBarrierForce::compute_barrier_force_particle_contribution() co std::vector relindices; neighborpairs_->get_relevant_particle_pair_indices_for_equal_combination(fluidtypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& temp = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Temperature); + ParticleContainerBundleStatePtrs& acc = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Acceleration); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -100,38 +111,32 @@ void Particle::SPHBarrierForce::compute_barrier_force_particle_contribution() co neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); const double* temp_i = - container_i->try_get_ptr_to_state(Particle::State::Temperature, particle_i); - double* acc_i = - container_i->get_ptr_to_state_writable(Particle::State::Acceleration, particle_i); + Particle::bundle_state_ptrs_index(temp, nullptr, type_i, status_i, particle_i); + double* acc_i = Particle::bundle_state_ptrs_index(acc, type_i, status_i, particle_i, statedim); - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - const double* vel_j = container_j->get_ptr_to_state(Particle::State::Velocity, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* vel_j = + Particle::bundle_state_ptrs_index(vel, type_j, status_j, particle_j, statedim); const double* temp_j = - container_j->try_get_ptr_to_state(Particle::State::Temperature, particle_j); + Particle::bundle_state_ptrs_index(temp, nullptr, type_j, status_j, particle_j); double* acc_j = nullptr; - if (status_j == Particle::Status::Owned) - acc_j = container_j->get_ptr_to_state_writable(Particle::State::Acceleration, particle_j); + if (status_j == ParticleStatus::Owned) + acc_j = Particle::bundle_state_ptrs_index(acc, type_j, status_j, particle_j, statedim); // evaluate transition factor above reference temperature double tempfac_i = 0.0; @@ -176,6 +181,17 @@ void Particle::SPHBarrierForce::compute_barrier_force_particle_boundary_contribu neighborpairs_->get_relevant_particle_pair_indices_for_disjoint_combination( fluidtypes_, boundarytypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& temp = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Temperature); + ParticleContainerBundleStatePtrs& acc = particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::Acceleration, ParticleStatus::Owned); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -183,13 +199,13 @@ void Particle::SPHBarrierForce::compute_barrier_force_particle_boundary_contribu neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; @@ -209,27 +225,22 @@ void Particle::SPHBarrierForce::compute_barrier_force_particle_boundary_contribu ParticleUtils::vec_set(e_ij, particlepair.e_ij_); if (swapparticles) ParticleUtils::vec_scale(e_ij, -1.0); - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); const double* temp_i = - container_i->try_get_ptr_to_state(Particle::State::Temperature, particle_i); + Particle::bundle_state_ptrs_index(temp, nullptr, type_i, status_i, particle_i); double* acc_i = nullptr; - if (status_i == Particle::Status::Owned) - acc_i = container_i->get_ptr_to_state_writable(Particle::State::Acceleration, particle_i); + if (status_i == ParticleStatus::Owned) + acc_i = Particle::bundle_state_ptrs_index(acc, type_i, status_i, particle_i, statedim); // get pointer to boundary particle states - const double* vel_j = container_j->get_ptr_to_state(Particle::State::Velocity, particle_j); + const double* vel_j = + Particle::bundle_state_ptrs_index(vel, type_j, status_j, particle_j, statedim); const double* temp_j = - container_j->try_get_ptr_to_state(Particle::State::Temperature, particle_j); + Particle::bundle_state_ptrs_index(temp, nullptr, type_j, status_j, particle_j); // evaluate transition factor above reference temperature double tempfac_i = 0.0; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_barrier_force.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_barrier_force.hpp index 5f87c406ee..897285ac42 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_barrier_force.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_barrier_force.hpp @@ -68,16 +68,16 @@ namespace Particle std::shared_ptr neighborpairs_; //! liquid particle type - Particle::Type liquidtype_; + ParticleType liquidtype_; //! gas particle type - Particle::Type gastype_; + ParticleType gastype_; //! set of fluid particle types - std::set fluidtypes_; + std::set fluidtypes_; //! set of boundary particle types - std::set boundarytypes_; + std::set boundarytypes_; //! barrier force distance const double dist_; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_interface_viscosity.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_interface_viscosity.cpp index 836f703a9a..59eac7280e 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_interface_viscosity.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_interface_viscosity.cpp @@ -30,11 +30,11 @@ FOUR_C_NAMESPACE_OPEN *---------------------------------------------------------------------------*/ Particle::SPHInterfaceViscosity::SPHInterfaceViscosity(const Teuchos::ParameterList& params) : params_sph_(params), - liquidtype_(Particle::Type::Phase1), - gastype_(Particle::Type::Phase2), + liquidtype_(ParticleType::Phase1), + gastype_(ParticleType::Phase2), fluidtypes_({liquidtype_, gastype_}), boundarytypes_( - {Particle::Type::BoundaryPhase, Particle::Type::RigidPhase, Particle::Type::PDPhase}), + {ParticleType::BoundaryPhase, ParticleType::RigidPhase, ParticleType::PDPhase}), artvisc_lg_int_(params_sph_.get("INTERFACE_VISCOSITY_LIQUIDGAS")), artvisc_sl_int_(params_sph_.get("INTERFACE_VISCOSITY_SOLIDLIQUID")), trans_ref_temp_(params_sph_.get("TRANS_REF_TEMPERATURE")), @@ -123,6 +123,23 @@ void Particle::SPHInterfaceViscosity::compute_interface_viscosity_particle_contr std::vector relindices; neighborpairs_->get_relevant_particle_pair_indices_for_equal_combination(fluidtypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& cfg = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::ColorfieldGradient); + ConstParticleContainerBundleStatePtrs& temp = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Temperature); + ParticleContainerBundleStatePtrs& acc = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::Acceleration); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -130,49 +147,42 @@ void Particle::SPHInterfaceViscosity::compute_interface_viscosity_particle_contr neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get material for particle types const Mat::PAR::ParticleMaterialSPHFluid* material_i = fluidmaterial_[static_cast(type_i)]; const Mat::PAR::ParticleMaterialSPHFluid* material_j = fluidmaterial_[static_cast(type_j)]; - // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); + // get pointers to particle states + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); const double* cfg_i = - container_i->get_ptr_to_state(Particle::State::ColorfieldGradient, particle_i); + Particle::bundle_state_ptrs_index(cfg, type_i, status_i, particle_i, statedim); const double* temp_i = - container_i->try_get_ptr_to_state(Particle::State::Temperature, particle_i); - double* acc_i = - container_i->get_ptr_to_state_writable(Particle::State::Acceleration, particle_i); - - const double* rad_j = container_j->get_ptr_to_state(Particle::State::Radius, particle_j); - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - const double* dens_j = container_j->get_ptr_to_state(Particle::State::Density, particle_j); - const double* vel_j = container_j->get_ptr_to_state(Particle::State::Velocity, particle_j); + Particle::bundle_state_ptrs_index(temp, nullptr, type_i, status_i, particle_i); + double* acc_i = Particle::bundle_state_ptrs_index(acc, type_i, status_i, particle_i, statedim); + + const double* rad_j = Particle::bundle_state_ptrs_index(rad, type_j, status_j, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index(dens, type_j, status_j, particle_j); + const double* vel_j = + Particle::bundle_state_ptrs_index(vel, type_j, status_j, particle_j, statedim); const double* cfg_j = - container_j->get_ptr_to_state(Particle::State::ColorfieldGradient, particle_j); + Particle::bundle_state_ptrs_index(cfg, type_j, status_j, particle_j, statedim); const double* temp_j = - container_j->try_get_ptr_to_state(Particle::State::Temperature, particle_j); - double* acc_j = - container_j->get_ptr_to_state_writable(Particle::State::Acceleration, particle_j); + Particle::bundle_state_ptrs_index(temp, nullptr, type_j, status_j, particle_j); + double* acc_j = Particle::bundle_state_ptrs_index(acc, type_j, status_j, particle_j, statedim); // get smoothing length const double h_i = kernel_->smoothing_length(rad_i[0]); @@ -227,6 +237,27 @@ void Particle::SPHInterfaceViscosity::compute_interface_viscosity_particle_bound neighborpairs_->get_relevant_particle_pair_indices_for_disjoint_combination( fluidtypes_, boundarytypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& cfg = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::ColorfieldGradient); + ConstParticleContainerBundleStatePtrs& temp = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Temperature); + ConstParticleContainerBundleStatePtrs& bpress = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::BoundaryPressure); + ConstParticleContainerBundleStatePtrs& bvel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::BoundaryVelocity); + ParticleContainerBundleStatePtrs& acc = particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::Acceleration, ParticleStatus::Owned); + // iterate over relevant particle pairs for (const int particlepairindex : relindices) { @@ -234,13 +265,13 @@ void Particle::SPHInterfaceViscosity::compute_interface_viscosity_particle_bound neighborpairs_->get_ref_to_particle_pair_data()[particlepairindex]; // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; @@ -263,13 +294,6 @@ void Particle::SPHInterfaceViscosity::compute_interface_viscosity_particle_bound // first derivative of kernel const double dWdrij = (swapparticles) ? particlepair.dWdrji_ : particlepair.dWdrij_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get material for particle types const Mat::PAR::ParticleMaterialSPHFluid* material_i = fluidmaterial_[static_cast(type_i)]; @@ -277,26 +301,26 @@ void Particle::SPHInterfaceViscosity::compute_interface_viscosity_particle_bound const Particle::SPHEquationOfStateBase* equationofstate_i = equationofstatebundle_->get_ptr_to_specific_equation_of_state(type_i); - // get pointer to particle states - const double* rad_i = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - const double* vel_i = container_i->get_ptr_to_state(Particle::State::Velocity, particle_i); + // get pointers to particle states + const double* rad_i = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index(dens, type_i, status_i, particle_i); + const double* vel_i = + Particle::bundle_state_ptrs_index(vel, type_i, status_i, particle_i, statedim); const double* cfg_i = - container_i->get_ptr_to_state(Particle::State::ColorfieldGradient, particle_i); + Particle::bundle_state_ptrs_index(cfg, type_i, status_i, particle_i, statedim); const double* temp_i = - container_i->try_get_ptr_to_state(Particle::State::Temperature, particle_i); + Particle::bundle_state_ptrs_index(temp, nullptr, type_i, status_i, particle_i); double* acc_i = nullptr; - if (status_i == Particle::Status::Owned) - acc_i = container_i->get_ptr_to_state_writable(Particle::State::Acceleration, particle_i); + if (status_i == ParticleStatus::Owned) + acc_i = Particle::bundle_state_ptrs_index(acc, type_i, status_i, particle_i, statedim); - // get pointer to boundary particle states - const double* mass_j = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - const double* press_j = - container_j->get_ptr_to_state(Particle::State::BoundaryPressure, particle_j); + // get pointers to boundary particle states + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* press_j = Particle::bundle_state_ptrs_index(bpress, type_j, status_j, particle_j); const double* vel_j = - container_j->get_ptr_to_state(Particle::State::BoundaryVelocity, particle_j); + Particle::bundle_state_ptrs_index(bvel, type_j, status_j, particle_j, statedim); double temp_dens(0.0); temp_dens = equationofstate_i->pressure_to_density(press_j[0], material_i->initDensity_); diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_interface_viscosity.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_interface_viscosity.hpp index d229bb8022..94543f052c 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_interface_viscosity.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_interface_viscosity.hpp @@ -107,16 +107,16 @@ namespace Particle std::vector fluidmaterial_; //! liquid particle type - Particle::Type liquidtype_; + ParticleType liquidtype_; //! gas particle type - Particle::Type gastype_; + ParticleType gastype_; //! set of fluid particle types - std::set fluidtypes_; + std::set fluidtypes_; //! set of boundary particle types - std::set boundarytypes_; + std::set boundarytypes_; //! artificial viscosity on liquid-gas interface const double artvisc_lg_int_; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_recoilpressure_evaporation.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_recoilpressure_evaporation.cpp index c0bd8b0444..d48dcb3d33 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_recoilpressure_evaporation.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_recoilpressure_evaporation.cpp @@ -21,7 +21,7 @@ FOUR_C_NAMESPACE_OPEN Particle::SPHRecoilPressureEvaporation::SPHRecoilPressureEvaporation( const Teuchos::ParameterList& params) : params_sph_(params), - evaporatingphase_(Particle::Type::Phase1), + evaporatingphase_(ParticleType::Phase1), recoilboilingtemp_(params_sph_.get("VAPOR_RECOIL_BOILINGTEMPERATURE")), recoil_pfac_(params_sph_.get("VAPOR_RECOIL_PFAC")), recoil_tfac_(params_sph_.get("VAPOR_RECOIL_TFAC")) @@ -43,19 +43,25 @@ void Particle::SPHRecoilPressureEvaporation::compute_recoil_pressure_contributio { // get container of owned particles of evaporating phase Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(evaporatingphase_, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(evaporatingphase_, ParticleStatus::Owned); + + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + const double* dens = container_i->get_ptr_to_state(ParticleState::Density); + const double* temp = container_i->get_ptr_to_state(ParticleState::Temperature); + const double* cfg = container_i->get_ptr_to_state(ParticleState::ColorfieldGradient); + const double* ifn = container_i->get_ptr_to_state(ParticleState::InterfaceNormal); + double* acc = container_i->get_ptr_to_state_writable(ParticleState::Acceleration); // iterate over particles in container for (int particle_i = 0; particle_i < container_i->particles_stored(); ++particle_i) { - const double* dens_i = container_i->get_ptr_to_state(Particle::State::Density, particle_i); - const double* temp_i = container_i->get_ptr_to_state(Particle::State::Temperature, particle_i); - const double* cfg_i = - container_i->get_ptr_to_state(Particle::State::ColorfieldGradient, particle_i); - const double* ifn_i = - container_i->get_ptr_to_state(Particle::State::InterfaceNormal, particle_i); - double* acc_i = - container_i->get_ptr_to_state_writable(Particle::State::Acceleration, particle_i); + // get pointers to states + const double* dens_i = &dens[particle_i]; + const double* temp_i = &temp[particle_i]; + const double* cfg_i = &cfg[particle_i * statedim]; + const double* ifn_i = &ifn[particle_i * statedim]; + double* acc_i = &acc[particle_i * statedim]; // evaluation only for non-zero interface normal if (not(ParticleUtils::vec_norm_two(ifn_i) > 0.0)) continue; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_recoilpressure_evaporation.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_recoilpressure_evaporation.hpp index db388719c8..56abc3d464 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_recoilpressure_evaporation.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_surface_tension_recoilpressure_evaporation.hpp @@ -57,7 +57,7 @@ namespace Particle Particle::ParticleContainerBundleShrdPtr particlecontainerbundle_; //! evaporating phase - Particle::Type evaporatingphase_; + ParticleType evaporatingphase_; //! boiling temperature in recoil pressure formula double recoilboilingtemp_; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_temperature.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_temperature.cpp index 82d58b1b99..1287ecee78 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_temperature.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_temperature.cpp @@ -32,7 +32,7 @@ Particle::SPHTemperature::SPHTemperature(const Teuchos::ParameterList& params) time_(0.0), dt_(0.0), temperaturegradient_(params_sph_.get("TEMPERATUREGRADIENT")), - intthermotypes_({Particle::Type::Phase1, Particle::Type::Phase2, Particle::Type::RigidPhase}) + intthermotypes_({ParticleType::Phase1, ParticleType::Phase2, ParticleType::RigidPhase}) { init_heat_source_handler(); @@ -67,7 +67,7 @@ void Particle::SPHTemperature::setup( // setup temperature of ghosted particles to refresh { - std::vector states{Particle::State::Temperature}; + std::vector states{ParticleState::Temperature}; for (const auto& type_i : intthermotypes_) temptorefresh_.push_back(std::make_pair(type_i, states)); @@ -108,28 +108,28 @@ void Particle::SPHTemperature::set_current_step_size(const double currentstepsiz } void Particle::SPHTemperature::insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const + std::map>& particlestatestotypes) const { // iterate over particle types for (auto& typeIt : particlestatestotypes) { // get type of particles - Particle::Type type = typeIt.first; + ParticleType type = typeIt.first; // set of particle states for current particle type - std::set& particlestates = typeIt.second; + std::set& particlestates = typeIt.second; // set temperature state - particlestates.insert(Particle::State::Temperature); + particlestates.insert(ParticleState::Temperature); // current particle type is not an integrated thermo particle type if (not intthermotypes_.contains(type)) continue; // state for temperature evaluation scheme - particlestates.insert(Particle::State::TemperatureDot); + particlestates.insert(ParticleState::TemperatureDot); // state for temperature gradient evaluation - if (temperaturegradient_) particlestates.insert(Particle::State::TemperatureGradient); + if (temperaturegradient_) particlestates.insert(ParticleState::TemperatureGradient); } } @@ -151,11 +151,10 @@ void Particle::SPHTemperature::compute_temperature() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // update temperature of all particles - container_i->update_state( - 1.0, Particle::State::Temperature, dt_, Particle::State::TemperatureDot); + container_i->update_state(1.0, ParticleState::Temperature, dt_, ParticleState::TemperatureDot); } // refresh temperature of ghosted particles @@ -206,33 +205,36 @@ void Particle::SPHTemperature::energy_equation() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // clear temperature dot state - container_i->clear_state(Particle::State::TemperatureDot); + container_i->clear_state(ParticleState::TemperatureDot); } + // get pointers to particle states + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& temp = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Temperature); + ParticleContainerBundleStatePtrs& tempdot = + particlecontainerbundle_->try_get_ptrs_to_state_writable(ParticleState::TemperatureDot); + // iterate over particle pairs for (auto& particlepair : neighborpairs_->get_ref_to_particle_pair_data()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get material for particle types const Mat::PAR::ParticleMaterialBase* basematerial_i = particlematerial_->get_ptr_to_particle_mat_parameter(type_i); @@ -244,28 +246,21 @@ void Particle::SPHTemperature::energy_equation() const const Mat::PAR::ParticleMaterialThermo* thermomaterial_j = thermomaterial_[static_cast(type_j)]; - // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - - const double* dens_i = (container_i->have_stored_state(Particle::State::Density)) - ? container_i->get_ptr_to_state(Particle::State::Density, particle_i) - : &(basematerial_i->initDensity_); - - const double* temp_i = container_i->get_ptr_to_state(Particle::State::Temperature, particle_i); + // get pointers to particle states + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index( + dens, &(basematerial_i->initDensity_), type_i, status_i, particle_i); + const double* temp_i = Particle::bundle_state_ptrs_index(temp, type_i, status_i, particle_i); double* tempdot_i = - container_i->try_get_ptr_to_state_writable(Particle::State::TemperatureDot, particle_i); - - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); + Particle::bundle_state_ptrs_index(tempdot, nullptr, type_i, status_i, particle_i); - const double* dens_j = (container_j->have_stored_state(Particle::State::Density)) - ? container_j->get_ptr_to_state(Particle::State::Density, particle_j) - : &(basematerial_j->initDensity_); - - const double* temp_j = container_j->get_ptr_to_state(Particle::State::Temperature, particle_j); + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index( + dens, &(basematerial_j->initDensity_), type_j, status_j, particle_j); + const double* temp_j = Particle::bundle_state_ptrs_index(temp, type_j, status_j, particle_j); double* tempdot_j = nullptr; - if (status_j == Particle::Status::Owned) - tempdot_j = - container_j->try_get_ptr_to_state_writable(Particle::State::TemperatureDot, particle_j); + if (status_j == ParticleStatus::Owned) + tempdot_j = Particle::bundle_state_ptrs_index(tempdot, nullptr, type_j, status_j, particle_j); // thermal conductivities const double& k_i = thermomaterial_i->thermalConductivity_; @@ -296,61 +291,60 @@ void Particle::SPHTemperature::temperature_gradient() const { // get container of owned particles of current particle type Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, Particle::Status::Owned); + particlecontainerbundle_->get_specific_container(type_i, ParticleStatus::Owned); // clear temperature gradient state - container_i->clear_state(Particle::State::TemperatureGradient); + container_i->clear_state(ParticleState::TemperatureGradient); } + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& mass = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Mass); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& temp = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Temperature); + ParticleContainerBundleStatePtrs& tempgrad = + particlecontainerbundle_->try_get_ptrs_to_state_writable( + ParticleState::TemperatureGradient, ParticleStatus::Owned); + // iterate over particle pairs for (auto& particlepair : neighborpairs_->get_ref_to_particle_pair_data()) { // access values of local index tuples of particle i and j - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlepair.tuple_i_; - Particle::Type type_j; - Particle::Status status_j; + ParticleType type_j; + ParticleStatus status_j; int particle_j; std::tie(type_j, status_j, particle_j) = particlepair.tuple_j_; - // get corresponding particle containers - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - Particle::ParticleContainer* container_j = - particlecontainerbundle_->get_specific_container(type_j, status_j); - // get material for particle types const Mat::PAR::ParticleMaterialBase* basematerial_i = particlematerial_->get_ptr_to_particle_mat_parameter(type_i); const Mat::PAR::ParticleMaterialBase* basematerial_j = particlematerial_->get_ptr_to_particle_mat_parameter(type_j); - // get pointer to particle states - const double* mass_i = container_i->get_ptr_to_state(Particle::State::Mass, particle_i); - - const double* dens_i = (container_i->have_stored_state(Particle::State::Density)) - ? container_i->get_ptr_to_state(Particle::State::Density, particle_i) - : &(basematerial_i->initDensity_); - - const double* temp_i = container_i->get_ptr_to_state(Particle::State::Temperature, particle_i); - double* tempgrad_i = container_i->try_get_ptr_to_state_writable( - Particle::State::TemperatureGradient, particle_i); - - const double* mass_j = container_j->get_ptr_to_state(Particle::State::Mass, particle_j); - - const double* dens_j = (container_j->have_stored_state(Particle::State::Density)) - ? container_j->get_ptr_to_state(Particle::State::Density, particle_j) - : &(basematerial_j->initDensity_); - - const double* temp_j = container_j->get_ptr_to_state(Particle::State::Temperature, particle_j); + // get pointers to particle states + const double* mass_i = Particle::bundle_state_ptrs_index(mass, type_i, status_i, particle_i); + const double* dens_i = Particle::bundle_state_ptrs_index( + dens, &(basematerial_i->initDensity_), type_i, status_i, particle_i); + const double* temp_i = Particle::bundle_state_ptrs_index(temp, type_i, status_i, particle_i); + double* tempgrad_i = Particle::bundle_state_ptrs_index( + tempgrad, nullptr, type_i, status_i, particle_i, statedim); + + const double* mass_j = Particle::bundle_state_ptrs_index(mass, type_j, status_j, particle_j); + const double* dens_j = Particle::bundle_state_ptrs_index( + dens, &(basematerial_j->initDensity_), type_j, status_j, particle_j); + const double* temp_j = Particle::bundle_state_ptrs_index(temp, type_j, status_j, particle_j); double* tempgrad_j = nullptr; - if (status_j == Particle::Status::Owned) - tempgrad_j = container_j->try_get_ptr_to_state_writable( - Particle::State::TemperatureGradient, particle_j); + if (status_j == ParticleStatus::Owned) + tempgrad_j = Particle::bundle_state_ptrs_index( + tempgrad, nullptr, type_j, status_j, particle_j, statedim); const double temp_ji = temp_j[0] - temp_i[0]; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_temperature.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_temperature.hpp index bf169fec9d..9d25c57022 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_temperature.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_temperature.hpp @@ -74,7 +74,7 @@ namespace Particle //! insert temperature evaluation dependent states void insert_particle_states_of_particle_types( - std::map>& particlestatestotypes) const; + std::map>& particlestatestotypes) const; //! compute temperature field using energy equation void compute_temperature() const; @@ -126,7 +126,7 @@ namespace Particle std::vector thermomaterial_; //! set of integrated thermo particle types - std::set intthermotypes_; + std::set intthermotypes_; }; } // namespace Particle diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_virtual_wall_particle.cpp b/src/particle/src/interaction/4C_particle_interaction_sph_virtual_wall_particle.cpp index 7ac2c26227..a3d0f3fe45 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_virtual_wall_particle.cpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_virtual_wall_particle.cpp @@ -29,9 +29,9 @@ FOUR_C_NAMESPACE_OPEN *---------------------------------------------------------------------------*/ Particle::SPHVirtualWallParticle::SPHVirtualWallParticle(const Teuchos::ParameterList& params) : params_sph_(params), - allfluidtypes_({Particle::Type::Phase1, Particle::Type::Phase2, - Particle::Type::DirichletPhase, Particle::Type::NeumannPhase}), - intfluidtypes_({Particle::Type::Phase1, Particle::Type::Phase2, Particle::Type::NeumannPhase}) + allfluidtypes_({ParticleType::Phase1, ParticleType::Phase2, ParticleType::DirichletPhase, + ParticleType::NeumannPhase}), + intfluidtypes_({ParticleType::Phase1, ParticleType::Phase2, ParticleType::NeumannPhase}) { // empty constructor } @@ -148,26 +148,34 @@ void Particle::SPHVirtualWallParticle::init_states_at_wall_contact_points( std::vector relindices; neighborpairs_->get_relevant_particle_wall_pair_indices(intfluidtypes_, relindices); + // get pointers to particle states + const int statedim = Particle::enum_to_state_dim(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& pos = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Position); + ConstParticleContainerBundleStatePtrs& rad = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Radius); + ConstParticleContainerBundleStatePtrs& vel = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Velocity); + ConstParticleContainerBundleStatePtrs& dens = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Density); + ConstParticleContainerBundleStatePtrs& press = + particlecontainerbundle_->try_get_ptrs_to_state(ParticleState::Pressure); + // iterate over relevant particle-wall pairs for (const int particlewallpairindex : relindices) { const SPHParticleWallPair& particlewallpair = particlewallpairdata[particlewallpairindex]; // access values of local index tuple of particle i - Particle::Type type_i; - Particle::Status status_i; + ParticleType type_i; + ParticleStatus status_i; int particle_i; std::tie(type_i, status_i, particle_i) = particlewallpair.tuple_i_; - // get corresponding particle container - Particle::ParticleContainer* container_i = - particlecontainerbundle_->get_specific_container(type_i, status_i); - - // get pointer to particle states - const double* pos_i = container_i->get_ptr_to_state(Particle::State::Position, particle_i); - - // get pointer to wall contact point states - const double* rad_j = container_i->get_ptr_to_state(Particle::State::Radius, particle_i); + // get pointers to particle states + const double* pos_i = + Particle::bundle_state_ptrs_index(pos, type_i, status_i, particle_i, statedim); + const double* rad_j = Particle::bundle_state_ptrs_index(rad, type_i, status_i, particle_i); // get pointer to column wall element Core::Elements::Element* ele = particlewallpair.ele_; @@ -235,23 +243,22 @@ void Particle::SPHVirtualWallParticle::init_states_at_wall_contact_points( for (const auto& neighboringparticle : neighboringparticles) { // access values of local index tuple of particle k - Particle::Type type_k; - Particle::Status status_k; + ParticleType type_k; + ParticleStatus status_k; int particle_k; std::tie(type_k, status_k, particle_k) = neighboringparticle; // evaluation only for fluid particles if (not allfluidtypes_.contains(type_k)) continue; - // get container of particles of current particle type - Particle::ParticleContainer* container_k = - particlecontainerbundle_->get_specific_container(type_k, status_k); - - // get pointer to particle states - const double* pos_k = container_k->get_ptr_to_state(Particle::State::Position, particle_k); - const double* vel_k = container_k->get_ptr_to_state(Particle::State::Velocity, particle_k); - const double* dens_k = container_k->get_ptr_to_state(Particle::State::Density, particle_k); - const double* press_k = container_k->get_ptr_to_state(Particle::State::Pressure, particle_k); + // get pointers to particle states + const double* pos_k = + Particle::bundle_state_ptrs_index(pos, type_k, status_k, particle_k, statedim); + const double* vel_k = + Particle::bundle_state_ptrs_index(vel, type_k, status_k, particle_k, statedim); + const double* dens_k = Particle::bundle_state_ptrs_index(dens, type_k, status_k, particle_k); + const double* press_k = + Particle::bundle_state_ptrs_index(press, type_k, status_k, particle_k); // vector from particle k to wall contact point j double r_jk[3]; diff --git a/src/particle/src/interaction/4C_particle_interaction_sph_virtual_wall_particle.hpp b/src/particle/src/interaction/4C_particle_interaction_sph_virtual_wall_particle.hpp index befcf2bcde..ec48952d94 100644 --- a/src/particle/src/interaction/4C_particle_interaction_sph_virtual_wall_particle.hpp +++ b/src/particle/src/interaction/4C_particle_interaction_sph_virtual_wall_particle.hpp @@ -118,10 +118,10 @@ namespace Particle std::vector> weightedvelocity_; //! set of all fluid particle types - std::set allfluidtypes_; + std::set allfluidtypes_; //! set of integrated fluid particle types - std::set intfluidtypes_; + std::set intfluidtypes_; }; } // namespace Particle diff --git a/src/particle/tests/4C_particle_container_test.cpp b/src/particle/tests/4C_particle_container_test.cpp index 0935c3a590..c076175d44 100644 --- a/src/particle/tests/4C_particle_container_test.cpp +++ b/src/particle/tests/4C_particle_container_test.cpp @@ -19,6 +19,7 @@ namespace { protected: std::unique_ptr container_; + std::unique_ptr container_empty_; int statesvectorsize_; @@ -32,6 +33,10 @@ namespace container_ = std::make_unique(); container_->setup(size, stateEnumSet); + // and the empty container + container_empty_ = std::make_unique(); + container_empty_->setup(0, stateEnumSet); + const int maximum_stored_state_enum_set_value{static_cast(*(--stateEnumSet.end()))}; statesvectorsize_ = maximum_stored_state_enum_set_value + 1; @@ -301,12 +306,20 @@ namespace { double* newmass = container_->get_ptr_to_state_writable(Particle::State::Mass, index); newmass[0] = newmass[0] * 3.14; + + double* newvel = container_->get_ptr_to_state_writable(Particle::State::Velocity); + newvel[index * 3] = newvel[index * 3] * 3.14; } { const double* currmass = container_->get_ptr_to_state(Particle::State::Mass, index); EXPECT_NEAR(currmass[0], mass[0] * 3.14, 1e-14); + + const double* currvel = container_->get_ptr_to_state(Particle::State::Velocity, index); + EXPECT_NEAR(currvel[0], vel[0] * 3.14, 1e-14); } } + EXPECT_EQ(container_empty_->get_ptr_to_state(Particle::State::Velocity), nullptr); + EXPECT_EQ(container_empty_->get_ptr_to_state_writable(Particle::State::Velocity), nullptr); } TEST_F(ParticleContainerTest, TryGetPtrToState) @@ -360,21 +373,36 @@ namespace { double* newmass = container_->try_get_ptr_to_state_writable(Particle::State::Mass, index); newmass[0] = newmass[0] * 3.14; + + double* newvel = container_->try_get_ptr_to_state_writable(Particle::State::Velocity); + newvel[index * 3] = newvel[index * 3] * 3.14; } { const double* currmass = container_->try_get_ptr_to_state(Particle::State::Mass, index); EXPECT_NEAR(currmass[0], mass[0] * 3.14, 1e-14); + + const double* currvel = container_->try_get_ptr_to_state(Particle::State::Velocity, index); + EXPECT_NEAR(currvel[0], vel[0] * 3.14, 1e-14); } } + EXPECT_EQ(container_empty_->try_get_ptr_to_state(Particle::State::Velocity), nullptr); + EXPECT_EQ(container_empty_->try_get_ptr_to_state_writable(Particle::State::Velocity), nullptr); } TEST_F(ParticleContainerTest, TryGetPtrToStateNotStored) { - const double* acc = container_->try_get_ptr_to_state(Particle::State::Acceleration, 0); + const double* acc_0 = container_->try_get_ptr_to_state(Particle::State::Acceleration, 0); + EXPECT_EQ(acc_0, nullptr); + + const double* acc = container_->try_get_ptr_to_state(Particle::State::Acceleration); EXPECT_EQ(acc, nullptr); - double* angacc = + double* angacc_0 = container_->try_get_ptr_to_state_writable(Particle::State::AngularAcceleration, 0); + EXPECT_EQ(angacc_0, nullptr); + + double* angacc = + container_->try_get_ptr_to_state_writable(Particle::State::AngularAcceleration); EXPECT_EQ(angacc, nullptr); }