Merge branch 'lbm-mesapd-add-virtualmass-test' into 'master'

Add virtual mass functionality to lbm-mesapd coupling

See merge request !472

apps/CMakeLists.txt

@@ -32,4 +32,4 @@ endif()
 # Python module
 if ( WALBERLA_BUILD_WITH_PYTHON )
     add_subdirectory( pythonmodule )
-endif()
\ No newline at end of file
+endif()

apps/showcases/CMakeLists.txt

@@ -2,6 +2,7 @@ add_subdirectory( BidisperseFluidizedBed )
 add_subdirectory( CombinedResolvedUnresolved )
 add_subdirectory( FluidizedBed )
 add_subdirectory( HeatConduction )
+add_subdirectory( LightRisingParticleInFluidAMR )
 add_subdirectory( Mixer )
 add_subdirectory( PegIntoSphereBed )
 if ( WALBERLA_BUILD_WITH_CODEGEN AND WALBERLA_BUILD_WITH_PYTHON )

apps/showcases/LightRisingParticleInFluidAMR/CMakeLists.txt

+waLBerla_add_executable ( NAME LightRisingParticleInFluidAMR
+        FILES LightRisingParticleInFluidAMR.cpp
+        DEPENDS core mesa_pd lbm lbm_mesapd_coupling domain_decomposition field vtk geometry postprocessing )

python/mesa_pd.py

@@ -63,6 +63,22 @@ if __name__ == '__main__':
     ps.add_property("oldHydrodynamicTorque", "walberla::mesa_pd::Vec3", defValue="real_t(0)",
                     syncMode="ON_OWNERSHIP_CHANGE")
 
+    # Properties for virtual mass:
+    ps.add_property("virtualMass",                  "walberla::real_t",        defValue="real_t(0)",
+                    syncMode="ON_OWNERSHIP_CHANGE")
+    ps.add_property("invMassIncludingVirtual",      "walberla::real_t",        defValue="real_t(0)",
+                    syncMode="ON_OWNERSHIP_CHANGE")
+    ps.add_property("oldLinearAcceleration",        "walberla::mesa_pd::Vec3", defValue="real_t(0)",
+                    syncMode="ON_OWNERSHIP_CHANGE")
+    ps.add_property("invInertiaBF",                 "walberla::mesa_pd::Mat3", defValue="real_t(0)",
+                    syncMode="ON_OWNERSHIP_CHANGE")
+    ps.add_property("virtualInertiaBF",             "walberla::mesa_pd::Mat3", defValue="real_t(0)",
+                    syncMode="ON_OWNERSHIP_CHANGE")
+    ps.add_property("invInertiaBFIncludingVirtual", "walberla::mesa_pd::Mat3", defValue="real_t(0)",
+                    syncMode="ON_OWNERSHIP_CHANGE")
+    ps.add_property("oldAngularAcceleration",       "walberla::mesa_pd::Vec3", defValue="real_t(0)",
+                    syncMode="ON_OWNERSHIP_CHANGE")
+
     # properties for VBond model
     ps.add_property("clusterID", "int64_t", defValue="-1", syncMode="ON_GHOST_CREATION")
     ps.add_property("segmentID", "int64_t", defValue="-1", syncMode="ON_GHOST_CREATION")

src/lbm_mesapd_coupling/amr/level_determination/ParticlePresenceLevelDetermination.h

