nimble::BvhContactManager Class Reference

#include <bvh_contact_manager.h>

Inheritance diagram for nimble::BvhContactManager:

Public Member Functions
	BvhContactManager (std::shared_ptr< ContactInterface > interface, nimble::DataManager &data_manager, std::size_t _overdecomposition, std::string splitting_alg)
	BvhContactManager (const BvhContactManager &)=delete
	BvhContactManager (BvhContactManager &&)=delete
BvhContactManager &	operator= (const BvhContactManager &)=delete
BvhContactManager &	operator= (BvhContactManager &&)=delete
	~BvhContactManager ()=default

Protected Member Functions
void	ComputeParallelContactForce (int step, bool debug_output, nimble::Viewify< 2 > contact_force) override
void	ComputeBoundingVolumes ()

Protected Attributes
bvh::collision_world	m_world
bvh::collision_object *	m_nodes
bvh::collision_object *	m_faces
bvh::split_algorithm	m_split_alg = bvh::split_algorithm::geom_axis
std::vector< NarrowphaseResult >	m_last_results

Constructor & Destructor Documentation

BvhContactManager() [1/3]

nimble::BvhContactManager::BvhContactManager	(	std::shared_ptr< ContactInterface >	interface,
		nimble::DataManager &	data_manager,
		std::size_t	_overdecomposition,
		std::string	splitting_alg )

    : ParallelContactManager(interface, data_manager),
      m_world{_overdecomposition},
      m_nodes{&m_world.create_collision_object()},
      m_faces{&m_world.create_collision_object()}
{
  m_world.set_narrowphase_functor<ContactEntity>(NarrowphaseFunc{this});
  if (splitting_alg == "geom_axis")
    m_split_alg = bvh::split_algorithm::geom_axis;
  else if (splitting_alg == "ml_geom_axis")
    m_split_alg = bvh::split_algorithm::ml_geom_axis;
  else if (splitting_alg == "clustering")
    m_split_alg = bvh::split_algorithm::clustering;
  else
    throw std::runtime_error("invalid splitting algorithm");
}

BvhContactManager() [2/3]

nimble::BvhContactManager::BvhContactManager ( const BvhContactManager & )

delete

BvhContactManager() [3/3]

nimble::BvhContactManager::BvhContactManager ( BvhContactManager && )

delete

~BvhContactManager()

nimble::BvhContactManager::~BvhContactManager ( )

default

Member Function Documentation

ComputeBoundingVolumes()

void nimble::BvhContactManager::ComputeBoundingVolumes ( )

protected

{
  Kokkos::parallel_for( contact_nodes_d_.extent( 0 ), KOKKOS_LAMBDA( int _i ) {
    auto &node = contact_nodes_d_( _i );
    const double           inflation_length = node.inflation_factor * node.char_len_;
    ContactEntity::vertex* v                = reinterpret_cast<ContactEntity::vertex*>(&node.coord_1_x_);
    node.kdop_                              = bvh::bphase_kdop::from_sphere(*v, inflation_length);
  } );
  Kokkos::parallel_for( contact_faces_d_.extent( 0 ), KOKKOS_LAMBDA( int _i ) {
    auto &face = contact_faces_d_( _i );
    const double           inflation_length = face.inflation_factor * face.char_len_;
    ContactEntity::vertex* v                = reinterpret_cast<ContactEntity::vertex*>(&face.coord_1_x_);
    face.kdop_                              = bvh::bphase_kdop::from_vertices(v, v + 3, inflation_length);
  } );
}

ComputeParallelContactForce()

void nimble::BvhContactManager::ComputeParallelContactForce ( int step, bool debug_output, nimble::Viewify< 2 > contact_force )

overrideprotected

{
  auto model_ptr = this->data_manager_.GetModelData();
  auto model_data = &dynamic_cast<nimble_kokkos::ModelData &>(*model_ptr);
 
  auto field_ids    = this->data_manager_.GetFieldIDs();
  auto displacement_d = model_data->GetDeviceVectorNodeData(field_ids.displacement);
 
  auto contact_force_h = model_data->GetHostVectorNodeData(field_ids.contact_force);
  auto contact_force_d = model_data->GetDeviceVectorNodeData(field_ids.contact_force);
  Kokkos::deep_copy(contact_force_d, 0.0);
 
  this->ApplyDisplacements(displacement_d);
 
  total_search_time.Start();
  m_world.start_iteration();
 
  // Update collision objects, this will build the trees
  ComputeBoundingVolumes();
 
  this->startTimer("BVH::SetEntity::Nodes");
  m_nodes->set_entity_data(contact_nodes_d_, m_split_alg);
  this->stopTimer("BVH::SetEntity::Nodes");
 
  this->startTimer("BVH::SetEntity::Faces");
  m_faces->set_entity_data(contact_faces_d_, m_split_alg);
  this->stopTimer("BVH::SetEntity::Faces");
 
  m_nodes->init_broadphase();
  m_faces->init_broadphase();
 
  m_faces->broadphase(*m_nodes);
 
  m_last_results.clear();
  m_faces->for_each_result<NarrowphaseResult>(
      [this](const NarrowphaseResult& _res) { m_last_results.emplace_back(_res); });
 
  m_world.finish_iteration();
  total_search_time.Stop();
 
  total_enforcement_time.Start();
  // Update contact entities
  for (auto&& r : m_last_results) {
    if (r.node) {
      if (r.local_index >= contact_nodes_d_.extent( 0 ))
        std::cerr << "contact node index " << r.local_index << " is out of bounds (" << contact_nodes_d_.extent( 0 ) << ")\n";
      auto& node = contact_nodes_d_(r.local_index);
      node.set_contact_status(true);
      node.SetNodalContactForces(r.contact_force);
      node.ScatterForceToContactManagerForceVector(force_d_);
    } else {
      if (r.local_index >= contact_faces_d_.extent( 0 ))
        std::cerr << "contact face index " << r.local_index << " is out of bounds (" << contact_faces_d_.extent( 0 ) << ")\n";
      auto& face = contact_faces_d_(r.local_index);
      face.set_contact_status(true);
      face.SetNodalContactForces(r.contact_force, r.bary);
      face.ScatterForceToContactManagerForceVector(force_d_);
    }
  }
  total_num_contacts += m_last_results.size();
  total_enforcement_time.Stop();
 
  this->GetForces(contact_force_d);
  Kokkos::deep_copy(contact_force_h, contact_force_d);
 
  constexpr int vector_dim           = 3;
  auto          myVectorCommunicator = this->data_manager_.GetVectorCommunicator();
  myVectorCommunicator->VectorReduction(vector_dim, contact_force_h);
}

operator=() [1/2]

BvhContactManager & nimble::BvhContactManager::operator= ( BvhContactManager && )

delete

operator=() [2/2]

BvhContactManager & nimble::BvhContactManager::operator= ( const BvhContactManager & )

delete

Member Data Documentation

m_faces

bvh::collision_object* nimble::BvhContactManager::m_faces

protected

m_last_results

std::vector<NarrowphaseResult> nimble::BvhContactManager::m_last_results

protected

m_nodes

bvh::collision_object* nimble::BvhContactManager::m_nodes

protected

m_split_alg

bvh::split_algorithm nimble::BvhContactManager::m_split_alg = bvh::split_algorithm::geom_axis

protected

m_world

bvh::collision_world nimble::BvhContactManager::m_world

protected

---

The documentation for this class was generated from the following files:

• src/contact/parallel/bvh_contact_manager.h
• src/contact/parallel/bvh_contact_manager.cc