Dear CS10-Gitlab-users, on Thursday, Feb 3 there will be maintenance. That will lead to a downtime of the CS10-Gitlab-service including Subversion and Mattermost chat from 09:30. This might take the whole day since we don't know how long it is going to take. We are sorry for the inconvenience! Best regards, CS10-Admin-Team

Commit f596683c authored by Sebastian Eibl's avatar Sebastian Eibl
Browse files

added union pe data structure

parent 376cb7f4
......@@ -179,6 +179,8 @@ public:
template< typename Engine >
inline vector_type randomPoint( Engine & engine ) const;
bool checkInvariant() const;
/**
* \brief Deserializes an GenericAABB from a mpi::GenericRecvBuffer
*
......@@ -206,8 +208,6 @@ protected:
inline GenericAABB( const GenericAABB & lhs, const GenericAABB & rhs );
private:
bool checkInvariant() const;
vector_type minCorner_; /// minimal values
vector_type maxCorner_; /// maximal values
};
......
......@@ -277,7 +277,8 @@ inline Quaternion<Type>::Quaternion( Vector3<Axis> axis, Type angle )
{
static_assert(boost::is_floating_point<Axis>::value, "Axis has to be floating point!" );
if( math::equal(std::fabs(angle), real_c(0)) ) {
auto axisLength = axis.length();
if( (floatIsEqual(axisLength, 0)) || (math::equal(std::fabs(angle), real_c(0))) ) {
reset();
return;
}
......@@ -287,7 +288,8 @@ inline Quaternion<Type>::Quaternion( Vector3<Axis> axis, Type angle )
const Type sina( std::sin( angle*Type(0.5) ) );
const Type cosa( std::cos( angle*Type(0.5) ) );
axis = axis.getNormalized();
auto invAxisLength = real_c(1) / axisLength;
axis *= invAxisLength;
v_[0] = cosa;
v_[1] = sina * axis[0];
......
......@@ -84,6 +84,7 @@ class SliderJoint;
class Sphere;
class Spring;
class TriangleMesh;
template <typename BodyTypeTuple>
class Union;
typedef RigidBody BodyType; //!< Type of the rigid bodies.
......@@ -117,10 +118,6 @@ typedef TriangleMesh MeshType; //!< Type of the triangle me
typedef TriangleMesh* MeshID; //!< Handle for a triangle mesh primitive.
typedef const TriangleMesh* ConstMeshID; //!< Handle for a constant triangle mesh primitive.
typedef Union UnionType; //!< Type of the union compound geometry.
typedef Union* UnionID; //!< Handle for a union.
typedef const Union* ConstUnionID; //!< Handle for a constant union.
typedef Attachable AttachableType; //!< Type of the attachables.
typedef Attachable* AttachableID; //!< Handle for an attachable.
typedef const Attachable* ConstAttachableID; //!< Handle for a constant attachable.
......
......@@ -43,6 +43,7 @@
#include "pe/rigidbody/CapsuleFactory.h"
#include "pe/rigidbody/PlaneFactory.h"
#include "pe/rigidbody/SphereFactory.h"
#include "pe/rigidbody/UnionFactory.h"
#include "pe/synchronization/SyncNextNeighbors.h"
#include "pe/synchronization/SyncShadowOwners.h"
......
......@@ -20,11 +20,14 @@
//
//======================================================================================================================
#pragma once
#include "pe/Types.h"
#include "pe/rigidbody/Box.h"
#include "pe/rigidbody/Capsule.h"
#include "pe/rigidbody/Plane.h"
#include "pe/rigidbody/Sphere.h"
#include "pe/rigidbody/Union.h"
#include "pe/contact/Contact.h"
#include "GJKEPAHelper.h"
......@@ -34,9 +37,17 @@
#include "core/math/Shims.h"
#include "geometry/GeometricalFunctions.h"
#include <boost/tuple/tuple.hpp>
namespace walberla {
namespace pe {
namespace fcd {
//Forward Declaration
template < typename BodyTypeTuple, typename BaseT >
struct DoubleDispatch;
}
//*************************************************************************************************
/*!\brief Contact generation between two colliding rigid bodies.
* \ingroup contact_generation
......@@ -74,9 +85,6 @@ bool collide( SphereID s1, SphereID s2, Container& container )
{
WALBERLA_ASSERT_UNEQUAL(s1->getSystemID(), s2->getSystemID(), "colliding with itself!\n" << s1 << "\n" << s2);
WALBERLA_CHECK_EQUAL(s1->getSuperBody(), s1);
WALBERLA_CHECK_EQUAL(s2->getSuperBody(), s2);
Vec3 contactNormal = ( s1->getPosition() - s2->getPosition() );
real_t penetrationDepth = ( contactNormal.length() - s1->getRadius() - s2->getRadius() );
......@@ -1994,5 +2002,39 @@ bool collide( CapsuleID c, BoxID b, Container& container )
return collide(b, c, container);
}
template <typename BodyTypeTuple, typename BodyB, typename Container>
inline
bool collide( Union<BodyTypeTuple>* bd1, BodyB* bd2, Container& container )
{
bool collision = false;
for( auto it=bd1->begin(); it!=bd1->end(); ++it )
{
collision |= fcd::DoubleDispatch< BodyTypeTuple, boost::tuple<BodyB> >::execute(*it, bd2, container);
}
return collision;
}
template <typename BodyA, typename BodyTypeTuple, typename Container>
inline
bool collide( BodyA* bd1, Union<BodyTypeTuple>* bd2, Container& container )
{
return collide (bd2, bd1, container);
}
template <typename BodyTypeTupleA, typename BodyTypeTupleB, typename Container>
inline
bool collide( Union<BodyTypeTupleA>* bd1, Union<BodyTypeTupleB>* bd2, Container& container )
{
bool collision = false;
for( auto it1=bd1->begin(); it1!=bd1->end(); ++it1 )
{
for( auto it2=bd2->begin(); it2!=bd2->end(); ++it2 )
{
collision |= fcd::DoubleDispatch< BodyTypeTupleA, BodyTypeTupleB >::execute(*it1, *it2, container);
}
}
return collision;
}
}
}
......@@ -33,6 +33,7 @@
#include "pe/communication/rigidbody/Box.h"
#include "pe/communication/rigidbody/Capsule.h"
#include "pe/communication/rigidbody/Sphere.h"
#include "pe/communication/rigidbody/Union.h"
#include "core/Abort.h"
......@@ -95,7 +96,8 @@ struct UnmarshalDynamically{
if (BodyTypeTuple::head_type::getStaticTypeID() == typeID)
{
typedef typename BodyTypeTuple::head_type BodyT;
return instantiate<BodyT>( buffer, domain, block );
BodyT* newBody;
return instantiate( buffer, domain, block, newBody );
} else
{
return UnmarshalDynamically<typename BodyTypeTuple::tail_type>::execute(buffer, typeID, domain, block);
......
......@@ -28,6 +28,7 @@
// Includes
//*************************************************************************************************
#include "core/Abort.h"
#include "core/math/AABB.h"
#include "core/math/Vector3.h"
......@@ -55,9 +56,9 @@ void correctBodyPosition(const math::AABB& domain, const Vec3& center, Vec3& pos
}
template < class BodyT >
BodyID instantiate( mpi::RecvBuffer& /*buffer*/, const math::AABB& /*domain*/, const math::AABB& /*block*/ )
BodyT* instantiate( mpi::RecvBuffer& /*buffer*/, const math::AABB& /*domain*/, const math::AABB& /*block*/, BodyT*& /*newBody*/ )
{
throw std::runtime_error( "Body instantiation not implemented!" );
WALBERLA_ABORT( "Body instantiation not implemented! (" << demangle(typeid(BodyT).name()) << ")" );
}
} // namespace communication
......
......@@ -47,7 +47,7 @@ void marshal( mpi::SendBuffer& buffer, const MPIRigidBodyTrait& obj ) {
* \param hasSuperBody False if body is not part of a union. Subordinate bodies in unions do not encode velocities but encode relative positions.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, MPIRigidBodyTraitParameter& objparam, bool /*hasSuperBody*/ ) {
void unmarshal( mpi::RecvBuffer& buffer, MPIRigidBodyTraitParameter& objparam ) {
buffer >> objparam.owner_;
}
......@@ -66,6 +66,7 @@ void marshal( mpi::SendBuffer& buffer, const RigidBody& obj ) {
buffer << obj.isCommunicating();
buffer << obj.hasInfiniteMass();
buffer << obj.getPosition();
buffer << obj.hasSuperBody();
if( obj.hasSuperBody() )
{
buffer << obj.getRelPosition();
......@@ -87,23 +88,24 @@ void marshal( mpi::SendBuffer& buffer, const RigidBody& obj ) {
* \param hasSuperBody False if body is not part of a union. Subordinate bodies in unions do not encode velocities but encode relative positions.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, RigidBodyParameters& objparam, bool hasSuperBody ) {
unmarshal( buffer, objparam.mpiTrait_, hasSuperBody );
void unmarshal( mpi::RecvBuffer& buffer, RigidBodyParameters& objparam ) {
unmarshal( buffer, objparam.mpiTrait_ );
buffer >> objparam.sid_;
buffer >> objparam.uid_;
buffer >> objparam.communicating_;
buffer >> objparam.infiniteMass_;
buffer >> objparam.gpos_;
buffer >> objparam.hasSuperBody_;
if( hasSuperBody )
if( objparam.hasSuperBody_ )
{
buffer >> objparam.rpos_;
}
buffer >> objparam.q_;
if( !hasSuperBody )
if( !objparam.hasSuperBody_ )
{
buffer >> objparam.v_;
buffer >> objparam.w_;
......@@ -139,8 +141,8 @@ void marshal( mpi::SendBuffer& buffer, const GeomPrimitive& obj ) {
* \param hasSuperBody False if body is not part of a union. Passed on to rigid body unmarshalling.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, GeomPrimitiveParameters& objparam, bool hasSuperBody ) {
unmarshal( buffer, static_cast<RigidBodyParameters&>( objparam ), hasSuperBody );
void unmarshal( mpi::RecvBuffer& buffer, GeomPrimitiveParameters& objparam ) {
unmarshal( buffer, static_cast<RigidBodyParameters&>( objparam ) );
buffer >> objparam.material_;
}
......
......@@ -63,7 +63,7 @@ void marshal( mpi::SendBuffer& buffer, const MPIRigidBodyTrait& obj );
* \param hasSuperBody False if body is not part of a union. Subordinate bodies in unions do not encode velocities but encode relative positions.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, MPIRigidBodyTraitParameter& objparam, bool hasSuperBody );
void unmarshal( mpi::RecvBuffer& buffer, MPIRigidBodyTraitParameter& objparam );
//*************************************************************************************************
//*************************************************************************************************
......@@ -77,6 +77,7 @@ struct RigidBodyParameters {
bool communicating_, infiniteMass_;
id_t sid_, uid_;
Vec3 gpos_, rpos_, v_, w_;
bool hasSuperBody_;
Quat q_;
};
......@@ -98,7 +99,7 @@ void marshal( mpi::SendBuffer& buffer, const RigidBody& obj );
* \param hasSuperBody False if body is not part of a union. Subordinate bodies in unions do not encode velocities but encode relative positions.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, RigidBodyParameters& objparam, bool hasSuperBody );
void unmarshal( mpi::RecvBuffer& buffer, RigidBodyParameters& objparam );
//*************************************************************************************************
//*************************************************************************************************
......@@ -130,7 +131,7 @@ void marshal( mpi::SendBuffer& buffer, const GeomPrimitive& obj );
* \param hasSuperBody False if body is not part of a union. Passed on to rigid body unmarshalling.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, GeomPrimitiveParameters& objparam, bool hasSuperBody );
void unmarshal( mpi::RecvBuffer& buffer, GeomPrimitiveParameters& objparam );
} // namespace communication
} // namespace pe
......
......@@ -49,8 +49,8 @@ void marshal( mpi::SendBuffer& buffer, const Box& obj ) {
* \param hasSuperBody False if body is not part of a union. Passed on to rigid body unmarshalling.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, BoxParameters& objparam, bool hasSuperBody ) {
unmarshal( buffer, static_cast<GeomPrimitiveParameters&>( objparam ), hasSuperBody );
void unmarshal( mpi::RecvBuffer& buffer, BoxParameters& objparam ) {
unmarshal( buffer, static_cast<GeomPrimitiveParameters&>( objparam ) );
buffer >> objparam.lengths_;
}
//*************************************************************************************************
......
......@@ -58,21 +58,18 @@ void marshal( mpi::SendBuffer& buffer, const Box& obj );
* \param hasSuperBody False if body is not part of a union. Passed on to rigid body unmarshalling.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, BoxParameters& objparam, bool hasSuperBody );
void unmarshal( mpi::RecvBuffer& buffer, BoxParameters& objparam );
//*************************************************************************************************
template <>
inline BodyID instantiate<Box>( mpi::RecvBuffer& buffer, const math::AABB& domain, const math::AABB& block )
inline BoxID instantiate( mpi::RecvBuffer& buffer, const math::AABB& domain, const math::AABB& block, BoxID& newBody )
{
BoxParameters subobjparam;
unmarshal( buffer, subobjparam, false );
unmarshal( buffer, subobjparam );
correctBodyPosition(domain, block.center(), subobjparam.gpos_);
BoxID obj = new Box( subobjparam.sid_, subobjparam.uid_, subobjparam.gpos_, subobjparam.rpos_, subobjparam.q_, subobjparam.lengths_, subobjparam.material_, false, subobjparam.communicating_, subobjparam.infiniteMass_ );
obj->setLinearVel( subobjparam.v_ );
obj->setAngularVel( subobjparam.w_ );
obj->MPITrait.setOwner( subobjparam.mpiTrait_.owner_ );
return obj;
newBody = new Box( subobjparam.sid_, subobjparam.uid_, subobjparam.gpos_, subobjparam.rpos_, subobjparam.q_, subobjparam.lengths_, subobjparam.material_, false, subobjparam.communicating_, subobjparam.infiniteMass_ );
newBody->setLinearVel( subobjparam.v_ );
newBody->setAngularVel( subobjparam.w_ );
newBody->MPITrait.setOwner( subobjparam.mpiTrait_.owner_ );
return newBody;
}
} // namespace communication
......
......@@ -51,9 +51,9 @@ void marshal( mpi::SendBuffer& buffer, const Capsule& obj )
* \param hasSuperBody False if body is not part of a union. Passed on to rigid body unmarshalling.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, CapsuleParameters& objparam, bool hasSuperBody )
void unmarshal( mpi::RecvBuffer& buffer, CapsuleParameters& objparam )
{
unmarshal( buffer, static_cast<GeomPrimitiveParameters&>( objparam ), hasSuperBody );
unmarshal( buffer, static_cast<GeomPrimitiveParameters&>( objparam ) );
buffer >> objparam.radius_;
buffer >> objparam.length_;
}
......
......@@ -58,21 +58,20 @@ void marshal( mpi::SendBuffer& buffer, const Capsule& obj );
* \param hasSuperBody False if body is not part of a union. Passed on to rigid body unmarshalling.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, CapsuleParameters& objparam, bool hasSuperBody );
void unmarshal( mpi::RecvBuffer& buffer, CapsuleParameters& objparam );
//*************************************************************************************************
template <>
inline BodyID instantiate<Capsule>( mpi::RecvBuffer& buffer, const math::AABB& domain, const math::AABB& block )
inline CapsuleID instantiate( mpi::RecvBuffer& buffer, const math::AABB& domain, const math::AABB& block, CapsuleID& newBody )
{
CapsuleParameters subobjparam;
unmarshal( buffer, subobjparam, false );
unmarshal( buffer, subobjparam );
correctBodyPosition(domain, block.center(), subobjparam.gpos_);
CapsuleID obj = new Capsule( subobjparam.sid_, subobjparam.uid_, subobjparam.gpos_, subobjparam.rpos_, subobjparam.q_, subobjparam.radius_, subobjparam.length_, subobjparam.material_, false, subobjparam.communicating_, subobjparam.infiniteMass_ );
obj->setLinearVel( subobjparam.v_ );
obj->setAngularVel( subobjparam.w_ );
obj->MPITrait.setOwner( subobjparam.mpiTrait_.owner_ );
return obj;
newBody = new Capsule( subobjparam.sid_, subobjparam.uid_, subobjparam.gpos_, subobjparam.rpos_, subobjparam.q_, subobjparam.radius_, subobjparam.length_, subobjparam.material_, false, subobjparam.communicating_, subobjparam.infiniteMass_ );
newBody->setLinearVel( subobjparam.v_ );
newBody->setAngularVel( subobjparam.w_ );
newBody->MPITrait.setOwner( subobjparam.mpiTrait_.owner_ );
return newBody;
}
} // namespace communication
......
......@@ -49,8 +49,8 @@ void marshal( mpi::SendBuffer& buffer, const Sphere& obj ) {
* \param hasSuperBody False if body is not part of a union. Passed on to rigid body unmarshalling.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, SphereParameters& objparam, bool hasSuperBody ) {
unmarshal( buffer, static_cast<GeomPrimitiveParameters&>( objparam ), hasSuperBody );
void unmarshal( mpi::RecvBuffer& buffer, SphereParameters& objparam ) {
unmarshal( buffer, static_cast<GeomPrimitiveParameters&>( objparam ) );
buffer >> objparam.radius_;
}
//*************************************************************************************************
......
......@@ -58,21 +58,20 @@ void marshal( mpi::SendBuffer& buffer, const Sphere& obj );
* \param hasSuperBody False if body is not part of a union. Passed on to rigid body unmarshalling.
* \return void
*/
void unmarshal( mpi::RecvBuffer& buffer, SphereParameters& objparam, bool hasSuperBody );
void unmarshal( mpi::RecvBuffer& buffer, SphereParameters& objparam );
//*************************************************************************************************
template <>
inline BodyID instantiate<Sphere>( mpi::RecvBuffer& buffer, const math::AABB& domain, const math::AABB& block )
inline SphereID instantiate( mpi::RecvBuffer& buffer, const math::AABB& domain, const math::AABB& block, SphereID& newBody )
{
SphereParameters subobjparam;
unmarshal( buffer, subobjparam, false );
unmarshal( buffer, subobjparam );
correctBodyPosition(domain, block.center(), subobjparam.gpos_);
SphereID obj = new Sphere( subobjparam.sid_, subobjparam.uid_, subobjparam.gpos_, subobjparam.rpos_, subobjparam.q_, subobjparam.radius_, subobjparam.material_, false, subobjparam.communicating_, subobjparam.infiniteMass_ );
obj->setLinearVel( subobjparam.v_ );
obj->setAngularVel( subobjparam.w_ );
obj->MPITrait.setOwner( subobjparam.mpiTrait_.owner_ );
return obj;
newBody = new Sphere( subobjparam.sid_, subobjparam.uid_, subobjparam.gpos_, subobjparam.rpos_, subobjparam.q_, subobjparam.radius_, subobjparam.material_, false, subobjparam.communicating_, subobjparam.infiniteMass_ );
newBody->setLinearVel( subobjparam.v_ );
newBody->setAngularVel( subobjparam.w_ );
newBody->MPITrait.setOwner( subobjparam.mpiTrait_.owner_ );
return newBody;
}
} // namespace communication
......
//======================================================================================================================
//
// 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 Union.h
//! \ingroup pe
//! \author Tobias Preclik
//! \author Sebastian Eibl <sebastian.eibl@fau.de>
//! \brief Marshalling of objects for data transmission or storage.
//
//======================================================================================================================
#pragma once
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include "pe/communication/Instantiate.h"
#include "pe/communication/Marshalling.h"
#include "pe/rigidbody/Union.h"
namespace walberla {
namespace pe {
namespace communication {
//forward declaration
template < typename BodyTypeTuple >
struct MarshalDynamically;
//forward declaration
template < typename BodyTypeTuple >
struct UnmarshalDynamically;
struct UnionParameters : public GeomPrimitiveParameters {
real_t m_;
Mat3 I_;
math::AABB aabb_;
size_t size_;
};
//*************************************************************************************************
/*!\brief Marshalling a box primitive.
*
* \param buffer The buffer to be filled.
* \param obj The object to be marshalled.
* \return void
*/
template < typename BodyTypeTuple >
void marshal( mpi::SendBuffer& buffer, const Union<BodyTypeTuple>& obj )
{
// Material of union is not relevant for reconstruction thus marshal RigidBody instead of GeomPrimitive.
marshal( buffer, static_cast<const RigidBody&>( obj ) );
buffer << obj.getMass(); // Encoding the total mass
buffer << obj.getBodyInertia(); // Encoding the moment of inertia
// Preparing the axis-aligned bounding box
buffer << obj.getAABB(); // Encoding the axis-aligned bounding box
buffer << static_cast<size_t> (obj.size()); // Encoding the number of contained bodies
// Encoding the contained primitives
const typename Union<BodyTypeTuple>::ConstIterator begin( obj.begin() );
const typename Union<BodyTypeTuple>::ConstIterator end ( obj.end() );
for( typename Union<BodyTypeTuple>::ConstIterator body=begin; body!=end; ++body )
{
buffer << body->getTypeID();
MarshalDynamically<BodyTypeTuple>::execute( buffer, **body );
}
}
//*************************************************************************************************
//*************************************************************************************************
/*!\brief Unmarshalling a box primitive.
*
* \param buffer The buffer from where to read.
* \param objparam The object to be reconstructed.
* \param hasSuperBody False if body is not part of a union. Passed on to rigid body unmarshalling.
* \return void
*/
inline
void unmarshal( mpi::RecvBuffer& buffer, UnionParameters& objparam )
{
// Material of union is not relevant for reconstruction thus marshal RigidBody instead of GeomPrimitive.
unmarshal( buffer, static_cast<RigidBodyParameters&>( objparam ) );
buffer >> objparam.m_;
buffer >> objparam.I_;
buffer >> objparam.aabb_;
//std::cout << "mass of union: " << objparam.m_ << std::endl;
// Decode the number of contained bodies
buffer >> objparam.size_;
//std::cout << "size of union: " << size << std::endl;
}
//*************************************************************************************************
template <typename BodyTypeTuple>
inline Union<BodyTypeTuple>* instantiate( mpi::RecvBuffer& buffer, const math::AABB& domain, const math::AABB& block, Union<BodyTypeTuple>*& newBody )
{
UnionParameters subobjparam;
unmarshal( buffer, subobjparam );
correctBodyPosition(domain, block.center(), subobjparam.gpos_);
newBody = new Union<BodyTypeTuple>( subobjparam.sid_,
subobjparam.uid_,
subobjparam.gpos_,
subobjparam.rpos_,
subobjparam.q_,
false,
subobjparam.communicating_,
subobjparam.infiniteMass_ );
newBody->setLinearVel( subobjparam.v_ );
newBody->setAngularVel( subobjparam.w_ );
newBody->MPITrait.setOwner( subobjparam.mpiTrait_.owner_ );
// Decoding the contained primitives
for( size_t i = 0; i < subobjparam.size_; ++i )
{
decltype ( static_cast<BodyID>(nullptr)->getTypeID() ) type;
buffer >> type;
BodyID obj = UnmarshalDynamically<BodyTypeTuple>::execute(buffer, type, domain, block);
obj->setRemote( true );
newBody->add(obj);
}
return newBody;
}
} // namespace communication
} // namespace pe
} // namespace walberla
......@@ -64,8 +64,8 @@ Contact::Contact( GeomID g1, GeomID g2, const Vec3& gpos, const Vec3& normal, re
WALBERLA_ASSERT( !( b1_->hasInfiniteMass() && b2_->hasInfiniteMass() ), "Invalid contact between two rigid bodies with infinite masses" );
// Registering the contact with both attached rigid bodies
if( !b1_->hasInfiniteMass() ) b1_->registerContact( this );
if( !b2_->hasInfiniteMass() ) b2_->registerContact( this );
// if( !b1_->hasInfiniteMass() ) b1_->registerContact( this );
// if( !b2_->hasInfiniteMass() ) b2_->registerContact( this );
// Merging the contact graph
// if( !b1_->hasInfiniteMass() && !b2_->hasInfiniteMass() )
......
......@@ -1774,12 +1774,8 @@ inline void HardContactSemiImplicitTimesteppingSolvers::integratePositions( Body
body->resetNode();
body->clearContacts();
if( body->isAwake() ) {
if (body->getSystemID() == 6917529027641081896)
{
//WALBERLA_LOG_DEVEL("pos: " << body->getPosition() << "\nvel: " << body->getLinearVel() << "\nv: " << v);
}
if( body->isAwake() )
{
// Calculating the translational displacement
body->setPosition( body->getPosition() + v * dt );
......@@ -1794,14 +1790,6 @@ inline void HardContactSemiImplicitTimesteppingSolvers::integratePositions( Body
body->setLinearVel( v );
body->setAngularVel( w );
// if( body->getType() == unionType ) {
// // Updating the contained bodies
// UnionID u( static_cast<UnionID>( body ) );
// for( BodyIterator subbody=u->begin(); subbody!=u->end(); ++subbody )
// u->updateBody( *subbody, dq );
// }
// Setting the axis-aligned bounding box