@@ -25,7 +25,8 @@
 
 namespace walberla {
 namespace lbm_mesapd_coupling {
-
+namespace amr
+{
 /*
  * Class to determine the minimum level a block can be.
  * For coupled LBM-PE simulations the following rules apply:
@@ -39,21 +40,24 @@ namespace lbm_mesapd_coupling {
  */
 class ParticlePresenceLevelDetermination
 {
-public:
-
-   ParticlePresenceLevelDetermination( const shared_ptr<lbm_mesapd_coupling::InfoCollection> & infoCollection, uint_t finestLevel) :
-         infoCollection_( infoCollection ), finestLevel_( finestLevel)
+ public:
+   ParticlePresenceLevelDetermination(const shared_ptr< InfoCollection > infoCollection,
+                                      uint_t finestLevel)
+      : infoCollection_(infoCollection), finestLevel_(finestLevel)
    {}
 
-   void operator()( std::vector< std::pair< const Block *, uint_t > > & minTargetLevels,
-                    std::vector< const Block * > &, const BlockForest & /*forest*/ ) {
-      for (auto &minTargetLevel : minTargetLevels) {
+   void operator()(std::vector< std::pair< const Block*, uint_t > >& minTargetLevels, std::vector< const Block* >&,
+                   const BlockForest& /*forest*/)
+   {
+      for (auto& minTargetLevel : minTargetLevels)
+      {
          uint_t currentLevelOfBlock = minTargetLevel.first->getLevel();
 
-         const uint_t numberOfParticlesInDirectNeighborhood = getNumberOfLocalAndShadowParticlesInNeighborhood(minTargetLevel.first);
+         const uint_t numberOfParticlesInDirectNeighborhood =
+            getNumberOfLocalAndShadowParticlesInNeighborhood(minTargetLevel.first);
 
-         uint_t targetLevelOfBlock = currentLevelOfBlock; //keep everything as it is
-         if ( numberOfParticlesInDirectNeighborhood > uint_t(0) )
+         uint_t targetLevelOfBlock = currentLevelOfBlock; // keep everything as it is
+         if (numberOfParticlesInDirectNeighborhood > uint_t(0))
          {
             // set block to finest level if there are particles nearby
             targetLevelOfBlock = finestLevel_;
@@ -61,41 +65,44 @@ public:
          else
          {
             // block could coarsen since there are no particles nearby
-            if( currentLevelOfBlock > uint_t(0) )
-               targetLevelOfBlock = currentLevelOfBlock - uint_t(1);
+            if (currentLevelOfBlock > uint_t(0)) targetLevelOfBlock = currentLevelOfBlock - uint_t(1);
          }
 
-         WALBERLA_CHECK_LESS_EQUAL(std::abs(int_c(targetLevelOfBlock) - int_c(currentLevelOfBlock)), uint_t(1), "Only level difference of maximum 1 allowed!");
+         WALBERLA_CHECK_LESS_EQUAL(std::abs(int_c(targetLevelOfBlock) - int_c(currentLevelOfBlock)), uint_t(1),
+                                   "Only level difference of maximum 1 allowed!");
          minTargetLevel.second = targetLevelOfBlock;
       }
    }
 
-private:
-
-   uint_t getNumberOfLocalAndShadowParticlesInNeighborhood(const Block * block) {
+ private:
+   uint_t getNumberOfLocalAndShadowParticlesInNeighborhood(const Block* block)
+   {
       auto numParticles = uint_t(0);
 
       // add particles of current block
       const auto infoIt = infoCollection_->find(block->getId());
-      WALBERLA_CHECK_UNEQUAL(infoIt, infoCollection_->end(), "Block with ID " << block->getId() << " not found in info collection!");
+      WALBERLA_CHECK_UNEQUAL(infoIt, infoCollection_->end(),
+                             "Block with ID " << block->getId() << " not found in info collection!");
 
-      numParticles += infoIt->second.numberOfLocalParticles + infoIt->second.numberOfShadowParticles;
+      numParticles += infoIt->second.numberOfLocalParticles + infoIt->second.numberOfGhostParticles;
 
       // add particles of all neighboring blocks
-      for(uint_t i = 0; i < block->getNeighborhoodSize(); ++i)
+      for (uint_t i = 0; i < block->getNeighborhoodSize(); ++i)
       {
-         const BlockID &neighborBlockID = block->getNeighborId(i);
-         const auto infoItNeighbor = infoCollection_->find(neighborBlockID);
-         WALBERLA_CHECK_UNEQUAL(infoItNeighbor, infoCollection_->end(), "Neighbor block with ID " << neighborBlockID << " not found in info collection!");
+         const BlockID& neighborBlockID = block->getNeighborId(i);
+         const auto infoItNeighbor      = infoCollection_->find(neighborBlockID);
+         WALBERLA_CHECK_UNEQUAL(infoItNeighbor, infoCollection_->end(),
+                                "Neighbor block with ID " << neighborBlockID << " not found in info collection!");
 
-         numParticles += infoItNeighbor->second.numberOfLocalParticles + infoItNeighbor->second.numberOfShadowParticles;
+         numParticles += infoItNeighbor->second.numberOfLocalParticles + infoItNeighbor->second.numberOfGhostParticles;
       }
       return numParticles;
    }
 
-   shared_ptr<lbm_mesapd_coupling::InfoCollection> infoCollection_;
+   shared_ptr< InfoCollection > infoCollection_;
    uint_t finestLevel_;
 };
 
+} // namespace amr
 } // namespace lbm_mesapd_coupling
 } // namespace walberla

src/lbm_mesapd_coupling/utility/virtualmass/AddVirtualForceTorqueKernel.h

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file AddVirtualForceTorqueKernel.h
+//! \ingroup lbm_mesapd_coupling
+//! \author Lukas Werner <lks.werner@fau.de>
+//
+//======================================================================================================================
+
+#pragma once
+
+#include <utility>
+
+#include "mesa_pd/data/DataTypes.h"
+#include "mesa_pd/data/IAccessor.h"
+#include "mesa_pd/common/ParticleFunctions.h"
+#include "mesa_pd/data/ParticleStorage.h"
+
+namespace walberla {
+namespace lbm_mesapd_coupling {
+
+/**
+ * Kernel that sets a virtual force and torque on particles. It accesses a virtual mass and inertia, which have to be
+ * set beforehand using InitializeVirtualMassKernel.
+ * During the calculation of virtual force and torque linear and angular accelerations are used, for which acceleration
+ * estimators need to be supplied.
+ *
+ * This kernel requires the following particle attributes:
+ *  ps.addProperty("virtualMass",       "walberla::real_t",        defValue="real_t(0)", syncMode="ON_OWNERSHIP_CHANGE")
+ *  ps.addProperty("virtualInertiaBF",  "walberla::mesa_pd::Mat3", defValue="real_t(0)", syncMode="ON_OWNERSHIP_CHANGE")
+ *  ps.add_property("oldLinearAcceleration",  "walberla::mesa_pd::Vec3", defValue="real_t(0)", syncMode="ON_OWNERSHIP_CHANGE")
+ *  ps.add_property("oldAngularAcceleration", "walberla::mesa_pd::Vec3", defValue="real_t(0)", syncMode="ON_OWNERSHIP_CHANGE")
+ */
+class AddVirtualForceTorqueKernel
+{
+public:
+   explicit AddVirtualForceTorqueKernel(shared_ptr<mesa_pd::data::ParticleStorage> ps) : ps_(std::move(ps)){};
+
+   template <typename Accessor_T>
+   void operator()(const size_t idx, Accessor_T& ac) {
+      static_assert(std::is_base_of<mesa_pd::data::IAccessor, Accessor_T>::value, "please provide a valid accessor");
+
+      WALBERLA_CHECK_FLOAT_UNEQUAL(ac.getVirtualMass(idx), real_t(0.),
+                                   "No virtual mass set on body. Was the virtualMass kernel not called before?");
+
+      //// force
+      // obtain the acceleration estimation
+      Vector3<real_t> approximatedCurrentLinearAcceleration = ac.getOldLinearAcceleration(idx);
+
+      // prepare the next acceleration estimation for the following time step
+      const Vector3<real_t> virtualForce = ac.getVirtualMass(idx) * approximatedCurrentLinearAcceleration;
+      const Vector3<real_t> currentLinearAcceleration = (ac.getForce(idx) + virtualForce) /
+                                                          (ac.getVirtualMass(idx) + ac.getMass(idx));
+      ac.setOldLinearAcceleration(idx, currentLinearAcceleration);
+
+      mesa_pd::addForceAtomic(idx, ac, virtualForce);
+
+      //// torque
+      // obtain the acceleration estimation
+      Vector3<real_t> approximatedCurrentAngularAcceleration = ac.getOldAngularAcceleration(idx);
+
+      // prepare the next acceleration estimation for the following time step
+      const Vector3<real_t> virtualTorque = ac.getVirtualInertiaBF(idx) * approximatedCurrentAngularAcceleration;
+      const Vector3<real_t> angularAcceleration = math::transformMatrixRART(ac.getRotation(idx).getMatrix(),
+        ac.getInvInertiaBFIncludingVirtual(idx)) * (ac.getTorque(idx) + virtualTorque);
+      ac.setOldAngularAcceleration(idx, angularAcceleration);
+
+      mesa_pd::addTorqueAtomic(idx, ac, virtualTorque);
+   }
+
+private:
+   const shared_ptr<mesa_pd::data::ParticleStorage> ps_;
+};
+
+}
+}
\ No newline at end of file

src/lbm_mesapd_coupling/utility/virtualmass/InitializeVirtualMassKernel.h

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file VirtualMass.h
+//! \author Lukas Werner <lks.werner@fau.de>
+//
+//======================================================================================================================
+
+#pragma once
+
+#include <mesa_pd/data/DataTypes.h>
+#include <mesa_pd/data/IAccessor.h>
+
+namespace walberla {
+namespace lbm_mesapd_coupling {
+
+/**
+ * This kernel calculates virtual mass and inertia and sets them as attributes on a particle.
+ *
+ * It requires the following particle attributes:
+ *  ps.addProperty("virtualMass",                  "walberla::real_t",        defValue="real_t(0)", syncMode="ON_OWNERSHIP_CHANGE")
+ *  ps.addProperty("invMassIncludingVirtual",      "walberla::real_t",        defValue="real_t(0)", syncMode="ON_OWNERSHIP_CHANGE")
+ *  ps.addProperty("virtualInertiaBF",             "walberla::mesa_pd::Mat3", defValue="real_t(0)", syncMode="ON_OWNERSHIP_CHANGE")
+ *  ps.addProperty("invInertiaBFIncludingVirtual", "walberla::mesa_pd::Mat3", defValue="real_t(0)", syncMode="ON_OWNERSHIP_CHANGE")
+ */
+class InitializeVirtualMassKernel {
+public:
+   InitializeVirtualMassKernel() = default;
+
+   template <typename Accessor>
+   void operator()(size_t i, Accessor& ac, real_t C_v, real_t C_v_omega, real_t fluidDensity) const;
+};
+
+
+template <typename Accessor>
+inline void InitializeVirtualMassKernel::operator()(const size_t i, Accessor& ac, const real_t C_v, const real_t C_v_omega,
+        const real_t fluidDensity) const {
+   static_assert(std::is_base_of<mesa_pd::data::IAccessor, Accessor>::value, "please provide a valid accessor");
+
+   const real_t virtualMass = C_v * fluidDensity * ac.getVolume(i);
+   ac.setVirtualMass(i, virtualMass);
+   ac.setInvMassIncludingVirtual(i, real_t(1.) / (ac.getMass(i) + virtualMass));
+
+   const real_t angularVirtualMass = C_v_omega * fluidDensity * ac.getVolume(i);
+   const mesa_pd::Mat3 virtualInertiaBF = ac.getInertiaBF(i) * ac.getInvMass(i) * angularVirtualMass;
+   const mesa_pd::Mat3 inertiaBFIncludingVirtual = ac.getInertiaBF(i) + virtualInertiaBF;
+   ac.setVirtualInertiaBF(i, virtualInertiaBF);
+   ac.setInvInertiaBFIncludingVirtual(i, inertiaBFIncludingVirtual.getInverse());
+}
+
+} //namespace lbm_mesapd_coupling
+} //namespace walberla
\ No newline at end of file

src/lbm_mesapd_coupling/utility/virtualmass/ParticleAccessorWithShapeVirtualMassWrapper.h

+//======================================================================================================================
+//
+//  This file is part of waLBerla. waLBerla is free software: you can
+//  redistribute it and/or modify it under the terms of the GNU General Public
+//  License as published by the Free Software Foundation, either version 3 of
+//  the License, or (at your option) any later version.
+//
+//  waLBerla is distributed in the hope that it will be useful, but WITHOUT
+//  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+//  for more details.
+//
+//  You should have received a copy of the GNU General Public License along
+//  with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file ParticleAccessorWithShapeAndVirtualMassWrapper.h
+//! \author Lukas Werner <lks.werner@fau.de>
+//
+//======================================================================================================================
+
+#pragma once
+
+#include <mesa_pd/data/ParticleStorage.h>
+#include <mesa_pd/data/ShapeStorage.h>
+
+namespace walberla {
+namespace lbm_mesapd_coupling {
+
+/**
+ * !\brief Wraps a ParticleAccessor to change its getInvMass and getInvInertiaBF methods to include virtual mass.
+ * @tparam T A ParticleAccessor providing functions getInvMass and getInvInertiaBF, and their respective getInvMassIncludingVirtual and getInvInertiaBFIncludingVirtual.
+ */
+template <typename T>
+class ParticleAccessorWithShapeVirtualMassWrapper : public T {
+public:
+  ParticleAccessorWithShapeVirtualMassWrapper(std::shared_ptr<mesa_pd::data::ParticleStorage>& ps, std::shared_ptr<mesa_pd::data::ShapeStorage>& ss)
+      : T(ps, ss) {
+   }
+
+   auto getInvMass(const size_t p_idx) const {
+      return T::getInvMassIncludingVirtual(p_idx);
+   }
+
+   const auto getMass(const size_t p_idx) const {
+      return T::getMass(p_idx) + T::getVirtualMass(p_idx);
+   }
+
+   auto getInvInertiaBF(const size_t p_idx) const {
+      return T::getInvInertiaBFIncludingVirtual(p_idx);
+   }
+
+   const auto getInertiaBF(const size_t p_idx) const {
+      return T::getInertiaBF(p_idx) + T::getVirtualInertiaBF(p_idx);
+   }
+};
+
+}
+}
\ No newline at end of file

src/mesa_pd/data/ParticleAccessor.h

@@ -164,6 +164,34 @@ public:
    walberla::mesa_pd::Vec3& getOldHydrodynamicTorqueRef(const size_t p_idx) {return ps_->getOldHydrodynamicTorqueRef(p_idx);}
    void setOldHydrodynamicTorque(const size_t p_idx, walberla::mesa_pd::Vec3 const & v) { ps_->setOldHydrodynamicTorque(p_idx, v);}
    
+   walberla::real_t const & getVirtualMass(const size_t p_idx) const {return ps_->getVirtualMass(p_idx);}
+   walberla::real_t& getVirtualMassRef(const size_t p_idx) {return ps_->getVirtualMassRef(p_idx);}
+   void setVirtualMass(const size_t p_idx, walberla::real_t const & v) { ps_->setVirtualMass(p_idx, v);}
+   
+   walberla::real_t const & getInvMassIncludingVirtual(const size_t p_idx) const {return ps_->getInvMassIncludingVirtual(p_idx);}
+   walberla::real_t& getInvMassIncludingVirtualRef(const size_t p_idx) {return ps_->getInvMassIncludingVirtualRef(p_idx);}
+   void setInvMassIncludingVirtual(const size_t p_idx, walberla::real_t const & v) { ps_->setInvMassIncludingVirtual(p_idx, v);}
+   
+   walberla::mesa_pd::Vec3 const & getOldLinearAcceleration(const size_t p_idx) const {return ps_->getOldLinearAcceleration(p_idx);}
+   walberla::mesa_pd::Vec3& getOldLinearAccelerationRef(const size_t p_idx) {return ps_->getOldLinearAccelerationRef(p_idx);}
+   void setOldLinearAcceleration(const size_t p_idx, walberla::mesa_pd::Vec3 const & v) { ps_->setOldLinearAcceleration(p_idx, v);}
+   
+   walberla::mesa_pd::Mat3 const & getInvInertiaBF(const size_t p_idx) const {return ps_->getInvInertiaBF(p_idx);}
+   walberla::mesa_pd::Mat3& getInvInertiaBFRef(const size_t p_idx) {return ps_->getInvInertiaBFRef(p_idx);}
+   void setInvInertiaBF(const size_t p_idx, walberla::mesa_pd::Mat3 const & v) { ps_->setInvInertiaBF(p_idx, v);}
+   
+   walberla::mesa_pd::Mat3 const & getVirtualInertiaBF(const size_t p_idx) const {return ps_->getVirtualInertiaBF(p_idx);}
+   walberla::mesa_pd::Mat3& getVirtualInertiaBFRef(const size_t p_idx) {return ps_->getVirtualInertiaBFRef(p_idx);}
+   void setVirtualInertiaBF(const size_t p_idx, walberla::mesa_pd::Mat3 const & v) { ps_->setVirtualInertiaBF(p_idx, v);}
+   
+   walberla::mesa_pd::Mat3 const & getInvInertiaBFIncludingVirtual(const size_t p_idx) const {return ps_->getInvInertiaBFIncludingVirtual(p_idx);}
+   walberla::mesa_pd::Mat3& getInvInertiaBFIncludingVirtualRef(const size_t p_idx) {return ps_->getInvInertiaBFIncludingVirtualRef(p_idx);}
+   void setInvInertiaBFIncludingVirtual(const size_t p_idx, walberla::mesa_pd::Mat3 const & v) { ps_->setInvInertiaBFIncludingVirtual(p_idx, v);}
+   
+   walberla::mesa_pd::Vec3 const & getOldAngularAcceleration(const size_t p_idx) const {return ps_->getOldAngularAcceleration(p_idx);}
+   walberla::mesa_pd::Vec3& getOldAngularAccelerationRef(const size_t p_idx) {return ps_->getOldAngularAccelerationRef(p_idx);}
+   void setOldAngularAcceleration(const size_t p_idx, walberla::mesa_pd::Vec3 const & v) { ps_->setOldAngularAcceleration(p_idx, v);}
+   
    int64_t const & getClusterID(const size_t p_idx) const {return ps_->getClusterID(p_idx);}
    int64_t& getClusterIDRef(const size_t p_idx) {return ps_->getClusterIDRef(p_idx);}
    void setClusterID(const size_t p_idx, int64_t const & v) { ps_->setClusterID(p_idx, v);}
@@ -337,6 +365,34 @@ public:
    void setOldHydrodynamicTorque(const size_t /*p_idx*/, walberla::mesa_pd::Vec3 const & v) { oldHydrodynamicTorque_ = v;}
    walberla::mesa_pd::Vec3& getOldHydrodynamicTorqueRef(const size_t /*p_idx*/) {return oldHydrodynamicTorque_;}
    
+   walberla::real_t const & getVirtualMass(const size_t /*p_idx*/) const {return virtualMass_;}
+   void setVirtualMass(const size_t /*p_idx*/, walberla::real_t const & v) { virtualMass_ = v;}
+   walberla::real_t& getVirtualMassRef(const size_t /*p_idx*/) {return virtualMass_;}
+   
+   walberla::real_t const & getInvMassIncludingVirtual(const size_t /*p_idx*/) const {return invMassIncludingVirtual_;}
+   void setInvMassIncludingVirtual(const size_t /*p_idx*/, walberla::real_t const & v) { invMassIncludingVirtual_ = v;}
+   walberla::real_t& getInvMassIncludingVirtualRef(const size_t /*p_idx*/) {return invMassIncludingVirtual_;}
+   
+   walberla::mesa_pd::Vec3 const & getOldLinearAcceleration(const size_t /*p_idx*/) const {return oldLinearAcceleration_;}
+   void setOldLinearAcceleration(const size_t /*p_idx*/, walberla::mesa_pd::Vec3 const & v) { oldLinearAcceleration_ = v;}
+   walberla::mesa_pd::Vec3& getOldLinearAccelerationRef(const size_t /*p_idx*/) {return oldLinearAcceleration_;}
+   
+   walberla::mesa_pd::Mat3 const & getInvInertiaBF(const size_t /*p_idx*/) const {return invInertiaBF_;}
+   void setInvInertiaBF(const size_t /*p_idx*/, walberla::mesa_pd::Mat3 const & v) { invInertiaBF_ = v;}
+   walberla::mesa_pd::Mat3& getInvInertiaBFRef(const size_t /*p_idx*/) {return invInertiaBF_;}
+   
+   walberla::mesa_pd::Mat3 const & getVirtualInertiaBF(const size_t /*p_idx*/) const {return virtualInertiaBF_;}
+   void setVirtualInertiaBF(const size_t /*p_idx*/, walberla::mesa_pd::Mat3 const & v) { virtualInertiaBF_ = v;}
+   walberla::mesa_pd::Mat3& getVirtualInertiaBFRef(const size_t /*p_idx*/) {return virtualInertiaBF_;}
+   
+   walberla::mesa_pd::Mat3 const & getInvInertiaBFIncludingVirtual(const size_t /*p_idx*/) const {return invInertiaBFIncludingVirtual_;}
+   void setInvInertiaBFIncludingVirtual(const size_t /*p_idx*/, walberla::mesa_pd::Mat3 const & v) { invInertiaBFIncludingVirtual_ = v;}
+   walberla::mesa_pd::Mat3& getInvInertiaBFIncludingVirtualRef(const size_t /*p_idx*/) {return invInertiaBFIncludingVirtual_;}
+   
+   walberla::mesa_pd::Vec3 const & getOldAngularAcceleration(const size_t /*p_idx*/) const {return oldAngularAcceleration_;}
+   void setOldAngularAcceleration(const size_t /*p_idx*/, walberla::mesa_pd::Vec3 const & v) { oldAngularAcceleration_ = v;}
+   walberla::mesa_pd::Vec3& getOldAngularAccelerationRef(const size_t /*p_idx*/) {return oldAngularAcceleration_;}
+   
    int64_t const & getClusterID(const size_t /*p_idx*/) const {return clusterID_;}
    void setClusterID(const size_t /*p_idx*/, int64_t const & v) { clusterID_ = v;}
    int64_t& getClusterIDRef(const size_t /*p_idx*/) {return clusterID_;}
@@ -389,6 +445,13 @@ private:
    walberla::mesa_pd::Vec3 hydrodynamicTorque_;
    walberla::mesa_pd::Vec3 oldHydrodynamicForce_;
    walberla::mesa_pd::Vec3 oldHydrodynamicTorque_;
+   walberla::real_t virtualMass_;
+   walberla::real_t invMassIncludingVirtual_;
+   walberla::mesa_pd::Vec3 oldLinearAcceleration_;
+   walberla::mesa_pd::Mat3 invInertiaBF_;
+   walberla::mesa_pd::Mat3 virtualInertiaBF_;
+   walberla::mesa_pd::Mat3 invInertiaBFIncludingVirtual_;
+   walberla::mesa_pd::Vec3 oldAngularAcceleration_;
    int64_t clusterID_;
    int64_t segmentID_;
    std::unordered_set<walberla::mpi::MPIRank> neighborState_;

src/mesa_pd/data/ParticleAccessorWithShape.h

@@ -37,7 +37,10 @@ public:
    {}
 
    const auto& getInvMass(const size_t p_idx) const {return ss_->shapes[ps_->getShapeIDRef(p_idx)]->getInvMass();}
+   const auto& getMass(const size_t p_idx) const {return ss_->shapes[ps_->getShapeIDRef(p_idx)]->getMass();}
    const auto& getInvInertiaBF(const size_t p_idx) const {return ss_->shapes[ps_->getShapeIDRef(p_idx)]->getInvInertiaBF();}
+   const auto& getInertiaBF(const size_t p_idx) const {return ss_->shapes[ps_->getShapeIDRef(p_idx)]->getInertiaBF();}
+   const auto getVolume(const size_t p_idx) const {return ss_->shapes[ps_->getShapeIDRef(p_idx)]->getVolume();}
 
    data::BaseShape* getShape(const size_t p_idx) const {return ss_->shapes[ps_->getShapeIDRef(p_idx)].get();}
 private:

src/mesa_pd/data/ParticleStorage.h

@@ -100,6 +100,13 @@ public:
       using hydrodynamicTorque_type = walberla::mesa_pd::Vec3;
       using oldHydrodynamicForce_type = walberla::mesa_pd::Vec3;
       using oldHydrodynamicTorque_type = walberla::mesa_pd::Vec3;
+      using virtualMass_type = walberla::real_t;
+      using invMassIncludingVirtual_type = walberla::real_t;
+      using oldLinearAcceleration_type = walberla::mesa_pd::Vec3;
+      using invInertiaBF_type = walberla::mesa_pd::Mat3;
+      using virtualInertiaBF_type = walberla::mesa_pd::Mat3;
+      using invInertiaBFIncludingVirtual_type = walberla::mesa_pd::Mat3;
+      using oldAngularAcceleration_type = walberla::mesa_pd::Vec3;
       using clusterID_type = int64_t;
       using segmentID_type = int64_t;
       using neighborState_type = std::unordered_set<walberla::mpi::MPIRank>;
@@ -221,6 +228,34 @@ public:
       oldHydrodynamicTorque_type& getOldHydrodynamicTorqueRef() {return storage_.getOldHydrodynamicTorqueRef(i_);}
       void setOldHydrodynamicTorque(oldHydrodynamicTorque_type const & v) { storage_.setOldHydrodynamicTorque(i_, v);}
       
+      virtualMass_type const & getVirtualMass() const {return storage_.getVirtualMass(i_);}
+      virtualMass_type& getVirtualMassRef() {return storage_.getVirtualMassRef(i_);}
+      void setVirtualMass(virtualMass_type const & v) { storage_.setVirtualMass(i_, v);}
+      
+      invMassIncludingVirtual_type const & getInvMassIncludingVirtual() const {return storage_.getInvMassIncludingVirtual(i_);}
+      invMassIncludingVirtual_type& getInvMassIncludingVirtualRef() {return storage_.getInvMassIncludingVirtualRef(i_);}
+      void setInvMassIncludingVirtual(invMassIncludingVirtual_type const & v) { storage_.setInvMassIncludingVirtual(i_, v);}
+      
+      oldLinearAcceleration_type const & getOldLinearAcceleration() const {return storage_.getOldLinearAcceleration(i_);}
+      oldLinearAcceleration_type& getOldLinearAccelerationRef() {return storage_.getOldLinearAccelerationRef(i_);}
+      void setOldLinearAcceleration(oldLinearAcceleration_type const & v) { storage_.setOldLinearAcceleration(i_, v);}
+      
+      invInertiaBF_type const & getInvInertiaBF() const {return storage_.getInvInertiaBF(i_);}
+      invInertiaBF_type& getInvInertiaBFRef() {return storage_.getInvInertiaBFRef(i_);}
+      void setInvInertiaBF(invInertiaBF_type const & v) { storage_.setInvInertiaBF(i_, v);}
+      
+      virtualInertiaBF_type const & getVirtualInertiaBF() const {return storage_.getVirtualInertiaBF(i_);}
+      virtualInertiaBF_type& getVirtualInertiaBFRef() {return storage_.getVirtualInertiaBFRef(i_);}
+      void setVirtualInertiaBF(virtualInertiaBF_type const & v) { storage_.setVirtualInertiaBF(i_, v);}
+      
+      invInertiaBFIncludingVirtual_type const & getInvInertiaBFIncludingVirtual() const {return storage_.getInvInertiaBFIncludingVirtual(i_);}
+      invInertiaBFIncludingVirtual_type& getInvInertiaBFIncludingVirtualRef() {return storage_.getInvInertiaBFIncludingVirtualRef(i_);}
+      void setInvInertiaBFIncludingVirtual(invInertiaBFIncludingVirtual_type const & v) { storage_.setInvInertiaBFIncludingVirtual(i_, v);}
+      
+      oldAngularAcceleration_type const & getOldAngularAcceleration() const {return storage_.getOldAngularAcceleration(i_);}
+      oldAngularAcceleration_type& getOldAngularAccelerationRef() {return storage_.getOldAngularAccelerationRef(i_);}
+      void setOldAngularAcceleration(oldAngularAcceleration_type const & v) { storage_.setOldAngularAcceleration(i_, v);}
+      
       clusterID_type const & getClusterID() const {return storage_.getClusterID(i_);}
       clusterID_type& getClusterIDRef() {return storage_.getClusterIDRef(i_);}
       void setClusterID(clusterID_type const & v) { storage_.setClusterID(i_, v);}
@@ -322,6 +357,13 @@ public:
    using hydrodynamicTorque_type = walberla::mesa_pd::Vec3;
    using oldHydrodynamicForce_type = walberla::mesa_pd::Vec3;
    using oldHydrodynamicTorque_type = walberla::mesa_pd::Vec3;
+   using virtualMass_type = walberla::real_t;
+   using invMassIncludingVirtual_type = walberla::real_t;
+   using oldLinearAcceleration_type = walberla::mesa_pd::Vec3;
+   using invInertiaBF_type = walberla::mesa_pd::Mat3;
+   using virtualInertiaBF_type = walberla::mesa_pd::Mat3;
+   using invInertiaBFIncludingVirtual_type = walberla::mesa_pd::Mat3;
+   using oldAngularAcceleration_type = walberla::mesa_pd::Vec3;
    using clusterID_type = int64_t;
    using segmentID_type = int64_t;
    using neighborState_type = std::unordered_set<walberla::mpi::MPIRank>;
@@ -443,6 +485,34 @@ public:
    oldHydrodynamicTorque_type& getOldHydrodynamicTorqueRef(const size_t idx) {return oldHydrodynamicTorque_[idx];}
    void setOldHydrodynamicTorque(const size_t idx, oldHydrodynamicTorque_type const & v) { oldHydrodynamicTorque_[idx] = v; }
    
+   virtualMass_type const & getVirtualMass(const size_t idx) const {return virtualMass_[idx];}
+   virtualMass_type& getVirtualMassRef(const size_t idx) {return virtualMass_[idx];}
+   void setVirtualMass(const size_t idx, virtualMass_type const & v) { virtualMass_[idx] = v; }
+   
+   invMassIncludingVirtual_type const & getInvMassIncludingVirtual(const size_t idx) const {return invMassIncludingVirtual_[idx];}
+   invMassIncludingVirtual_type& getInvMassIncludingVirtualRef(const size_t idx) {return invMassIncludingVirtual_[idx];}
+   void setInvMassIncludingVirtual(const size_t idx, invMassIncludingVirtual_type const & v) { invMassIncludingVirtual_[idx] = v; }
+   
+   oldLinearAcceleration_type const & getOldLinearAcceleration(const size_t idx) const {return oldLinearAcceleration_[idx];}
+   oldLinearAcceleration_type& getOldLinearAccelerationRef(const size_t idx) {return oldLinearAcceleration_[idx];}
+   void setOldLinearAcceleration(const size_t idx, oldLinearAcceleration_type const & v) { oldLinearAcceleration_[idx] = v; }
+   
+   invInertiaBF_type const & getInvInertiaBF(const size_t idx) const {return invInertiaBF_[idx];}
+   invInertiaBF_type& getInvInertiaBFRef(const size_t idx) {return invInertiaBF_[idx];}
+   void setInvInertiaBF(const size_t idx, invInertiaBF_type const & v) { invInertiaBF_[idx] = v; }
+   
+   virtualInertiaBF_type const & getVirtualInertiaBF(const size_t idx) const {return virtualInertiaBF_[idx];}
+   virtualInertiaBF_type& getVirtualInertiaBFRef(const size_t idx) {return virtualInertiaBF_[idx];}
+   void setVirtualInertiaBF(const size_t idx, virtualInertiaBF_type const & v) { virtualInertiaBF_[idx] = v; }
+   
+   invInertiaBFIncludingVirtual_type const & getInvInertiaBFIncludingVirtual(const size_t idx) const {return invInertiaBFIncludingVirtual_[idx];}
+   invInertiaBFIncludingVirtual_type& getInvInertiaBFIncludingVirtualRef(const size_t idx) {return invInertiaBFIncludingVirtual_[idx];}
+   void setInvInertiaBFIncludingVirtual(const size_t idx, invInertiaBFIncludingVirtual_type const & v) { invInertiaBFIncludingVirtual_[idx] = v; }
+   
+   oldAngularAcceleration_type const & getOldAngularAcceleration(const size_t idx) const {return oldAngularAcceleration_[idx];}
+   oldAngularAcceleration_type& getOldAngularAccelerationRef(const size_t idx) {return oldAngularAcceleration_[idx];}
+   void setOldAngularAcceleration(const size_t idx, oldAngularAcceleration_type const & v) { oldAngularAcceleration_[idx] = v; }
+   
    clusterID_type const & getClusterID(const size_t idx) const {return clusterID_[idx];}
    clusterID_type& getClusterIDRef(const size_t idx) {return clusterID_[idx];}